Safe Haskell	None

Language.Bash

Description

Types and functions for generation of Bash scripts, with safe escaping and composition of a large subset of Bash statements and expressions.

This module is meant to be imported qualified -- perhaps as Bash -- and contains everything you need to build and render Bash scripts. For examples of usage, look at Language.Bash.Lib.

Synopsis

Documentation

data Statement t Source

The Statement type captures the different kind of statements that may exist in a Bash statement tree. It is mutually recursive with Annotated. It is a Foldable and a Functor.

Constructors

Empty
SimpleCommand (Expression t) [Expression t]
NoOp ByteString
Bang (Annotated t)
AndAnd (Annotated t) (Annotated t)
OrOr (Annotated t) (Annotated t)
Pipe (Annotated t) (Annotated t)
Sequence (Annotated t) (Annotated t)
Background (Annotated t) (Annotated t)
Group (Annotated t)
Subshell (Annotated t)
Function Identifier (Annotated t)
IfThen (Annotated t) (Annotated t)
IfThenElse (Annotated t) (Annotated t) (Annotated t)
For Identifier [Expression t] (Annotated t)
Case (Expression t) [(Expression t, Annotated t)]
While (Annotated t) (Annotated t)
Until (Annotated t) (Annotated t)
VarAssign Identifier (Expression t)
Export Identifier (Expression t)
ArrayDecl Identifier [Expression t]
ArrayUpdate Identifier (Expression t) (Expression t)
ArrayAssign Identifier [Expression t]
DictDecl Identifier [(Identifier, Expression t)]
DictUpdate Identifier (Expression t) (Expression t)
DictAssign Identifier [(Expression t, Expression t)]
Redirect (Annotated t) Redirection FileDescriptor (Either (Expression t) FileDescriptor)

Instances

Functor Statement
Foldable Statement
Eq t => Eq (Statement t)
(Eq (Statement t), Ord t) => Ord (Statement t)
Show t => Show (Statement t)
Annotation t => PP (Statement t)

data Annotated t Source

The Annotated type captures the annotatedness of a tree of Bash statements. It is Foldable and a Functor.

Constructors

Annotated
Fields annotation :: t statement :: Statement t

Instances

Functor Annotated
Foldable Annotated
Eq t => Eq (Annotated t)
(Eq (Annotated t), Ord t) => Ord (Annotated t)
Show t => Show (Annotated t)
Annotation t => PP (Annotated t)

data Expression t Source

The type of Bash expressions, handling many kinds of variable reference as well as eval and process substitution. It is Foldable and a Functor.

Constructors

Literal Bash
Asterisk
QuestionMark
Tilde
ReadVar VarName
ReadVarSafe VarName
ReadArray Identifier (Expression t)
ReadArraySafe Identifier (Expression t)
ARGVElements
ARGVLength
Elements Identifier
Keys Identifier
Length VarName
Trim Trim VarName (Expression t)
ArrayLength Identifier
Concat (Expression t) (Expression t)
Eval (Annotated t)
EvalUnquoted (Annotated t)
ProcessIn (Annotated t)
ProcessOut (Annotated t)

Instances

Functor Expression
Foldable Expression
Eq t => Eq (Expression t)
(Eq (Expression t), Ord t) => Ord (Expression t)
Show t => Show (Expression t)
IsString (Expression t)
Annotation t => PP (Expression t)

literal :: ByteString -> Expression tSource

Escape a ByteString to produce a literal expression.

data Identifier Source

The type of legal Bash identifiers, strings beginning with letters or _ and containing letters, _ and digits.

Instances

Eq Identifier
Ord Identifier
Show Identifier
IsString Identifier
PP Identifier

identifier :: ByteString -> Maybe Identifier Source

Produce an Identifier from a ByteString of legal format.

data SpecialVar Source

The names of special variables, with otherwise illegal identifiers, are represented by this type.

Instances

Eq SpecialVar
Ord SpecialVar
Show SpecialVar
IsString SpecialVar
PP SpecialVar

specialVar :: ByteString -> Maybe SpecialVar Source

Try to render a SpecialVar from a ByteString.

data VarName Source

Constructors

VarIdent Identifier
VarSpecial SpecialVar

Instances

Eq VarName
Ord VarName
Show VarName
IsString VarName

varName :: ByteString -> Maybe VarName Source

data Redirection Source

Redirection "directions".

Constructors

In	Input redirection, `<`.
Out	Output redirection, `>`.
Append	Appending output, `>>`.

Instances

Eq Redirection
Ord Redirection
Show Redirection

newtype FileDescriptor Source

A file descriptor in Bash is simply a number between 0 and 255.

Constructors

FileDescriptor Word8

Instances

Eq FileDescriptor
Num FileDescriptor
Ord FileDescriptor
Show FileDescriptor
PP FileDescriptor

class PP t whereSource

Methods

pp :: t -> State PPState ()Source

Instances

PP FileDescriptor
PP SpecialVar
PP Identifier
Annotation t => PP (Expression t)
Annotation t => PP (Statement t)
Annotation t => PP (Annotated t)

bytes :: PP t => t -> ByteString Source

builder :: PP t => t -> Builder Source

data PPState Source

State of pretty printing -- string being built, indent levels, present column, brace nesting.

Instances

Show PPState

render :: PPState -> State PPState () -> Builder Source

Produce a builder from a pretty printer state computation.

nlCol :: Word -> PPState Source

Pretty printer state starting on a new line indented to the given column.

script :: Annotation t => Statement t -> Builder Source

Produce a script beginning with #!/bin/bash and a safe set statement.

script_sha1 :: forall t t'. (Annotation t, Annotation t') => ByteString -> Statement t -> Statement t' -> Builder Source

Produce a script beginning with #!/bin/bash and some (optional) documentation. Cause the script to be scanned for SHA-1 hash of the setup (first statement argument) and main (second statement argument) before running the safe set statement and running the second argument.

module Language.Bash.Annotations

module Language.Bash.Lib