ruby2js 1.4.0 → 1.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTU0NmY4ZDc4NDJiMGVjZGNiMmJjOWJhZmZkYzk3ODUwNjQ4YjVjMw==
+    YmM0YzQzZjZkNGQ5YTMzZTA0N2Q4YjU3ZTJjNGFkMDZjYTY3YTdmZQ==
   data.tar.gz: !binary |-
-    NzRlMTE2ZWY5NTRjYjQ1ODBhMDUzMzZjMzFkNjY3M2IxNDVjY2VkNQ==
+    ZjVlOTkzMWE4NjcwMDI0MjdlYTdmZDAyMmYzZGVjNWM0ZWM0ZDI4Yg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZDk5MGVjOTdmNWRiNWY1ODhmMTMxMjdhOWMwNWEzNTUxYThiMGVlYWRjOTY4
-    YjU4MDM2OWI1ZmFhMjZhOTM3NzIwYjgyZWI4ZjA5ODE1MmFhMWU5YmZlYmYw
-    OTcyMmNhYzE0NDMyZDNlMTAxODdjYzEyNjBjOTY0ZmI0OGNmMzA=
+    YTBiMjdjZTA1ZjYyNWRkMjI5OTVmYzRhOTIxYmNmMjQwMTEzNjEwZTQ5OGFk
+    NjUzMzQzOGFlZTU4ODM2ZjJlN2E5NTcwMzEwYzNmMjRkNzg4ZjdkYmM2N2U0
+    OWNlY2Q2MzUyMGZjY2UxNjBlYjU3ZTc2ODAzZGY5ZjdjNjBiMGY=
   data.tar.gz: !binary |-
-    NDhmNTY1OGNhNWVmYmRmMGVkZTMwMTg4ZTMzMGY0YjE0YjFiY2UwNmYzYjNi
-    YTc4ZmViYWFjZWFjOGIyY2FhOThjNWM1M2E1M2MzZDZmYjI3NDQ5YjE5MjU5
-    MjA0ZTk3NzkzYjA2ZTIzNGY2MWU4NzNmZjE3NjFmM2FmYzM3N2U=
+    NThlN2I2N2RiMzJlMDY0OWIzMGYwN2Y4MjQzZTkxNDdhZWJlMGFhMjkxZjY5
+    ZDMzMDdkNzI0OTNjNGVjNGNmZjlmNDZkMTU4ODg5MTRhN2JjNGJhOTdjNjVh
+    M2IwYjkzYTg4ZWUzNjEwZDBlYzA3YzBhODE4YmE2M2E3Y2E1YWU=

data/README.md

@@ -96,8 +96,14 @@ 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
+Fortunately, Ruby provides `?` and `!` as legal suffixes for method names,
+Ruby2js filters do an exact match, so if you select a filter that maps `each`
+to `forEach`, `each!` will pass through the filter.  The final code that emits
+JavaScript function calls and parameter accesses will strip off these
+suffixes.
+
+Static transformations and runtime libraries aren't aren’t mutually exclusive.
+With enough of each, one could reproduce any functionality desired.  Just be
 forewarned, that implementing a function like `method_missing` would require a
 _lot_ of work.
 
@@ -131,36 +137,81 @@ the script.
 
 * [functions](https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/functions.rb)
 
-    * `.to_s` becomes `to_String`
-    * `.to_a` becomes `to_Array`
-    * `.to_i` becomes `parseInt`
-    * `.to_f` becomes `parseFloat`
-    * `.ord` becomes `charCodeAt(0)`
+    * `.all?` becomes `.every`
+    * `.any?` becomes `.some`
     * `.chr` becomes `fromCharCode`
-    * `.sub` becomes `replace`
-    * `.gsub` becomes `replace //g`
-    * `x.sub!` and `x.gsub!` become equivalent `x = x.replace` statements
+    * `.clear` becomes `.length = 0`
+    * `.each` becomes `forEach`
+    * `.each_with_index` becomes `forEach`
+    * `.empty?` becomes `.length == 0`
     * `.first` becomes `[0]`
+    * `.first(n)` becomes `.slice(0, n)`
+    * `.gsub` becomes `replace //g`
+    * `.include?` becomes `.indexOf() != -1`
+    * `.keys` becomes `Object.keys()`
     * `.last` becomes `[*.length-1]`
+    * `.last(n)` becomes `.slice(*.length-1, *.length)`
+    * `.max` becomes `Math.max.apply(Math)`
+    * `.min` becomes `Math.min.apply(Math)`
+    * `.ord` becomes `charCodeAt(0)`
+    * `puts` becomes `console.log`
+    * `.replace` becomes `.length = 0; ...push.apply(*)`
+    * `.sub` becomes `replace`
+    * `.to_a` becomes `to_Array`
+    * `.to_f` becomes `parseFloat`
+    * `.to_i` becomes `parseInt`
+    * `.to_s` becomes `to_String`
     * `[-n]` becomes `[*.length-n]` for literal values of `n`
-    * `[n..m]` becomes `.slice(n,m+1)`
     * `[n...m]` becomes `.slice(n,m)`
+    * `[n..m]` becomes `.slice(n,m+1)`
     * `[/r/, n]` becomes `.match(/r/)[n]`
-    * `.empty?` becomes `.length == 0`
-    * `.clear!` becomes `.length = 0`
-    * `.replace!` becomes `.length = 0; ...push.apply(*)`
-    * `.include?` becomes `.indexOf() != -1`
-    * `.any?` becomes `.some`
-    * `.all?` becomes `.every`
-    * `puts` becomes `console.log`
-    * `.each` becomes `forEach` unless jquery is included
-    * `.each_with_index` becomes `forEach`
+    * `.sub!` and `.gsub!` become equivalent `x = x.replace` statements
+    * `.map!`, `.reverse!`, and `.select` become equivalent 
+      `.splice(0, .length, *.method())` statements
     * `setInterval` and `setTimeout` allow block to be treated as the
        first parameter on the call
     * for the following methods, if the block consists entirely of a simple
       expression (or ends with one), a `return` is added prior to the
       expression: `sub`, `gsub`, `any?`, `all?`, `map`.
 
+* [underscore](https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/underscore.rb)
+
+    * `.clone()` becomes `_.clone()`
+    * `.compact()` becomes `_.compact()`
+    * `.count_by {}` becomes `_.countBy {}`
+    * `.find {}` becomes `_.find {}`
+    * `.find_by()` becomes `_.findWhere()`
+    * `.flatten()` becomes `_.flatten()`
+    * `.group_by {}` becomes `_.groupBy {}`
+    * `.has_key?()` becomes `_.has()`
+    * `.index_by {}` becomes `_.indexBy {}`
+    * `.invert()` becomes `_.invert()`
+    * `.invoke(&:n)` becomes `_.invoke(, :n)`
+    * `.map(&:n)` becomes `_.pluck(, :n)`
+    * `.merge!()` becomes `_.extend()`
+    * `.merge()` becomes `_.extend({}, )`
+    * `.reduce {}` becomes `_.reduce {}`
+    * `.reduce()` becomes `_.reduce()`
+    * `.reject {}` becomes `_.reject {}`
+    * `.sample()` becomes `_.sample()`
+    * `.select {}` becomes `_.select {}`
+    * `.shuffle()` becomes `_.shuffle()`
+    * `.size()` becomes `_.size()`
+    * `.sort()` becomes `_.sort_by(, _.identity)`
+    * `.sort_by {}` becomes `_.sortBy {}`
+    * `.times {}` becomes `_.times {}`
+    * `.values()` becomes `_.values()`
+    * `.where()` becomes `_.where()`
+    * `.zip()` becomes `_.zip()`
+    * `(n...m)` becomes `_.range(n, m)`
+    * `(n..m)` becomes `_.range(n, m+1)`
+    * `.compact!`, `.flatten!`, `shuffle!`, `reject!`, `sort_by!`, and 
+      `.uniq` become equivalent `.splice(0, .length, *.method())` statements
+    * for the following methods, if the block consists entirely of a simple
+      expression (or ends with one), a `return` is added prior to the
+      expression: `reduce`, `sort_by`, `group_by`, `index_by`, `count_by`,
+      `find`, `select`, `reject`.
+
 * [jquery](https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter/jquery.rb)
 
     * maps Ruby unary operator `~` to jQuery `$` function
@@ -212,6 +263,10 @@ the script.
 Picking a Ruby to JS mapping tool
 ---
 
+> dsl — A domain specific language, where code is written in one language and
+> errors are given in another. 
+> -- [Devil’s Dictionary of Programming](http://programmingisterrible.com/post/65781074112/devils-dictionary-of-programming)
+
 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.

data/lib/ruby2js.rb

@@ -13,8 +13,26 @@ module Ruby2JS
     end
 
     class Processor < Parser::AST::Processor
+      BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
+
       def on_attr(node)
-        node.updated nil, [process(node.children.first), node.children.last]
+        on_send(node)
+      end
+
+      def on_send(node)
+        if node.children.length > 2 and node.children.last.type == :block_pass
+          method = node.children.last.children.first.children.last
+          if BINARY_OPERATORS.include? method
+            return on_block s(:block, s(:send, *node.children[0..-2]),
+              s(:args, s(:arg, :a), s(:arg, :b)), s(:return,
+              process(s(:send, s(:lvar, :a), method, s(:lvar, :b)))))
+          else
+            return on_block s(:block, s(:send, *node.children[0..-2]),
+              s(:args, s(:arg, :item)), s(:return,
+              process(s(:attr, s(:lvar, :item), method))))
+          end
+        end
+        super
       end
     end
   end

data/lib/ruby2js/converter.rb

@@ -67,14 +67,6 @@ module Ruby2JS
       Parser::AST::Node.new(type, args)
     end
 
-    def is_method?(node)
-      return false unless node.type == :send
-      return true unless node.loc
-      selector = node.loc.selector
-      return true unless selector.source_buffer
-      selector.source_buffer.source[selector.end_pos] == '('
-    end
-
     @@handlers = []
     def self.handle(*types, &block)
       types.each do |type| 
@@ -103,6 +95,21 @@ module Ruby2JS
   end
 end
 
+module Parser
+  module AST
+    class Node
+      def is_method?
+        return false if type == :attr
+        return true if children.length > 2
+        return true unless loc
+        selector = loc.selector
+        return true unless selector.source_buffer
+        selector.source_buffer.source[selector.end_pos] == '('
+      end
+    end
+  end
+end
+
 # see https://github.com/whitequark/parser/blob/master/doc/AST_FORMAT.md
 
 require 'ruby2js/converter/arg'

data/lib/ruby2js/converter/class.rb

@@ -77,6 +77,13 @@ module Ruby2JS
             # class method call
             s(:send, name, *m.children[1..-1])
           end
+        elsif m.type == :block and m.children.first.children.first == nil
+          # class method calls passing a block
+          s(:block, s(:send, name, *m.children.first.children[1..-1]), 
+            *m.children[1..-1])
+        elsif [:send, :block].include? m.type
+          # pass through method calls with non-nil targets
+          m
         elsif m.type == :lvasgn
           # class variable
           s(:send, name, "#{m.children[0]}=", *m.children[1..-1])

data/lib/ruby2js/converter/return.rb

@@ -12,7 +12,7 @@ module Ruby2JS
       end
     end
 
-    EXPRESSIONS = [ :array, :float, :hash, :int, :lvar, :nil, :send,
+    EXPRESSIONS = [ :array, :float, :hash, :int, :lvar, :nil, :send, :attr,
       :str, :sym, :dstr, :dsym ]
 
     handle :autoreturn do |*statements|

data/lib/ruby2js/converter/send.rb

@@ -18,9 +18,8 @@ module Ruby2JS
 
       width = ((ast.type == :sendw && !@nl.empty?) ? 0 : @width)
 
-      if method =~ /\w[!?]$/
-        raise NotImplementedError, "invalid method name #{ method }"
-      end
+      # strip '!' and '?' decorations
+      method = method.to_s[0..-2] if method =~ /\w[!?]$/
 
       # three ways to define anonymous functions
       if method == :new and receiver and receiver.children == [nil, :Proc]
@@ -73,6 +72,9 @@ module Ruby2JS
       elsif method == :!~
         "!#{ parse args.first }.test(#{ parse receiver })"
 
+      elsif method == :<< and args.length == 1 and @state == :statement
+        "#{ parse receiver }.push(#{ parse args.first })"
+
       elsif OPERATORS.flatten.include? method
         "#{ group_receiver ? group(receiver) : parse(receiver) } #{ method } #{ group_target ? group(target) : parse(target) }"  
 
@@ -104,7 +106,7 @@ module Ruby2JS
 
         args = args.map {|a| parse a}.join(', ')
 
-        if args.length > 0 or is_method?(ast)
+        if ast.is_method?
           "new #{ parse receiver }(#{ args })"
         else
           "new #{ parse receiver }"
@@ -121,19 +123,15 @@ module Ruby2JS
         "typeof #{ parse args.first }"
 
       else
-        if args.length == 0 and not is_method?(ast)
+        if not ast.is_method?
           if receiver
             "#{ parse receiver }.#{ method }"
           else
             parse s(:lvasgn, method), @state
           end
-        elsif args.length == 1 and args.first.type == :splat
-          parse s(:send, s(:attr, receiver, method), :apply, receiver, 
-            args.first.children.first)
-        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))
+        elsif args.length > 0 and args.any? {|arg| arg.type == :splat}
+          parse s(:send, s(:attr, receiver, method), :apply, 
+            (receiver || s(:nil)), s(:array, *args))
         else
           call = "#{ parse receiver }#{ '.' if receiver && method}#{ method }"
           args = args.map {|a| parse a}

data/lib/ruby2js/filter/angularrb.rb

@@ -350,6 +350,15 @@ module Ruby2JS
         end
       end
 
+      # convert cvar referencess in controllers to self
+      def on_cvar(node)
+        if @ngContext == :controller
+          process s(:attr, s(:self), node.children.first.to_s[2..-1])
+        else
+          super
+        end
+      end
+
       # input:
       #  watch 'expression' do |oldvalue, newvalue|
       #    ...
@@ -376,9 +385,9 @@ module Ruby2JS
           method = call.children[1]
           expression = call.children[2]
         end
-        call = s(:send, target, method, process(expression), 
+        call = s(:send, process(target), method, process(expression), 
           *process_all(call.children[3..-1]))
-        node = node.updated nil, [call, *process_all(node.children[1..-1])]
+        node.updated nil, [call, *process_all(node.children[1..-1])]
       end
 
       # input:
@@ -417,6 +426,20 @@ module Ruby2JS
         end
       end
 
+      # convert cvar assignments in controllers to self 
+      def on_cvasgn(node)
+        if @ngContext == :controller
+          if node.children.length == 1
+            process s(:attr, s(:self), "#{node.children.first.to_s[2..-1]}")
+          else
+            process s(:send, s(:self), "#{node.children.first.to_s[2..-1]}=",
+              node.children.last)
+          end
+        else
+          super
+        end
+      end
+
       NG_METHOD_MAP = {
         :apply! => [:$rootScope, :$apply],
         :apply => [:$scope, :$apply],

data/lib/ruby2js/filter/functions.rb

@@ -6,28 +6,39 @@ module Ruby2JS
       include SEXP
 
       def on_send(node)
-        target = process(node.children.first)
-        args = process_all(node.children[2..-1])
+        target = node.children.first
 
-        if node.children[1] == :to_s
-          s(:send, target, :toString, *args)
+        args = node.children[2..-1]
+
+        if [:max, :min].include? node.children[1] and args.length == 0
+          return super unless node.is_method?
+          process s(:send, s(:attr, s(:const, nil, :Math), node.children[1]),
+            :apply, s(:const, nil, :Math), target)
+
+        elsif node.children[1] == :keys and  node.children.length == 2
+          if node.is_method?
+            process s(:send, s(:const, nil, :Object), :keys, target)
+          else
+            super
+          end
+
+        elsif node.children[1] == :to_s
+          process s(:send, target, :toString, *args)
 
         elsif node.children[1] == :to_a
-          s(:send, target, :toArray, *args)
+          process s(:send, target, :toArray, *args)
 
         elsif node.children[1] == :to_i
-          node.updated nil, [nil, :parseInt, target, *args]
+          process node.updated :send, [nil, :parseInt, target, *args]
 
         elsif node.children[1] == :to_f
-          process node.updated nil, [nil, :parseFloat, target, *args]
+          process node.updated :send, [nil, :parseFloat, target, *args]
 
-        elsif node.children[1] == :sub and node.children.length == 4
-          source, method, before, after = node.children
-          process node.updated nil, [source, :replace, before, after]
+        elsif node.children[1] == :sub and args.length == 2
+          process node.updated nil, [target, :replace, *args]
 
         elsif [:sub!, :gsub!].include? node.children[1]
           method = :"#{node.children[1].to_s[0..-2]}"
-          target = node.children[0]
           if target.type == :lvar
             process s(:lvasgn, target.children[0], s(:send,
               s(:lvar, target.children[0]), method, *node.children[2..-1]))
@@ -56,46 +67,64 @@ module Ruby2JS
 
         elsif node.children[1] == :ord and node.children.length == 2
           if target.type == :str
-            s(:int, target.children.last.ord)
+            process s(:int, target.children.last.ord)
           else
-            node.updated nil, [target, :charCodeAt, s(:int, 0)]
+            process node.updated nil, [target, :charCodeAt, s(:int, 0)]
           end
 
         elsif node.children[1] == :chr and node.children.length == 2
           if target.type == :int
-            s(:str, target.children.last.chr)
+            process s(:str, target.children.last.chr)
           else
-            node.updated nil, [s(:const, nil, :String), :fromCharCode, target]
+            process node.updated nil, [s(:const, nil, :String), :fromCharCode,
+              target]
           end
 
         elsif node.children[1] == :empty? and node.children.length == 2
-          s(:send, s(:attr, target, :length), :==, s(:int, 0))
+          process s(:send, s(:attr, target, :length), :==, s(:int, 0))
 
-        elsif node.children[1] == :clear! and node.children.length == 2
-          s(:send, target, :length=, s(:int, 0))
+        elsif node.children[1] == :clear and node.children.length == 2
+          if node.is_method?
+            process s(:send, target, :length=, s(:int, 0))
+          else
+            super
+          end
 
-        elsif node.children[1] == :replace! and node.children.length == 3
-          s(:begin, s(:send, target, :length=, s(:int, 0)),
+        elsif node.children[1] == :replace and node.children.length == 3
+          process s(:begin, s(:send, target, :length=, s(:int, 0)),
              s(:send, target, :push, s(:splat, node.children[2])))
 
         elsif node.children[1] == :include? and node.children.length == 3
-          s(:send, s(:send, target, :indexOf, args.first), :!=, s(:int, -1))
+          process s(:send, s(:send, target, :indexOf, args.first), :!=,
+            s(:int, -1))
 
         elsif node.children[1] == :each
-          if @each # disable `each` mapping, see jquery filter for an example
-            super
-          else
-            node.updated nil, [target, :forEach, *args]
-          end
+          process node.updated nil, [target, :forEach, *args]
 
         elsif node.children[0..1] == [nil, :puts]
-          s(:send, s(:attr, nil, :console), :log, *args)
+          process s(:send, s(:attr, nil, :console), :log, *args)
+
+        elsif node.children[1] == :first
+          if node.children.length == 2
+            process node.updated nil, [target, :[], s(:int, 0)]
+          elsif node.children.length == 3
+            process on_send node.updated nil, [target, :[], s(:erange,
+              s(:int, 0), node.children[2])]
+          else
+            super
+          end
 
-        elsif node.children[1..-1] == [:first]
-          node.updated nil, [target, :[], s(:int, 0)]
+        elsif node.children[1] == :last
+          if node.children.length == 2
+            process on_send node.updated nil, [target, :[], s(:int, -1)]
+          elsif node.children.length == 3
+            process node.updated nil, [target, :slice,
+              s(:send, s(:attr, target, :length), :-, node.children[2]),
+              s(:attr, target, :length)]
+          else
+            super
+          end
 
-        elsif node.children[1..-1] == [:last]
-          on_send node.updated nil, [target, :[], s(:int, -1)]
 
         elsif node.children[1] == :[]
           index = args.first
@@ -103,7 +132,7 @@ module Ruby2JS
           # resolve negative literal indexes
           i = proc do |index|
             if index.type == :int and index.children.first < 0
-              s(:send, s(:attr, target, :length), :-, 
+              process s(:send, s(:attr, target, :length), :-, 
                 s(:int, -index.children.first))
             else
               index
@@ -111,18 +140,18 @@ module Ruby2JS
           end
 
           if index.type == :regexp
-            s(:send, s(:send, target, :match, index), :[], 
+            process s(:send, s(:send, target, :match, index), :[], 
               args[1] || s(:int, 0))
 
           elsif node.children.length != 3
             super
 
           elsif index.type == :int and index.children.first < 0
-            node.updated nil, [target, :[], i.(index)]
+            process node.updated nil, [target, :[], i.(index)]
 
           elsif index.type == :erange
             start, finish = index.children
-            node.updated nil, [target, :slice, i.(start), i.(finish)]
+            process node.updated nil, [target, :slice, i.(start), i.(finish)]
 
           elsif index.type == :irange
             start, finish = index.children
@@ -136,14 +165,22 @@ module Ruby2JS
             else
               finish = s(:send, finish, :+, s(:int, 1))
             end
-            node.updated nil, [target, :slice, start, finish]
+            process node.updated nil, [target, :slice, start, finish]
 
           else
             super
           end
 
+        elsif node.children[1] == :reverse! and node.is_method? 
+          # input: a.reverse!
+          # output: a.splice(0, a.length, *a.reverse)
+          target = node.children.first
+          process s(:send, target, :splice, s(:int, 0), 
+            s(:attr, target, :length), s(:splat, s(:send, target, 
+            :"#{node.children[1].to_s[0..-2]}", *node.children[2..-1])))
+
         elsif node.children[1] == :each_with_index
-          node.updated nil, [target, :forEach, *args]
+          process node.updated nil, [target, :forEach, *args]
 
         else
           super
@@ -155,7 +192,8 @@ module Ruby2JS
         if [:setInterval, :setTimeout].include? call.children[1]
           return super unless call.children.first == nil
           block = process s(:block, s(:send, nil, :proc), *node.children[1..-1])
-          call.updated nil, [*call.children[0..1], block, *call.children[2..-1]]
+          on_send call.updated nil, [*call.children[0..1], block,
+            *call.children[2..-1]]
 
         elsif [:sub, :gsub, :sub!, :gsub!].include? call.children[1]
           return super if call.children.first == nil
@@ -163,20 +201,35 @@ module Ruby2JS
             s(:autoreturn, *node.children[2..-1]))
           process call.updated(nil, [*call.children, block])
 
+        elsif call.children[1] == :select and call.children.length == 2
+          call = call.updated nil, [call.children.first, :filter]
+          node.updated nil, [process(call), process(node.children[1]),
+            s(:autoreturn, *process_all(node.children[2..-1]))]
+
         elsif call.children[1] == :any? and call.children.length == 2
           call = call.updated nil, [call.children.first, :some]
-          process node.updated nil, [call, node.children[1],
-            s(:autoreturn, *node.children[2..-1])]
+          node.updated nil, [process(call), process(node.children[1]),
+            s(:autoreturn, *process_all(node.children[2..-1]))]
 
         elsif call.children[1] == :all? and call.children.length == 2
           call = call.updated nil, [call.children.first, :every]
-          process node.updated nil, [call, node.children[1],
-            s(:autoreturn, *node.children[2..-1])]
+          node.updated nil, [process(call), process(node.children[1]),
+            s(:autoreturn, *process_all(node.children[2..-1]))]
 
         elsif call.children[1] == :map and call.children.length == 2
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
+        elsif [:map!, :select!].include? call.children[1]
+          # input: a.map! {expression}
+          # output: a.splice(0, a.length, *a.map {expression})
+          method = (call.children[1] == :map! ? :map : :select)
+          target = call.children.first
+          process s(:send, target, :splice, s(:splat, s(:send, s(:array, 
+            s(:int, 0), s(:attr, target, :length)), :concat,
+            s(:block, s(:send, target, method, *call.children[2..-1]),
+            *node.children[1..-1]))))
+
         else
           super
         end

data/lib/ruby2js/filter/jquery.rb

@@ -65,10 +65,6 @@ module Ruby2JS
     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] == :$$
@@ -128,6 +124,7 @@ module Ruby2JS
                 # possible getter/setter
                 method = node.children[1]
                 method = method.to_s.chomp('=') if method =~ /=$/
+                method = :each! if method == :each
                 rewrite = [rewrite_tilda[node.children[0]], 
                   method, *node.children[2..-1]]
                 if props.include? node.children[1]

data/lib/ruby2js/filter/underscore.rb

@@ -0,0 +1,186 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Underscore
+      include SEXP
+
+      def on_send(node)
+        return super if node.children.first and node.children.first.children.last == :_
+
+        if [:clone, :shuffle, :size, :compact, :flatten, :invert, :values,
+          :uniq].include? node.children[1]
+          if node.is_method?  and node.children.length == 2
+            process s(:send, s(:lvar, :_), node.children[1], node.children[0])
+          else
+            super
+          end
+        elsif node.children[1] == :sample and  node.children.length <= 3
+          process s(:send, s(:lvar, :_), :sample, node.children[0],
+            *node.children[2..-1])
+        elsif node.children[1] == :has_key? and  node.children.length == 3
+          process s(:send, s(:lvar, :_), :has, node.children[0],
+            node.children[2])
+        elsif node.children[1] == :sort and  node.children.length == 2
+          if node.is_method?
+            process s(:send, s(:lvar, :_), :sortBy, node.children[0],
+              s(:attr, s(:lvar, :_), :identity))
+          else
+            super
+          end
+        elsif node.children[1] == :map
+          if node.children.length == 3 and node.children[2].type == :block_pass
+            process s(:send, s(:lvar, :_), :pluck, node.children[0],
+              node.children[2].children.first)
+          else
+            super
+          end
+        elsif node.children[1] == :merge and node.children.length >= 3
+          process s(:send, s(:lvar, :_), :extend, s(:hash), node.children[0],
+            *node.children[2..-1])
+        elsif node.children[1] == :merge! and node.children.length >= 3
+          process s(:send, s(:lvar, :_), :extend, node.children[0],
+            *node.children[2..-1])
+        elsif node.children[1] == :zip and node.children.length >= 3
+          process s(:send, s(:lvar, :_), :zip, node.children[0],
+            *node.children[2..-1])
+        elsif node.children[1] == :invoke
+          if node.children.length >= 3 and node.children.last.type==:block_pass
+            process s(:send, s(:lvar, :_), :invoke, node.children[0],
+              node.children.last.children.first,
+              *node.children[2..-2])
+          else
+            super
+          end
+        elsif [:where, :find_by].include? node.children[1]
+          method = node.children[1] == :where ? :where : :findWhere
+          process s(:send, s(:lvar, :_), method, node.children[0],
+            *node.children[2..-1])
+        elsif node.children[1] == :reduce
+          if node.children.length == 3 and node.children[2].type == :sym
+            # input: a.reduce(:+)
+            # output: _.reduce(_.rest(a), 
+            #                  proc {|memo, item| return memo+item},
+            #                  a[0])
+            process s(:send, s(:lvar, :_), :reduce, 
+              s(:send, s(:lvar, :_), :rest, node.children.first),
+              s(:block, s(:send, nil, :proc), 
+                s(:args, s(:arg, :memo), s(:arg, :item)),
+                s(:autoreturn, s(:send, s(:lvar, :memo), 
+                  node.children[2].children.first, s(:lvar, :item)))),
+                s(:send, node.children.first, :[], s(:int, 0)))
+          elsif node.children.last.type == :block_pass
+            on_send node.updated(nil, [*node.children[0..1],
+              node.children[2].children.first])
+          elsif node.children.length == 4 and node.children[3].type == :sym
+            # input: a.reduce(n, :+)
+            # output: _.reduce(a, proc {|memo, item| return memo+item}, n)
+            process s(:send, s(:lvar, :_), :reduce, node.children.first,
+              s(:block, s(:send, nil, :proc), 
+                s(:args, s(:arg, :memo), s(:arg, :item)),
+                s(:autoreturn, s(:send, s(:lvar, :memo), 
+                node.children[3].children.first, s(:lvar, :item)))),
+                node.children[2])
+          else
+            super
+          end
+
+        elsif [:compact!, :flatten!, :shuffle!, :uniq!].
+          include? node.children[1] and node.is_method?
+          # input: a.compact!
+          # output: a.splice(0, a.length, *a.compact)
+          target = node.children.first
+          process s(:send, target, :splice, s(:int, 0), 
+            s(:attr, target, :length), s(:splat, s(:send, target, 
+            :"#{node.children[1].to_s[0..-2]}", *node.children[2..-1])))
+        else
+          super
+        end
+      end
+
+      def on_block(node)
+        call = node.children.first
+        if [:sort_by, :group_by, :index_by, :count_by].include? call.children[1]
+          # input: a.sort_by {}
+          # output: _.sortBy {return expression}
+          method = call.children[1].to_s.sub(/\_by$/,'By').to_sym
+          process s(:block, s(:send, s(:lvar, :_), method,
+            call.children.first), node.children[1], 
+            s(:autoreturn, node.children[2]))
+        elsif [:find, :reject].include? call.children[1]
+          if call.children.length == 2
+            # input: a.find {|item| item > 0}
+            # output: _.find(a) {|item| return item > 0}
+            process s(:block, s(:send, s(:lvar, :_), call.children[1], 
+              call.children.first), node.children[1], 
+              s(:autoreturn, node.children[2]))
+          else
+            super
+          end
+
+        elsif call.children[1] == :times and call.children.length == 2
+          # input: 5.times {|i| console.log i}
+          # output: _.find(5) {|i| console.log(i)}
+          process s(:block, s(:send, s(:lvar, :_), call.children[1], 
+            call.children.first), node.children[1], node.children[2])
+
+        elsif call.children[1] == :reduce
+          if call.children.length == 2
+            # input: a.reduce {|memo, item| memo+item}
+            # output: _.reduce(_.rest(a), 
+            #                  proc {|memo, item| return memo+item},
+            #                  a[0])
+            process s(:send, s(:lvar, :_), :reduce, 
+              s(:send, s(:lvar, :_), :rest, call.children.first),
+              s(:block, s(:send, nil, :proc), 
+                node.children[1], s(:autoreturn, node.children[2])),
+                s(:send, call.children.first, :[], s(:int, 0)))
+          elsif call.children.length == 3
+            # input: a.reduce(n) {|memo, item| memo+item}
+            # output: _.reduce(a, proc {|memo, item| return memo+item}, n)
+            process s(:send, s(:lvar, :_), :reduce, call.children.first,
+              s(:block, s(:send, nil, :proc), 
+                node.children[1], s(:autoreturn, node.children[2])),
+                call.children[2])
+          end
+
+        elsif [:map!, :reject!, :select!, :sort_by!].include? call.children[1]
+          # input: a.map! {expression}
+          # output: a.splice(0, a.length, *a.map {expression})
+          method = :"#{call.children[1].to_s[0..-2]}"
+          target = call.children.first
+          process s(:send, target, :splice, s(:splat, s(:send, s(:array, 
+            s(:int, 0), s(:attr, target, :length)), :concat,
+            s(:block, s(:send, target, method, *call.children[2..-1]),
+            *node.children[1..-1]))))
+
+        else
+          super
+        end
+      end
+
+      def on_erange(node)
+        process s(:send, s(:lvar, :_), :range, *node.children)
+      end
+
+      def on_irange(node)
+        if node.children.last.type == :int
+          process s(:send, s(:lvar, :_), :range, node.children.first,
+            s(:int, node.children.last.children.last+1))
+        else
+          process s(:send, s(:lvar, :_), :range, node.children.first,
+            s(:send, node.children.last, :+, s(:int, 1)))
+        end
+      end
+
+      def on_for(node)
+        # pass through irange, erange unprocessed
+        return super unless [:irange, :erange].include? node.children[1].type
+        s(:for, process(node.children[0]), s(node.children[1].type,
+          *process_all(node.children[1].children)), process(node.children[2]))
+      end
+    end
+
+    DEFAULTS.push Underscore
+  end
+end

data/lib/ruby2js/version.rb

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

data/ruby2js.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name = "ruby2js"
-  s.version = "1.4.0"
+  s.version = "1.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sam Ruby"]
-  s.date = "2014-01-18"
+  s.date = "2014-01-23"
   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/rails.rb", "lib/ruby2js/version.rb", "lib/ruby2js/converter", "lib/ruby2js/converter/kwbegin.rb", "lib/ruby2js/converter/const.rb", "lib/ruby2js/converter/return.rb", "lib/ruby2js/converter/prototype.rb", "lib/ruby2js/converter/opasgn.rb", "lib/ruby2js/converter/xstr.rb", "lib/ruby2js/converter/args.rb", "lib/ruby2js/converter/defs.rb", "lib/ruby2js/converter/literal.rb", "lib/ruby2js/converter/array.rb", "lib/ruby2js/converter/if.rb", "lib/ruby2js/converter/nil.rb", "lib/ruby2js/converter/logical.rb", "lib/ruby2js/converter/next.rb", "lib/ruby2js/converter/while.rb", "lib/ruby2js/converter/whilepost.rb", "lib/ruby2js/converter/arg.rb", "lib/ruby2js/converter/case.rb", "lib/ruby2js/converter/break.rb", "lib/ruby2js/converter/hash.rb", "lib/ruby2js/converter/for.rb", "lib/ruby2js/converter/boolean.rb", "lib/ruby2js/converter/module.rb", "lib/ruby2js/converter/var.rb", "lib/ruby2js/converter/undef.rb", "lib/ruby2js/converter/blockpass.rb", "lib/ruby2js/converter/until.rb", "lib/ruby2js/converter/regexp.rb", "lib/ruby2js/converter/untilpost.rb", "lib/ruby2js/converter/masgn.rb", "lib/ruby2js/converter/cvasgn.rb", "lib/ruby2js/converter/block.rb", "lib/ruby2js/converter/ivar.rb", "lib/ruby2js/converter/send.rb", "lib/ruby2js/converter/vasgn.rb", "lib/ruby2js/converter/defined.rb", "lib/ruby2js/converter/def.rb", "lib/ruby2js/converter/sym.rb", "lib/ruby2js/converter/cvar.rb", "lib/ruby2js/converter/ivasgn.rb", "lib/ruby2js/converter/casgn.rb", "lib/ruby2js/converter/self.rb", "lib/ruby2js/converter/begin.rb", "lib/ruby2js/converter/dstr.rb", "lib/ruby2js/converter/class.rb", "lib/ruby2js/cgi.rb", "lib/ruby2js/converter.rb", "lib/ruby2js/filter", "lib/ruby2js/filter/return.rb", "lib/ruby2js/filter/strict.rb", "lib/ruby2js/filter/angularrb.rb", "lib/ruby2js/filter/angular-resource.rb", "lib/ruby2js/filter/functions.rb", "lib/ruby2js/filter/jquery.rb", "lib/ruby2js/filter/angular-route.rb", "lib/ruby2js/sinatra.rb", "lib/ruby2js.rb"]
+  s.files = ["ruby2js.gemspec", "README.md", "lib/ruby2js", "lib/ruby2js/rails.rb", "lib/ruby2js/version.rb", "lib/ruby2js/converter", "lib/ruby2js/converter/kwbegin.rb", "lib/ruby2js/converter/const.rb", "lib/ruby2js/converter/return.rb", "lib/ruby2js/converter/prototype.rb", "lib/ruby2js/converter/opasgn.rb", "lib/ruby2js/converter/xstr.rb", "lib/ruby2js/converter/args.rb", "lib/ruby2js/converter/defs.rb", "lib/ruby2js/converter/literal.rb", "lib/ruby2js/converter/array.rb", "lib/ruby2js/converter/if.rb", "lib/ruby2js/converter/nil.rb", "lib/ruby2js/converter/logical.rb", "lib/ruby2js/converter/next.rb", "lib/ruby2js/converter/while.rb", "lib/ruby2js/converter/whilepost.rb", "lib/ruby2js/converter/arg.rb", "lib/ruby2js/converter/case.rb", "lib/ruby2js/converter/break.rb", "lib/ruby2js/converter/hash.rb", "lib/ruby2js/converter/for.rb", "lib/ruby2js/converter/boolean.rb", "lib/ruby2js/converter/module.rb", "lib/ruby2js/converter/var.rb", "lib/ruby2js/converter/undef.rb", "lib/ruby2js/converter/blockpass.rb", "lib/ruby2js/converter/until.rb", "lib/ruby2js/converter/regexp.rb", "lib/ruby2js/converter/untilpost.rb", "lib/ruby2js/converter/masgn.rb", "lib/ruby2js/converter/cvasgn.rb", "lib/ruby2js/converter/block.rb", "lib/ruby2js/converter/ivar.rb", "lib/ruby2js/converter/send.rb", "lib/ruby2js/converter/vasgn.rb", "lib/ruby2js/converter/defined.rb", "lib/ruby2js/converter/def.rb", "lib/ruby2js/converter/sym.rb", "lib/ruby2js/converter/cvar.rb", "lib/ruby2js/converter/ivasgn.rb", "lib/ruby2js/converter/casgn.rb", "lib/ruby2js/converter/self.rb", "lib/ruby2js/converter/begin.rb", "lib/ruby2js/converter/dstr.rb", "lib/ruby2js/converter/class.rb", "lib/ruby2js/cgi.rb", "lib/ruby2js/converter.rb", "lib/ruby2js/filter", "lib/ruby2js/filter/return.rb", "lib/ruby2js/filter/strict.rb", "lib/ruby2js/filter/angularrb.rb", "lib/ruby2js/filter/underscore.rb", "lib/ruby2js/filter/angular-resource.rb", "lib/ruby2js/filter/functions.rb", "lib/ruby2js/filter/jquery.rb", "lib/ruby2js/filter/angular-route.rb", "lib/ruby2js/sinatra.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: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Sam Ruby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
+date: 2014-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -85,6 +85,7 @@ files:
 - lib/ruby2js/filter/return.rb
 - lib/ruby2js/filter/strict.rb
 - lib/ruby2js/filter/angularrb.rb
+- lib/ruby2js/filter/underscore.rb
 - lib/ruby2js/filter/angular-resource.rb
 - lib/ruby2js/filter/functions.rb
 - lib/ruby2js/filter/jquery.rb