ruby2js 0.2.0 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzA1Mzk5YzBmMWU5OWVhNTQ1MzdlODkwMmE0ZTAyMzhkYjkzZTQzOQ==
+    NWUwYjJjY2RiMjE2MDhkMjdlMDVkODQ4MDFlNWUwYWZjODg3NjUwNA==
   data.tar.gz: !binary |-
-    NzA2YmI3ODFkM2I0Y2I0ZjY1MTFiOTBkNDIxMTE5ZTM5ODdiNzU3ZA==
+    NGU5ZWI1ODU4MThkMTFjOTZjNDZmNDlkYzg2Mjc4NzIxMjNjZDk5MA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NzY0MjhhMzA5YTI0NzVkZWMzYTQxYzBlOTQ1ZjIyZmE5MTkwNmM3ZTViOTA4
-    OGE0ZDNhY2NjYjk3ZDliNDYxOGRmNWY5NDZjYzUyNjBjMmVjNjFkOGMxOWUz
-    NjA5ZDI5MmVlZGYyNzdlMmUwYmJkMDhlNmEyYjNhYTYzZTEyOWI=
+    ODA4MGVkMTZlZjU0MTA5YWM4YTg1OGNhMThlNTg0Nzc4NTViNjI2NDZhZDkx
+    M2YyZmY2YTkxMTE5ZDM5OTA0OGQ4NmNmNzRkNjU2MWJiMjA3MGIwMmExZTFh
+    YTM5OWE3MjExN2NhOGI2ZWJhYWNmYjFjYTc2Y2Y4OWZkYmQyOGY=
   data.tar.gz: !binary |-
-    YzAxMzRhMmY2NGRkMzZlYWNiYjIzZDkyMWM4ZGYyYWYzODRlZGUzMjdkMjQ1
-    ZTAyNzUxOTA4ZTViZmQyZGZiZTg2Y2U3NTk5NDU1NjA2OWVlN2M2YTEyOTQ5
-    ZGI1NTczNDhjNmJlZDNmNjRiMzg1YTljY2EzNmJkMTllZGE3Y2Q=
+    MjI0MzE3MmVmNzNjYzdiOWRjODFlYmRmYzA0NjNkY2U0YTdhZTViNTlhNGRj
+    NzE5ZjY3NjI3NmE3NjhjNzY3MjFiNDEwMDU3M2RiYWU0YTg4MDA2ODhmZWM5
+    YjM0NGM5ZWI2YTA4MWI3OTFiOGM0MTQ5YWE1NzlhNmJiNDU5NTg=

data/README.md

@@ -13,10 +13,14 @@ calls IF there are either one or more arguments passed OR parenthesis are
 used, otherwise Ruby method calls become JavaScript property accesses.
 By default, methods, lambdas, and procs return `undefined`.
 
-Filters may be provided to add Ruby-specific or Framework specific
+Filters may be provided to add Ruby-specific or framework specific
 behavior.  Filters are essentially macro facilities that operate on
 an AST representation of the code.
 
+See
+[notimplemented_spec](https://github.com/rubys/ruby2js/blob/master/spec/notimplemented_spec.rb)
+for a list of Ruby features _known_ to be not implemented.
+
 Synopsis
 ---
 
@@ -37,6 +41,72 @@ puts Ruby2JS.convert('"2A".to_i(16)')
 Conversions can be explored interactively using the
 [demo](https://github.com/rubys/ruby2js/blob/master/demo/ruby2js.rb) provided.
 
+Introduction
+---
+
+JavaScript is a language where `0` is considered `false`, strings are
+immutable, and the [behaviors](http://zero.milosz.ca/) for operators like `==` 
+are, at best, convoluted.
+
+Any attempt to bridge the semantics of Ruby and JavaScript will involve
+trade-offs.  Consider the following expression:
+
+```ruby
+a[-1]
+```
+
+Programmers who are familiar with Ruby will recognize that this returns the
+last element (or character) of an array (or string).  However, the meaning is
+quite different if a is a Hash.
+
+One way to resolve this is to change the way indexing operators are evaluated,
+and to provide a runtime library that adds properties to global JavaScript
+objects to handle this.  It’s the approach that [Opal](http://opalrb.org/)
+takes.  It is a fine approach, with a number of benefits.  It also has some
+notable drawbacks.  For example,
+[Readability](http://opalrb.org/try/#code:a%20%3D%20%22abc%22%3B%20puts%20a[-1])
+and 
+[compatibility with other frameworks](https://github.com/opal/opal/issues/400).
+
+Another approach is to simply accept JavaScript semantics for what they are.
+This would mean that negative indexes would return `undefined` for arrays
+and strings.  This is the base approach provided by ruby2js.
+
+A third approach would be to do static transformations on the source in order
+to address common usage patterns or idioms.  These transformations can even be
+occasionally unsafe, as long as the transformations themselves are opt-in.
+ruby2js provides a number of such filters, including one that handles negative
+indexes when passes as a literal.  As indicated above, this is unsafe in that
+it will do the wrong thing when it encounters a hash index which is expressed
+as a literal constant negative one.  My experience is that such is rare enough
+to be safely ignored, but YMMV.  More troublesome, this also won’t work when
+the index is not a literal (e.g., `a[n]`) where the index happens to be
+negative at runtime.
+
+This quickly gets into gray areas.  `each` in Ruby is a common method that
+facilitates iteration over arrays.  `forEach` is the JavaScript equivalent.
+Mapping this is fine until you start using a framework like jQuery which
+provides a function named [each](http://api.jquery.com/jQuery.each/).
+
+These approaches aren’t mutually exclusive. With enough static transformations
+and runtime libraries, one could reproduce any functionality desired.  Just be
+forewarned, that implementing a function like `method_missing` would require a
+_lot_ of work.
+
+Picking a Ruby to JS mapping tool
+---
+
+If you simply want to get a job done, and would like a mature and tested
+framework, and only use one of the many integrations that
+[Opal](http://opalrb.org/) provides, then Opal is the way to go right now.
+
+ruby2js is for those that want to produce JavaScript that looks like it
+wasn’t machine generated, and with the absolute bare minimum in terms of
+limitations as to what JavaScript can be produced.
+
+[Try](http://intertwingly.net/projects/ruby2js/all) for yourself.
+[Compare](http://opalrb.org/try/#code:).
+
 License
 ---
 

data/lib/ruby2js.rb

@@ -4,13 +4,20 @@ require 'ruby2js/converter'
 module Ruby2JS
   module Filter
     DEFAULTS = []
+
+    module SEXP
+      # construct an AST Node
+      def s(type, *args)
+        Parser::AST::Node.new type, args
+      end
+    end
   end
 
   def self.convert(source, options={})
 
     if Proc === source
       file,line = source.source_location
-      source = File.read(file)
+      source = File.read(file).untaint
       ast = find_block( parse(source), line )
     elsif Parser::AST::Node === source
       ast = source
@@ -31,6 +38,8 @@ module Ruby2JS
 
     ruby2js = Ruby2JS::Converter.new( ast )
 
+    ruby2js.binding = options[:binding]
+
     if source.include? "\n"
       ruby2js.enable_vertical_whitespace 
       lines = ruby2js.to_js.split("\n")
@@ -55,7 +64,8 @@ module Ruby2JS
 
         blank = pending
       end
-      lines.join("\n")
+
+      lines.join("\n").gsub(/^  ( *(case.*|default):$)/, '\1')
     else
       ruby2js.to_js
     end

data/lib/ruby2js/converter.rb

@@ -4,17 +4,26 @@ module Ruby2JS
   class Converter
     LOGICAL   = :and, :not, :or
     OPERATORS = [:[], :[]=], [:not, :!], [:*, :/, :%], [:+, :-], [:>>, :<<], 
-      [:<=, :<, :>, :>=], [:==, :!=], [:and, :or]
+      [:<=, :<, :>, :>=], [:==, :!=, :===, :"!=="], [:and, :or]
     
+    attr_accessor :binding
+
     def initialize( ast, vars = {} )
       @ast, @vars = ast, vars.dup
       @sep = '; '
       @nl = ''
+      @ws = ' '
+      @varstack = []
     end
     
     def enable_vertical_whitespace
       @sep = ";\n"
       @nl = "\n"
+      @ws = @nl
+    end
+
+    def binding=(binding)
+      @binding = binding
     end
 
     def to_js
@@ -25,10 +34,12 @@ module Ruby2JS
       OPERATORS.index( OPERATORS.find{ |el| el.include? op } ) || -1
     end
     
-    def scope( ast )
-      frame = self.class.new( nil, @vars )
-      frame.enable_vertical_whitespace if @nl == "\n"
-      frame.parse( ast, :statement )
+    def scope( ast, args={} )
+      @varstack.push @vars
+      @vars = @vars.merge(args)
+      parse( ast, :statement )
+    ensure
+      @vars = @varstack.pop
     end
 
     def s(type, *args)
@@ -54,7 +65,7 @@ module Ruby2JS
       when :sym
         ast.children.first.to_s.inspect
 
-      when :lvar, :gvar
+      when :lvar, :gvar, :cvar
         ast.children.first
         
       when :true, :false
@@ -118,12 +129,41 @@ module Ruby2JS
         end
         "{#{ hashy.join(', ') }}"
 
+      when :regexp
+        str, opt = ast.children
+        if str.children.first.include? '/'
+          if opt.children.empty?
+            "new RegExp(#{ str.children.first.inspect })"
+          else
+            "new RegExp(#{ str.children.first.inspect }, #{ opt.children.join.inspect})"
+          end
+        else
+          "/#{ str.children.first }/#{ opt.children.join }"
+        end
+
       when :array
-        list = ast.children.map { |a| parse a }
-        if list.join(', ').length < 80
-          "[#{ list.join(', ') }]"
+        splat = ast.children.rindex { |a| a.type == :splat }
+        if splat
+          items = ast.children
+          item = items[splat].children.first
+          if items.length == 1
+            parse item
+          elsif splat == items.length - 1
+            parse s(:send, s(:array, *items[0..-2]), :concat, item)
+          elsif splat == 0
+            parse s(:send, item, :concat, s(:array, *items[1..-1]))
+          else
+            parse s(:send, 
+              s(:send, s(:array, *items[0..splat-1]), :concat, item), 
+              :concat, s(:array, *items[splat+1..-1]))
+          end
         else
-          "[\n#{ list.join(",\n") }\n]"
+          list = ast.children.map { |a| parse a }
+          if list.join(', ').length < 80
+            "[#{ list.join(', ') }]"
+          else
+            "[\n#{ list.join(",\n") }\n]"
+          end
         end
 
       when :begin
@@ -155,9 +195,13 @@ module Ruby2JS
     
       when :send, :attr
         receiver, method, *args = ast.children
+        if method =~ /\w[!?]$/
+          raise NotImplementedError, "invalid method name #{ method }"
+        end
+
         if method == :new and receiver and receiver.children == [nil, :Proc]
           return parse args.first
-        elsif method == :lambda and not receiver
+        elsif not receiver and [:lambda, :proc].include? method
           return parse args.first
         end
 
@@ -171,30 +215,53 @@ module Ruby2JS
         group_receiver = receiver.type == :send && op_index <= operator_index( receiver.children[1] ) if receiver
         group_target = target.type == :send && op_index <= operator_index( target.children[1] ) if target
 
-        case method
-        when :!
-          group_receiver ||= (receiver.children.length > 1)
-          "!#{ group_receiver ? group(receiver) : parse(receiver) }"
-
-        when :call
-          "#{ parse receiver }(#{ parse args.first })"
+        if method == :!
+          if receiver.type == :defined?
+            parse s(:undefined?, *receiver.children)
+          else
+            group_receiver ||= (receiver.type != :send && receiver.children.length > 1)
+            "!#{ group_receiver ? group(receiver) : parse(receiver) }"
+          end
 
-        when :[]
-          raise 'parse error' unless receiver
-          "#{ parse receiver }[#{ parse args.first }]"
+        elsif method == :[]
+          "#{ parse receiver }[#{ args.map {|arg| parse arg}.join(', ') }]"
 
-        when :-@, :+@
+        elsif method == :-@ or method == :+@
           "#{ method.to_s[0] }#{ parse receiver }"
-          
-        when *OPERATORS.flatten
+
+        elsif method == :=~
+          "#{ parse args.first }.test(#{ parse receiver })"
+
+        elsif method == :!~
+          "!#{ parse args.first }.test(#{ parse receiver })"
+
+        elsif OPERATORS.flatten.include? method
           "#{ group_receiver ? group(receiver) : parse(receiver) } #{ method } #{ group_target ? group(target) : parse(target) }"  
 
-        when /=$/
+        elsif method =~ /=$/
           "#{ parse receiver }#{ '.' if receiver }#{ method.to_s.sub(/=$/, ' =') } #{ parse args.first }"
 
+        elsif method == :new and receiver
+          args = args.map {|a| parse a}.join(', ')
+          "new #{ parse receiver }(#{ args })"
+
+        elsif method == :raise and receiver == nil
+          if args.length == 1
+            "throw #{ parse args.first }"
+          else
+            "throw new #{ parse args.first }(#{ parse args[1] })"
+          end
+
+        elsif method == :typeof and receiver == nil
+          "typeof #{ parse args.first }"
+
         else
           if args.length == 0 and not is_method?(ast)
             "#{ parse receiver }#{ '.' if receiver }#{ method }"
+          elsif args.length > 0 and args.last.type == :splat
+            parse s(:send, s(:attr, receiver, method), :apply, receiver, 
+              s(:send, s(:array, *args[0..-2]), :concat,
+                args[-1].children.first))
           else
             args = args.map {|a| parse a}.join(', ')
             "#{ parse receiver }#{ '.' if receiver }#{ method }(#{ args })"
@@ -231,6 +298,19 @@ module Ruby2JS
         condition, block = ast.children
         "while (#{ parse condition }) {#@nl#{ scope block }#@nl}"
 
+      when :until
+        condition, block = ast.children
+        parse s(:while, s(:send, condition, :!), block)
+
+      when :while_post
+        condition, block = ast.children
+        block = block.updated(:begin) if block.type == :kwbegin
+        "do {#@nl#{ scope block }#@nl} while (#{ parse condition })"
+
+      when :until_post
+        condition, block = ast.children
+        parse s(:while_post, s(:send, condition, :!), block)
+
       when :for
         var, expression, block = ast.children
         parse s(:block, 
@@ -238,6 +318,19 @@ module Ruby2JS
           s(:args, s(:arg, var.children.last)),
           block);
 
+      when :case
+        expr, *whens, other = ast.children
+
+        whens.map! do |node|
+          *values, code = node.children
+          cases = values.map {|value| "case #{ parse value }:#@ws"}.join
+          "#{ cases }#{ parse code }#{@sep}break#@sep"
+        end
+
+        other = "#{@nl}default:#@ws#{ parse other }#@nl" if other
+
+        "switch (#{ parse expr }) {#@nl#{whens.join(@nl)}#{other}}"
+
       when :block
         call, args, block = ast.children
         block ||= s(:begin)
@@ -247,37 +340,195 @@ module Ruby2JS
       when :def
         name, args, body = ast.children
         body ||= s(:begin)
-        body   = s(:scope, body) unless body.type == :scope
-        body   = parse body
-        body.sub! /return var (\w+) = ([^;]+)\z/, "var \\1 = \\2#{@sep}return \\1"
-        "function#{ " #{name}" if name }(#{ parse args }) {#@nl#{ body }#@nl}"
-
-      when :scope
-        body = ast.children.first
-        body = s(:begin, body) unless body.type == :begin
-        block = body.children
-        scope body
-        
+        if name =~ /[!?]$/
+          raise NotImplementedError, "invalid method name #{ name }"
+        end
+
+        vars = {}
+        if args and !args.children.empty?
+          # splats
+          if args.children.last.type == :restarg
+            if args.children[-1].children.first
+              body = s(:begin, body) unless body.type == :begin
+              assign = s(:lvasgn, args.children[-1].children.first,
+                s(:send, s(:attr, 
+                  s(:attr, s(:const, nil, :Array), :prototype), :slice),
+                  :call, s(:lvar, :arguments),
+                  s(:int, args.children.length-1)))
+              body = s(:begin, assign, *body.children)
+            end
+
+            args = s(:args, *args.children[0..-2])
+
+          elsif args.children.last.type == :blockarg and
+            args.children.length > 1 and args.children[-2].type == :restarg
+            body = s(:begin, body) unless body.type == :begin
+            blk = args.children[-1].children.first
+            vararg = args.children[-2].children.first
+            last = s(:send, s(:attr, s(:lvar, :arguments), :length), :-,
+                    s(:int, 1))
+
+            # set block argument to the last argument passed
+            assign2 = s(:lvasgn, blk, s(:send, s(:lvar, :arguments), :[], last))
+
+            if vararg
+              # extract arguments between those defined and the last
+              assign1 = s(:lvasgn, vararg, s(:send, s(:attr, s(:attr, s(:const,
+                nil, :Array), :prototype), :slice), :call, s(:lvar, :arguments),
+                s(:int, args.children.length-1), last))
+              # push block argument back onto args if not a function
+              pushback = s(:if, s(:send, s(:send, nil, :typeof, s(:lvar, blk)), 
+                :"!==", s(:str, "function")), s(:begin, s(:send, s(:lvar,
+                vararg), :push, s(:lvar, blk)), s(:lvasgn, blk, s(:nil))), nil)
+              # set block argument to null if all arguments were defined
+              pushback = s(:if, s(:send, s(:attr, s(:lvar, :arguments),
+                :length), :<=, s(:int, args.children.length-2)), s(:lvasgn, 
+                blk, s(:nil)), pushback)
+              # combine statements
+              body = s(:begin, assign1, assign2, pushback, *body.children)
+            else
+              # set block argument to null if all arguments were defined
+              ignore = s(:if, s(:send, s(:attr, s(:lvar, :arguments),
+                :length), :<=, s(:int, args.children.length-2)), s(:lvasgn, 
+                blk, s(:nil)), nil)
+              body = s(:begin, assign2, ignore, *body.children)
+            end
+
+            args = s(:args, *args.children[0..-3])
+          end
+
+          # optional arguments
+          args.children.each_with_index do |arg, i|
+            if arg.type == :optarg
+              body = s(:begin, body) unless body.type == :begin
+              argname, value = arg.children
+              children = args.children.dup
+              children[i] = s(:arg, argname)
+              args = s(:args, *children)
+              body = s(:begin, body) unless body.type == :begin
+              default = s(:if, s(:send, s(:defined?, s(:lvar, argname)), :!),
+                s(:lvasgn, argname, value), nil)
+              body = s(:begin, default, *body.children)
+            end
+            vars[arg.children.first] = true
+          end
+        end
+
+        "function#{ " #{name}" if name }(#{ parse args }) {#@nl#{ scope body, vars}#{@nl unless body == s(:begin)}}"
+
       when :class
         name, inheritance, *body = ast.children
+        init = s(:def, :initialize, s(:args))
         body.compact!
-        body = body.first.children.dup if body.length == 1 and body.first.type == :begin
-        methods = body.select { |a| a.type == :def }
-        init    = (body.delete methods.find { |m| m.children.first == :initialize }) || s(:def, :initialize)
-        block   = body.collect { |m| parse( m ).sub(/function (\w+)/, "#{ parse name }.prototype.\\1 = function") }.join @sep
-        "#{ parse( s(:def, parse(name), init.children[1], init.children[2]) ).sub(/return (?:null|(.*))\}\z/, '\1}') }#{ @sep if block and not block.empty?}#{ block }"
+
+        if body.length == 1 and body.first.type == :begin
+          body = body.first.children.dup 
+        end
+
+        body.map! do |m| 
+          if m.type == :def
+            if m.children.first == :initialize
+              # constructor: remove from body and overwrite init function
+              init = m
+              nil
+            else
+              # method: add to prototype
+              s(:send, s(:attr, name, :prototype), "#{m.children[0]}=",
+                s(:block, s(:send, nil, :proc), *m.children[1..-1]))
+            end
+          elsif m.type == :defs and m.children.first == s(:self)
+            # class method definition: add to prototype
+            s(:send, name, "#{m.children[1]}=",
+              s(:block, s(:send, nil, :proc), *m.children[2..-1]))
+          elsif m.type == :send and m.children.first == nil
+            # class method call
+            s(:send, name, *m.children[1..-1])
+          elsif m.type == :lvasgn
+            # class variable
+            s(:send, name, "#{m.children[0]}=", *m.children[1..-1])
+          elsif m.type == :casgn and m.children[0] == nil
+            # class constant
+            s(:send, name, "#{m.children[1]}=", *m.children[2..-1])
+          else
+            raise NotImplementedError, "class #{ m.type }"
+          end
+        end
+
+        if inheritance
+          body.unshift s(:send, name, :prototype=, s(:send, inheritance, :new))
+        end
+
+        # prepend constructor
+        body.unshift s(:def, parse(name), *init.children[1..-1])
+
+        parse s(:begin, *body.compact)
 
       when :args
-        ast.children.map { |a| a.children.first }.join(', ')
+        ast.children.map { |a| parse a }.join(', ')
+
+      when :arg, :blockarg
+        ast.children.first
+
+      when :block_pass
+        parse ast.children.first
         
-      when :dstr
+      when :dstr, :dsym
         ast.children.map{ |s| parse s }.join(' + ')
         
+      when :xstr
+        if @binding
+          @binding.eval(ast.children.first.children.first).to_s
+        else
+          eval(ast.children.first.children.first).to_s
+        end
+
       when :self
         'this'
 
+      when :break
+        'break'
+
+      when :next
+        'continue'
+
+      when :defined?
+        "typeof #{ parse ast.children.first } !== 'undefined'"
+
+      when :undefined?
+        "typeof #{ parse ast.children.first } === 'undefined'"
+
+      when :undef
+        ast.children.map {|c| "delete #{c.children.last}"}.join @sep
+
+      when :kwbegin
+        block = ast.children.first
+        if block.type == :ensure
+          block, finally = block.children
+        else
+          finally = nil
+        end
+
+        if block and block.type == :rescue
+          body, recover, otherwise = block.children
+          raise NotImplementedError, "block else" if otherwise
+          exception, name, recovery = recover.children
+          raise NotImplementedError, parse(exception) if exception
+        else
+          body = block
+        end
+
+        output = "try {#@nl#{ parse body }#@nl}"
+        output += " catch (#{ parse name }) {#@nl#{ parse recovery }#@nl}" if recovery
+        output += " finally {#@nl#{ parse finally }#@nl}" if finally
+
+        if recovery or finally
+          output
+        else
+          parse s(:begin, *ast.children)
+        end
+
       else 
-        raise "unknown AST type #{ ast.type }"
+        raise NotImplementedError, "unknown AST type #{ ast.type }"
       end
     end
     

data/lib/ruby2js/filter/angularrb.rb

@@ -4,6 +4,8 @@ require 'ruby2js'
 module Ruby2JS
   module Filter
     module AngularRB
+      include SEXP
+
       def initialize(*args)
         @ngApp = nil
         super
@@ -30,13 +32,13 @@ module Ruby2JS
 
         # find the block
         block = process_all(node.children[1..-1])
-        while block.length == 1 and block.first.type == :begin
+        while block.length == 1 and block.first and block.first.type == :begin
           block = block.first.children.dup
         end
 
         # find use class method calls
         uses = block.find_all do |node|
-          node.type == :send and node.children[0..1] == [nil, :use]
+          node and node.type == :send and node.children[0..1] == [nil, :use]
         end
 
         # convert use calls into dependencies
@@ -154,13 +156,6 @@ module Ruby2JS
 
         node.updated nil, [outer, s(:args), s(:return, inner)]
       end
-
-      private
-
-      # construct an AST Node
-      def s(type, *args)
-        Parser::AST::Node.new type, args
-      end
     end
 
     DEFAULTS.push AngularRB

data/lib/ruby2js/filter/functions.rb

@@ -3,15 +3,7 @@ require 'ruby2js'
 module Ruby2JS
   module Filter
     module Functions
-
-      # map $$ to $
-      def on_gvar(node)
-        if node.children[0] == :$$
-          node.updated nil, ['$']
-        else
-          super
-        end
-      end
+      include SEXP
 
       def on_send(node)
         target = process(node.children.first)
@@ -26,15 +18,76 @@ module Ruby2JS
         elsif node.children[1] == :to_f
           node.updated nil, [nil, :parseFloat, target, *args]
 
+        elsif node.children[1] == :sub and node.children.length == 4
+          source, method, before, after = node.children
+          node.updated nil, [source, :replace, before, after]
+
+        elsif node.children[1] == :gsub and node.children.length == 4
+          source, method, before, after = node.children
+          if before.type == :regexp
+            before = s(:regexp, before.children.first,
+              s(:regopt, :g, *before.children[1]))
+          elsif before.type == :str
+            before = s(:regexp, s(:str, Regexp.escape(before.children.first)),
+              s(:regopt, :g))
+          end
+          node.updated nil, [source, :replace, before, after]
+
         elsif node.children[1] == :each
-          if target.type == :gvar and target.children == ['$']
-            super
-          elsif target.type == :send and target.children == [nil, :jQuery]
+          if @each # disable `each` mapping, see jquery filter for an example
             super
           else
             node.updated nil, [target, :forEach, *args]
           end
 
+        elsif node.children[0..1] == [nil, :puts]
+          s(:send, s(:attr, nil, :console), :log, *node.children[2..-1])
+
+        elsif node.children[1..-1] == [:first]
+          node.updated nil, [node.children[0], :[], s(:int, 0)]
+
+        elsif node.children[1..-1] == [:last]
+          on_send node.updated nil, [node.children[0], :[], s(:int, -1)]
+
+        elsif node.children[1] == :[] and node.children.length == 3
+          source = node.children[0]
+          index = node.children[2]
+
+          # resolve negative literal indexes
+          i = proc do |index|
+            if index.type == :int and index.children.first < 0
+              s(:send, s(:attr, source, :length), :-, 
+                s(:int, -index.children.first))
+            else
+              index
+            end
+          end
+
+          if index.type == :int and index.children.first < 0
+            node.updated nil, [source, :[], i.(index)]
+
+          elsif index.type == :erange
+            start, finish = index.children
+            node.updated nil, [source, :slice, i.(start), i.(finish)]
+
+          elsif index.type == :irange
+            start, finish = index.children
+            start = i.(start)
+            if finish.type == :int
+              if finish.children.first == -1
+                finish = s(:attr, source, :length)
+              else
+                finish = i.(s(:int, finish.children.first+1))
+              end
+            else
+              finish = s(:send, finish, :+, s(:int, 1))
+            end
+            node.updated nil, [source, :slice, start, finish]
+
+          else
+            super
+          end
+
         elsif node.children[1] == :each_with_index
           node.updated nil, [target, :forEach, *args]
 
@@ -42,13 +95,6 @@ module Ruby2JS
           super
         end
       end
-
-      private
-
-      # construct an AST Node
-      def s(type, *args)
-        Parser::AST::Node.new type, args
-      end
     end
 
     DEFAULTS.push Functions

data/lib/ruby2js/filter/jquery.rb

@@ -0,0 +1,37 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module JQuery
+      include SEXP
+
+      def initialize
+        @each = true # disable each mapping, see functions filter
+      end
+
+      # map $$ to $
+      def on_gvar(node)
+        if node.children[0] == :$$
+          node.updated nil, ['$']
+        else
+          super
+        end
+      end
+
+      def on_send(node)
+        if node.children[1] == :call
+          target = process(node.children.first)
+          if target.type == :gvar and target.children == ['$']
+            s(:send, nil, '$', *process_all(node.children[2..-1]))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+
+    DEFAULTS.push JQuery
+  end
+end

data/lib/ruby2js/filter/return.rb

@@ -3,6 +3,8 @@ require 'ruby2js'
 module Ruby2JS
   module Filter
     module Return
+      include SEXP
+
       EXPRESSIONS = [ :array, :float, :hash, :if, :int, :lvar, :nil, :send ]
 
       def on_block(node)
@@ -49,13 +51,6 @@ module Ruby2JS
 
         node.updated nil, children
       end
-      
-      private
-
-      # construct an AST Node
-      def s(type, *args)
-        Parser::AST::Node.new type, args
-      end
     end
 
     DEFAULTS.push Return

data/lib/ruby2js/version.rb

@@ -1,7 +1,7 @@
 module Ruby2JS
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 2
+    MAJOR = 1
+    MINOR = 0
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/ruby2js.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name = "ruby2js"
-  s.version = "0.2.0"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sam Ruby"]
-  s.date = "2013-11-12"
-  s.description = "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters may be provided to add Ruby-specific or Framework specific\n    behavior.\n"
+  s.date = "2013-11-15"
+  s.description = "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters may be provided to add Ruby-specific or framework specific\n    behavior.\n"
   s.email = "rubys@intertwingly.net"
-  s.files = ["ruby2js.gemspec", "README.md", "lib/ruby2js", "lib/ruby2js/version.rb", "lib/ruby2js/converter.rb", "lib/ruby2js/filter", "lib/ruby2js/filter/return.rb", "lib/ruby2js/filter/angularrb.rb", "lib/ruby2js/filter/functions.rb", "lib/ruby2js.rb"]
+  s.files = ["ruby2js.gemspec", "README.md", "lib/ruby2js", "lib/ruby2js/version.rb", "lib/ruby2js/converter.rb", "lib/ruby2js/filter", "lib/ruby2js/filter/return.rb", "lib/ruby2js/filter/angularrb.rb", "lib/ruby2js/filter/functions.rb", "lib/ruby2js/filter/jquery.rb", "lib/ruby2js.rb"]
   s.homepage = "http://github.com/rubys/ruby2js"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby2js
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Sam Ruby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-12 00:00:00.000000000 Z
+date: 2013-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: ! "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters
-  may be provided to add Ruby-specific or Framework specific\n    behavior.\n"
+  may be provided to add Ruby-specific or framework specific\n    behavior.\n"
 email: rubys@intertwingly.net
 executables: []
 extensions: []
@@ -38,6 +38,7 @@ files:
 - lib/ruby2js/filter/return.rb
 - lib/ruby2js/filter/angularrb.rb
 - lib/ruby2js/filter/functions.rb
+- lib/ruby2js/filter/jquery.rb
 - lib/ruby2js.rb
 homepage: http://github.com/rubys/ruby2js
 licenses: