Support declarative fs/modified-since with :produces field

[borkdude]

In tasks where some tasks are expensive, currently you can use fs/modified-since to speed up things:

{:tasks
 {:requires ([babashka.fs :as fs])
  :init (do
          (def libsci (str (first (fs/glob "clj" "LibScimacs.{dylib,lib,so}"))))
          (def lib-ext (fs/extension libsci))
          (def local-lib (str "scimacs." lib-ext))
          (def uberjar "clj/target/uber.jar")
          (def rust-lib (str "target/debug/libscimacs." lib-ext)))
  javac {:doc "Build libscimacs's JVM bytecode"
         :task (when (seq (fs/modified-since uberjar ["clj/src" "clj/build.clj" "clj/deps.edn"]))
                 (clojure
                  {:dir "clj"} "-T:build libscimacs"))}
  native-image {:doc "Build native-image"
                :depends [javac]
                :task (when (seq (fs/modified-since libsci uberjar))
                        (shell
                         {:dir "clj"}
                         "native-image"
                         "-cp" "target/uber.jar"
                         "--shared"
                         "-H:Name=LibScimacs"
                         "--enable-preview"
                         "-H:+ReportExceptionStackTraces"
                         "-J-Dclojure.spec.skip-macros=true"
                         "-J-Dclojure.compiler.direct-linking=true"
                         "--verbose"
                         "--no-fallback"
                         "--no-server"
                         "-J-Xmx3g"))}
  rustc {:doc "Build Rust binary"
         :depends [native-image]
         :task (when (seq (fs/modified-since rust-lib [libsci "src" "Cargo.toml"]))
                 (shell "cargo build"))}

  all {:doc "Build all"
       :depends [rustc]
       :task (when-not (fs/exists? local-lib)
               (fs/create-sym-link local-lib rust-lib))}}}

But wrapping stuff in fs/modified-since? is sometimes a bit verbose. If people could explicitly describe what files are produced by a task, you could automate this:

{:tasks
 {:requires ([babashka.fs :as fs])
  :init (do
          (def libsci (str (first (fs/glob "clj" "LibScimacs.{dylib,dll,solib}"))))
          (def lib-ext (fs/extension libsci))
          (def local-lib (str "scimacs." lib-ext))
          (def uberjar "clj/target/uber.jar")
          (def rust-lib (str "target/debug/libscimacs." lib-ext)))
  javac {:doc "Build libscimacs's JVM bytecode"
         :task (clojure
                {:dir "clj"} "-T:build libscimacs")
         :produces uberjar}
  native-image {:doc "Build native-image"
                :depends [javac]
                :produces libsci
                :task (shell
                       {:dir "clj"}
                       "native-image"
                       "-cp" "target/uber.jar"
                       "--shared"
                       "-H:Name=LibScimacs"
                       "--enable-preview"
                       "-H:+ReportExceptionStackTraces"
                       "-J-Dclojure.spec.skip-macros=true"
                       "-J-Dclojure.compiler.direct-linking=true"
                       "--verbose"
                       "--no-fallback"
                       "--no-server"
                       "-J-Xmx3g")}
  rustc {:doc "Build Rust binary"
         :depends [native-image]
         :produces [rust-lib]
         :task (shell "cargo build")}

  all {:doc "Build all"
       :depends [rustc]
       :task (when-not (fs/exists? local-lib)
               (fs/create-sym-link local-lib rust-lib))}}}

The :produces will be evaluated so it can be dynamic. If :produces files are newer than what :depends tasks produce we could know that the task does not have to run (this statement needs further investigation though, there must be edge case).
Also we could implement an automatic clean task that will erase all :produces files before running any tasks.