just/notes

notes
-----


- all assignments are evaluated before running anything
- for shebang recipes, all expressions are evaluated first
- for non-shebang recipes, lines are evaluated one by one and executed

- later we can decide to not evaluate assignments that aren't referenced
  by any recipe

- deferred evaluation, even though it's good for testing, is a bad idea
  i should have a resolve assignments phase which just checks,
  an evaluate assignments phase which runs before any recipe
  and a evaluate recipe phase that runs when a recipe is run
  and produces the evaluated lines

- --debug tests that:
  - should consider renaming it to --evaluate if it actually evaluates stuff
  - test values of assignments
  - test values of interpolations
  - test results of concatination
  - test string escape parsing

- remove evaluated_lines field from recipe

- change unknown variable to undefined variable

- save result of commands in variables
  . backticks: `echo hello`
  . backticks in assignments are evaluated before the first recipe is run
  . backticks in recipes are evaluated before that recipe is run
  . should i do deferred evaluation for everything and just resolve initially?
  . should i merge evaluator into Justfile?
  . backtick evaluation returns None initially
  . justfile.run() evaluates all backticks in assignments
  . should i have a resolve step and an deval step? should they be different code?
  . when you run the recipe, then you execute it
  . eval shebang recipes all at once, but plain recipes line by line
  . we want to avoid executing backticks before we need them

- --debug mode will evaluate everything and print values after assignments and interpolation expressions

- nicely convert a map to option string to a map to string

- set variables from the command line:
  . j --set build linux
  . j build=linux

- before release:

- where can users get help?
  - irc, email, github, mailing list
- rewrite grammar.txt
- start with an example justfile
- then installation instructions
- then a long guide
- make it clear it's beta, mention that, as a command runner
  there is probably a higher than normal chance of disaster
- change name back to 'just', suggest j as alias
- change description to "a polyglot command runner"?
- update readme
- document all code, including private stuff
  (can this be enforced with a lint?)
  #![deny(missing_docs)]
- note that shell is invoked with -cu, explain -c and -u
- document all features with example justfiles
  (also make them runnable as tests)
  . update tarball dep
  . check version string
  . clean
  . update logs (repetitive git flow)
- full documentation
  . talk about why the syntax is so unforgiving
    easier to accept a program that you once rejected than to
    no longer accept a program or change its meaning
  . habit of using clever commands and writing little scripts
  . debugging with --debug or --evaluate
  . very low friction to write a script (no new file, chmod, add to rcs)
  . make list of contributors, include travis
  . alias .j='just --justfile ~/.justfile --working-directory ~'
  . lay out the structure of the code, mention tests, give tips
    for contributing
- vim and emacs syntax hilighting (use makefile syntax hilighting for now)
- make sure there isn't any unused code
- ask users to contribute their justfiles as tests
- try to get some users
  . facebook friends
  . irc
  . r/rust

enhancements:

- use cow strings where we currently use String
- colored error messages
- multi line strings (maybe not in recipe interpolations)
- raw strings with ''
- iteration: {{x for x in y}}
- allow calling recipes in a justfile in a different directory:
  . just ../foo  # ../justfile:foo
  . just xyz/foo # xyz/justfile:foo
  . just xyz/    # xyz/justfile:DEFAULT
- allow setting and exporting environment variables
- indentation or slash for line continuation in plain recipes