Add ‘newtags’ watch expressionHEADmaster

2 files changed, 109 insertions, 4 deletions

diff --git a/src/Expression.hs b/src/Expression.hs
index 43f859e..49fb4c1 100644
--- a/src/Expression.hs
+++ b/src/Expression.hs
@@ -73,8 +73,13 @@ data WatchedTags a = WatchedTags
     , wtChan :: TChan (Tag Commit)
     }
 
+data TagPattern = TagPattern
+    { tpPattern :: Pattern
+    , tpOnlyNew :: Bool
+    }
+
 type family WatchedTags' d :: Type where
-    WatchedTags' Declared = Pattern
+    WatchedTags' Declared = TagPattern
     WatchedTags' Evaluated = WatchedTags [ Tag Commit ]
 
 
@@ -106,7 +111,7 @@ watchedRange :: DeclaredRangeExpression -> DeclaredRangeExpression
 watchedRange = \case
     SingleRevisionExpression rev -> SingleRevisionExpression (watchedRevision rev)
     RangeExpression r1 r2 -> RangeExpression (watchedRevision r1) (watchedRevision r2)
-    StaticTagsExpression pat -> WatchedTagsExpression pat
+    StaticTagsExpression pat -> WatchedTagsExpression TagPattern { tpOnlyNew = False, tpPattern = pat }
     WatchedTagsExpression pat -> WatchedTagsExpression pat
 
 
@@ -158,10 +163,16 @@ evaluateDeclaredRange repo = \case
         RangeExpression <$> evaluateDeclaredRevision repo a <*> evaluateDeclaredRevision repo b
     StaticTagsExpression pat ->
         StaticTagsExpression . filter (Glob.match pat . T.unpack . tagTag) <$> listTags repo
-    WatchedTagsExpression wtPattern -> do
+    WatchedTagsExpression TagPattern {..} -> do
+        let wtPattern = tpPattern
         wtChan <- watchTags repo
-        wtValue <- liftIO . newTVarIO . filter (Glob.match wtPattern . T.unpack . tagTag) =<< listTags repo
+        value <- if tpOnlyNew
+            then return []
+            else filter (Glob.match wtPattern . T.unpack . tagTag) <$> listTags repo
+        wtValue <- liftIO $ newTVarIO value
         let wtUpdate = (:)
+        output <- getOutput
+        outputEvent output $ TestMessage $ "watch-tags-started " <> T.pack (decompile wtPattern)
         return $ WatchedTagsExpression WatchedTags {..}
 
 evaluateRevision :: RevisionExpression -> STM (Maybe CommitRef)
@@ -279,6 +290,10 @@ parseRangeExpression = bimap errorBundlePretty id . runParser parser ""
                 case tok of
                     "watch" -> watchedRange <$> parseRange
                     "tags" -> StaticTagsExpression <$> parseTagPattern
+                    "newtags" -> do
+                        tpPattern <- parseTagPattern
+                        let tpOnlyNew = True
+                        return $ WatchedTagsExpression TagPattern {..}
                     "highesttag" -> do
                         pat <- parseTagPattern
                         return $ SingleRevisionExpression $ StaticRef $ TagRef pat higherTag
diff --git a/test/script/expression.et b/test/script/expression.et
index f137fe7..9896e7a 100644
--- a/test/script/expression.et
+++ b/test/script/expression.et
@@ -262,6 +262,96 @@ test WatchTagList:
             /job-finish $te:single done/
 
 
+test WatchNewTags:
+    node n
+    shell on n as git_init:
+        git -c init.defaultBranch=master init -q
+        git -c user.name=test -c user.email=test commit -q --allow-empty -m 'initial commit'
+        cp "${scripts.path}/single.yaml" minici.yaml
+        git add minici.yaml
+        git -c user.name=test -c user.email=test commit -q -m 'minici.yaml'
+        git rev-parse HEAD
+
+        touch a
+        git add a
+        git -c user.name=test -c user.email=test commit -q -m a
+        git rev-parse HEAD
+        git rev-parse HEAD^{tree}
+
+        touch b
+        git add b
+        git -c user.name=test -c user.email=test commit -q -m b
+        git rev-parse HEAD
+        git rev-parse HEAD^{tree}
+
+        touch c
+        git add c
+        git -c user.name=test -c user.email=test commit -q -m c
+        git rev-parse HEAD
+        git rev-parse HEAD^{tree}
+
+        touch d
+        git add d
+        git -c user.name=test -c user.email=test commit -q -m d
+        git rev-parse HEAD
+        git rev-parse HEAD^{tree}
+
+        touch e
+        git add e
+        git -c user.name=test -c user.email=test commit -q -m e
+        git rev-parse HEAD
+        git rev-parse HEAD^{tree}
+
+        git reset --hard HEAD~5
+        git rev-parse HEAD
+
+    expect /([0-9a-f]+)/ from git_init capture c_init
+    expect /([0-9a-f]+)/ from git_init capture ca
+    expect /([0-9a-f]+)/ from git_init capture ta
+    expect /([0-9a-f]+)/ from git_init capture cb
+    expect /([0-9a-f]+)/ from git_init capture tb
+    expect /([0-9a-f]+)/ from git_init capture cc
+    expect /([0-9a-f]+)/ from git_init capture tc
+    expect /([0-9a-f]+)/ from git_init capture cd
+    expect /([0-9a-f]+)/ from git_init capture td
+    expect /([0-9a-f]+)/ from git_init capture ce
+    expect /([0-9a-f]+)/ from git_init capture te
+    expect /([0-9a-f]+)/ from git_init capture c_end
+
+    guard (c_init == c_end)
+
+    shell on n:
+        git -c user.name=test -c user.email=test tag -a -m . v1 $ca
+        git -c user.name=test -c user.email=test tag -a -m . x1 $cb
+
+    local:
+        spawn on n as p args [ "run", "--rerun-all", "newtags(v*)" ] killwith SIGINT
+        expect from p /watch-tags-started v\*/
+
+        shell on n:
+            git -c user.name=test -c user.email=test tag -a -m . v2 $cc
+
+        local:
+            expect from p /job-enqueue ([0-9a-f]+):single/ capture tid
+            guard (tid == tc)
+        expect from p:
+            /job-start $tc:single/
+            /job-finish $tc:single done/
+
+        shell on n:
+            git -c user.name=test -c user.email=test tag -a -m . x2 $cd
+
+        shell on n:
+            git -c user.name=test -c user.email=test tag -a -m . v3 $ce
+
+        local:
+            expect from p /job-enqueue ([0-9a-f]+):single/ capture tid
+            guard (tid == te)
+        expect from p:
+            /job-start $te:single/
+            /job-finish $te:single done/
+
+
 test WatchHighestTag:
     node n
     shell on n as git_init: