Release code as open sourceHEADmaster

33 files changed, 1806 insertions, 0 deletions

diff --git a/scaffolder/src/Text/Edifact/Scaffolder/CodedSimples/Specification.hs b/scaffolder/src/Text/Edifact/Scaffolder/CodedSimples/Specification.hs
new file mode 100644
index 0000000..967f685
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/CodedSimples/Specification.hs
@@ -0,0 +1,28 @@
+module Text.Edifact.Scaffolder.CodedSimples.Specification
+  ( -- *
+    specificationParser
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Parsec                     as P (anyChar, count, digit,
+                                                       endOfLine, manyTill,
+                                                       oneOf, skipMany, string,
+                                                       try)
+import           Text.Parsec.String              (Parser)
+
+specificationParser :: Parser (SimpleCode, SimpleName)
+specificationParser = scanUntil [ codedSimpleParser ]
+
+codedSimpleParser :: Parser (SimpleCode, SimpleName)
+codedSimpleParser = do
+  _ <- count 2 (oneOf "+*#|-X ")
+  skipMany (string " ")
+  code <- simpleCodeParser
+  _ <- string " "
+  skipMany (string " ")
+  name <- SimpleName <$> manyTill anyChar (() <$ try endOfLine)
+  pure (code, name)
+
+simpleCodeParser :: Parser SimpleCode
+simpleCodeParser = fromString <$> count 4 digit
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons.hs
new file mode 100644
index 0000000..ce960b1
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons.hs
@@ -0,0 +1,29 @@
+module Text.Edifact.Scaffolder.Commons
+  ( -- *
+    runScaffolding
+    -- * Reexports
+  , module X
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons.Formatters as X
+import           Text.Edifact.Scaffolder.Commons.Language   as X
+import           Text.Edifact.Scaffolder.Commons.Logging    as X
+import           Text.Edifact.Scaffolder.Commons.Parsing    as X
+import           Text.Edifact.Scaffolder.Commons.Text       as X
+import           Text.Edifact.Scaffolder.Commons.Types      as X
+
+import           Control.Monad.IO.Class                     as X (liftIO)
+import           Data.List.NonEmpty                         as X (NonEmpty, nub,
+                                                                  sort)
+import           Data.Maybe                                 as X (fromMaybe)
+import           Data.Semigroup                             as X ((<>))
+import           Data.String                                as X (IsString,
+                                                                  fromString)
+import           Data.Text                                  as X (Text)
+import           System.Directory                           as X (listDirectory)
+import           System.FilePath                            as X ((</>))
+
+import           Control.Monad.Reader                       (runReaderT)
+
+runScaffolding :: Scaffolding a -> ScaffoldingEnv -> IO a
+runScaffolding = runReaderT
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Formatters.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Formatters.hs
new file mode 100644
index 0000000..6f0210b
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Formatters.hs
@@ -0,0 +1,88 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Commons.Formatters
+  ( -- *
+    fMessageCode
+  , fMessageParserFunction
+  , fGroupCode
+  , fSegmentCode
+  , fSegmentParserFunction
+  , fCompositeCode
+  , fCompositeParserFunction
+  , fSimpleCode
+  , fSimpleParserFunction
+
+    -- *
+  , fParserSignature
+  , fParserDeclaration
+    -- *
+  , fModuleName
+  , fPosition
+  , fPresence
+    -- *
+  , quoted
+  , simpleQuoted
+  , parens
+  , notYetImplemented
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons.Types
+
+import           Formatting                            as F
+
+fMessageCode:: Format r (MessageCode -> r)
+fMessageCode = mapf getMessageCode F.string
+
+fMessageParserFunction :: Format r (MessageCode -> r)
+fMessageParserFunction = mapf getMessageCode ("message" % F.string)
+
+fGroupCode :: Format r (GroupCode -> r)
+fGroupCode = mapf getGroupCode F.string
+
+fSegmentCode :: Format r (SegmentCode -> r)
+fSegmentCode = mapf getSegmentCode F.string
+
+fSegmentParserFunction :: Format r (SegmentCode -> r)
+fSegmentParserFunction = mapf getSegmentCode ("segment" % F.string)
+
+fCompositeCode :: Format r (CompositeCode -> r)
+fCompositeCode = mapf getCompositeCode F.string
+
+fCompositeParserFunction :: Format r (CompositeCode -> r)
+fCompositeParserFunction = mapf getCompositeCode ("composite" % F.string)
+
+fSimpleCode :: Format r (SimpleCode -> r)
+fSimpleCode = mapf getSimpleCode F.string
+
+fSimpleParserFunction :: Format r (SimpleCode -> r)
+fSimpleParserFunction = mapf getSimpleCode ("simple" % F.string)
+
+fParserSignature :: Format r a -> Format r a
+fParserSignature f = f % " :: Parser Value"
+
+fParserDeclaration :: Format r a -> Format r a
+fParserDeclaration f = f % " ="
+
+fModuleName :: Format r (ModuleName -> r)
+fModuleName = mapf getModuleName string
+
+fPosition :: Format r (Position -> r)
+fPosition = mapf getPosition F.string
+
+fPresence :: Format r (Presence -> r)
+fPresence =
+  let f Mandatory = "mandatory"
+      f Optional  = "optional "
+  in mapf f F.string
+
+quoted :: Format r a -> Format r a
+quoted f = "\"" % f % "\""
+
+simpleQuoted :: Format r a -> Format r a
+simpleQuoted f = "'" % f % "'"
+
+parens :: Format r a -> Format r a
+parens f = "(" % f % ")"
+
+notYetImplemented :: Format r a -> Format r a
+notYetImplemented desc = "notYetImplemented " % quoted (desc % " not yet implemented")
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Language.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Language.hs
new file mode 100644
index 0000000..214ee43
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Language.hs
@@ -0,0 +1,286 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE OverloadedLists            #-}
+{-# LANGUAGE OverloadedStrings          #-}
+
+module Text.Edifact.Scaffolder.Commons.Language
+  ( -- *
+    saveHaskellModule
+  , includeSpecification
+    -- *
+  , scaffoldModule
+    -- *
+  , getRootModuleName
+  , getRootModuleNameFor
+    -- *
+  , scaffoldElements
+  , ElementWithDefinition
+    -- *
+  , parentModule
+    -- *
+  , haddockDependencies
+    -- *
+  , reexportDependencies
+    -- *
+  , importDependencies
+  , importCombinators
+  , importNotYetImplementedHelper
+    -- *
+  , moduleDeclaration
+  , Export(..)
+    -- *
+  , reexportAlias
+  , singleImport
+  , ImportGroup(..)
+  , Import(..)
+  , ImportName(..)
+  , ModuleAlias(..)
+  , LanguageExtension(..)
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons.Formatters (fModuleName,
+                                                             parens,
+                                                             simpleQuoted)
+import           Text.Edifact.Scaffolder.Commons.Logging    (say)
+import           Text.Edifact.Scaffolder.Commons.Text       (commaSeparated,
+                                                             extensions,
+                                                             formatSpecification,
+                                                             indent, newline)
+import           Text.Edifact.Scaffolder.Commons.Types      (LanguageExtension (..),
+                                                             ModuleName (..),
+                                                             Scaffolding,
+                                                             getRevision,
+                                                             hostModule,
+                                                             revision,
+                                                             targetDirectory,
+                                                             (<.>))
+
+import           Control.Monad                              ((>=>))
+import           Control.Monad.IO.Class                     (liftIO)
+import           Control.Monad.Reader                       (asks)
+import           Data.Bifunctor                             (bimap)
+import           Data.Foldable                              (traverse_)
+import           Data.List                                  (intercalate,
+                                                             uncons)
+import           Data.List.NonEmpty                         (NonEmpty, nonEmpty)
+import qualified Data.List.NonEmpty                         as NE (cons, toList)
+import           Data.List.Split                            (splitOn)
+import           Data.String                                (IsString (..))
+import           Data.Text                                  as T (Text, drop,
+                                                                  lines,
+                                                                  unlines)
+import qualified Data.Text.IO                               as TIO (readFile,
+                                                                    writeFile)
+import           Data.Tuple                                 (swap)
+import           Formatting                                 as F (Format,
+                                                                  bprint, later,
+                                                                  mapf, sformat,
+                                                                  stext, (%))
+import           System.Directory                           (createDirectoryIfMissing)
+import           System.FilePath                            ((</>))
+import           System.Process                             (callCommand)
+
+getRootModuleName :: Scaffolding ModuleName
+getRootModuleName =
+  let prefix host rev = host <.> ModuleName (getRevision rev)
+  in asks (prefix . hostModule) <*> asks revision
+
+getRootModuleNameFor :: ModuleName -> Scaffolding ModuleName
+getRootModuleNameFor name =
+  let suffix root = root <.> name
+  in suffix <$> getRootModuleName
+
+saveHaskellModule :: ModuleName -> [Text] -> Scaffolding ()
+saveHaskellModule mn body =
+  let sources = T.unlines body
+      saveModule file = liftIO (saveFile file >> stylishHaskell file)
+      saveFile = flip TIO.writeFile sources
+      stylishHaskell file = callCommand ("stylish-haskell -i " <> file)
+      doNothing = pure ()
+  in say ("module " % fModuleName) mn >> mkSourceFile mn >>= maybe doNothing saveModule
+
+mkSourceFile :: ModuleName -> Scaffolding (Maybe FilePath)
+mkSourceFile = locateSourceFile >=> traverse prepareHierarchy
+
+type FileInDirectory = (Directory, FileName)
+type Directory = FilePath
+type FileName = FilePath
+
+prepareHierarchy :: FileInDirectory -> Scaffolding FilePath
+prepareHierarchy (directory, file) =
+  let fullPath = directory </> file
+  in fullPath <$ liftIO (createDirectoryIfMissing True directory)
+
+locateSourceFile :: ModuleName -> Scaffolding (Maybe FileInDirectory)
+locateSourceFile (ModuleName mn) =
+  let hierarchy = splitOn "." mn
+      toFile n = n <> ".hs"
+      path :: Directory -> Maybe (Directory, FileName)
+      path directory = fmap toFile . swap . fmap (foldl (</>) directory . reverse) <$> uncons (reverse hierarchy)
+  in asks (path . targetDirectory)
+
+includeSpecification :: FilePath -> Scaffolding [Text]
+includeSpecification = fmap (formatSpecification . T.lines) . liftIO . TIO.readFile
+
+type ElementWithDefinition elt = (FilePath, elt)
+
+scaffoldElements :: (NonEmpty (ElementWithDefinition element) -> Scaffolding ())
+                 -> (          ElementWithDefinition element  -> Scaffolding ())
+                 -> ([         ElementWithDefinition element] -> Scaffolding ())
+scaffoldElements parentScaffolder elementScaffolder =
+  let doNothing = pure ()
+      scaffolder elts = parentScaffolder elts >> traverse_ elementScaffolder elts
+  in maybe doNothing scaffolder . nonEmpty
+
+parentModule :: ModuleName -> ModuleAlias -> (ModuleName -> element -> ModuleName) -> NonEmpty (ElementWithDefinition element) -> Scaffolding ()
+parentModule elementName alias nameModule elements =
+  getRootModuleNameFor elementName >>= generateRootModule alias nameModule (snd <$> elements)
+
+generateRootModule :: ModuleAlias -> (ModuleName -> element -> ModuleName) -> NonEmpty element -> ModuleName -> Scaffolding ()
+generateRootModule alias nameModule codes mn =
+  let importElement code = ImportAll (ImportAs (nameModule mn code) alias)
+      imports = [ ImportGroup (importElement <$> codes) ]
+      exports = [ reexportAlias alias ]
+  in saveHaskellModule mn $
+       moduleDeclaration mn exports imports
+
+haddockDependencies :: Format Text (elt -> Text) -> NonEmpty elt -> Scaffolding [Text]
+haddockDependencies formatter elts =
+  let formattedDependencies = commaSeparated . fmap (sformat (simpleQuoted formatter))
+      formatHaddock = sformat ("-- Dependencies: " % F.stext % ".")
+  in pure [ "--"
+          , formatHaddock (formattedDependencies elts)
+          ]
+
+reexportDependencies :: Format Text (elt -> Text) -> NonEmpty elt -> Scaffolding [Export]
+reexportDependencies formatter =
+  let mkReexport = Name . sformat formatter
+      prependTitle = NE.cons (Comment "* Dependencies")
+  in pure . NE.toList . prependTitle . fmap mkReexport
+
+importDependencies :: ModuleName -> Format Text (elt -> Text) -> NonEmpty elt -> Scaffolding Import
+importDependencies moduleName formatter elts =
+  let imports = NE.toList (sformat formatter <$> elts)
+      mkImport mn = Import (BasicImport mn) imports
+  in mkImport <$> getRootModuleNameFor moduleName
+
+importCombinators :: ImportGroup
+importCombinators =
+  ImportGroup
+    [ ImportAll "Text.Edifact.Parsing"
+    , Import    "Text.Edifact.Types"   [ "Value" ]
+    ]
+
+importNotYetImplementedHelper :: ImportGroup
+importNotYetImplementedHelper =
+  ImportGroup
+    [ Import "Text.Edifact.Parsing.Commons" [ "notYetImplemented" ]
+    ]
+
+moduleDeclaration :: ModuleName -> [Export] -> [ImportGroup] -> [Text]
+moduleDeclaration moduleName exports imports =
+  let decl mn [] = [sformat ("module " % fModuleName % " where") mn]
+      decl mn ex = sformat ("module " % fModuleName) mn
+                 : renderExports ex
+  in intercalate newline [ decl moduleName exports
+                         , renderImports imports
+                         ]
+
+machineGeneratedWarning :: [Text]
+machineGeneratedWarning =
+  [ "---- Machine generated code."
+  , "---- Output of edi-parser-scaffolder"
+  ]
+
+scaffoldModule :: ModuleName -> [LanguageExtension] -> [Export] -> [ImportGroup] -> [Text] -> Scaffolding ()
+scaffoldModule mn exts exports imports code =
+  saveHaskellModule mn $
+    intercalate newline
+      [ extensions exts
+      , machineGeneratedWarning
+      , moduleDeclaration mn exports imports
+      , code
+      ]
+
+renderExports :: [Export] -> [Text]
+renderExports exports =
+  let formatExport (First e)     = sformat ("  " % fExport) e
+      formatExport (Following e) = sformat (", " % fExport) e
+      formatExport (Skipped e)   = sformat ("  " % fExport) e
+      fExport =
+        let f (Comment t) = bprint ("-- " % stext) t
+            f (Name    t) = bprint stext t
+        in later f
+      parensOnFirstLine [] = []
+      parensOnFirstLine (firstLine : rest) = ("(" <> T.drop 1 firstLine) : rest
+      ls = parensOnFirstLine (formatExport <$> tag exports) <> [ ") where" ]
+  in indent <$> ls
+
+data Export = Name    Text
+            | Comment Text
+
+instance IsString Export where
+  fromString = Name . fromString
+
+data Tag a = First     a
+           | Following a
+           | Skipped   a
+
+tag :: [Export] -> [Tag Export]
+tag =
+  let skipAll = fmap Skipped
+      tagFirst []             = []
+      tagFirst (elt : others) = First elt : tagOthers others
+      tagOthers = fmap tagOther
+      tagOther v | isComment v = Skipped v
+                 | otherwise   = Following v
+      merge (xs, ys) = xs <> ys
+  in merge . bimap skipAll tagFirst . span isComment
+
+isComment :: Export -> Bool
+isComment (Comment _) = True
+isComment _           = False
+
+newtype ModuleAlias = ModuleAlias { getModuleAlias :: Text } deriving newtype (IsString)
+
+singleImport :: Import -> ImportGroup
+singleImport = ImportGroup . pure
+
+newtype ImportGroup = ImportGroup (NonEmpty Import) deriving newtype Semigroup
+
+data Import = Import    ImportName [Text]
+            | ImportAll ImportName
+
+data ImportName = BasicImport       ModuleName
+                | ImportAs          ModuleName ModuleAlias
+                | ImportQualified   ModuleName
+                | ImportQualifiedAs ModuleName ModuleAlias
+
+instance IsString ImportName where
+  fromString = BasicImport . fromString
+
+renderImports :: [ImportGroup] -> [Text]
+renderImports = intercalate newline . fmap renderImportGroup
+
+reexportAlias :: ModuleAlias -> Export
+reexportAlias = Name . sformat ("module " % fModuleAlias)
+
+renderImportGroup :: ImportGroup -> [Text]
+renderImportGroup (ImportGroup imports) = NE.toList (renderImport <$> imports)
+
+renderImport :: Import -> Text
+renderImport (ImportAll name)            = sformat fImportName name
+renderImport (Import    name references) =
+  sformat (fImportName % " " % parens stext) name (commaSeparated references)
+
+fImportName :: Format r (ImportName -> r)
+fImportName =
+  let
+      build (BasicImport       name)       = bprint ("import " % fModuleName) name
+      build (ImportAs          name alias) = bprint ("import " % fModuleName % " as " % fModuleAlias) name alias
+      build (ImportQualified   name)       = bprint ("import qualified " % fModuleName) name
+      build (ImportQualifiedAs name alias) = bprint ("import qualified " % fModuleName % " as " % fModuleAlias) name alias
+  in later build
+
+fModuleAlias :: Format r (ModuleAlias -> r)
+fModuleAlias = mapf getModuleAlias stext
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Logging.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Logging.hs
new file mode 100644
index 0000000..1287f7f
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Logging.hs
@@ -0,0 +1,11 @@
+module Text.Edifact.Scaffolder.Commons.Logging
+  ( say
+  ) where
+
+import           Control.Monad.IO.Class (MonadIO, liftIO)
+import qualified Data.Text.Lazy.Builder as TLB (toLazyText)
+import qualified Data.Text.Lazy.IO      as TLIO (putStrLn)
+import           Formatting             as F (Format, runFormat)
+
+say :: MonadIO m => Format (m ()) a -> a
+say m = runFormat m (liftIO . TLIO.putStrLn . TLB.toLazyText)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Parsing.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Parsing.hs
new file mode 100644
index 0000000..24f8f80
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Parsing.hs
@@ -0,0 +1,122 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TupleSections    #-}
+
+module Text.Edifact.Scaffolder.Commons.Parsing
+  ( -- *
+    maybeParse
+  , skipBeginning
+  , single
+  , silent
+    -- *
+  , listElements
+    -- *
+  , presenceParser
+  , stringToPresenceParser
+    -- *
+  , messageCodeParser
+    -- *
+  , scanDependencies
+  , scan
+  , scanUntil
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons.Logging (say)
+import           Text.Edifact.Scaffolder.Commons.Types
+
+import           Control.Monad.IO.Class                  (liftIO)
+import           Control.Monad.Identity                  (Identity)
+import           Control.Monad.Reader                    (asks, local)
+import           Data.Bifunctor                          (first)
+import           Data.List                               (sort)
+import           Data.List.NonEmpty                      (NonEmpty, nonEmpty)
+import           Data.Maybe                              (catMaybes)
+import           Data.String                             (fromString)
+import           Data.Text                               (Text)
+import           Formatting                              as F (shown)
+import           System.Directory                        (listDirectory)
+import           System.FilePath                         ((</>))
+import           Text.Parsec                             (Parsec, SourceName,
+                                                          Stream, anyChar, char,
+                                                          choice, count,
+                                                          endOfLine, eof,
+                                                          lookAhead, many,
+                                                          many1, manyTill,
+                                                          oneOf, optionMaybe,
+                                                          runParser, string,
+                                                          try, upper, (<?>))
+
+maybeParse :: (Show a, Stream s Identity t, Monoid u) => SourceName -> Parsec s u a -> s -> Scaffolding (Maybe a)
+maybeParse source parser input =
+  let interpretParsingResult (Right v) _     = pure (Just v)
+      interpretParsingResult e         True  = Nothing <$ say shown e
+      interpretParsingResult _         False = pure Nothing
+      shouldDebug = asks debugParsing
+  in shouldDebug >>= interpretParsingResult (runParser parser mempty source input)
+
+-- | Disable parsing error logging locally
+silent :: Scaffolding a -> Scaffolding a
+silent = local disableDebugging
+
+-- | Let you traverse a directory and filter files matching a parser.
+-- The filename is then paired with the matched value
+listElements :: (Show elt, Ord elt) => FilePath -> Parsec String () elt -> Scaffolding [(FilePath, elt)]
+listElements subpath parser = do
+  home <- getSpecificationHome
+  let directory = home </> subpath
+  files <- sort <$> liftIO (listDirectory directory)
+  let prependDirectory f = directory </> f
+  fmap (first prependDirectory) . catMaybes <$> traverse (extractElement parser) files
+
+getSpecificationHome :: Scaffolding FilePath
+getSpecificationHome =
+  let concatenate path (Revision rev) = path </> rev
+  in asks (concatenate . specificationsHome) <*> asks revision
+
+extractElement :: Show elt => Parsec String () elt -> FilePath -> Scaffolding (Maybe (FilePath, elt))
+extractElement parser path = silent (fmap (path,) <$> maybeParse path parser path)
+
+skipBeginning :: Stream s Identity Char => Parsec s () a -> Parsec s () a
+skipBeginning p = manyTill anyChar (try (lookAhead p)) *> p
+
+single :: Stream s Identity Char => Parsec s u a -> Parsec s u [a]
+single = count 1
+
+presenceParser :: Stream s Identity Char => Parsec s u Presence
+presenceParser =
+  choice [ Mandatory <$ char 'M'
+         , Optional  <$ char 'C'
+         ] <?> "Presence"
+
+stringToPresenceParser :: Stream s Identity Char => Parsec s u Text
+stringToPresenceParser = fromString <$>
+        manyTill anyChar (try $ lookAhead $ many1 (string " ") >> presenceParser >> string " " >> many (oneOf " 0123456789"))
+        <?> "Description"
+
+messageCodeParser :: Stream s Identity Char => Parsec s u MessageCode
+messageCodeParser = fromString <$> count 6 upper
+
+scanDependencies :: (Monoid u, Show result) => FilePath -> Parsec String u [result] -> Scaffolding (Maybe (NonEmpty result))
+scanDependencies file parser =
+  let readLines = liftIO (readFile file)
+  in readLines >>= fmap (nonEmpty =<<) . maybeParse file parser
+
+scan :: Stream s Identity Char => [Parsec s u [a]] -> Parsec s u [a]
+scan scanners =
+  let parsers = (scanLine <$> scanners) <> [skipLine]
+      end = choice [ () <$ try endOfLine
+                   , () <$ eof
+                   ]
+      scanLine p = optionMaybe (try p) <* end
+      skipLine = Nothing <$ manyTill anyChar end
+  in concat . catMaybes <$> manyTill (choice parsers) eof
+
+scanUntil :: Stream s Identity Char => [Parsec s u a] -> Parsec s u a
+scanUntil scanners =
+  let parsers = scanLine <$> scanners
+      end = choice [ () <$ try endOfLine
+                   , () <$ eof
+                   ]
+      searching = choice $ fmap (() <$) parsers <> [ () <$ eof ]
+      scanLine p = p <* end
+      skipLine = manyTill anyChar end
+  in manyTill skipLine (try $ lookAhead searching) >> try (choice parsers)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Text.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Text.hs
new file mode 100644
index 0000000..ef4e805
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Text.hs
@@ -0,0 +1,91 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE OverloadedStrings          #-}
+
+module Text.Edifact.Scaffolder.Commons.Text
+  ( -- *
+    indent
+  , quote
+  , haskellList
+  , commaSeparated
+    -- *
+  , newline
+    -- *
+  , formatSpecification
+    -- *
+  , extensions
+  ) where
+
+
+import           Text.Edifact.Scaffolder.Commons.Types (LanguageExtension (..))
+
+import           Control.Category                      ((>>>))
+import           Data.Char                             (isSpace)
+import           Data.List                             (dropWhileEnd)
+import           Data.String                           (IsString)
+import           Data.Text                             (Text)
+import qualified Data.Text                             as T (all, dropWhileEnd,
+                                                             null)
+import           Formatting                            as F (mapf, sformat,
+                                                             stext, string, (%))
+
+formatSpecification :: [Text] -> [Text]
+formatSpecification = cleanEmptyLines
+                  >>> fmap quoteLine
+                  >>> prependQuote
+
+prependQuote :: [Text] -> [Text]
+prependQuote ls =
+  [ "-- | Derived from this specification:"
+  , "--"
+  ] <> ls
+
+cleanEmptyLines :: [Text] -> [Text]
+cleanEmptyLines = dropWhile blank >>> dropWhileEnd blank
+
+blank :: Text -> Bool
+blank t = T.null t || T.all isSpace t
+
+quoteLine :: Text -> Text
+quoteLine = haskellQuote >>> cleanWhitespaces
+
+haskellQuote :: Text -> Text
+haskellQuote line = "-- > " <> line
+
+cleanWhitespaces :: Text -> Text
+cleanWhitespaces = T.dropWhileEnd (== ' ')
+
+indent :: Text -> Text
+indent t = "  " <> t
+
+quote :: Text -> Text
+quote t = "'" <> t <> "'"
+
+haskellList :: [Text] -> [Text]
+haskellList =
+  let prefix :: Int -> Text -> Text
+      prefix 1 dep = sformat ("[ " % F.stext) dep
+      prefix _ dep = sformat (", " % F.stext) dep
+      suffix deps = deps <> ["]"]
+  in suffix . zipWith prefix [1..]
+
+newtype CommaSeparated = CommaSeparated { getCommaSeparated :: Text } deriving newtype (IsString, Eq)
+
+instance Semigroup CommaSeparated where
+  t1 <> "" = t1
+  "" <> t2 = t2
+  t1 <> t2 = CommaSeparated (getCommaSeparated t1 <> ", " <> getCommaSeparated t2)
+
+instance Monoid CommaSeparated where
+  mempty = ""
+
+commaSeparated :: Foldable f => f Text -> Text
+commaSeparated = getCommaSeparated . foldMap CommaSeparated
+
+newline :: [Text]
+newline = [""]
+
+extensions :: [LanguageExtension] -> [Text]
+extensions =
+  let fExtension = "{-# LANGUAGE " % mapf getLanguageExtension F.string % " #-}"
+  in fmap (sformat fExtension)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Commons/Types.hs b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Types.hs
new file mode 100644
index 0000000..4d1c0a6
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Commons/Types.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Text.Edifact.Scaffolder.Commons.Types
+  ( -- * Codes of elements
+    MessageCode(..)
+  , GroupCode(..)
+  , SegmentCode(..)
+  , SegmentName(..)
+  , CompositeCode (..)
+  , CompositeName (..)
+  , SimpleCode(..)
+  , SimpleName(..)
+    -- * Ordering of elements
+  , Position(..)
+    -- * Attributes
+  , Presence(..)
+    -- *
+  , ModuleName(..)
+  , (<.>)
+    -- *
+  , LanguageExtension(..)
+    -- *
+  , Scaffolding
+  , Revision(..)
+  , ScaffoldingEnv(..)
+  , disableDebugging
+  ) where
+
+import           Control.Monad.Reader (ReaderT)
+import           Data.String          (IsString)
+
+newtype MessageCode   = MessageCode   { getMessageCode   :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype GroupCode     = GroupCode     { getGroupCode     :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype SegmentCode   = SegmentCode   { getSegmentCode   :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype SegmentName   = SegmentName   { getSegmentName   :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype CompositeCode = CompositeCode { getCompositeCode :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype CompositeName = CompositeName { getCompositeName :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype SimpleCode    = SimpleCode    { getSimpleCode    :: String } deriving newtype (Show, Eq, Ord, IsString)
+newtype SimpleName    = SimpleName    { getSimpleName    :: String } deriving newtype (Show, Eq, Ord, IsString)
+
+newtype Position = Position { getPosition :: String } deriving newtype (Show, Eq, Ord, IsString)
+
+data Presence = Mandatory
+              | Optional
+                deriving (Show, Eq, Ord)
+
+newtype ModuleName = ModuleName { getModuleName :: String } deriving newtype (Show, Eq, IsString)
+
+instance Semigroup ModuleName where
+  (<>) = (<.>)
+
+(<.>) :: ModuleName -> ModuleName -> ModuleName
+(ModuleName parent) <.> (ModuleName child) = ModuleName (parent <> "." <> child)
+
+newtype LanguageExtension = LanguageExtension { getLanguageExtension :: String } deriving newtype IsString
+
+type Scaffolding = ReaderT ScaffoldingEnv IO
+
+newtype Revision = Revision { getRevision :: String } deriving newtype (Show, Eq, IsString)
+
+data ScaffoldingEnv =
+  ScaffoldingEnv
+    { revision           :: Revision
+    , hostModule         :: ModuleName
+    , specificationsHome :: FilePath
+    , targetDirectory    :: FilePath
+    , debugParsing       :: Bool
+    }
+
+disableDebugging :: ScaffoldingEnv -> ScaffoldingEnv
+disableDebugging env = env { debugParsing = False }
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites.hs
new file mode 100644
index 0000000..07ef32a
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites.hs
@@ -0,0 +1,53 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Composites
+  ( composites
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Edifact.Scaffolder.Composites.Dependencies
+import           Text.Edifact.Scaffolder.Composites.Elements
+import           Text.Edifact.Scaffolder.Composites.Implementation
+import           Text.Edifact.Scaffolder.Composites.Specification
+import           Text.Edifact.Scaffolder.Composites.Types
+
+import           Formatting
+
+composites :: Scaffolding ()
+composites = listComposites >>= scaffoldElements parentCompositeModule compositeModule
+
+parentCompositeModule :: NonEmpty (ElementWithDefinition CompositeCode) -> Scaffolding ()
+parentCompositeModule = parentModule "Composites" "C" compositeModuleName
+
+compositeModuleName :: ModuleName -> CompositeCode -> ModuleName
+compositeModuleName mn code = mn <.> fromString (getCompositeCode code)
+
+compositeModule :: ElementWithDefinition CompositeCode -> Scaffolding ()
+compositeModule (inputFile, code) = do
+  moduleName <- getRootModuleNameFor (compositeModuleName "Composites" code)
+  dependencies <- scanDependencies inputFile (snd <$> specificationParser)
+  specification <- includeSpecification inputFile
+  let parserFunction = fCompositeParserFunction
+      fDescription = "Composite " % fCompositeCode
+      parserNotYetImplemented = sformat (notYetImplemented fDescription) code
+      defaultImplementation = haskellList [ parserNotYetImplemented ]
+      elements = sort . nub . fmap dependencyElement <$> dependencies
+      implementation = maybe defaultImplementation toImplementation dependencies
+      buildDependencies b = fromMaybe [] <$> traverse b elements
+  dependenciesReexports <- buildDependencies mkDependenciesReexports
+  dependenciesImports   <- buildDependencies mkDependenciesImports
+  dependenciesHaddock   <- buildDependencies mkDependenciesHaddock
+  let exports = Comment "* Definition"
+              : Name (sformat parserFunction code)
+              : dependenciesReexports
+      imports = dependenciesImports
+             <> [ importCombinators ]
+             <> maybe [ importNotYetImplementedHelper ] (const []) dependencies
+      documentation = specification <> dependenciesHaddock
+      signature = sformat (fParserSignature parserFunction) code
+      definition = [ sformat (fParserDeclaration parserFunction) code
+                   , indent (sformat ("composite " % quoted fCompositeCode) code)
+                   ] <> (indent . indent <$> implementation)
+      parser = signature : definition
+  scaffoldModule moduleName ["OverloadedStrings"] exports imports (documentation <> parser)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites/Dependencies.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Dependencies.hs
new file mode 100644
index 0000000..51d45bf
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Dependencies.hs
@@ -0,0 +1,20 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Composites.Dependencies
+  ( -- *
+    mkDependenciesHaddock
+  , mkDependenciesImports
+  , mkDependenciesReexports
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Composites.Types
+
+mkDependenciesReexports :: NonEmpty Element -> Scaffolding [Export]
+mkDependenciesReexports = reexportDependencies fElement
+
+mkDependenciesImports :: NonEmpty Element -> Scaffolding [ImportGroup]
+mkDependenciesImports = fmap (pure . singleImport) . importDependencies "Simples" fElement
+
+mkDependenciesHaddock :: NonEmpty Element -> Scaffolding [Text]
+mkDependenciesHaddock = haddockDependencies fElement
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites/Elements.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Elements.hs
new file mode 100644
index 0000000..acfcbdb
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Elements.hs
@@ -0,0 +1,20 @@
+module Text.Edifact.Scaffolder.Composites.Elements
+  ( listComposites
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Data.Char                       (toUpper)
+import           Text.Parsec                     (count, digit, eof, oneOf,
+                                                  string)
+import           Text.Parsec.String              (Parser)
+
+listComposites :: Scaffolding [ElementWithDefinition CompositeCode]
+listComposites = listElements "composites" compositeCodeParser
+
+compositeCodeParser :: Parser CompositeCode
+compositeCodeParser = do
+  initial <- toUpper <$> oneOf "ce"
+  rest <- count 3 digit
+  _ <- string ".txt"
+  CompositeCode (initial : rest) <$ eof
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites/Implementation.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Implementation.hs
new file mode 100644
index 0000000..0f3e939
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Implementation.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Composites.Implementation
+  ( -- *
+    toImplementation
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Composites.Types
+
+import           Data.List.NonEmpty                       as NE (toList)
+import           Formatting
+
+toImplementation :: NonEmpty Dependency -> [Text]
+toImplementation = haskellList . fmap callDependency . NE.toList
+
+callDependency :: Dependency -> Text
+callDependency (Dependency pos element presence) =
+  sformat (quoted fPosition % " .@ " % fPresence % " " % fElement) pos presence element
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites/Specification.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Specification.hs
new file mode 100644
index 0000000..0bb749d
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Specification.hs
@@ -0,0 +1,69 @@
+module Text.Edifact.Scaffolder.Composites.Specification
+  ( -- *
+    specificationParser
+  , listSimples
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Composites.Types
+
+import           Text.Parsec                              as P (anyChar, count,
+                                                                digit,
+                                                                endOfLine, many,
+                                                                many1, manyTill,
+                                                                oneOf, skipMany,
+                                                                string, try,
+                                                                (<?>))
+import           Text.Parsec.String                       (Parser)
+
+specificationParser :: Parser ((CompositeCode, CompositeName), [Dependency])
+specificationParser = do
+  compositeInfo <- scanUntil [ compositeParser ]
+  dependencies <- scan [ inLine dependencyParser ] <?> "Composites specification"
+  pure (compositeInfo, dependencies)
+
+listSimples :: Parser (CompositeCode, [SimpleCode])
+listSimples = do
+  parsed <- specificationParser
+  pure (fst $ fst parsed, getElementSimpleCode . dependencyElement <$> snd parsed)
+
+compositeParser :: Parser (CompositeCode, CompositeName)
+compositeParser = do
+  _ <- count 6 (oneOf "+*#|X ")
+  skipMany (string " ")
+  code <- compositeCodeParser
+  _ <- string " "
+  name <- CompositeName <$> manyTill anyChar (() <$ try endOfLine)
+  pure (code, name)
+
+compositeCodeParser :: Parser CompositeCode
+compositeCodeParser = do
+  initial <- oneOf "CE"
+  rest <- count 3 digit
+  pure (fromString (initial : rest))
+
+dependencyParser :: Parser Dependency
+dependencyParser =
+  Dependency <$> positionParser
+             <*  many1 (oneOf "+*#|-X ")
+             <*> elementParser
+             <*  stringToPresenceParser
+             <*  many1 (string " ")
+             <*> presenceParser
+             <?> "Dependency"
+
+inLine :: Parser a -> Parser [a]
+inLine p = single (many (string " ") *> p <* filler)
+
+filler :: Parser ()
+filler = () <$ many (oneOf "an.0123456789 ")
+
+positionParser :: Parser Position
+positionParser =
+  fromString <$> count 3 digit
+             <?> "Position"
+
+elementParser :: Parser Element
+elementParser =
+  fromString <$> count 4 digit
+             <?> "Element"
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Composites/Types.hs b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Types.hs
new file mode 100644
index 0000000..c7a676f
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Composites/Types.hs
@@ -0,0 +1,18 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Text.Edifact.Scaffolder.Composites.Types where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Formatting
+
+data Dependency = Dependency { dependencyPosition :: Position
+                             , dependencyElement  :: Element
+                             , dependencyPresence :: Presence
+                             } deriving Show
+
+newtype Element = Simple { getElementSimpleCode :: SimpleCode } deriving newtype (Show, Eq, Ord, IsString)
+
+fElement :: Format r (Element -> r)
+fElement = mapf getElementSimpleCode fSimpleParserFunction
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages.hs
new file mode 100644
index 0000000..8919a82
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages.hs
@@ -0,0 +1,54 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Messages
+  ( messages
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Edifact.Scaffolder.Messages.Dependencies
+import           Text.Edifact.Scaffolder.Messages.Elements
+import           Text.Edifact.Scaffolder.Messages.Implementation
+import           Text.Edifact.Scaffolder.Messages.Specification
+import           Text.Edifact.Scaffolder.Messages.Types
+
+import           Formatting
+
+messages :: Scaffolding ()
+messages = listMessages >>= scaffoldElements parentMessageModule messageModule
+
+parentMessageModule :: NonEmpty (ElementWithDefinition MessageCode) -> Scaffolding ()
+parentMessageModule = parentModule "Messages" "M" messageModuleName
+
+messageModuleName :: ModuleName -> MessageCode -> ModuleName
+messageModuleName mn code = mn <.> fromString (getMessageCode code)
+
+messageModule :: ElementWithDefinition MessageCode -> Scaffolding ()
+messageModule (inputFile, code) = do
+  moduleName <- getRootModuleNameFor (messageModuleName "Messages" code)
+  dependencies <- scanDependencies inputFile specificationParser
+  specification <- includeSpecification inputFile
+  let parserFunction = fMessageParserFunction
+      fDescription = "Message " % fMessageCode
+      parserNotYetImplemented = sformat (notYetImplemented fDescription) code
+      defaultImplementation = haskellList [ parserNotYetImplemented ]
+      elements = sort . nub . fmap getElement <$> dependencies
+      implementation = maybe defaultImplementation (toImplementation code) dependencies
+      buildDependencies b = fromMaybe [] <$> traverse b elements
+  dependenciesReexports <- buildDependencies mkDependenciesReexports
+  dependenciesImports   <- buildDependencies mkDependenciesImports
+  dependenciesHaddock   <- buildDependencies mkDependenciesHaddock
+  let exports = Comment "* Definition"
+              : Name (sformat parserFunction code)
+              : dependenciesReexports
+      segmentImport = singleImport (ImportAll "Text.Edifact.Common.Segments")
+      imports = maybe importNotYetImplementedHelper (const segmentImport) dependencies
+              : dependenciesImports
+             <> [ importCombinators ]
+      documentation = specification <> dependenciesHaddock
+      signature = sformat (fParserSignature parserFunction) code
+      definition = [ sformat (fParserDeclaration parserFunction) code
+                   , indent (sformat ("message " % quoted fMessageCode) code)
+                   ] <> (indent . indent <$> implementation)
+      parser = signature : definition
+  scaffoldModule moduleName ["OverloadedStrings"] exports imports (documentation <> parser)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages/Dependencies.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Dependencies.hs
new file mode 100644
index 0000000..fbcc56b
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Dependencies.hs
@@ -0,0 +1,47 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Messages.Dependencies
+  ( -- *
+    mkDependenciesHaddock
+  , mkDependenciesImports
+  , mkDependenciesReexports
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Messages.Types
+
+import           Control.Monad                          ((>=>))
+import           Data.List                              (isPrefixOf)
+import           Data.List.NonEmpty                     as NE (nonEmpty, toList)
+import           Data.Maybe                             (mapMaybe)
+
+unlessIsCommon :: SegmentCode -> Maybe SegmentCode
+unlessIsCommon sc@(SegmentCode code) | "U" `isPrefixOf` code = Nothing
+                                     | otherwise             = Just sc
+
+mkDependenciesReexports :: NonEmpty Element -> Scaffolding [Export]
+mkDependenciesReexports = mkSegmentDependencies mkSegmentDependenciesReexports
+
+mkSegmentDependenciesReexports :: NonEmpty SegmentCode -> Scaffolding [Export]
+mkSegmentDependenciesReexports = reexportDependencies fSegmentParserFunction
+
+mkDependenciesImports :: NonEmpty Element -> Scaffolding [ImportGroup]
+mkDependenciesImports = mkSegmentDependencies mkSegmentDependenciesImports
+
+mkSegmentDependencies :: (NonEmpty SegmentCode -> Scaffolding [output])
+                      -> (NonEmpty Element     -> Scaffolding [output])
+mkSegmentDependencies mk = maybe (pure []) mk . filterSegmentDependencies
+
+filterSegmentDependencies :: NonEmpty Element -> Maybe (NonEmpty SegmentCode)
+filterSegmentDependencies =
+  fmap nub . nonEmpty . mapMaybe (getSegment >=> unlessIsCommon) . NE.toList
+
+mkSegmentDependenciesImports :: NonEmpty SegmentCode -> Scaffolding [ImportGroup]
+mkSegmentDependenciesImports =
+  fmap (pure . singleImport) . importDependencies "Segments" fSegmentParserFunction
+
+mkDependenciesHaddock :: NonEmpty Element -> Scaffolding [Text]
+mkDependenciesHaddock = mkSegmentDependencies mkSegmentDependenciesHaddock
+
+mkSegmentDependenciesHaddock :: NonEmpty SegmentCode -> Scaffolding [Text]
+mkSegmentDependenciesHaddock = haddockDependencies fSegmentParserFunction
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages/Elements.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Elements.hs
new file mode 100644
index 0000000..fb590ad
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Elements.hs
@@ -0,0 +1,22 @@
+module Text.Edifact.Scaffolder.Messages.Elements
+  ( listMessages
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Data.Char                       (toUpper)
+import           Text.Parsec                     (count, eof, lower, string,
+                                                  (<?>))
+import           Text.Parsec.String              (Parser)
+
+-- | List elements
+listMessages :: Scaffolding [ElementWithDefinition MessageCode]
+listMessages = listElements "messages" messageFilenameParser
+
+messageFilenameParser :: Parser MessageCode
+messageFilenameParser =
+  let mkCode = MessageCode . fmap toUpper
+  in mkCode <$> count 6 lower
+            <*  string "_s.txt"
+            <*  eof
+            <?> "MessageCode"
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages/Implementation.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Implementation.hs
new file mode 100644
index 0000000..121aa45
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Implementation.hs
@@ -0,0 +1,114 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Messages.Implementation
+  ( -- *
+    toImplementation
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Messages.Types
+
+import           Control.Monad.State.Strict             (State, evalState, gets,
+                                                         modify)
+import           Data.List.NonEmpty                     as NE (NonEmpty (..),
+                                                               fromList, head,
+                                                               toList, (<|))
+import           Formatting
+
+toImplementation :: MessageCode -> NonEmpty Dependency -> [Text]
+toImplementation _ =
+  let closeList deps = deps <> [ "]" ]
+  in closeList . render . fmap concat . traverse callDependency . NE.toList
+
+render :: Rendering a -> a
+render r =
+  let initialState = RenderingContext 0 0 :| []
+  in evalState r initialState
+
+type Trail = NonEmpty
+
+data RenderingContext = RenderingContext { listPosition :: Int
+                                         , indentLevel  :: Int
+                                         }
+
+type Rendering = State (Trail RenderingContext)
+
+callDependency :: Dependency -> Rendering [Text]
+callDependency (Dependency element) = renderElement element
+
+increment :: Rendering ()
+increment =
+  let mapHead f (v :| t)  = f v :| t
+  in modify (mapHead (\ ctx -> ctx { listPosition = listPosition ctx + 1 }))
+
+pushIndent :: Rendering ()
+pushIndent =
+  let indentState t@(previous :| _) = RenderingContext 0 (indentLevel previous + 2) <| t
+  in modify indentState
+
+popIndent :: Rendering ()
+popIndent =
+  let pop (_ :| []) = error "Incoherent state: can't unindent anymore (this shouldn't happen)"
+      pop (_ :| up) = NE.fromList up
+  in modify pop
+
+getCurrentIndex :: Rendering Int
+getCurrentIndex = gets (listPosition . NE.head)
+
+getCurrentIndentation :: Rendering Int
+getCurrentIndentation = gets (indentLevel . NE.head)
+
+renderElement :: Element -> Rendering [Text]
+renderElement (Segment code positional) =
+  let output index indentation =
+        [ sformat (fIndentation % fIndex % " " % fPositional % " " % fSegmentParserFunction) indentation index positional code
+        ]
+  in output <$> getCurrentIndex
+            <*> getCurrentIndentation
+            <*  increment
+renderElement (GroupStart code positional) =
+  let output index indentation =
+        [ sformat (fIndentation % fIndex % " " % fPositional % " (") indentation index positional
+        , sformat (fIndentation % fSegmentGroupFunction) (indentation + 1) code
+        ]
+  in output <$> getCurrentIndex
+            <*> getCurrentIndentation
+            <*  increment
+            <*  pushIndent
+renderElement (GroupEnd _) =
+  let output indentation =
+        [ sformat (fIndentation % "]") indentation
+        , sformat (fIndentation % ")") (indentation - 1)
+        ]
+  in output <$> getCurrentIndentation
+            <*  popIndent
+
+fIndentation :: Format r (Int -> r)
+fIndentation =
+  let buildIndentation n = fromString (replicate (n * 2) ' ')
+  in later buildIndentation
+
+fIndex :: Format r (Int -> r)
+fIndex =
+  let buildIndex 0 = "["
+      buildIndex _ = ","
+  in later buildIndex
+
+fPositional :: Format r (Positional -> r)
+fPositional =
+  let buildPositional (Positional p r) = bprint (quoted fPosition % " .@ " % fRepetition) p r
+  in later buildPositional
+
+fSegmentGroupFunction :: Format r (GroupCode -> r)
+fSegmentGroupFunction = "segmentGroup " % quoted fGroupCode
+
+fRepetition :: Format r (Repetition -> r)
+fRepetition =
+  let buildRepetition (Repetition Mandatory 1) = bprint  "once"
+      buildRepetition (Repetition Optional  1) = bprint  "maybeOnce"
+      buildRepetition (Repetition Mandatory c) = bprint ("repeatedAtLeastOnce" % " " % fCardinality) c
+      buildRepetition (Repetition Optional  c) = bprint ("repeated" % " " % fCardinality) c
+  in later buildRepetition
+
+fCardinality :: Format r (Cardinality -> r)
+fCardinality = mapf getCardinality int
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages/Specification.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Specification.hs
new file mode 100644
index 0000000..b1e5c2a
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Specification.hs
@@ -0,0 +1,129 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Text.Edifact.Scaffolder.Messages.Specification
+  ( -- *
+    specificationParser
+  , messageNameParser
+  , listSegments
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Messages.Types
+
+import           Data.Maybe                             (mapMaybe)
+import           Text.Parsec
+
+type Parser = Parsec String GroupTrail
+
+newtype GroupTrail = GroupTrail [GroupCode]
+  deriving stock Show
+  deriving newtype (Semigroup, Monoid)
+
+messageNameParser :: Parser MessageCode
+messageNameParser = scanUntil [
+    manyTill anyChar (string "Message Type : ") >> MessageCode <$> count 6 upper
+  ]
+
+specificationParser :: Parser [Dependency]
+specificationParser =
+  let scanElements = scan [ segmentInLine segmentElementParser
+                          , groupInLine   groupStartElementParser
+                          ]
+  in interpretDependencies <$> scanElements <?> "Messages specification"
+
+listSegments :: Parser [SegmentCode]
+listSegments = mapMaybe (getSegment . getElement) <$> specificationParser
+
+interpretDependencies :: [Element] -> [Dependency]
+interpretDependencies = fmap Dependency
+
+groupInLine :: Parser a -> Parser [a]
+groupInLine p = single (many (string " ") *> p <* countClosingGroups)
+
+countClosingGroups :: Parser Int
+countClosingGroups =
+  let parser = many1 (char '-')
+            *> many1 (char '+')
+           <*  many  (char '|')
+  in length <$> parser
+
+closingGroupTrail :: Parser [Element]
+closingGroupTrail =
+  let groupEndParser = GroupEnd <$> popFromTrail
+  in countClosingGroups >>= flip count groupEndParser
+
+groupStartElementParser :: Parser Element
+groupStartElementParser =
+  let parseStart pos code rep = GroupStart code (Positional pos rep)
+  in parseStart <$> positionParser
+                <*  many1 (choice [ () <$ try (oneOf "+*#|X "), () <$ try (string "- ") ])
+                <*> groupCodeParser
+                <*  many1 (char ' ')
+                <*> repetitionParser
+                <?> "GroupElement"
+
+groupCodeParser :: Parser GroupCode
+groupCodeParser =
+  let parser = manyTill (char '-') (try $ string "-- Segment group")
+            *> many1 (char ' ')
+            *> many1 digit
+           <*  many1 space
+           <*  many1 (char '-')
+      group = GroupCode <$> parser
+  in group >>= appendToTrail <?> "GroupCodeParser"
+
+appendToTrail :: GroupCode -> Parser GroupCode
+appendToTrail code =
+  let append (GroupTrail trail) = GroupTrail (code : trail)
+  in code <$ modifyState append
+
+popFromTrail :: Parser GroupCode
+popFromTrail = do
+  previous <- getState
+  case previous of
+    GroupTrail (current : trail) -> current <$ putState (GroupTrail trail)
+    GroupTrail []                -> unexpected "GroupEnd, when state is currently clear"
+
+segmentTrail :: Parser [a]
+segmentTrail = [] <$ (many1 (char ' ') <* many (char '|'))
+
+segmentInLine :: Parser Element -> Parser [Element]
+segmentInLine p = do
+  segment <- many (string " ") *> p
+  trail <- choice [ try closingGroupTrail
+                  , try segmentTrail
+                  ]
+  pure (segment : trail)
+
+repetitionParser :: Parser Repetition
+repetitionParser =
+  Repetition <$> presenceParser
+             <*  many1 (string " ")
+             <*> cardinalityParser
+             <?> "Repetition"
+
+positionParser :: Parser Position
+positionParser =
+  fromString <$> many1 digit
+             <?> "Position"
+
+segmentElementParser :: Parser Element
+segmentElementParser =
+  let parseSegment pos code rep = Segment code (Positional pos rep)
+  in parseSegment <$> positionParser
+                  <*  many1 (oneOf "+*#|-X ")
+                  <*> segmentCodeParser
+                  <*  many1 (string " ")
+                  <*  stringToPresenceParser
+                  <*  many1 (string " ")
+                  <*> repetitionParser
+                  <?> "SegmentElement"
+
+segmentCodeParser :: Parser SegmentCode
+segmentCodeParser =
+  fromString <$> count 3 upper
+             <?> "SegmentCode"
+
+cardinalityParser :: Parser Cardinality
+cardinalityParser = Cardinality . read <$> many1 digit
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Messages/Types.hs b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Types.hs
new file mode 100644
index 0000000..73cc702
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Messages/Types.hs
@@ -0,0 +1,36 @@
+{-# LANGUAGE DerivingStrategies         #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Text.Edifact.Scaffolder.Messages.Types where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Data.Function                   (on)
+import           Data.Ord                        (comparing)
+
+newtype Dependency = Dependency { getElement :: Element } deriving newtype (Show, Ord, Eq)
+
+data Repetition = Repetition Presence Cardinality deriving Show
+
+data Positional = Positional { positionalPosition   :: Position
+                             , positionalRepetition :: Repetition
+                             } deriving (Show)
+
+instance Eq Positional where
+  (==) = (==) `on` positionalPosition
+
+instance Ord Positional where
+  compare = comparing positionalPosition
+
+data Element = Segment    SegmentCode Positional
+             | GroupStart GroupCode   Positional
+             | GroupEnd   GroupCode
+               deriving (Show, Ord, Eq)
+
+getSegment :: Element -> Maybe SegmentCode
+getSegment (Segment code _) = Just code
+getSegment _                = Nothing
+
+newtype Cardinality = Cardinality { getCardinality :: Int }
+  deriving stock (Show)
+  deriving newtype (Eq, Num)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Root.hs b/scaffolder/src/Text/Edifact/Scaffolder/Root.hs
new file mode 100644
index 0000000..54a48d5
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Root.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE OverloadedLists   #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Root
+  ( rootModule
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+rootModule :: Scaffolding ()
+rootModule = getRootModuleName >>= generateRootModule
+
+generateRootModule :: ModuleName -> Scaffolding ()
+generateRootModule mn =
+  let exports = [ reexportAlias subModulesAlias ]
+      subModulesAlias = "S"
+      importSubModule sm = ImportAll (ImportAs (mn <.> sm) subModulesAlias)
+      subModules = [ "Composites"
+                   , "Messages"
+                   , "Segments"
+                   ]
+      imports = [ ImportGroup (importSubModule <$> subModules) ]
+  in
+    saveHaskellModule mn $
+      moduleDeclaration mn exports imports
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments.hs
new file mode 100644
index 0000000..a0b6c3d
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments.hs
@@ -0,0 +1,54 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Segments
+  ( segments
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Edifact.Scaffolder.Segments.Dependencies
+import           Text.Edifact.Scaffolder.Segments.Elements
+import           Text.Edifact.Scaffolder.Segments.Implementation
+import           Text.Edifact.Scaffolder.Segments.Specification
+import           Text.Edifact.Scaffolder.Segments.Types
+
+import           Data.List.NonEmpty                              (nubBy)
+import           Formatting
+
+segments :: Scaffolding ()
+segments = listSegments >>= scaffoldElements parentSegmentModule segmentModule
+
+parentSegmentModule :: NonEmpty (ElementWithDefinition SegmentCode) -> Scaffolding ()
+parentSegmentModule = parentModule "Segments" "S" segmentModuleName
+
+segmentModuleName :: ModuleName -> SegmentCode -> ModuleName
+segmentModuleName mn code = mn <.> fromString (getSegmentCode code)
+
+segmentModule :: ElementWithDefinition SegmentCode -> Scaffolding ()
+segmentModule (inputFile, code) = do
+  moduleName <- getRootModuleNameFor (segmentModuleName "Segments" code)
+  dependencies <- scanDependencies inputFile (snd <$> specificationParser)
+  specification <- includeSpecification inputFile
+  let parserFunction = fSegmentParserFunction
+      fDescription = "Segment " % fSegmentCode
+      parserNotYetImplemented = sformat (notYetImplemented fDescription) code
+      defaultImplementation = haskellList [ parserNotYetImplemented ]
+      elements = sort . nubBy (\a b -> getCode a == getCode b) . fmap dependencyElement <$> dependencies
+      implementation = maybe defaultImplementation toImplementation dependencies
+      buildDependencies b = fromMaybe [] <$> traverse b elements
+  dependenciesReexports <- buildDependencies mkDependenciesReexports
+  dependenciesImports   <- buildDependencies mkDependenciesImports
+  dependenciesHaddock   <- buildDependencies mkDependenciesHaddock
+  let exports = Comment "* Definition"
+              : Name (sformat parserFunction code)
+              : dependenciesReexports
+      imports = dependenciesImports
+             <> [ importCombinators ]
+             <> maybe [ importNotYetImplementedHelper ] (const []) dependencies
+      documentation = specification <> dependenciesHaddock
+      signature = sformat (fParserSignature parserFunction) code
+      definition = [ sformat (fParserDeclaration parserFunction) code
+                   , indent (sformat ("segment " % quoted fSegmentCode) code)
+                   ] <> (indent . indent <$> implementation)
+      parser = signature : definition
+  scaffoldModule moduleName ["OverloadedStrings"] exports imports (documentation <> parser)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments/Dependencies.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Dependencies.hs
new file mode 100644
index 0000000..acb9ea8
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Dependencies.hs
@@ -0,0 +1,47 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Segments.Dependencies
+  ( -- *
+    mkDependenciesHaddock
+  , mkDependenciesImports
+  , mkDependenciesReexports
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Segments.Types
+
+import           Data.List.NonEmpty                     as NE (nonEmpty, toList)
+import           Data.Maybe                             (catMaybes, mapMaybe)
+import           Formatting                             as F
+
+mkDependenciesReexports :: NonEmpty Element -> Scaffolding [Export]
+mkDependenciesReexports = reexportDependencies fElementFunction
+
+mkDependenciesImports :: NonEmpty Element -> Scaffolding [ImportGroup]
+mkDependenciesImports elements =
+  let filterElements optic = mapMaybe optic . NE.toList
+  in maybe [] (pure . ImportGroup) . nonEmpty . catMaybes <$>
+       sequence
+         [ mkCompositeDependenciesImports (filterElements getComposite elements)
+         , mkSimpleDependenciesImports    (filterElements getSimple    elements)
+         ]
+
+mkSimpleDependenciesImports :: [SimpleCode] -> Scaffolding (Maybe Import)
+mkSimpleDependenciesImports =
+  ifNonEmpty (importDependencies "Simples" fSimpleParserFunction)
+
+mkCompositeDependenciesImports :: [CompositeCode] -> Scaffolding (Maybe Import)
+mkCompositeDependenciesImports =
+  ifNonEmpty (importDependencies "Composites" fCompositeParserFunction)
+
+ifNonEmpty :: Applicative f => (NonEmpty input -> f output) -> [input] -> f (Maybe output)
+ifNonEmpty f = traverse f . nonEmpty
+
+mkDependenciesHaddock :: NonEmpty Element -> Scaffolding [Text]
+mkDependenciesHaddock = haddockDependencies fElementFunction
+
+fElementFunction :: Format r (Element -> r)
+fElementFunction =
+  let buildElementFunction (Simple    code _ _ _ _) = bprint fSimpleParserFunction    code
+      buildElementFunction (Composite code _ _)     = bprint fCompositeParserFunction code
+  in later buildElementFunction
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments/Elements.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Elements.hs
new file mode 100644
index 0000000..4e8b39c
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Elements.hs
@@ -0,0 +1,26 @@
+module Text.Edifact.Scaffolder.Segments.Elements
+  ( listSegments
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Data.Char                       (isLower, toUpper)
+import           Text.Parsec                     (eof, lower, satisfy, string,
+                                                  (<?>))
+import           Text.Parsec.String              (Parser)
+
+listSegments :: Scaffolding [ElementWithDefinition SegmentCode]
+listSegments = listElements "segments" segmentCodeParser
+
+segmentCodeParser :: Parser SegmentCode
+segmentCodeParser = do
+  c1 <- lowerExceptU
+  c2 <- lower
+  c3 <- lower
+  let code = SegmentCode (toUpper <$> [c1,c2,c3])
+  code <$  string ".txt"
+       <*  eof
+       <?> "SegmentCode"
+
+lowerExceptU :: Parser Char
+lowerExceptU = satisfy (\ c -> isLower c && c /= 'u')
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments/Implementation.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Implementation.hs
new file mode 100644
index 0000000..8535a17
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Implementation.hs
@@ -0,0 +1,21 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Segments.Implementation
+  ( -- *
+    toImplementation
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Segments.Types
+
+import           Data.List.NonEmpty                     as NE (toList)
+import           Formatting
+
+toImplementation :: NonEmpty Dependency -> [Text]
+toImplementation = haskellList . fmap callDependency . NE.toList
+
+callDependency :: Dependency -> Text
+callDependency (Dependency pos (Simple code _ presence _ _)) =
+  sformat ( quoted fPosition % " .@ " % fPresence % " simple" % fSimpleCode) pos presence code
+callDependency (Dependency pos (Composite code _ presence)) =
+  sformat ( quoted fPosition % " .@ " % fPresence % " composite" % fCompositeCode) pos presence code
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments/Specification.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Specification.hs
new file mode 100644
index 0000000..39a7ad4
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Specification.hs
@@ -0,0 +1,99 @@
+module Text.Edifact.Scaffolder.Segments.Specification
+  ( -- *
+    specificationParser
+  , listCompositesAndSimples
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Segments.Types
+
+import           Text.Parsec                            as P (anyChar, choice,
+                                                              count, digit,
+                                                              endOfLine, many,
+                                                              many1, manyTill,
+                                                              oneOf, skipMany,
+                                                              string, try,
+                                                              upper, (<?>))
+import           Text.Parsec.String                     (Parser)
+
+specificationParser :: Parser ((SegmentCode, SegmentName), [Dependency])
+specificationParser = do
+  segmentInfo <- scanUntil [ segmentParser ]
+  dependencies <- scan [ inLine dependencyParser ] <?> "Segments specification"
+  pure (segmentInfo, dependencies)
+
+listCompositesAndSimples :: Parser (SegmentCode, [Element])
+listCompositesAndSimples = do
+  parsed <- specificationParser
+  pure (fst $ fst parsed, dependencyElement <$> snd parsed)
+
+segmentParser :: Parser (SegmentCode, SegmentName)
+segmentParser = do
+  _ <- count 6 (oneOf "+*#|X ")
+  skipMany (string " ")
+  code <- SegmentCode <$> count 3 upper
+  _ <- count 2 (string " ")
+  skipMany (string " ")
+  name <- SegmentName <$> manyTill anyChar (() <$ try endOfLine)
+  pure (code, name)
+
+dependencyParser :: Parser Dependency
+dependencyParser =
+  Dependency <$> positionParser
+             <*  many1 (oneOf "+*#|-X ")
+             <*> elementParser
+             <?> "Dependency"
+
+inLine :: Parser a -> Parser [a]
+inLine p = single (many (string " ") *> p)
+
+positionParser :: Parser Position
+positionParser =
+  fromString <$> count 3 digit
+             <?> "Position"
+
+elementParser :: Parser Element
+elementParser =
+  choice [ compositeParser
+         , simpleParser
+         ]
+         <?> "Element"
+
+compositeParser :: Parser Element
+compositeParser = Composite <$> compositeCodeParser
+                      <*  many (string " ")
+                      <*> stringToPresenceParser
+                      <*  many1 (string " ")
+                      <*> presenceParser
+                      <*  string " "
+                      <*  many (oneOf " 0123456789")
+                      <?> "Composite"
+
+simpleParser :: Parser Element
+simpleParser = Simple <$> (fromString <$> count 4 digit)
+                      <*  many1 (string " ")
+                      <*> stringToPresenceParser
+                      <*  many1 (string " ")
+                      <*> presenceParser
+                      <*  string "  "
+                      <*  many (oneOf " 0123456789")
+                      <*> simpleTypeParser
+                      <*> simpleLengthParser
+                      <?> "Simple"
+
+simpleTypeParser :: Parser SimpleType
+simpleTypeParser = choice [ Alphanumeric <$ string "an"
+                          , Alphabetic   <$ string "a"
+                          , Numeric      <$ string "n"
+                          ] <?> "SimpleType"
+
+simpleLengthParser :: Parser SimpleLength
+simpleLengthParser = choice [ UpTo <$> fmap fromString (string ".." >> many1 digit)
+                            , Exactly <$> (fromString <$> many1 digit)
+                            ] <?> "SimpleLength"
+
+compositeCodeParser :: Parser CompositeCode
+compositeCodeParser = do
+  initial <- oneOf "CE"
+  rest <- count 3 digit
+  pure (fromString (initial : rest))
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Segments/Types.hs b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Types.hs
new file mode 100644
index 0000000..6a34cbc
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Segments/Types.hs
@@ -0,0 +1,27 @@
+module Text.Edifact.Scaffolder.Segments.Types where
+
+import           Text.Edifact.Scaffolder.Commons
+
+data Dependency = Dependency { dependencyPosition :: Position
+                             , dependencyElement  :: Element
+                             } deriving Show
+
+data Element = Composite CompositeCode Text Presence
+             | Simple SimpleCode Text Presence SimpleType SimpleLength
+               deriving (Show, Eq, Ord)
+
+data SimpleType = Alphanumeric | Alphabetic | Numeric deriving (Show, Eq, Ord)
+
+data SimpleLength = Exactly Text | UpTo Text deriving (Show, Eq, Ord)
+
+getCode :: Element -> String
+getCode (Simple (SimpleCode c) _ _ _ _)   = c
+getCode (Composite (CompositeCode c) _ _) = c
+
+getSimple :: Element -> Maybe SimpleCode
+getSimple (Simple c _ _ _ _) = Just c
+getSimple _                  = Nothing
+
+getComposite :: Element -> Maybe CompositeCode
+getComposite (Composite c _ _) = Just c
+getComposite _                 = Nothing
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples.hs
new file mode 100644
index 0000000..95885c2
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples.hs
@@ -0,0 +1,41 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Simples
+  ( simples
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Edifact.Scaffolder.Simples.Elements
+import           Text.Edifact.Scaffolder.Simples.Implementation
+import           Text.Edifact.Scaffolder.Simples.Representation
+
+import           Formatting
+
+simples :: Scaffolding ()
+simples = listSimples >>= scaffoldElements parentSimpleModule simpleModule
+
+parentSimpleModule :: NonEmpty (ElementWithDefinition SimpleCode) -> Scaffolding ()
+parentSimpleModule = parentModule "Simples" "S" simpleModuleName
+
+simpleModuleName :: ModuleName -> SimpleCode -> ModuleName
+simpleModuleName mn code = mn <.> fromString ("S" <> getSimpleCode code)
+
+simpleModule :: ElementWithDefinition SimpleCode -> Scaffolding ()
+simpleModule (inputFile, code) = do
+  moduleName <- getRootModuleNameFor (simpleModuleName "Simples" code)
+  representation <- extractRepresentation inputFile
+  specification <- includeSpecification inputFile
+  let parserFunction = fSimpleParserFunction
+      fDescription = "Simple " % fSimpleCode
+      defaultImplementation = sformat (notYetImplemented fDescription) code
+      implementation = maybe defaultImplementation toImplementation representation
+      exports = [ Name (sformat parserFunction code) ]
+      imports = importCombinators
+              : maybe [importNotYetImplementedHelper] (const []) representation
+      documentation = specification
+      signature = sformat (fParserSignature parserFunction) code
+      definition = [ sformat (fParserDeclaration parserFunction % " simple " % quoted fSimpleCode % " " % parens stext) code code implementation
+                   ]
+      parser = signature : definition
+  scaffoldModule moduleName ["OverloadedStrings"] exports imports (documentation <> parser)
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples/Elements.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Elements.hs
new file mode 100644
index 0000000..328a5d0
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Elements.hs
@@ -0,0 +1,26 @@
+module Text.Edifact.Scaffolder.Simples.Elements
+  ( listSimples
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Parsec                     (digit, eof, oneOf, string,
+                                                  (<?>))
+import           Text.Parsec.String              (Parser)
+
+listSimples :: Scaffolding [ElementWithDefinition SimpleCode]
+listSimples = listElements "simples" simpleCodeParser
+
+simpleCodeParser :: Parser SimpleCode
+simpleCodeParser =
+  let codeParser =
+        sequence [ oneOf ['1'..'9']
+                 , digit
+                 , digit
+                 , digit
+                 ]
+  in
+  SimpleCode <$> codeParser
+             <*  string ".txt"
+             <*  eof
+             <?> "SimpleCode"
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples/Implementation.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Implementation.hs
new file mode 100644
index 0000000..6cfb2ab
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Implementation.hs
@@ -0,0 +1,23 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Simples.Implementation
+  ( -- *
+    toImplementation
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Simples.Types
+
+import           Formatting
+
+toImplementation :: Representation -> Text
+toImplementation (Representation content (UpTo n)   ) = sformat (fContent % " `upTo` " % int) content n
+toImplementation (Representation content (Exactly n)) = sformat (fContent % " `exactly` " % int) content n
+toImplementation (Representation content AnyNumber  ) = sformat ("many " % fContent) content
+
+fContent :: Format t (Content -> t)
+fContent =
+  let display AlphaNumeric = "alphaNumeric"
+      display Alpha        = "alpha"
+      display Numeric      = "numeric"
+  in mapf display stext
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples/Representation.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Representation.hs
new file mode 100644
index 0000000..9555536
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Representation.hs
@@ -0,0 +1,47 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Text.Edifact.Scaffolder.Simples.Representation
+  ( -- *
+    extractRepresentation
+  , representationParser
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+import           Text.Edifact.Scaffolder.Simples.Types
+
+import           Text.Parsec                           as P (char, choice,
+                                                             digit, many1,
+                                                             option, optional,
+                                                             space, string, try)
+import           Text.Parsec.String                    (Parser)
+
+extractRepresentation :: FilePath -> Scaffolding (Maybe Representation)
+extractRepresentation file =
+  let parser = skipBeginning representationParser
+  in liftIO (readFile file) >>= maybeParse file parser
+
+contentParser :: Parser Content
+contentParser =
+  choice [ AlphaNumeric <$ try (P.string "an")
+         , Alpha        <$ P.string "a"
+         , Numeric      <$ P.string "n"
+         ]
+
+cardinalityParser :: Parser Cardinality
+cardinalityParser =
+  option AnyNumber $
+    choice [ Exactly <$> (optional space *> numberParser)
+           , UpTo    <$> (dot *> dot *> numberParser)
+           ]
+
+numberParser :: Parser Int
+numberParser = read <$> many1 digit
+
+dot :: Parser Char
+dot = P.char '.'
+
+representationParser :: Parser Representation
+representationParser =
+  let parser = Representation <$> contentParser
+                              <*> cardinalityParser
+  in P.string "Repr:" *> space *> parser
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples/Specification.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Specification.hs
new file mode 100644
index 0000000..0651cbd
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Specification.hs
@@ -0,0 +1,28 @@
+module Text.Edifact.Scaffolder.Simples.Specification
+  ( -- *
+    specificationParser
+  ) where
+
+import           Text.Edifact.Scaffolder.Commons
+
+import           Text.Parsec                     as P (anyChar, count, digit,
+                                                       endOfLine, manyTill,
+                                                       oneOf, skipMany, string,
+                                                       try)
+import           Text.Parsec.String              (Parser)
+
+specificationParser :: Parser (SimpleCode, SimpleName)
+specificationParser = scanUntil [ simpleParser ]
+
+simpleParser :: Parser (SimpleCode, SimpleName)
+simpleParser = do
+  _ <- count 3 (oneOf "+*#|-X ")
+  skipMany (string " ")
+  code <- simpleCodeParser
+  _ <- string " "
+  skipMany (string " ")
+  name <- SimpleName <$> manyTill anyChar (() <$ try endOfLine)
+  pure (code, name)
+
+simpleCodeParser :: Parser SimpleCode
+simpleCodeParser = fromString <$> count 4 digit
diff --git a/scaffolder/src/Text/Edifact/Scaffolder/Simples/Types.hs b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Types.hs
new file mode 100644
index 0000000..08b6ca5
--- /dev/null
+++ b/scaffolder/src/Text/Edifact/Scaffolder/Simples/Types.hs
@@ -0,0 +1,14 @@
+module Text.Edifact.Scaffolder.Simples.Types where
+
+data Representation = Representation Content Cardinality
+                      deriving Show
+
+data Content = AlphaNumeric
+             | Alpha
+             | Numeric
+               deriving Show
+
+data Cardinality = UpTo Int
+                 | Exactly Int
+                 | AnyNumber
+                   deriving Show