alda standalone script

daveyarwood · daveyarwood · commit adefdf8b44f4 · 2015-09-03T11:00:49.000-04:00
diff --git a/README.md b/README.md
@@ -65,23 +65,37 @@ Assuming you have [Boot](http://www.boot-clj.com) installed, try this on for siz
 
     git clone git@github.com:alda-lang/alda.git
     cd alda
-    boot play --file test/examples/awobmolg.alda
+    bin/alda play --file test/examples/awobmolg.alda
 
-> NOTE: The first time you run the `boot play` task, you may need to wait a minute for the FluidR3 MIDI soundfont dependency (~141 MB) to download. Alda uses this soundfont in order to make your JVM's MIDI instruments sound a lot nicer. If you'd prefer to skip this step and use your JVM's default soundfont instead, include the `--stock` flag (i.e. `boot play --stock --file ...`).
+> NOTE: The first time you run the `play` task, you may need to wait a minute for the FluidR3 MIDI soundfont dependency (~141 MB) to download. Alda uses this soundfont in order to make your JVM's MIDI instruments sound a lot nicer. If you'd prefer to skip this step and use your JVM's default soundfont instead, include the `--stock` flag (i.e. `play --stock --file ...`).
 
 You can also execute arbitrary Alda code, like this:
 
-    boot play --code "piano: c6 d12 e6 g12~4"
+    bin/alda play --code "piano: c6 d12 e6 g12~4"
+
+## Installation
+
+The executable file `alda` in the `bin` directory of this repository is a standalone executable script that can be run from anywhere. It will retrieve the latest release version of Alda and run it, passing along any command-line arguments you give it.
+
+This script requires the Clojure build tool [Boot](http://www.boot-clj.com), so you will need to have that installed first. Mac OS X users with [Homebrew](https://github.com/homebrew/homebrew) can run `brew install boot-clj` to install Boot.
+
+To install Alda, simply copy the `alda` script into any directory in your `$PATH`, e.g. `/bin` or `/usr/local/bin`:
+
+    git clone git@github.com:alda-lang/alda.git
+    cd alda
+    cp bin/alda /usr/local/bin
+
+You can now run `alda` from any working directory.
 
 ## alda.lisp
 
 Under the hood, Alda transforms input (i.e. Alda code) into Clojure code which, when evaluated, produces a map of score information, which the audio component of Alda can then use to make sound. This Clojure code is written in a DSL called **alda.lisp**. See below for an example of alda.lisp code and the result of evaluating it.
 
 ### Parsing demo
 
-You can use the `parse` Boot task to parse Alda code into alda.lisp (`-l`/`--lisp`) and/or evaluate it to produce a map (`-m`/`--map`) of score information.
+You can use the `parse` task to parse Alda code into alda.lisp (`-l`/`--lisp`) and/or evaluate it to produce a map (`-m`/`--map`) of score information.
 
-    $ boot parse --lisp --map -f test/examples/hello_world.alda
+    $ alda parse --lisp --map -f test/examples/hello_world.alda
     (alda.lisp/score
       (alda.lisp/part {:names ["piano"]}
         (alda.lisp/note (alda.lisp/pitch :c)
@@ -99,7 +113,7 @@ You can use the `parse` Boot task to parse Alda code into alda.lisp (`-l`/`--lis
     {:events #{#alda.lisp.Note{:offset 2000.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 261.6255653005986, :duration 1350.0} #alda.lisp.Note{:offset 0, :instrument "piano-VoUlp", :volume 1.0, :pitch 261.6255653005986, :duration 225.0} #alda.lisp.Note{:offset 250.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 293.6647679174076, :duration 225.0} #alda.lisp.Note{:offset 1250.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 349.2282314330039, :duration 225.0} #alda.lisp.Note{:offset 750.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 349.2282314330039, :duration 225.0} #alda.lisp.Note{:offset 1000.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 391.99543598174927, :duration 225.0} #alda.lisp.Note{:offset 1750.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 293.6647679174076, :duration 225.0} #alda.lisp.Note{:offset 1500.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 329.6275569128699, :duration 225.0} #alda.lisp.Note{:offset 500.0, :instrument "piano-VoUlp", :volume 1.0, :pitch 329.6275569128699, :duration 225.0}},
      :instruments {"piano-VoUlp" {:octave 4, :current-offset #alda.lisp.AbsoluteOffset{:offset 3500.0}, :config {:type :midi}, :duration 3N, :volume 1.0, :last-offset #alda.lisp.AbsoluteOffset{:offset 2000.0}, :id "piano-VoUlp", :quantization 0.9, :tempo 120, :panning 0.5, :current-marker :start, :stock "piano"}}}
 
-    $ boot parse --lisp -c 'cello: c+'
+    $ alda parse --lisp -c 'cello: c+'
     (alda.lisp/score
       (alda.lisp/part {:names ["cello"]}
         (alda.lisp/note (alda.lisp/pitch :c :sharp))))
diff --git a/bin/alda b/bin/alda
@@ -0,0 +1,15 @@
+#!/usr/bin/env boot
+
+; this is a minimal dispatch script that fetches the latest version of
+; alda from clojars (a maven repository for clojure projects) and runs the
+; alda.cli/main method, passing along any command-line arguments.
+
+; this script will automatically update your version of alda as newer
+; versions are released.
+
+(set-env! :dependencies '[[alda "LATEST"]])
+
+(require '[alda.cli])
+
+(defn -main [& args]
+  (apply (resolve 'alda.cli/-main) args))
diff --git a/build.boot b/build.boot
@@ -16,23 +16,22 @@
 
 (require '[adzerk.bootlaces :refer :all]
          '[adzerk.boot-test :refer :all]
-         '[alda.core]
-         '[alda.parser :refer (parse-input)]
-         '[alda.repl])
+         '[alda.version]
+         '[alda.cli])
 
-(def +version+ "0.3.0")
-(bootlaces! +version+)
+; version number is stored in alda.version 
+(bootlaces! alda.version/-version-)
 
 (task-options!
-  aot {:namespace '#{alda.core}}
+  aot {:namespace '#{alda.cli}}
   pom {:project 'alda
-       :version +version+
+       :version alda.version/-version-
        :description "A music programming language for musicians"
        :url "https://github.com/alda-lang/alda"
        :scm {:url "https://github.com/alda-lang/alda"}
        :license {"name" "Eclipse Public License"
                  "url" "http://www.eclipse.org/legal/epl-v10.html"}}
-  jar {:main 'alda.core}
+  jar {:main 'alda.cli}
   test {:namespaces '#{alda.test.parser.attributes
                        alda.test.parser.comments
                        alda.test.parser.duration
@@ -49,66 +48,5 @@
                        alda.test.lisp.score
                        alda.test.lisp.voices}})
 
-(deftask build
-  "Builds uberjar.
-   TODO: be able to build an executable à la lein bin"
-  []
-  (comp (aot) (pom) (uber) (jar)))
-
-(deftask parse
-  "Parse some Alda code and print the results to the console."
-  [f file FILE str  "The path to a file containing Alda code."
-   c code CODE str  "A string of Alda code."
-   l lisp      bool "Parse into alda.lisp code."
-   m map       bool "Evaluate the score and show the resulting instruments/events map."]
-  (let [alda-lisp-code (parse-input (if code code (slurp file)))]
-    (when lisp
-      (prn alda-lisp-code))
-    (when map
-      (require 'alda.lisp)
-      (println)
-      (prn (eval alda-lisp-code)))))
-
-(defn fluid-r3! 
-  "Fetches FluidR3 dependency and returns the input stream handle."
-  []
-  (clojure.core/eval
-    '(do (merge-env!
-           :dependencies '[[org.bitbucket.daveyarwood/fluid-r3 "0.1.1"]])
-         (require '[midi.soundfont.fluid-r3 :as fluid-r3])
-         fluid-r3/sf2)))
-
-(deftask play
-  "Parse some Alda code and play the resulting score."
-  [f file        FILE str "The path to a file containing Alda code."
-   c code        CODE str "A string of Alda code."
-   ; TODO: implement smart buffering and remove the buffer options
-   p pre-buffer  MS  int  "The number of milliseconds of lead time for buffering. (default: 0)"
-   P post-buffer MS  int  "The number of milliseconds to keep the synth open after the score ends. (default: 1000)"
-   s stock           bool "Use the default MIDI soundfont of your JVM, instead of FluidR3."]
-  (require '[alda.lisp]
-           '[alda.sound]
-           '[instaparse.core])
-  (binding [alda.sound.midi/*midi-soundfont* (when-not stock (fluid-r3!))
-            alda.sound/*play-opts* {:pre-buffer  (or pre-buffer 0)
-                                    :post-buffer (or post-buffer 1000)
-                                    :one-off?    true}]
-    (let [parsed (parse-input (if code code (slurp file)))]
-      (if (instaparse.core/failure? parsed)
-        (prn parsed) 
-        (alda.sound/play! (eval parsed)))
-      identity)))
-
-(deftask alda-repl
-  "Starts an Alda Read-Evaluate-Play-Loop."
-  [p pre-buffer  MS int  "The number of milliseconds of lead time for buffering. (default: 0)"
-   P post-buffer MS int  "The number of milliseconds to wait after the score ends. (default: 0)"
-   s stock          bool "Use the default MIDI soundfont of your JVM, instead of FluidR3."]
-  (binding [alda.sound.midi/*midi-soundfont* (when-not stock (fluid-r3!))
-            alda.sound/*play-opts* {:pre-buffer  pre-buffer
-                                    :post-buffer post-buffer
-                                    :async?      true}]
-    (alda.repl/start-repl! +version+)))
-
 (defn -main [& args]
-  (apply alda.core/-main args))
+  (apply alda.cli/-main args))
diff --git a/src/alda/cli.clj b/src/alda/cli.clj
@@ -0,0 +1,81 @@
+(ns alda.cli
+  (:require [boot.cli     :refer (defclifn)]
+            [boot.core    :refer (merge-env!)]
+            [alda.parser  :refer (parse-input)]
+            [alda.repl]))
+
+(defn fluid-r3! 
+  "Fetches FluidR3 dependency and returns the input stream handle."
+  []
+  (eval
+    '(do (merge-env!
+           :dependencies '[[org.bitbucket.daveyarwood/fluid-r3 "0.1.1"]])
+         (require '[midi.soundfont.fluid-r3 :as fluid-r3])
+         fluid-r3/sf2)))
+
+(defclifn parse
+  "Parse some Alda code and print the results to the console."
+  [f file FILE str  "The path to a file containing Alda code."
+   c code CODE str  "A string of Alda code."
+   l lisp      bool "Parse into alda.lisp code."
+   m map       bool "Evaluate the score and show the resulting instruments/events map."]
+  (let [alda-lisp-code (parse-input (if code code (slurp file)))]
+    (when lisp
+      (prn alda-lisp-code))
+    (when map
+      (require 'alda.lisp)
+      (println)
+      (prn (eval alda-lisp-code)))))
+
+(defclifn play
+  "Parse some Alda code and play the resulting score."
+  [f file        FILE str "The path to a file containing Alda code."
+   c code        CODE str "A string of Alda code."
+   ; TODO: implement smart buffering and remove the buffer options
+   p pre-buffer  MS  int  "The number of milliseconds of lead time for buffering. (default: 0)"
+   P post-buffer MS  int  "The number of milliseconds to keep the synth open after the score ends. (default: 1000)"
+   s stock           bool "Use the default MIDI soundfont of your JVM, instead of FluidR3."]
+  (require '[alda.lisp]
+           '[alda.sound]
+           '[instaparse.core])
+  (binding [alda.sound.midi/*midi-soundfont* (when-not stock (fluid-r3!))
+            alda.sound/*play-opts* {:pre-buffer  (or pre-buffer 0)
+                                    :post-buffer (or post-buffer 1000)
+                                    :one-off?    true}]
+    (let [parsed (parse-input (if code code (slurp file)))]
+      (if (instaparse.core/failure? parsed)
+        (prn parsed) 
+        (alda.sound/play! (eval parsed)))
+      identity)))
+
+(defclifn alda-repl
+  "Starts an Alda Read-Evaluate-Play-Loop."
+  [p pre-buffer  MS int  "The number of milliseconds of lead time for buffering. (default: 0)"
+   P post-buffer MS int  "The number of milliseconds to wait after the score ends. (default: 0)"
+   s stock          bool "Use the default MIDI soundfont of your JVM, instead of FluidR3."]
+  (binding [alda.sound.midi/*midi-soundfont* (when-not stock (fluid-r3!))
+            alda.sound/*play-opts* {:pre-buffer  pre-buffer
+                                    :post-buffer post-buffer
+                                    :async?      true}]
+    (alda.repl/start-repl!)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def help-text
+  "alda help text - TODO")
+
+(defn- delegate
+  [cmd args]
+  (if (empty? args)
+    (cmd "--help")
+    (apply cmd args)))
+
+(defn -main [& [cmd & args]]
+  (case cmd
+    nil      (println help-text)
+    "help"   (println help-text)
+    "--help" (println help-text)
+    "parse"  (delegate parse args)
+    "play"   (delegate play args)
+    "repl"   (delegate alda-repl args)
+    (printf "[alda] Invalid command '%s'.\n\n%s\n" cmd)))
diff --git a/src/alda/core.clj b/src/alda/core.clj
@@ -3,6 +3,8 @@
             [alda.sound :as sound])
   (:gen-class))
 
+; TODO: merge this namespace with alda.cli
+
 (def cli-options
   [["-h" "--help" "Display help text."]
    ["-s" "--start START"
diff --git a/src/alda/repl.clj b/src/alda/repl.clj
@@ -1,5 +1,6 @@
 (ns alda.repl
-  (:require [alda.parser                  :refer (parse-input)]
+  (:require [alda.version                 :refer (-version-)] 
+            [alda.parser                  :refer (parse-input)]
             [alda.lisp                    :refer :all]
             [alda.sound                   :refer (set-up! tear-down! play!)]
             [alda.sound.midi              :as    midi]
@@ -25,15 +26,15 @@
        "██║  ██║███████╗██████╔╝██║  ██║" \newline
        "╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝"))
 
-(defn text-below-ascii-art [version]
-  (str "            v" version \newline
+(def text-below-ascii-art
+  (str "            v" -version- \newline
        "         repl session"))
 
-(defn banner [version]
+(def banner
   (str (blue ascii-art)
        \newline
        \newline
-       (cyan (text-below-ascii-art version))))
+       (cyan text-below-ascii-art)))
 
 (defn parse-with-start-rule
   "Parse a string of Alda code starting from a particular level of the tree.
@@ -80,9 +81,9 @@
         prompt  (str (str/join "/" abbrevs) "> ")]
     (.setPrompt rdr prompt)))
 
-(defn start-repl! [version]
+(defn start-repl! []
   (println)
-  (println (banner version) \newline)
+  (println banner \newline)
   (let [done?   (atom false)
         context (atom :part)
         reader  (doto (ConsoleReader.) (.setPrompt "> "))]
diff --git a/src/alda/version.clj b/src/alda/version.clj
@@ -0,0 +1,4 @@
+(ns alda.version)
+
+(def ^:const -version- "0.4.0")
+
