1 files changed, 57 insertions, 15 deletions

diff --git a/src/Config.hs b/src/Config.hs
index 4327193..40eb1e5 100644
--- a/src/Config.hs
+++ b/src/Config.hs
@@ -26,6 +26,7 @@ import System.FilePath
 import System.FilePath.Glob
 import System.Process
 
+import Destination
 import Job.Types
 import Repo
 
@@ -42,18 +43,21 @@ data JobRoot
 data Config = Config
     { configJobs :: [ DeclaredJob ]
     , configRepos :: [ DeclaredRepo ]
+    , configDestinations :: [ DeclaredDestination ]
     }
 
 instance Semigroup Config where
     a <> b = Config
         { configJobs = configJobs a ++ configJobs b
         , configRepos = configRepos a ++ configRepos b
+        , configDestinations = configDestinations a ++ configDestinations b
         }
 
 instance Monoid Config where
     mempty = Config
         { configJobs = []
         , configRepos = []
+        , configDestinations = []
         }
 
 instance FromYAML Config where
@@ -72,24 +76,31 @@ instance FromYAML Config where
                 | [ "repo", name ] <- T.words tag -> do
                     repo <- parseRepo name node
                     return $ config { configRepos = configRepos config ++ [ repo ] }
+                | [ "destination", name ] <- T.words tag -> do
+                    destination <- parseDestination name node
+                    return $ config { configDestinations = configDestinations config ++ [ destination ] }
             _ -> return config
 
 parseJob :: Text -> Node Pos -> Parser DeclaredJob
 parseJob name node = flip (withMap "Job") node $ \j -> do
     let jobName = JobName name
         jobId = jobName
+    jobRecipe <- choice
+        [ fmap Just $ cabalJob =<< j .: "cabal"
+        , fmap Just $ shellJob =<< j .: "shell"
+        , return Nothing
+        ]
     jobCheckout <- choice
         [ parseSingleCheckout =<< j .: "checkout"
         , parseMultipleCheckouts =<< j .: "checkout"
         , withNull "no checkout" (return []) =<< j .: "checkout"
-        , return [ JobCheckout Nothing Nothing Nothing ]
-        ]
-    jobRecipe <- choice
-        [ cabalJob =<< j .: "cabal"
-        , shellJob =<< j .: "shell"
+        , return $ if isJust jobRecipe
+                     then [ JobCheckout Nothing Nothing Nothing ]
+                     else []
         ]
     jobArtifacts <- parseArtifacts j
     jobUses <- maybe (return []) parseUses =<< j .:? "uses"
+    jobPublish <- maybe (return []) (parsePublish jobName) =<< j .:? "publish"
     return Job {..}
 
 parseSingleCheckout :: Node Pos -> Parser [ JobCheckout Declared ]
@@ -106,18 +117,23 @@ parseSingleCheckout = withMap "checkout definition" $ \m -> do
 parseMultipleCheckouts :: Node Pos -> Parser [ JobCheckout Declared ]
 parseMultipleCheckouts = withSeq "checkout definitions" $ fmap concat . mapM parseSingleCheckout
 
-cabalJob :: Node Pos -> Parser [CreateProcess]
+cabalJob :: Node Pos -> Parser [ Either CreateProcess Text ]
 cabalJob = withMap "cabal job" $ \m -> do
     ghcOptions <- m .:? "ghc-options" >>= \case
         Nothing -> return []
         Just s -> withSeq "GHC option list" (mapM (withStr "GHC option" return)) s
 
     return
-        [ proc "cabal" $ concat [ ["build"], ("--ghc-option="++) . T.unpack <$> ghcOptions ] ]
-
-shellJob :: Node Pos -> Parser [CreateProcess]
-shellJob = withSeq "shell commands" $ \xs -> do
-    fmap (map shell) $ forM xs $ withStr "shell command" $ return . T.unpack
+        [ Left $ proc "cabal" $ concat [ ["build"], ("--ghc-option="++) . T.unpack <$> ghcOptions ] ]
+
+shellJob :: Node Pos -> Parser [ Either CreateProcess Text ]
+shellJob node = do
+    commands <- choice
+        [ withStr "shell commands" return node
+        , withSeq "shell commands" (\xs -> do
+            fmap T.unlines $ forM xs $ withStr "shell command" $ return) node
+        ]
+    return [ Right commands ]
 
 parseArtifacts :: Mapping Pos -> Parser [ ( ArtifactName, Pattern ) ]
 parseArtifacts m = do
@@ -136,11 +152,34 @@ parseUses = withSeq "Uses list" $ mapM $
         [job, art] <- return $ T.split (== '.') text
         return (JobName job, ArtifactName art)
 
+parsePublish :: JobName -> Node Pos -> Parser [ JobPublish Declared ]
+parsePublish ownName = withSeq "Publish list" $ mapM $
+    withMap "Publish specification" $ \m -> do
+        artifact <- m .: "artifact"
+        jpArtifact <- case T.split (== '.') artifact of
+            [ job, art ] -> return ( JobName job, ArtifactName art )
+            [ art ] -> return ( ownName, ArtifactName art )
+            _ -> mzero
+        jpDestination <- DestinationName <$> m .: "to"
+        jpPath <- fmap T.unpack <$> m .:? "path"
+        return JobPublish {..}
+
 
 parseRepo :: Text -> Node Pos -> Parser DeclaredRepo
-parseRepo name node = flip (withMap "Repo") node $ \r -> DeclaredRepo
-    <$> pure (RepoName name)
-    <*> (T.unpack <$> r .: "path")
+parseRepo name node = choice
+    [ flip (withNull "Repo") node $ return $ DeclaredRepo (RepoName name) Nothing
+    , flip (withMap "Repo") node $ \r -> DeclaredRepo
+        <$> pure (RepoName name)
+        <*> (fmap T.unpack <$> r .:? "path")
+    ]
+
+parseDestination :: Text -> Node Pos -> Parser DeclaredDestination
+parseDestination name node = choice
+    [ flip (withNull "Destination") node $ return $ DeclaredDestination (DestinationName name) Nothing
+    , flip (withMap "Destination") node $ \r -> DeclaredDestination
+        <$> pure (DestinationName name)
+        <*> (r .:? "url")
+    ]
 
 
 findConfig :: IO (Maybe FilePath)
@@ -173,6 +212,9 @@ loadJobSetForCommit :: (MonadIO m, MonadFail m) => Commit -> m DeclaredJobSet
 loadJobSetForCommit commit = return . toJobSet =<< loadConfigForCommit =<< getCommitTree commit
   where
     toJobSet configEither = JobSet
-        { jobsetCommit = Just commit
+        { jobsetId = ()
+        , jobsetConfig = either (const Nothing) Just configEither
+        , jobsetCommit = Just commit
+        , jobsetExplicitlyRequested = []
         , jobsetJobsEither = fmap configJobs configEither
         }