System.Directory.Layout

Directory layout DSL

Describe layouts

data Layout a

Directory layout description

Instances

Monad Layout

Functor Layout

Typeable1 Layout

Applicative Layout

Foldable Layout

Traversable Layout

Eq (Layout a)

Equality check does not care about the order the files are listed insofar they are consistent, i.e. different things aren't named the same

Generic (Layout a)

Semigroup (Layout a)

Nodes

file :: String -> Layout ()

Regular file with some contents or empty

>>> let layout = file "foo"

symlink :: String -> FilePath -> Layout ()

Symbolic link

>>> let layout = symlink "foo" "bar"

dir :: String -> Layout a -> Layout ()

Directory

>>> :{
let layout = dir "foo" $ do
      file "bar"
      file "baz"
:}

dirs :: [String] -> Layout () -> Layout ()

A nested list of directories

>>> :{
let layout = dirs ["foo", "bar"] $ do
               file "qux"
               file "quux"
:}

emptydir :: String -> Layout ()

Empty directory

>>> let layout = emptydir "foo"

Nodes augmentation

contents :: Traversal' (Layout a) (Maybe Contents)

An optic into file contents

data Contents

Regular file contents

Constructors

Binary ByteString

Text Text

CopyOf FilePath

Instances

Eq Contents

Data Contents

Typeable Contents

IsString Contents

Generic Contents

binary :: ByteString -> Contents

Binary contents

>>> let layout = file "foo" & contents ?~ binary (ByteString.pack [1..10])

text :: Text -> Contents

Plain text contents

>>> let layout = file "foo" & contents ?~ text (Data.Text.pack "hello")

dedent :: QuasiQuoter

A handy quasiquoter to work with the multiline file contents

Strips the longest common leading spaces segment. All spacey characters are treated equally. The first line is ignored if it's spaces only.

>>> :{
putStr [dedent|
  hello
    world
    !
|]
:}
hello
  world
  !

dedentSubst :: QuasiQuoter

dedent with variable substitution

>>> let hello = "bye" :: String
>>> :{
putStr [dedentSubst|
  #{hello}
    world
    !
|]
:}
bye
  world
  !

copyOf :: FilePath -> Contents

Contents are the copy of whose of the real file

>>> let layout = file "foo" & contents ?~ copyOf "/home/user/.vimrc"

source :: Traversal' (Layout a) String

An optic into symbolic link source

>>> symlink "foo" "bar" ^? source
Just "bar"

exists :: Traversal' (Layout a) Bool

An optic into symbolic link source expected existence

>>> let layout = symlink "foo" "bar" & exists .~ True

data User

File owner

Constructors

UserID UserID

Username String

Instances

Eq User

Show User

Typeable User

IsString User

Generic User

user :: Traversal' (Layout a) (Maybe User)

An optic into file owner

>>> let layout = file "foo" & user ?~ uid 0

uid :: UserID -> User

Set the file owner by uid

username :: String -> User

Set the file owner by username

>>> let layout = file "foo" & user ?~ username "root"

data Group

File group

Constructors

GroupID GroupID

Groupname String

Instances

Eq Group

Show Group

Typeable Group

IsString Group

Generic Group

group :: Traversal' (Layout a) (Maybe Group)

An optic into file group

>>> let layout = file "foo" & group ?~ gid 0

gid :: GroupID -> Group

Set the file group by groupname

groupname :: String -> Group

Set the file group by groupname

>>> let layout = file "foo" & group ?~ groupname "wheel"

mode :: Traversal' (Layout a) (Maybe FileMode)

An optic into file mode

>>> let layout = file "foo" & mode ?~ 0o100777

anything :: Maybe a

Anything

>>> let layout = file "foo" & contents .~ anything
>>> let layout = file "foo" & user .~ anything

into :: String -> Traversal' (Layout ()) (Layout ())

An optic into the directory contents of the particular directory

>>> :{
dirs ["foo", "bar", "baz"] (symlink "qux" "quux")
  ^? into "foo".into "bar".into "baz".focus "qux".source
:}
Just "quux"

focus :: String -> Traversal' (Layout ()) (Layout ())

An optic into the particular node

Run layouts

module System.Directory.Layout.Interpreter