sibilant 0.0.1 → 0.0.2

data/README.md

@@ -4,18 +4,20 @@
 # Sibilant Ruby Gem
 
 This is a ruby wrapper for the sibilant compiler, which is written in
-javascript.  Instead of depending on ExecJS, it expects to find NodeJS
-available on the path as node.  Sibilant doesn't need to be installed.
+javascript. It expects to find NodeJS available on the path as node.
+Sibilant doesn't need to be installed.
 
 # Tilt support
 
-Providing sibilant code inside of a [tilt](https://github.com/rtomayko/tilt/) environment is provided by
+[Tilt](https://github.com/rtomayko/tilt/) support is provided by `sibilant/tilt`:
 
     require 'sibilant/tilt'
     Tilt['test.sibilant'].new { "(+ 1 2 3)" }.render #=> '(1 + 2 + 3)'
 
 # Sinatra
 
+[Sinatra](http://sinatrarb.com) support is provided by `sibilant/sinatra`:
+
     require 'sinatra'
     require 'sibilant/sinatra'
     helpers Sinatra::Sibilant
@@ -24,7 +26,9 @@ Providing sibilant code inside of a [tilt](https://github.com/rtomayko/tilt/) en
     #./views/templated.sibilant
     get('/templated.js') { sibilant :templated }
 
-## When it's ready, here's how you'll install it
+## How to install
+
+First, you'll need [NodeJS](http://nodejs.org/) installed.
 
 Add this line to your application's Gemfile:
 

data/js/sibilant/.gitignore

@@ -0,0 +1,4 @@
+public/.sass-cache
+lib/core.js
+tmp/*
+*.swp

data/js/sibilant/.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+  - "0.8"
+  - "0.6"

data/js/sibilant/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jacob Rothstein
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/js/sibilant/README.md

@@ -0,0 +1,70 @@
+[![Build Status](https://travis-ci.org/jbr/sibilant.png?branch=master)](https://travis-ci.org/jbr/sibilant)
+
+# Sibilant
+
+- Sibilant is a language that is parsed by javascript and compiles to
+  javascript.
+- Sibilant is inspired by lisp and follows many lisp conventions,
+  although it is still relatively close to the underlying javascript.
+- Macros can be defined in sibilant and included at compile time.
+- Sibilant is entirely written in sibilant and can recompile itself.
+
+## Language Priorities
+
+- Prefer verbose names to abbreviations by default.
+- Avoid line noise.  Prefer established punctuation semantics from
+  natural languages and common programming languages (eg commas come
+  after things and mean a pause or separation).
+- Prefer readable and idiomatic javascript output, which necessitates
+  sticking fairly closely to javascript semantics. Switching cost from
+  sibilant to directly editing the output javascript should be low.
+- Prefer expressions to statements. This is the most notable exception
+  to the adherance to idiomatic javascript. Self-executing functions
+  are used extensively to this end.
+- Allow as much of the language to be modified in-source as
+  possible. This includes the ability to rename/remove/redefine all
+  keywords and macros.
+- Any language constructs that do not output readable javascript
+  should be opt-in.
+- Add language features slowly, and only when there's a real use
+  case. Don't blindly implement Lisp features without reasoning
+  through the need.
+- Provide tools to simplify avoidance of repetition.
+
+## Try it before you install
+
+[sibilantjs.info](http://sibilantjs.info) includes an in-browser
+as-you-type sibilant compiler and tutorial, so you can get a sense of
+the language without leaving your browser.
+
+## Installation
+
+First, install [node.js](http://nodejs.org) [
+[github](http://github.com/ry/node) ] and [npm](http://npmjs.org) [
+[github](http://github.com/isaacs/npm) ].  Then, it's as simple as:
+
+    $ npm install sibilant -g
+    $ sibilant --help
+
+## Learning the language and examples
+
+The most up to date documentation will always be
+[sibilantjs.info](http://sibilantjs.info) which includes an
+as-you-type in-browser sibilant compiler.  Check out [sibilant itself,
+which is written 100% in
+sibilant](http://github.com/jbr/sibilant/tree/master/src) to get a
+sense of what's possible.
+
+## How to get involved or learn more
+
+Send a blank email to
+[sibilant@librelist.com](mailto:sibilant@librelist.com) to join the
+mailing list.  Add any bugs or feature requests to the
+[issues](http://github.com/jbr/sibilant/issues) page or email the
+list.  Happy hacking, have fun!
+
+## License
+
+Sibilant is released under the [MIT
+license](http://github.com/jbr/sibilant/blob/master/LICENSE)
+([wikipedia](http://en.wikipedia.org/wiki/MIT_License)).

data/js/sibilant/bin/sibilant

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require ('./../lib/cli')

data/js/sibilant/cli-help

@@ -0,0 +1,79 @@
+Hi there!  Thanks for installing sibilant.
+Please leave feedback on github issues (http://github.com/jbr/sibilant/issues)
+
+The current commandline options are
+--------------------------------------------------------------------------------
+
+-v / --version         Print out a version string and exit
+
+-h / --help            This message
+
+--repl / [no args]     Sibilant interactive command prompt
+
+--eval [optional STRING] / -e [optional STRING]
+                       Evaluate STRING if provided, otherwise evaluate STDIN.
+                       This is the same as -x -i [optional STRING]
+
+--execute / -x         This is a flag. Execute input files in order supplied.
+
+--output DIR / -o DIR  Output input files to this dir, replacing .sibilant with .js.
+
+--input [optional STRING / -i [optional STRING]
+                       Interpret optional string as sibilant code.  If the execute
+                       flag is set, execute this code.  If STRING is not provided,
+                       read STDIN.
+
+--file FILE / -f FILE / FILE
+                       Add this file to the input files. If the execute flag is
+                       set, input files will be executed.  If an output dir is
+                       specified, each file will be written to that dir.
+                       Otherwise, each file will be written to STDOUT.
+
+
+To pass arguments to an executed file, append them after a \"--\", as follows
+$ sibilant -x myfile.sibilant -- --arg-for-my-program=stuff
+
+myfile.sibilant will see process.argv as
+[ 'sibilant', 'myfile.sibilant', '--arg-for-my-program=stuff' ]
+
+--------------------------------------------------------------------------------
+
+Examples
+
+to compile sibilant
+$ git clone git://github.com/jbr/sibilant.git
+$ npm link .
+$ sibilant src/*.sibilant -o lib
+$ sibilant -x test/test.sibilant # you're now running a sibilant you just compiled.
+
+to compile one file to stdout
+$ sibilant test/test.sibilant
+
+to compile a file to a directory
+$ sibilant test/test.sibilant -o . # put test.js here
+or
+$ sibilant --file test/test.sibilant --output .
+
+to run a file
+$ sibilant -x test/test.sibilant
+
+to enter the repl
+$ sibilant
+or
+$ sibilant --repl
+
+to see how something will translate to js,
+$ sibilant -i "(console.log (+ 2 2))"
+console.log((2 + 2));
+
+to execute a quick snippet,
+$ sibilant -e "(console.log (+ 2 2))" # this is the same as -x -i
+4
+
+to translate STDIN,
+$ echo "(console.log 'hello 'world)" | sibilant -i
+console.log("hello", "world");
+
+to execute sibilant code on STDIN,
+$ echo "console.log 'hello 'world)" | sibilant -e # or sibilant -x -i
+hello world

data/js/sibilant/include/functional.sibilant

@@ -0,0 +1,57 @@
+(defun bulk-map (arr fn)
+  (defvar index 0
+          group-size fn.length
+          ret-arr [])
+
+  (while (< index arr.length)
+    (send ret-arr push
+          (apply fn (send arr slice
+                          index (+ index group-size))))
+    (incr-by index group-size))
+  ret-arr)
+
+(defun inject (start items fn)
+  (defvar value start)
+  (when (list? items)
+    (each (item index) items
+      (setf value (fn value item index))))
+  value)
+
+(defun map (items fn)
+  (inject [] items
+          (lambda (collector item index)
+            (send collector push (fn item index))
+            collector)))
+
+(defun select (items fn)
+  (inject [] items
+          (lambda (collector item index)
+            (when (fn item index)
+              (send collector push item))
+            collector)))
+
+(defun detect (items fn)
+  (defvar return-item undefined
+          index 0
+          items items)
+
+  (until (or (= items.length index) return-item)
+         (when (fn (get items index) index)
+           (setf return-item (get items index)))
+         (incr index)))
+
+(defun reject (items fn)
+  (defvar args [ items fn ])
+  (select items (thunk (not (apply fn arguments)))))
+
+(defun compact (arr)
+  (select arr (lambda (item)
+                (as-boolean item))))
+
+(defun flatten (&rest items)
+  (inject [] items
+          (lambda (collector item)
+            (collector.concat
+             (if (list? item)
+               (apply flatten item)
+               item)))))

data/js/sibilant/include/macros.sibilant

@@ -0,0 +1,374 @@
+(defmacro cons (first rest)
+  (macros.send (macros.list first) 'concat rest))
+
+(defmacro join (glue arr)
+  (concat "(" (translate arr) ").join(" (translate glue) ")"))
+
+(defmacro list (&rest args)
+  (concat "[ " (join ", " (map args translate)) " ]"))
+
+(defmacro get (arr i) (concat "(" (translate arr) ")[" (translate i) "]"))
+
+(defmacro +   (&rest args)
+  (concat "(" (join " + " (map args translate)) ")"))
+(defmacro -   (&rest args)
+  (concat "(" (join " - " (map args translate)) ")"))
+(defmacro *   (&rest args)
+  (concat "(" (join " * " (map args translate)) ")"))
+(defmacro /   (&rest args)
+  (concat "(" (join " / " (map args translate)) ")"))
+(defmacro or  (&rest args)
+  (concat "(" (join " || " (map args translate)) ")"))
+(defmacro and (&rest args)
+  (concat "(" (join " && " (map args translate)) ")"))
+(defmacro mod (&rest args)
+  (concat "(" (join " % " (map args translate)) ")"))
+
+
+
+(defmacro infix-comparator (comparator args)
+  (concat "("
+          (join " && "
+                (map (args.slice 0 -1)
+                     (lambda (item index)
+                       (concat item
+                               " " comparator " "
+                               (get args (+ 1 index))))))
+          ")"))
+
+(defmacro >  (&rest args) (macros.infix-comparator  ">"  (map args translate)))
+(defmacro <  (&rest args) (macros.infix-comparator  "<"  (map args translate)))
+(defmacro <= (&rest args) (macros.infix-comparator "<="  (map args translate)))
+(defmacro >= (&rest args) (macros.infix-comparator ">="  (map args translate)))
+(defmacro != (&rest args) (macros.infix-comparator "!==" (map args translate)))
+
+(defmacro pow (base exponent)
+  (macros.call "Math.pow" base exponent))
+
+(defmacro incr-by (item increment)
+  (concat (translate item) " += " (translate increment)))
+
+(defmacro incr (item)
+  (concat "((" (translate item) ")++)"))
+
+(defmacro decr (item)
+  (concat "((" (translate item) ")--)"))
+
+(defmacro set (arr &rest kv-pairs)
+  (join "\n" (bulk-map kv-pairs
+		       (lambda (k v)
+			 (concat "(" (translate arr) ")"
+				 "[" (translate k) "] = " (translate v) ";")))))
+
+(defmacro send (object method &rest args)
+  (concat (translate object) "." (translate method)
+	  "(" (join ", " (map args translate)) ")"))
+
+(defmacro new (fn)
+  (concat "(new " (translate fn) ")"))
+
+(defmacro regex (string &optional glim)
+  ((get macros 'new) (macros.call "RegExp" string (or glim "undefined"))))
+
+(defmacro timestamp ()
+  (concat "\"" (send (new (-date)) to-string) "\""))
+
+(defmacro comment (&rest contents)
+  (map contents
+       (lambda (item)
+	 (join "\n" (map (send (translate item) split "\n")
+			 (lambda (line) (concat "// " line)))))))
+
+(defmacro meta (body)
+  (eval (translate body)))
+
+(defmacro apply (fn arglist)
+  (macros.send fn 'apply 'undefined arglist))
+
+(defmacro zero? (item)
+  ((get macros "=") (translate item) 0))
+
+(defmacro empty? (arr)
+  (concat "((" (translate arr) ").length === 0)"))
+
+(defmacro odd? (number)
+  ((get macros "!=") 0
+   (macros.mod (translate number) 2)))
+
+(defmacro even? (number)
+  ((get macros "=") 0
+   (macros.mod (translate number) 2)))
+
+
+(defmacro function? (thing)
+  (concat "typeof(" (translate thing) ") === 'function'"))
+
+(defmacro undefined? (thing)
+  (concat "typeof(" (translate thing) ") === 'undefined'"))
+
+(defmacro defined? (thing)
+  (concat "typeof(" (translate thing) ") !== 'undefined'"))
+
+(defmacro number? (thing)
+  (concat "typeof(" (translate thing) ") === 'number'"))
+
+(defmacro first (arr) (macros.get arr 0))
+(defmacro second (arr) (macros.get arr 1))
+(defmacro third (arr) (macros.get arr 2))
+(defmacro fourth (arr) (macros.get arr 3))
+(defmacro fifth (arr) (macros.get arr 4))
+(defmacro sixth (arr) (macros.get arr 5))
+(defmacro seventh (arr) (macros.get arr 6))
+(defmacro eighth (arr) (macros.get arr 7))
+(defmacro ninth (arr) (macros.get arr 8))
+
+(defmacro rest (arr)
+  (macros.send arr 'slice 1))
+
+(defmacro length (arr)
+  (macros.get arr "\"length\""))
+
+(defmacro last (arr)
+  (macros.get (macros.send arr 'slice -1) 0))
+
+(defmacro if (arg truebody falsebody)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "if (" (translate arg) ") {"
+	    (indent (macros.progn truebody))
+	    "} else {"
+	    (indent (macros.progn falsebody))
+	    "}"))
+   "})()"))
+
+(defmacro defvar (&rest pairs)
+  (as-statement
+   (concat "var "
+           (join ",\n    "
+                 (bulk-map pairs
+                           (lambda (name value)
+                             (concat (translate name) " = "
+                                     (translate value)))))
+           ";")))
+
+(defmacro = (first-thing &rest other-things)
+  (defvar translated-first-thing (translate first-thing))
+  (concat "("
+          (join " &&\n "
+                (map other-things
+                     (lambda (thing)
+                       (concat translated-first-thing
+                               " === "
+                               (translate thing)))))
+          ")"))
+
+
+(defmacro string? (thing)
+  (concat "typeof(" (translate thing) ") === \"string\""))
+
+(defmacro list? (thing)
+  (defvar translated (concat "(" (translate thing) ")"))
+  (concat translated " && "
+	  translated ".constructor.name === \"Array\""))
+
+
+(defmacro when (arg &rest body)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "if (" (translate arg) ") {"
+	    (indent (apply macros.progn body))
+	    "}"))
+   "})()"))
+
+
+
+(defmacro not (exp)
+  (concat "(!" (translate exp) ")"))
+
+(defmacro slice (arr start &optional end)
+  (macros.send (translate arr) "slice" start end))
+
+(defmacro inspect (&rest args)
+  (join " + \"\\n\" + "
+        (map args
+             (lambda (arg)
+               (concat "\"" arg ":\" + " (translate arg))))))
+
+(defmacro each (item array &rest body)
+  (macros.send (translate array) 'for-each
+               (apply macros.lambda (cons item body))))
+
+
+(defmacro setf (&rest args)
+  (join "\n"
+	(bulk-map args (lambda (name value)
+			 (as-statement (concat (translate name) " = "
+				 (translate value)))))))
+
+
+(defmacro macro-list ()
+  (concat "["
+	  (indent (join ",\n"
+			(map (-object.keys macros)
+			     macros.quote)))
+	  "]"))
+
+(defmacro macroexpand (name)
+  (defvar macro (get macros (translate name)))
+  (if macro
+    (concat "// macro: " name "\n" (send macro to-string))
+    "undefined"))
+
+(defmacro throw (&rest string)
+  (concat "throw new Error (" (join " " (map string translate)) ")"))
+
+(defmacro as-boolean (expr)
+  (concat "(!!(" (translate expr) "))"))
+
+(defmacro chain (object &rest calls)
+  (concat (translate object) " // chain"
+	  (indent (join "\n"
+                        (map calls
+                             (lambda (call, index)
+                               (defvar method (first call))
+                               (defvar args (rest call))
+                               (concat "." (translate method)
+                                       "(" (join ", " (map args translate)) ")")))))))
+
+(defmacro try (tryblock catchblock)
+  (concat
+   "(function() {"
+   (indent (concat
+	    "try {"
+	    (indent (macros.progn tryblock))
+	    "} catch (e) {"
+	    (indent (macros.progn catchblock))
+	    "}"))
+   "})()"))
+
+
+(defmacro while (condition &rest block)
+  (macros.scoped
+   (macros.defvar '**return-value**)
+   (concat "while (" (translate condition) ") {"
+           (indent (macros.setf '**return-value**
+                                (apply macros.scoped block))))
+   "}"
+   '**return-value**))
+
+(defmacro until (condition &rest block)
+  (apply (get macros 'while)
+         (cons ['not condition] block)))
+
+
+(defmacro thunk (&rest args)
+  (apply macros.lambda (cons [] args)))
+
+(defmacro keys (obj)
+  (macros.call "Object.keys" (translate obj)))
+
+(defmacro delete (&rest objects)
+  (join "\n" (map objects (lambda (obj)
+                            (concat "delete " (translate obj) ";")))))
+
+(defmacro delmacro (macro-name)
+  (delete (get macros (translate macro-name)))
+  "")
+
+(defmacro alias-macro (current-macro-name desired-macro-name)
+  (defvar current-macro-name (translate current-macro-name)
+          desired-macro-name (translate desired-macro-name))
+  (set macros desired-macro-name (get macros current-macro-name))
+  "")
+
+(defmacro rename-macro (current-macro-name desired-macro-name)
+  (macros.alias-macro current-macro-name desired-macro-name)
+  (macros.delmacro current-macro-name)
+  "")
+
+(defmacro defhash (name &rest pairs)
+  (macros.defvar name (apply macros.hash pairs)))
+
+(defmacro arguments ()
+  "(Array.prototype.slice.apply(arguments))")
+
+(defmacro scoped (&rest body)
+  (macros.call (apply macros.thunk body)))
+
+(defmacro each-key (as obj &rest body)
+  (concat "(function() {"
+	  (indent
+	   (concat "for (var " (translate as) " in " (translate obj) ") "
+		   (apply macros.scoped body)
+		   ";"))
+	  "})();"))
+
+(defmacro match? (regexp string)
+  (macros.send string 'match regexp))
+
+(defmacro switch (obj &rest cases)
+
+  ;; the complexity of this macro indicates there's a problem
+  ;; I'm not quite sure where to fix this, but it has to do with quoting.
+  (defvar lines (list (concat "switch(" (translate obj) ") {")))
+  (each (case-def) cases
+    (defvar case-name (first case-def))
+    (when (and (list? case-name)
+               (= (first case-name) 'quote))
+      (defvar second (second case-name))
+      (setf case-name (if (list? second)
+                        (map second macros.quote)
+                        (macros.quote second))))
+
+    (defvar case-string
+            (if (list? case-name)
+	      (join "\n" (map case-name (lambda (c)
+					  (concat "case " (translate c) ":"))))
+              (if (= 'default case-name) "default:"
+                  (concat "case " (translate case-name) ":"))))
+
+    (lines.push (concat case-string
+                        (indent (apply macros.progn (case-def.slice 1))))))
+
+  ;; the following two lines are to get the whitespace right
+  ;; this is necessary because switches are indented weird
+  (set lines (- lines.length 1)
+       (chain (get lines (- lines.length 1)) (concat "}")))
+
+  (concat "(function() {" (apply indent lines) "})()"))
+
+
+(defmacro if-else (&rest args)
+    (concat "(function() {"
+        (indent
+            (join " else "
+                (bulk-map args
+                    (lambda (cond val)
+                        (if (undefined? val)
+                            (concat "{" (indent (macros.progn cond)) "}")
+                            (concat "if (" (translate cond) ") {"
+                                (indent (macros.progn val))
+                                "}"))))))
+    "})()"))
+
+(defmacro let (args &optional body)
+  (concat "let (" (bulk-map args
+    (lambda (h k v)
+      (concat (translate k) " = " (translate v))))
+    (if (undefined? body) ");"
+        (concat ") {" (indent (translate body)) "}"))))
+
+(defmacro instance-of? (item type)
+  (concat "(" (translate item) " instanceof " (translate type) ")"))
+
+(defmacro slice (list &optional begin &optional end)
+  (concat "Array.prototype.slice.call(" (translate list)
+          ", " (or (translate begin) 0)
+          (if (defined? end) (concat ", " (translate end) ")") ")")))
+
+(defmacro ternary (cond if-true if-false)
+  (concat "(" (translate cond) ") ? "
+          (translate if-true) " : "
+          (translate if-false)))

data/js/sibilant/include/node.sibilant

@@ -0,0 +1,2 @@
+(defmacro on (thing event &rest args-and-body)
+  (macros.send thing 'on (macros.quote event) (apply macros.lambda args-and-body)))