Brief: add more pre/post steps for janet-pm

1. Adding these extra steps allows more user control of the build process
for complicated builds, including pre/post steps for build, install,
test and clean.

This also fixes #225, so that prebuild is only run before build.

2. Also removes redundant calls to build in the install hook since
Janet's core install hook calls build first as well. Having this in
spork too resulted in two calls to build when `janet-pm install`
was run.

3. Adds local assertf in `janet-pm` for older Janet

4. Fixes existing problem in `janet-pm` where hardcoded syspath at the top-level
is not honored when run as `(defn main ...`. This change adds a copy of the
hardcoded paths inside defn main in a binscript, if main exists in the input.

Author: rwtolbert

bin/janet-pm

@@ -5,6 +5,19 @@
 (import spork/pm)
 (import spork/pm-config)
 (import spork/sh)
+
+# Fix for janet without assertf
+(compwhen (not (dyn 'assertf))
+  (defmacro- assertf
+    "Convenience macro that combines `assert` and `string/format`."
+    [x fmt & args]
+    (def v (gensym))
+    ~(do
+       (def ,v ,x)
+       (if ,v
+         ,v
+         (,errorf ,fmt ,;args)))))
+
 # Do not import declare-cc here - keep a clean separation for faster load times
 
 (def help-text

spork/declare-cc.janet

@@ -266,11 +266,18 @@
   (def bd (build-dir))
   (def rules (get-rules))
   # Initialize build rules
-  (build-rules/build-rule rules :install ["build" "pre-install"])
+  (build-rules/build-rule rules :install [])
   (build-rules/build-rule rules :pre-install [])
+  (build-rules/build-rule rules :post-install [])
   (build-rules/build-rule rules :build [])
   (build-rules/build-rule rules :pre-build [])
+  (build-rules/build-rule rules :post-build [])
+  (build-rules/build-rule rules :check [])
   (build-rules/build-rule rules :pre-check [])
+  (build-rules/build-rule rules :post-check [])
+  (build-rules/build-rule rules :clean [])
+  (build-rules/build-rule rules :pre-clean [])
+  (build-rules/build-rule rules :post-clean [])
   # Add hooks
   (def e (curenv))
   (defn- prebuild
@@ -279,34 +286,59 @@
     (os/mkdir bd)
     (os/mkdir (path/join bd "static"))
     (build-rules/build-run e "pre-build" (dyn :workers)))
+  (defn- postbuild
+    []
+    (build-rules/build-run e "post-build" (dyn :workers)))
   (defn- precheck
     []
     (build-rules/build-run e "pre-check" (dyn :workers)))
+  (defn- postcheck
+    []
+    (build-rules/build-run e "post-check" (dyn :workers)))
+  (defn- preinstall
+    []
+    (build-rules/build-run e "pre-install" (dyn :workers)))
+  (defn- postinstall
+    []
+    (build-rules/build-run e "post-install" (dyn :workers)))
+  (defn- preclean
+    []
+    (build-rules/build-run e "pre-clean" (dyn :workers)))
+  (defn- postclean
+    []
+    (build-rules/build-run e "post-clean" (dyn :workers)))
   (defn build [&opt man target]
     (prebuild)
     (default target "build")
-    (build-rules/build-run e target (dyn :workers)))
+    (build-rules/build-run e target (dyn :workers))
+    (postbuild))
   (defn install [manifest &]
-    (build)
+    # (build) - removed since install in janet/src/boot/boot.janet calls build in the install hook
+    (preinstall)
     (with-dyns [*install-manifest* manifest]
-      (build-rules/build-run e "install" (dyn :workers))))
+      (build-rules/build-run e "install" (dyn :workers)))
+    (postinstall))
   (defn check [&]
     (build)
     (precheck)
-    (run-tests))
+    (run-tests)
+    (postcheck))
   (defn list-rules [&]
     (each k (sorted (filter string? (keys rules)))
       (print k)))
   (defn rule-tree [&]
     (show-rule-tree rules))
   (defn clean [&]
+    (preclean)
     (print "removing directory " bd)
-    (sh/rm bd))
+    (sh/rm bd)
+    (postclean))
   (defn clean-all [&]
+    (preclean)
     (print "removing directory " br)
-    (sh/rm br))
+    (sh/rm br)
+    (postclean))
   (defn run-task [task]
-    (prebuild)
     (build-rules/build-run e task (dyn :workers)))
   (defglobal 'install install)
   (defglobal 'build build)
@@ -351,6 +383,19 @@
   [&named main]
   (install-rule main "bin" 8r755 (mkbin)))
 
+(defn- main-replacer [dynamic-syspath hardcode-syspath l2 l3 l4]
+  (def parts @[])
+  (if (or dynamic-syspath hardcode-syspath) (array/push parts (string "\n  " l2)))
+  (if hardcode-syspath (array/push parts (string "  " l3)))
+  (if hardcode-syspath (array/push parts (string "  " l4)))
+  (fn [m & args] (string m (string/join parts "") "\n")))
+
+(defn- hardcode-syspath-in-main [dynamic-syspath hardcode-syspath contents l2 l3 l4]
+  (def patt (peg/compile '{:ws (some (choice :a :d :s "[" "&"))
+                           :defn (sequence "(defn" (any "-") :s "main" :ws "]" (any (choice " " "\n")))
+                           :main :defn}))
+  (peg/replace patt (main-replacer dynamic-syspath hardcode-syspath l2 l3 l4) contents))
+
 (defn declare-binscript
   ``Declare a janet file to be installed as an executable script. Creates
   a shim on windows. If hardcode is true, will insert code into the script
@@ -366,7 +411,7 @@
       (def auto-shebang (and is-janet (not (string/has-prefix? "#!" first-line))))
       (def dynamic-syspath (= hardcode-syspath :dynamic))
       (def second-line (string/format "(put root-env :original-syspath (os/realpath (dyn *syspath*))) # auto generated\n"))
-      (def third-line  (string/format "(put root-env :syspath %v) # auto generated\n" (dyn *syspath*)))
+      (def third-line (string/format "(put root-env :syspath %v) # auto generated\n" (dyn *syspath*)))
       (def fourth-line (string/format "(put root-env :install-time-syspath %v) # auto generated\n" (dyn *syspath*)))
       (def last-line "\n(put root-env :syspath (get root-env :original-syspath)) # auto generated\n")
       (def rest (:read f :all))
@@ -375,7 +420,9 @@
               (if (or dynamic-syspath hardcode-syspath) second-line)
               (if hardcode-syspath third-line)
               (if hardcode-syspath fourth-line)
-              rest
+              (if hardcode-syspath
+                (hardcode-syspath-in-main dynamic-syspath hardcode-syspath rest second-line third-line fourth-line)
+                rest)
               (if dynamic-syspath last-line))))
   (install-buffer contents dest 8r755 (mkbin))
   (when (is-win-or-mingw)

test-project/.gitignore

@@ -0,0 +1,3 @@
+/build
+/bundle
+/_build

test-project/bin/bin-no-hardcode

@@ -0,0 +1,7 @@
+#!/usr/bin/env janet
+
+(import spork)
+
+(defn- main
+  [&]
+  (printf "hello"))

test-project/bin/bin-no-main

@@ -0,0 +1,3 @@
+#!/usr/bin/env janet
+
+(print "hello")

test-project/bin/bin-with-main

@@ -0,0 +1,7 @@
+#!/usr/bin/env janet
+
+(import spork)
+
+(defn- main
+  [&]
+  (printf "hello"))

test-project/bin/bin-with-oneline-main

@@ -0,0 +1,5 @@
+#!/usr/bin/env janet
+
+(import spork)
+
+(defn main [&] (printf "hello"))

test-project/hello/init.janet

@@ -0,0 +1,2 @@
+(defn hello [arg]
+    (string/format "hello %s" arg))

test-project/project.janet

@@ -0,0 +1,64 @@
+(declare-project
+  :name "test-project"
+  :description "Janet project to test pre/post steps"
+  :version "0.0.1"
+  :dependencies [])
+
+(declare-source
+  :source @["hello"])
+
+(declare-binscript
+  :main "bin/bin-no-main"
+  :hardcode-syspath true
+  :is-janet true)
+
+(declare-binscript
+  :main "bin/bin-with-main"
+  :hardcode-syspath true
+  :is-janet true)
+
+(declare-binscript
+  :main "bin/bin-with-oneline-main"
+  :hardcode-syspath true
+  :is-janet true)
+
+(declare-binscript
+  :main "bin/bin-no-hardcode"
+  :hardcode-syspath false
+  :is-janet true)
+
+(task "pre-build" ["pre-build-test"])
+(task "post-build" ["post-build-test"])
+
+(task "pre-check" ["pre-check-test"])
+(task "post-check" ["post-check-test"])
+
+(task "pre-install" ["pre-install-test"])
+(task "post-install" ["post-install-test"])
+
+(task "pre-clean" ["pre-clean-test"])
+(task "post-clean" ["post-clean-test"])
+
+(task "pre-build-test" []
+      (printf "****** pre-build"))
+
+(task "post-build-test" []
+      (printf "****** post-build"))
+
+(task "pre-check-test" []
+      (printf "****** pre-check"))
+
+(task "post-check-test" []
+      (printf "****** post-check"))
+
+(task "pre-install-test" []
+      (printf "****** pre-install"))
+
+(task "post-install-test" []
+      (printf "****** post-install"))
+
+(task "pre-clean-test" []
+      (printf "****** pre-clean"))
+
+(task "post-clean-test" []
+      (printf "****** post-clean"))

test-project/test/test-hello.janet

@@ -0,0 +1 @@
+(assert true)