Alternative to lein run that can pass CLI options as-is

[alexander-yakushev]

I've seen this page which suggests that lein run translates to simply requiring and running the necessary function from the main namespace. I did that, but I also need to pass all the CLI arguments to -main method. Parsing the args on Boot side is not an option because I want to distribute the application later as an uberjar. At the same time, there is no easy way to deliver CLI args from Boot to -main without Boot processing them first. In the end, I had to add this hack to my build.boot:

(alter-var-root
 #'boot.core/construct-tasks
 (constantly
  (fn [& argv]
    (loop [ret [] [op-str & args] argv]
      (if-not op-str
        (apply comp (filter fn? ret))
        (let [op (-> op-str symbol resolve)]
          (when-not (and op (:boot.core/task (meta op)))
            (throw (IllegalArgumentException. (format "No such task (%s)" op-str))))
          (if (:raw-args (meta op))
            (recur (conj ret (apply (var-get op) (rest argv))) [])

            (let [spec   (:argspec (meta op))
                  parsed (boot.from.clojure.tools.cli/parse-opts args spec :in-order true)]
              (when (seq (:errors parsed))
                (throw (IllegalArgumentException. (clojure.string/join "\n" (:errors parsed)))))
              (let [[opts argv] (#'boot.core/parse-task-opts args spec)]
                (recur (conj ret (apply (var-get op) opts)) argv))))))))))

And subsequently make a task like this:

(defn ^:boot.core/task ^:raw-args run
  "Run the project."
  [& args]
  (with-pre-wrap fileset
    (require 'my.main.namespace)
    (eval `(my.main.namespace/-main ~@args))
    fileset)) 

Could we have something a little less hacky for this?

[micha]

What about something like this:

(deftask run
  "Resolves a function and applies it to arguments."
  [a argv ARG [str] "The argument vector."
   m main SYM  sym  "The symbol to resolve to obtain the -main fn."]
  (with-pass-thru _
    (require (symbol (namespace main)))
    (eval `(~main ~@argv))))

Example usage:

boot run -m my.main.namespace/-main -a foo -a bar -a baz

[alexander-yakushev]

That's a little too verbose for me. I pass a lot of arguments to main, putting -a in front of each would be tiresome and error-prone.

[seancorfield]

What does Boot currently do with --? That's used in some programs as a way to separate "control" arguments from "free form" arguments. Could that or a similar flag be used to tell Boot about a list of free form arguments to pass as-is?

[alexander-yakushev]

@seancorfield AFAIK boot uses -- to separate arguments to one task from other subsequent tasks.

[seancorfield]

Does it? Seems redundant since boot task1 -a arg --flag task2 -b --more stuff task3 is already unambiguous.

[alexander-yakushev]

At least it's like that in the docs. https://github.com/boot-clj/boot#build-from-the-command-line see third code example.

[seancorfield]

"The -- args below are optional" -- my emphasis there. Right now -- is just whitespace, ignored. I wonder how many people actually use them like that tho'? If zero then we could reuse them to indicate raw arguments. Else we need to pick something similar but different.

[micha]

Boot doesn't actually do anything with --, it's sort of like a comment. It's ignored during argument parsing if it appears in place of a task:

boot -- show -e -- repl -h # okay: -- ignored

but not when used as an argument:

boot -- show -- -e repl -h # error: -e is not a task

[micha]

Currently we're using :argspecs metadata on the var to validate cli arguments. Perhaps if a task doesn't have this metadata key but does have :arglists we can parse that instead, and collect the correct number of arguments.

[seancorfield]

Interesting. And then use -- as a way to signal "end of arguments" in the case of & args?

boot task1 -a regular -a args task2 any number of args -- task3 --back to --regular args

[micha]

Another option to consider in the meantime:

(deftask run
  [e expr EXPR edn "The expression to evaluate."]
  (with-pass-thru _ (eval expr)))

example:

boot run -e '(-main foo bar baz)'

and:

(task-options!
  run {:expr '(-main foo bar baz)})

[micha]

You could get more fancy from there, requiring namespaces, adding options for cleanup, etc.

[lachholden]

What I'm currently going with (similar to above):

(require 'namespace.core)
(require '[clojure.string :as s])

(deftask run
  "Runs namespace with the given arguments"
  [a args ARGS str "The arguments to pass the program"]
  (apply namespace.core/-main (s/split args #" ")))

Which can then be executed as boot run -a "the cli args to pass"

[alexander-yakushev]

Thanks @lachy-xe and @micha. I'm still using my hack, but I'll probably rewrite it to one of your suggestions.

[micha]

@alexander-yakushev I think I found a solution! How does this look to you?

# note the spaces around the brackets!
$ boot -v watch [ run -x arg1 arg2 ] deploy

In the command line above -x arg1 and arg2 will be passed to the run task. Within the
task body the positional arguments are accessible (as strings, of course) via *args*.

# brackets can be nested!
# - they're passed to the task as arguments
# - they must be balanced
$ boot -v watch [ run -x arg1 [ arg2 ] ] deploy

The task-options! macro would remain only for options, not for positional parameters.

[micha]

The -- would continue to keep its current meaning, for example suppose you wanted to pass -w
as a positional parameter, not an option:

# pass -w as an argument, not an option
$ boot -v watch [ run -x -- -w arg1 arg2 ] deploy

And you can still use -- to separate tasks from each other in the pipeline:

$ boot -v -- watch -- [ run -x -- -w arg1 arg2 ] -- deploy

[micha]

Feel free to reopen if this isn't a good solution :)

[alexander-yakushev]

It looks nice! How can I test it?

[daveyarwood]

+1, I like this.

So just for clarification, could I define a run task that takes only positional args by doing something like this?

(deftask run
  []
  (let [[x y z] *args*]
    (prn :x x :y y :z z)))

Then, on the command line:

boot [ run oh hello there ]

would result in this?

:x "oh" :y "hello" :z "there"

[micha]

@daveyarwood yep!

@alexander-yakushev this feature is in master branch now, if you want to build it. i'll try to release something on clojars though.