sibilant 0.0.1 → 0.0.2

data/js/sibilant/misc/sibilant-mode.el

@@ -0,0 +1,129 @@
+;;; sibilant-mode.el --- Major mode for Sibilant Lisp
+
+;; I should mention that I looked at clojure-mode
+;; (https://github.com/jochu/clojure-mode) when writing this.
+
+(require 'cl)
+
+(defgroup sibilant-mode nil
+  "A mode for Sibilant Lisp"
+  :prefix "sibilant-mode-"
+  :group 'applications)
+
+(defvar sibilant-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map lisp-mode-shared-map)
+    (define-key map (kbd "RET") 'reindent-then-newline-and-indent)
+    map)
+  "Keymap for Sibilant mode. Inherits from `lisp-mode-shared-map'.")
+
+(defvar sibilant-mode-syntax-table
+  (let ((table (copy-syntax-table emacs-lisp-mode-syntax-table)))
+    (modify-syntax-entry ?: "." table)
+    (modify-syntax-entry ?, "." table)
+    (modify-syntax-entry ?\{ "(}" table)
+    (modify-syntax-entry ?\} "){" table)
+    (modify-syntax-entry ?\[ "(]" table)
+    (modify-syntax-entry ?\] ")[" table)
+    (modify-syntax-entry ?/  "|" table)
+    table))
+
+;;;###autoload
+(defun sibilant-mode ()
+  "Major mode for editing Sibilant code - similar to Lisp mode."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map sibilant-mode-map)
+  (setq major-mode 'sibilant-mode)
+  (setq mode-name "Sibilant")
+  (lisp-mode-variables nil)
+
+  (set-syntax-table sibilant-mode-syntax-table)
+
+  (set (make-local-variable 'lisp-indent-function)
+       'sibilant-indent-function)
+
+  (sibilant-mode-font-lock-setup)
+
+  (run-mode-hooks 'sibilant-mode-hook))
+
+(defun sibilant-mode-font-lock-setup ()
+  "Configures font-lock for editing Sibilant code."
+  (interactive)
+  (setq font-lock-defaults
+        '(sibilant-font-lock-keywords)))
+
+(defconst sibilant-font-lock-keywords
+  '(("(\\(defun\\|defmacro\\)[ \t\n\r]+\\([[:alnum:].-]+[?!]?\\)[ \t\r\n]+(\\(.*?\\))"
+     (1 font-lock-keyword-face)
+     (2 font-lock-function-name-face)
+     (3 font-lock-variable-name-face))
+    ("(\\(lambda\\)[[:space:]]+(\\(.*?\\))"
+     (1 font-lock-keyword-face)
+     (2 font-lock-variable-name-face))
+    ("(\\(defvar\\|setf?\\)[ \r\n\t]+\\([[:alnum:].-]+[?!]?\\)"
+     (1 font-lock-keyword-face)
+     (2 font-lock-variable-name-face))
+    ("(\\(thunk\\|if\\|when\\|apply\\|concat\\|throw\\|switch\\|each\\|chain\\|try\\|progn\\|call\\|default\\)[ \t\r\n)]+"
+     (1 font-lock-builtin-face))
+    ("&[[:alnum:]]+" . font-lock-keyword-face)
+    ("'[[:alnum:].-]+[?!]?" . font-lock-string-face)
+    ("(\\([[:alnum:].-]+[?!]?\\)" (1 font-lock-constant-face nil t))
+    ))
+
+
+(defun sibilant-indent-function (indent-point state)
+  (let ((normal-indent (current-column)))
+    (goto-char (1+ (elt state 1)))
+    (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
+    (let ((function (buffer-substring (point)
+                                      (progn (forward-sexp 1) (point))))
+          (open-paren (elt state 1))
+          method)
+
+      (setq method (get (intern-soft function) 'sibilant-indent-function))
+
+      (cond
+       ((member (char-after open-paren) '(?\[ ?\{))
+        (goto-char open-paren)
+        (+ 2 (current-column)))
+
+       ((eq method 'defun)
+        (lisp-indent-defform state indent-point))
+
+       ((integerp method)
+        (lisp-indent-specform method state indent-point normal-indent))
+
+       (method
+        (funcall method indent-point state))))))
+
+
+(defun put-sibilant-indent (sym indent)
+  (put sym 'sibilant-indent-function indent))
+
+(defmacro define-sibilant-indent (&rest kvs)
+  `(progn
+     ,@(mapcar (lambda (x) `(put-sibilant-indent
+                        (quote ,(first x)) ,(second x))) kvs)))
+
+(define-sibilant-indent
+  (lambda 'defun)
+  (defun 'defun)
+  (defmacro 'defun)
+  (if 1)
+  (when 1)
+  (while 1)
+  (try 0)
+  (switch 1)
+  (progn 0)
+  (scoped 0)
+  (for 1)
+  (chain 1)
+  (each 2)
+  (thunk 0))
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.sib\\(?:ilant\\)?$" . sibilant-mode))
+
+(provide 'sibilant-mode)
+;;; sibilant-mode.el ends here

data/js/sibilant/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "sibilant",
+  "version": "0.1.3",
+  "keywords": [ "lisp", "javascript", "language" ],
+  "description": "javascript with a lisp",
+  "contributors": [ "Jacob Rothstein <hi@jbr.me> (http://jbr.me)", "Matthew Phillips (http://www.matthewphillips.info/)", "Yuest Wang (http://yue.st/)", "Lyndon Tremblay (http://www.hoovy.org)", "David Sargeant (https://github.com/dubiousdavid)" ],
+  "repositories": {
+    "type": "git",
+    "url": "http://github.com/jbr/sibilant.git"
+  },
+  "bugs": {
+    "mail": "sibilant@librelist.com",
+    "url": "http://github.com/jbr/sibilant/issues"
+  },
+  "bin": { "sibilant": "./bin/sibilant" },
+  "main": "./lib/sibilant",
+  "scripts": { "test": "node ./bin/sibilant test/test.sibilant -x" }
+}
+

data/js/sibilant/package.sibilant

@@ -0,0 +1,16 @@
+{ 'name 'sibilant
+  'version "0.1.3"
+  'keywords '(lisp javascript language)
+  'description "javascript with a lisp"
+  'contributors [ "Jacob Rothstein <hi@jbr.me> (http://jbr.me)"
+                  "Matthew Phillips (http://www.matthewphillips.info/)"
+                  "Yuest Wang (http://yue.st/)"
+                  "Lyndon Tremblay (http://www.hoovy.org)"
+                  "David Sargeant (https://github.com/dubiousdavid)" ]
+  'repositories { 'type 'git
+                  'url  "http://github.com/jbr/sibilant.git" }
+  'bugs         { 'mail "sibilant@librelist.com"
+                  'url "http://github.com/jbr/sibilant/issues" }
+  'bin          { 'sibilant "./bin/sibilant" }
+  'main         "./lib/sibilant"
+  'scripts      { 'test "node ./bin/sibilant test/test.sibilant -x" }}

data/js/sibilant/public/index.html

@@ -0,0 +1,502 @@
+<!DOCTYPE html> 
+<html> 
+  <head> 
+    <script src="/javascripts/jquery.js"></script> 
+    <script src="/javascripts/jquery-ui.js"></script> 
+    <script src="/javascripts/macros.sibilant" type="text/sibilant"></script> 
+    <script src="/javascripts/sibilant.info.sibilant" type="text/sibilant"></script> 
+    <script src="/javascripts/browser.js"></script> 
+    <link rel="stylesheet" href="/stylesheets/sibilant.css"/>
+    <title>Sibilant: Javascript with a lisp</title>
+    <script type="text/javascript">
+      var _gaq = _gaq || [];
+      _gaq.push(['_setAccount', 'UA-17635250-1']);
+      _gaq.push(['_trackPageview']);
+      
+      (function() {
+        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+      })();
+    </script>
+  </head>
+  <body>
+    <header>
+      <h1>SibilantJS</h1>
+      <h2>stuff</h2>
+      <div id="controls"> 
+	<a id="prev" href="#">Previous</a>
+	<a id="next" href="#">Next</a>
+      </div>
+    </header>
+
+    <a id="fork-me-on-github" href="http://github.com/jbr/sibilant"> 
+      <span>Fork me on github</span> 
+    </a> 
+ 
+    <div id="left"> 
+      <textarea name="content">
+      </textarea> 
+    </div> 
+ 
+    <div id="right"> 
+      <pre id="output">
+      </pre>
+    </div> 
+
+
+    <script id="welcome" language="sibilant/example" data-title="Welcome">
+; Welcome to the sibilant tutorial.
+; Sibilant code and comments will
+; appear in the left column and
+; the equivalent javascript will
+; be generated by your browser
+; in the right column.
+;
+;
+; You can edit the sibilant code
+; at any time to see how the js
+; changes.
+;
+;
+; Press the next button
+; to begin.
+</script>
+
+    <script id="numbers-and-strings"
+	    language="sibilant/example"
+	    data-title="Literals: Numbers & Strings">
+<![CDATA[
+; Numbers should look pretty familiar
+;
+5
+10.5
+-100.5
+;
+; Use commas for readability
+;
+1,000,000.00
+;
+; Strings start and end
+; with a double quote.
+;
+"hello world"
+"he said to them \"hello\""
+"multiline strings
+are allowed"
+]]>
+    </script>
+
+<script id="literal-variables"
+	language="sibilant/example"
+	data-title="Literals: Variable names">
+<![CDATA[
+"Variable names may include letters,
+the period (.) and the hyphen (-).
+Lower case letters are idiomatic.
+They may end with a question mark (?) or with a
+bang (!). They may start with a sigil ($)."
+
+simple
+multi-word-variable-name
+is-this-thing-on?
+save!
+variable-number-5
+$jquery
+JSON
+
+]]>
+</script>
+
+
+<script id="quoting"
+	language="sibilant/example"
+	data-title="Quoting">
+<![CDATA[
+; Sibilant supports quoting
+; with the single quote (').
+; Anything that is a legal
+; variable name can be
+; quoted, as well as lists.
+
+'a
+'this-is-a-multi-word-quote
+'(a b c d e)
+
+; This is equivalent to:
+;
+(quote a)
+(quote this-is-a-multi-word-quote)
+(quote (a b c d e))
+]]>
+</script>
+
+
+<script id="lists"
+	language="sibilant/example"
+	data-title="Lists">
+<![CDATA[
+; Lists are made with the list macro
+; and can be nested infinitely.
+; A list translates to a javascript
+; array.
+
+(list hello
+      '(q r s)
+      (list foo bar baz))
+
+; [ a b c ] is a shortcut for (list a b c)
+
+[ a 'b 'c  (this-is 'still-sibilant) ]
+
+]]>
+</script>
+
+<script id="hashes"
+	language="sibilant/example"
+	data-title="Hashes/Objects">
+<![CDATA[
+; Sibilant supports javascript
+; hash-objects by way of the
+; hash macro:
+(hash key-one value-one
+      key-two value-two)
+
+(hash a b c d e f)
+
+; { a b } is a shortcut for (hash a b)
+{ a 'b c (+ 1 2 3) }
+</script>
+
+
+<script id="defining-variables"
+	language="sibilant/example"
+	data-title="Defining Variables">
+<![CDATA[
+; Define a variable with the defvar
+; macro. This translates directly
+; to the var keyword in javascript.
+
+(defvar foo 35)
+(defvar wibble "test")
+(defvar bar '(multi word array))
+
+(defvar var1 val1
+        var2 val2)
+
+; To modify an existing variable,
+; use setf.
+
+(setf foo 10)
+(setf a 1
+      b 2)
+]]>
+</script>
+
+
+<script id="functions"
+	language="sibilant/example"
+	data-title="Defining Functions">
+<![CDATA[
+(defun alert-hello (planet-name)
+  (defvar message (concat "hello " planet-name))
+  (alert message)
+  message)
+
+(defvar my-message (alert-hello 'world))
+; my-message is now "hello world"
+]]>
+</script>
+
+<script id="variable-count-arguments"
+	language="sibilant/example"
+	data-title="Variable count arguments">
+<![CDATA[
+(defun alert-each-argument(&rest my-arguments)
+  (each (arg) my-arguments (alert arg)))
+
+(alert-each-argument 'hello 'world 'foo)
+]]>
+</script>
+
+<script id="optional-arguments"
+	language="sibilant/example"
+	data-title="Optional arguments">
+<![CDATA[
+; Optional arguments are specified with
+; &optional. If there are fewer than the
+; total number of possible arguments,
+; optional arguments are skipped.  If
+; there are several, they are filled
+; from left to right.
+
+(defun has-optional-arg (&optional optional-arg
+                         mandatory-arg)
+  (when (defined? optional-argument)
+    (alert "optional provided"))
+  mandatory-arg)
+
+(has-optional-arg "only one arg")
+(has-optional-arg true "return value")
+]]>
+</script>
+
+
+<script id="lambdas"
+	language="sibilant/example"
+	data-title="Lambdas">
+<![CDATA[
+; (lambda) works much like (defun)
+; This example uses Node's async
+; readfile
+
+(defvar fs (require 'fs))
+
+(fs.read-file "path/to/file"
+  (lambda (error content)
+    (alert (or error content))))
+]]>
+</script>
+
+
+<script id="when"
+	data-title="When"
+	language="sibilant/example">
+<![CDATA[
+; `when` is the simplest conditional.
+; It only considers the true case.
+; `when` will return the value of the
+; last statement
+
+(defvar this-will-be-true (when (= 5 (+ 3 2))
+  (alert "we've got a five")
+  (post-to-twitter "three and two is five")
+  true))
+]]>
+</script>
+
+<script id="if" data-title="If"
+	language="sibilant/example">
+<![CDATA[
+; `if` is like `when` with an "else."
+(defvar a-or-b (if (< 0.5 (-math.random)) 'a 'b))
+
+; Unlike when, cases may only be a single
+; statement. Use progn to execute several
+; statements.
+
+(defvar a-or-b
+  (if (< 0.5 (-math.random))
+    (progn
+      (log "random was more than 0.5")
+      'a)
+    (progn
+      (log "random was less than 0.5")
+      'b)))
+]]>
+</script>
+
+<script id="switch"
+	data-title="Switch"
+	language="sibilant/example">
+<![CDATA[
+; Switch allows you to check a variable
+; against any number of possible values.
+
+(defvar comment (switch month-name
+  ('january
+    (increment year)
+    "happy new year!")
+  ('(february march) "still pretty cold")
+  ('april "expect showers")
+  ("may" "flowers!")
+  ('(june july august)
+    (enjoy 'sunshine)
+    'summer)
+  ('(september october) "leaves change")
+  ('(november december) "getting chilly")
+  (default
+    (record-unexpected-month month-name)
+    "I didn't recognize that")))
+
+]]>
+</script>
+
+<script id="iteration-with-each"
+	data-title="Iteration with each"
+	language="sibilant/example">
+<![CDATA[
+; To iterate over an array, use the each
+; macro.
+
+(defvar list '(a b c d e))
+(each (letter) list
+  (when (= "C" (letter.to-upper-case))
+    (console.log "this was a c"))
+  (console.log letter))
+
+]]>
+</script>
+
+<script id="while"
+	data-title="While"
+	language="sibilant/example">
+<![CDATA[
+(defvar wall-bottle-count 99)
+
+(defun take-one-down ()
+  (decr wall-bottle-count)
+  the-bottle)
+
+(while (> wall-bottle-count 0)
+  (defvar bottle (take-one-down))
+  (each (person) room
+    (while (not (empty? bottle))
+      (sip bottle))))
+  
+]]>
+</script>
+
+<script id="chain"
+	data-title="Chaining function calls"
+	language="sibilant/example">
+<![CDATA[
+; It is often idiomatic in javascript libraries
+; to chain function calls. Here's how that looks
+; in sibilant:
+
+(chain ($ ".some.random#tag")
+       (show)
+       (css { background-color 'red })
+       (animate { width 100 })
+       (click (lambda (evt)
+         (chain ($ this)
+           (hide)
+           (data 'clicked true))
+         true)))
+]]>
+</script>
+
+<script id="macro-intro"
+	data-title="Sibilant is mostly macros"
+	language="sibilant/example">
+<![CDATA[
+"Now we're getting into advanced stuff.
+Go get a cup of tea or some fresh air.
+I'll be here when you get back.
+
+The real power of sibilant is the ability
+to define (and redefine) macros, extending
+the language.  All constructs can be
+redefined. This includes core language
+features like +, lambda, if, defun, defvar,
+and even defmacro itself.
+
+Defining macros is as easy as defining
+functions, but modify the interpreter
+instead of outputting compiled js.
+Most of sibilant is defined like this:
+
+http://http://j.mp/sibilantmacros"
+
+]]>
+</script>
+
+<script id="defining-macros"
+	data-title="Defining your own macros"
+	language="sibilant/example">
+<![CDATA[
+"As an example, let's say you want to
+add a ternary conditional macro to sibilant.
+Let's call it 'cond'."
+
+(defmacro cond (cond true-value false-value)
+  (concat (translate cond) " ? "
+          (translate true-value) " : "
+          (translate false-value) ";"))
+
+(cond (< 0.5 (-math.random)) 'yep 'nah)
+
+; once removed, cond is just a function call
+(delmacro cond)
+(cond (< 0.5 (-math.random)) 'yep 'nah)
+]]>
+</script>
+
+
+<script id="redefining-macros"
+	data-title="Redefining existing macros"
+	language="sibilant/example">
+<![CDATA[
+; All macros can be redefined, and
+; most of sibilant is macros.
+
+; Let's say we want to add newlines
+; after the commas in a list if
+; there are more than two items.
+
+(defmacro list (&rest args)
+  (concat "["
+    (if (> 3 args.length)
+      (concat " "
+        (join ", " (map args translate)) " ")
+      (indent (join ",\n" (map args translate))))
+    "]"))
+
+(list a b)
+(list a b c)
+]]>
+</script>
+
+<script id="macroexpand"
+	data-title="Expanding macros"
+	language="sibilant/example">
+<![CDATA[
+; Want to find out how a macro is
+; defined in js? Try macroexpand.
+
+(macroexpand if)
+
+(macroexpand defined?)
+
+(macroexpand first)
+
+]]>
+</script>
+
+
+<script id="macro-list"
+	data-title="Listing available macros"
+	language="sibilant/example">
+<![CDATA[
+; use macro-list to find out what
+; macros are available
+
+(macro-list)
+]]>
+</script>
+
+<script id="json"
+	data-title="JSON is valid sibilant"
+	language="sibilant/example">
+<![CDATA[
+"Example from http://www.json.org/example.html:"
+
+{"menu": {
+  "id": "file",
+  "value": "File",
+  "popup": {
+    "menuitem": [
+      {"value": "New", "onclick": "CreateNewDoc()"},
+      {"value": "Open", "onclick": "OpenDoc()"},
+      {"value": "Close", "onclick": "CloseDoc()"}
+    ]
+  }
+}}
+]]>
+</script>
+
+
+
+  </body>
+</html>