haml-more 0.4.0.c → 0.4.0.d

data/vendor/coffee-script/src/cake.coffee

@@ -1,4 +1,6 @@
 # `cake` is a simplified version of Make (Rake, Jake) for CoffeeScript.
+# You define tasks with names and descriptions in a Cakefile, and can call them
+# from the command line, or invoke them from other tasks.
 
 fs:       require 'fs'
 path:     require 'path'
@@ -6,11 +8,7 @@ coffee:   require 'coffee-script'
 
 tasks: {}
 
-no_such_task: (task) ->
-  process.stdio.writeError('No such task: "' + task + '"\n')
-  process.exit(1)
-
-# Mixin the Cake functionality.
+# Mixin the top-level Cake functions for Cakefiles to use.
 process.mixin {
 
   # Define a task with a name, a description, and the action itself.
@@ -23,13 +21,6 @@ process.mixin {
     tasks[name].action()
 }
 
-# Display the list of Cake tasks.
-print_tasks: ->
-  for name, task of tasks
-    spaces: 20 - name.length
-    spaces: if spaces > 0 then (' ' for i in [0..spaces]).join('') else ''
-    puts "cake " + name + spaces + ' # ' + task.description
-
 # Running `cake` runs the tasks you pass asynchronously (node-style), or
 # prints them out, with no arguments.
 exports.run: ->
@@ -39,7 +30,16 @@ exports.run: ->
     fs.readFile 'Cakefile', (err, source) ->
       eval coffee.compile source
       return print_tasks() unless args.length
-      for arg in args
-        no_such_task arg unless tasks[arg]
-        tasks[arg].action()
+      invoke arg for arg in args
 
+# Display the list of Cake tasks.
+print_tasks: ->
+  for name, task of tasks
+    spaces: 20 - name.length
+    spaces: if spaces > 0 then (' ' for i in [0..spaces]).join('') else ''
+    puts "cake " + name + spaces + ' # ' + task.description
+
+# Print an error and exit when attempting to all an undefined task.
+no_such_task: (task) ->
+  process.stdio.writeError('No such task: "' + task + '"\n')
+  process.exit(1)

data/vendor/coffee-script/src/coffee-script.coffee

@@ -24,7 +24,7 @@ parser.lexer: {
   showPosition: -> @pos
 }
 
-exports.VERSION: '0.5.1'
+exports.VERSION: '0.5.2'
 
 # Compile CoffeeScript to JavaScript, using the Coffee/Jison compiler.
 exports.compile: (code, options) ->
@@ -38,8 +38,8 @@ exports.tokenize: (code) ->
 exports.tree: (code) ->
   parser.parse lexer.tokenize code
 
-# Pretty-print a token stream.
-exports.print_tokens: (tokens) ->
-  strings: for token in tokens
-    '[' + token[0] + ' ' + token[1].toString().replace(/\n/, '\\n') + ']'
-  puts strings.join(' ')
+# Activate CoffeeScript in the browser by having it compile and eval
+# all script tags with a content-type of text/coffeescript.
+if document? and document.getElementsByTagName
+  for tag in document.getElementsByTagName('script') when tag.type is 'text/coffeescript'
+    eval exports.compile tag.innerHTML

data/vendor/coffee-script/src/command_line.coffee

@@ -1,7 +1,7 @@
-fs:       require 'fs'
-path:     require 'path'
-coffee:   require 'coffee-script'
-optparse: require('optparse')
+fs:           require 'fs'
+path:         require 'path'
+optparse:     require 'optparse'
+CoffeeScript: require 'coffee-script'
 
 BANNER: '''
   coffee compiles CoffeeScript source files into JavaScript.
@@ -17,10 +17,11 @@ SWITCHES: [
   ['-w', '--watch',         'watch scripts for changes, and recompile']
   ['-p', '--print',         'print the compiled JavaScript to stdout']
   ['-l', '--lint',          'pipe the compiled JavaScript through JSLint']
+  ['-s', '--stdio',         'listen for and compile scripts over stdio']
   ['-e', '--eval',          'compile a string from the command line']
+  ['-n', '--no-wrap',       'compile without the top-level function wrapper']
   ['-t', '--tokens',        'print the tokens that the lexer produces']
   ['-tr','--tree',          'print the parse tree that Jison produces']
-  ['-n', '--no-wrap',       'compile without the top-level function wrapper']
   ['-v', '--version',       'display CoffeeScript version']
   ['-h', '--help',          'display this help message']
 ]
@@ -32,9 +33,12 @@ option_parser: null
 # The CommandLine handles all of the functionality of the `coffee` utility.
 exports.run: ->
   parse_options()
-  return require 'repl' if options.interactive
-  return compile_script 'terminal', sources[0] if options.eval
-  usage() unless sources.length
+  return usage()                              if options.help
+  return version()                            if options.version
+  return require 'repl'                       if options.interactive
+  return compile_stdio()                      if options.stdio
+  return compile_script 'unknown', sources[0] if options.eval
+  return usage()                              unless sources.length
   separator: sources.indexOf '--'
   flags: []
   if separator >= 0
@@ -52,7 +56,7 @@ usage: ->
 
 # The "--version" message.
 version: ->
-  puts "CoffeeScript version " + coffee.VERSION
+  puts "CoffeeScript version " + CoffeeScript.VERSION
   process.exit 0
 
 # Compiles the source CoffeeScript, returning the desired JavaScript, tokens,
@@ -62,23 +66,30 @@ compile_scripts: ->
     fs.readFile source, (err, code) -> compile_script(source, code)
   compile(source) for source in sources
 
-
 # Compile a single source script, containing the given code, according to the
 # requested options. Both compile_scripts and watch_scripts share this method.
 compile_script: (source, code) ->
-  opts: options
-  o: if opts.no_wrap then {no_wrap: true} else {}
+  o: options
   try
-    if      opts.tokens   then coffee.print_tokens coffee.tokenize code
-    else if opts.tree     then puts coffee.tree(code).toString()
+    if      o.tokens            then print_tokens CoffeeScript.tokenize code
+    else if o.tree              then puts CoffeeScript.tree(code).toString()
     else
-      js: coffee.compile code, o
-      if      opts.run                then eval js
-      else if opts.lint               then lint js
-      else if opts.print or opts.eval then puts js
-      else                     write_js source, js
+      js: CoffeeScript.compile code, compile_options()
+      if      o.run             then eval js
+      else if o.lint            then lint js
+      else if o.print or o.eval then print js
+      else                           write_js source, js
   catch err
-    if opts.watch then puts err.message else throw err
+    if o.watch                  then puts err.message else throw err
+
+# Listen for and compile scripts over stdio.
+compile_stdio: ->
+  code: ''
+  process.stdio.open()
+  process.stdio.addListener 'data', (string) ->
+    code += string if string
+  process.stdio.addListener 'close', ->
+    process.stdio.write CoffeeScript.compile code, compile_options()
 
 # Watch a list of source CoffeeScript files, recompiling them every time the
 # files are updated.
@@ -106,25 +117,18 @@ lint: (js) ->
   jsl.write js
   jsl.close()
 
+# Pretty-print a token stream.
+print_tokens: (tokens) ->
+  strings: for token in tokens
+    '[' + token[0] + ' ' + token[1].toString().replace(/\n/, '\\n') + ']'
+  puts strings.join(' ')
+
 # Use OptionParser for all the options.
 parse_options: ->
-  opts:           options: {}
-  oparser:        option_parser: new optparse.OptionParser SWITCHES
-  oparser.banner: BANNER
-
-  oparser.add 'interactive',      -> opts.interactive: true
-  oparser.add 'run',              -> opts.run:         true
-  oparser.add 'output',     (dir) -> opts.output:      dir
-  oparser.add 'watch',            -> opts.watch:       true
-  oparser.add 'print',            -> opts.print:       true
-  oparser.add 'lint',             -> opts.lint:        true
-  oparser.add 'eval',             -> opts.eval:        true
-  oparser.add 'tokens',           -> opts.tokens:      true
-  oparser.add 'tree',             -> opts.tree:        true
-  oparser.add 'no-wrap',          -> opts.no_wrap:     true
-  oparser.add 'help',             => usage()
-  oparser.add 'version',          => version()
-
-  paths: oparser.parse(process.ARGV)
-  sources: paths[2...paths.length]
+  option_parser: new optparse.OptionParser SWITCHES, BANNER
+  options: option_parser.parse(process.ARGV)
+  sources: options.arguments[2...options.arguments.length]
 
+# The options to pass to the CoffeeScript compiler.
+compile_options: ->
+  if options['no-wrap'] then {no_wrap: true} else {}

data/vendor/coffee-script/src/nodes.coffee

@@ -54,13 +54,13 @@ statement: (klass, only) ->
 # generated code should be wrapped up in a closure. An options hash is passed
 # and cloned throughout, containing messages from higher in the AST,
 # information about the current scope, and indentation level.
-Node: exports.Node: ->
+BaseNode: exports.BaseNode: ->
 
 # This is extremely important -- we convert JS statements into expressions
 # by wrapping them in a closure, only if it's possible, and we're not at
 # the top level of a block (which would be unnecessary), and we haven't
 # already been asked to return the result.
-Node::compile: (o) ->
+BaseNode::compile: (o) ->
   @options: merge o or {}
   @indent:  o.indent
   del @options, 'operation' unless @operation_sensitive()
@@ -72,46 +72,46 @@ Node::compile: (o) ->
 
 # Statements converted into expressions share scope with their parent
 # closure, to preserve JavaScript-style lexical scope.
-Node::compile_closure: (o) ->
+BaseNode::compile_closure: (o) ->
   @indent: o.indent
   o.shared_scope: o.scope
   ClosureNode.wrap(this).compile(o)
 
 # If the code generation wishes to use the result of a complex expression
 # in multiple places, ensure that the expression is only ever evaluated once.
-Node::compile_reference: (o) ->
+BaseNode::compile_reference: (o) ->
   reference: new LiteralNode(o.scope.free_variable())
   compiled:  new AssignNode(reference, this)
   [compiled, reference]
 
 # Quick short method for the current indentation level, plus tabbing in.
-Node::idt: (tabs) ->
+BaseNode::idt: (tabs) ->
   idt: (@indent || '')
   idt += TAB for i in [0...(tabs or 0)]
   idt
 
 # Does this node, or any of its children, contain a node of a certain kind?
-Node::contains: (block) ->
+BaseNode::contains: (block) ->
   for node in @children
     return true if block(node)
-    return true if node instanceof Node and node.contains block
+    return true if node instanceof BaseNode and node.contains block
   false
 
 # toString representation of the node, for inspecting the parse tree.
-Node::toString: (idt) ->
+BaseNode::toString: (idt) ->
   idt ||= ''
   '\n' + idt + @type + (child.toString(idt + TAB) for child in @children).join('')
 
 # Default implementations of the common node methods.
-Node::unwrap:               -> this
-Node::children:             []
-Node::is_statement:         -> false
-Node::is_statement_only:    -> false
-Node::top_sensitive:        -> false
-Node::operation_sensitive:  -> false
+BaseNode::unwrap:               -> this
+BaseNode::children:             []
+BaseNode::is_statement:         -> false
+BaseNode::is_statement_only:    -> false
+BaseNode::top_sensitive:        -> false
+BaseNode::operation_sensitive:  -> false
 
 # A collection of nodes, each one representing an expression.
-Expressions: exports.Expressions: inherit Node, {
+Expressions: exports.Expressions: inherit BaseNode, {
   type: 'Expressions'
 
   constructor: (nodes) ->
@@ -144,7 +144,7 @@ Expressions: exports.Expressions: inherit Node, {
 
   compile: (o) ->
     o ||= {}
-    if o.scope then Node::compile.call(this, o) else @compile_root(o)
+    if o.scope then BaseNode::compile.call(this, o) else @compile_root(o)
 
   # Compile each expression in the Expressions body.
   compile_node: (o) ->
@@ -156,7 +156,7 @@ Expressions: exports.Expressions: inherit Node, {
     o.scope: new Scope(null, this, null)
     code: if o.globals then @compile_node(o) else @compile_with_declarations(o)
     code: code.replace(TRAILING_WHITESPACE, '')
-    if o.no_wrap then code else "(function(){\n"+code+"\n})();"
+    if o.no_wrap then code else "(function(){\n"+code+"\n})();\n"
 
   # Compile the expressions body, with declarations of all inner variables
   # pushed up to the top.
@@ -192,7 +192,7 @@ statement Expressions
 
 # Literals are static values that can be passed through directly into
 # JavaScript without translation, eg.: strings, numbers, true, false, null...
-LiteralNode: exports.LiteralNode: inherit Node, {
+LiteralNode: exports.LiteralNode: inherit BaseNode, {
   type: 'Literal'
 
   constructor: (value) ->
@@ -217,7 +217,7 @@ LiteralNode: exports.LiteralNode: inherit Node, {
 LiteralNode::is_statement_only: LiteralNode::is_statement
 
 # Return an expression, or wrap it in a closure and return it.
-ReturnNode: exports.ReturnNode: inherit Node, {
+ReturnNode: exports.ReturnNode: inherit BaseNode, {
   type: 'Return'
 
   constructor: (expression) ->
@@ -233,7 +233,7 @@ ReturnNode: exports.ReturnNode: inherit Node, {
 statement ReturnNode, true
 
 # A value, indexed or dotted into, or vanilla.
-ValueNode: exports.ValueNode: inherit Node, {
+ValueNode: exports.ValueNode: inherit BaseNode, {
   type: 'Value'
 
   SOAK: " == undefined ? undefined : "
@@ -302,7 +302,7 @@ ValueNode: exports.ValueNode: inherit Node, {
 
 # Pass through CoffeeScript comments into JavaScript comments at the
 # same position.
-CommentNode: exports.CommentNode: inherit Node, {
+CommentNode: exports.CommentNode: inherit BaseNode, {
   type: 'Comment'
 
   constructor: (lines) ->
@@ -318,7 +318,7 @@ statement CommentNode
 
 # Node for a function invocation. Takes care of converting super() calls into
 # calls against the prototype's function of the same name.
-CallNode: exports.CallNode: inherit Node, {
+CallNode: exports.CallNode: inherit BaseNode, {
   type: 'Call'
 
   constructor: (variable, args) ->
@@ -366,7 +366,7 @@ CallNode: exports.CallNode: inherit Node, {
 
 # Node to extend an object's prototype with an ancestor object.
 # After goog.inherits from the Closure Library.
-ExtendsNode: exports.ExtendsNode: inherit Node, {
+ExtendsNode: exports.ExtendsNode: inherit BaseNode, {
   type: 'Extends'
 
   constructor: (child, parent) ->
@@ -399,7 +399,7 @@ statement ExtendsNode
 
 # A dotted accessor into a part of a value, or the :: shorthand for
 # an accessor into the object's prototype.
-AccessorNode: exports.AccessorNode: inherit Node, {
+AccessorNode: exports.AccessorNode: inherit BaseNode, {
   type: 'Accessor'
 
   constructor: (name, tag) ->
@@ -414,7 +414,7 @@ AccessorNode: exports.AccessorNode: inherit Node, {
 }
 
 # An indexed accessor into a part of an array or object.
-IndexNode: exports.IndexNode: inherit Node, {
+IndexNode: exports.IndexNode: inherit BaseNode, {
   type: 'Index'
 
   constructor: (index, tag) ->
@@ -429,7 +429,7 @@ IndexNode: exports.IndexNode: inherit Node, {
 
 # A range literal. Ranges can be used to extract portions (slices) of arrays,
 # or to specify a range for list comprehensions.
-RangeNode: exports.RangeNode: inherit Node, {
+RangeNode: exports.RangeNode: inherit BaseNode, {
   type: 'Range'
 
   constructor: (from, to, exclusive) ->
@@ -469,7 +469,7 @@ RangeNode: exports.RangeNode: inherit Node, {
 # An array slice literal. Unlike JavaScript's Array#slice, the second parameter
 # specifies the index of the end of the slice (just like the first parameter)
 # is the index of the beginning.
-SliceNode: exports.SliceNode: inherit Node, {
+SliceNode: exports.SliceNode: inherit BaseNode, {
   type: 'Slice'
 
   constructor: (range) ->
@@ -485,7 +485,7 @@ SliceNode: exports.SliceNode: inherit Node, {
 }
 
 # An object literal.
-ObjectNode: exports.ObjectNode: inherit Node, {
+ObjectNode: exports.ObjectNode: inherit BaseNode, {
   type: 'Object'
 
   constructor: (props) ->
@@ -512,7 +512,7 @@ ObjectNode: exports.ObjectNode: inherit Node, {
 }
 
 # An array literal.
-ArrayNode: exports.ArrayNode: inherit Node, {
+ArrayNode: exports.ArrayNode: inherit BaseNode, {
   type: 'Array'
 
   constructor: (objects) ->
@@ -559,7 +559,7 @@ ClosureNode: exports.ClosureNode: {
 }
 
 # Setting the value of a local variable, or the value of an object property.
-AssignNode: exports.AssignNode: inherit Node, {
+AssignNode: exports.AssignNode: inherit BaseNode, {
   type: 'Assign'
 
   PROTO_ASSIGN: /^(\S+)\.prototype/
@@ -617,7 +617,9 @@ AssignNode: exports.AssignNode: inherit Node, {
         idx: new LiteralNode(idx) unless typeof idx is 'object'
         val: new ValueNode(new LiteralNode(val_var), [new access_class(idx)])
       assigns.push(new AssignNode(obj, val).compile(o))
-    assigns.join("\n")
+    code: assigns.join("\n")
+    code += '\n' + @idt() + 'return ' + @variable.compile(o) + ';' if o.returns
+    code
 
   compile_splice: (o) ->
     name:   @variable.compile(merge(o, {only_first: true}))
@@ -632,7 +634,7 @@ AssignNode: exports.AssignNode: inherit Node, {
 
 # A function definition. The only node that creates a new Scope.
 # A CodeNode does not have any children -- they're within the new scope.
-CodeNode: exports.CodeNode: inherit Node, {
+CodeNode: exports.CodeNode: inherit BaseNode, {
   type: 'Code'
 
   constructor: (params, body, tag) ->
@@ -676,7 +678,7 @@ CodeNode: exports.CodeNode: inherit Node, {
 
 # A splat, either as a parameter to a function, an argument to a call,
 # or in a destructuring assignment.
-SplatNode: exports.SplatNode: inherit Node, {
+SplatNode: exports.SplatNode: inherit BaseNode, {
   type: 'Splat'
 
   constructor: (name) ->
@@ -699,7 +701,7 @@ SplatNode: exports.SplatNode: inherit Node, {
 
 # A while loop, the only sort of low-level loop exposed by CoffeeScript. From
 # it, all other loops can be manufactured.
-WhileNode: exports.WhileNode: inherit Node, {
+WhileNode: exports.WhileNode: inherit BaseNode, {
   type: 'While'
 
   constructor: (condition, opts) ->
@@ -737,7 +739,7 @@ statement WhileNode
 
 # Simple Arithmetic and logical operations. Performs some conversion from
 # CoffeeScript operations into their JavaScript equivalents.
-OpNode: exports.OpNode: inherit Node, {
+OpNode: exports.OpNode: inherit BaseNode, {
   type: 'Op'
 
   CONVERSIONS: {
@@ -801,7 +803,7 @@ OpNode: exports.OpNode: inherit Node, {
 }
 
 # A try/catch/finally block.
-TryNode: exports.TryNode: inherit Node, {
+TryNode: exports.TryNode: inherit BaseNode, {
   type: 'Try'
 
   constructor: (attempt, error, recovery, ensure) ->
@@ -822,7 +824,7 @@ TryNode: exports.TryNode: inherit Node, {
 statement TryNode
 
 # Throw an exception.
-ThrowNode: exports.ThrowNode: inherit Node, {
+ThrowNode: exports.ThrowNode: inherit BaseNode, {
   type: 'Throw'
 
   constructor: (expression) ->
@@ -837,7 +839,7 @@ ThrowNode: exports.ThrowNode: inherit Node, {
 statement ThrowNode, true
 
 # Check an expression for existence (meaning not null or undefined).
-ExistenceNode: exports.ExistenceNode: inherit Node, {
+ExistenceNode: exports.ExistenceNode: inherit BaseNode, {
   type: 'Existence'
 
   constructor: (expression) ->
@@ -856,7 +858,7 @@ ExistenceNode.compile_test: (o, variable) ->
   '(typeof ' + first.compile(o) + ' !== "undefined" && ' + second.compile(o) + ' !== null)'
 
 # An extra set of parentheses, specified explicitly in the source.
-ParentheticalNode: exports.ParentheticalNode: inherit Node, {
+ParentheticalNode: exports.ParentheticalNode: inherit BaseNode, {
   type: 'Paren'
 
   constructor: (expression) ->
@@ -879,7 +881,7 @@ ParentheticalNode: exports.ParentheticalNode: inherit Node, {
 # into a for loop. Also acts as an expression, able to return the result
 # of the comprehenion. Unlike Python array comprehensions, it's able to pass
 # the current index of the loop as a second parameter.
-ForNode: exports.ForNode: inherit Node, {
+ForNode: exports.ForNode: inherit BaseNode, {
   type: 'For'
 
   constructor: (body, source, name, index) ->
@@ -949,7 +951,7 @@ statement ForNode
 # expression by pushing down requested returns to the expression bodies.
 # Single-expression IfNodes are compiled into ternary operators if possible,
 # because ternaries are first-class returnable assignable expressions.
-IfNode: exports.IfNode: inherit Node, {
+IfNode: exports.IfNode: inherit BaseNode, {
   type: 'If'
 
   constructor: (condition, body, else_body, tags) ->