ruby2js 1.15.1 → 2.0.0

data/lib/ruby2js/filter/camelCase.rb

@@ -17,7 +17,7 @@ module Ruby2JS
         if node.children[0] == nil and WHITELIST.include? node.children[1].to_s
           super
         elsif node.children[1] =~ /_.*\w$/
-          super s((node.is_method? ? :send : :attr) , node.children[0],
+          super S((node.is_method? ? :call : :attr) , node.children[0],
             camelCase(node.children[1]), *node.children[2..-1])
         else
           super
@@ -26,7 +26,7 @@ module Ruby2JS
 
       def on_def(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:def , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:def , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -34,7 +34,7 @@ module Ruby2JS
 
       def on_optarg(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:optarg , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:optarg , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -42,7 +42,7 @@ module Ruby2JS
 
       def on_lvar(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:lvar , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:lvar , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -50,7 +50,7 @@ module Ruby2JS
 
       def on_arg(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:arg , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:arg , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -58,7 +58,7 @@ module Ruby2JS
 
       def on_lvasgn(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:lvasgn , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:lvasgn , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -66,7 +66,7 @@ module Ruby2JS
 
       def on_sym(node)
         if node.children[0] =~ /_.*\w$/
-          super s(:sym , camelCase(node.children[0]), *node.children[1..-1])
+          super S(:sym , camelCase(node.children[0]), *node.children[1..-1])
         else
           super
         end
@@ -74,7 +74,7 @@ module Ruby2JS
 
       def on_defs(node)
         if node.children[1] =~ /_.*\w$/
-          super s(:defs , node.children[0],
+          super S(:defs , node.children[0],
             camelCase(node.children[1]), *node.children[2..-1])
         else
           super

data/lib/ruby2js/filter/functions.rb

@@ -15,22 +15,22 @@ module Ruby2JS
       def on_send(node)
         target, method, *args = node.children
 
-        if [:max, :min].include? node.children[1] and args.length == 0
+        if [:max, :min].include? method and args.length == 0
           return super unless node.is_method?
-          process s(:send, s(:attr, s(:const, nil, :Math), node.children[1]),
+          process S(:send, s(:attr, s(:const, nil, :Math), node.children[1]),
             :apply, s(:const, nil, :Math), target)
 
         elsif method == :keys and args.length == 0 and node.is_method?
-          process s(:send, s(:const, nil, :Object), :keys, target)
+          process S(:send, s(:const, nil, :Object), :keys, target)
 
         elsif method == :delete and args.length == 1
-          process s(:undef, s(:send, target, :[], args.first))
+          process S(:undef, S(:send, target, :[], args.first))
 
         elsif method == :to_s
-          process s(:send, target, :toString, *args)
+          process S(:call, target, :toString, *args)
 
         elsif method == :to_a
-          process s(:send, target, :toArray, *args)
+          process S(:call, target, :toArray, *args)
 
         elsif method == :to_i
           process node.updated :send, [nil, :parseInt, target, *args]
@@ -44,15 +44,15 @@ module Ruby2JS
         elsif [:sub!, :gsub!].include? method
           method = :"#{method.to_s[0..-2]}"
           if VAR_TO_ASSIGN.keys.include? target.type
-            process s(VAR_TO_ASSIGN[target.type], target.children[0], 
-              s(:send, target, method, *node.children[2..-1]))
+            process S(VAR_TO_ASSIGN[target.type], target.children[0], 
+              S(:send, target, method, *node.children[2..-1]))
           elsif target.type == :send
             if target.children[0] == nil
-              process s(:lvasgn, target.children[1], s(:send,
-                s(:lvar, target.children[1]), method, *node.children[2..-1]))
+              process S(:lvasgn, target.children[1], S(:send,
+                S(:lvar, target.children[1]), method, *node.children[2..-1]))
             else
-              process s(:send, target.children[0], :"#{target.children[1]}=", 
-                s(:send, target, method, *node.children[2..-1]))
+              process S(:send, target.children[0], :"#{target.children[1]}=", 
+                S(:send, target, method, *node.children[2..-1]))
             end
           else
             super
@@ -61,93 +61,92 @@ module Ruby2JS
         elsif method == :gsub and args.length == 2
           before, after = args
           if before.type == :regexp
-            before = s(:regexp, *before.children[0...-1],
-              s(:regopt, :g, *before.children.last))
+            before = before.updated(:regexp, [*before.children[0...-1],
+              s(:regopt, :g, *before.children.last)])
           elsif before.type == :str
-            before = s(:regexp, s(:str, Regexp.escape(before.children.first)),
-              s(:regopt, :g))
+            before = before.updated(:regexp,
+              [s(:str, Regexp.escape(before.children.first)), s(:regopt, :g)])
           end
           process node.updated nil, [target, :replace, before, after]
 
         elsif method == :ord and args.length == 0
           if target.type == :str
-            process s(:int, target.children.last.ord)
+            process S(:int, target.children.last.ord)
           else
-            process node.updated nil, [target, :charCodeAt, s(:int, 0)]
+            process S(:send, target, :charCodeAt, s(:int, 0))
           end
 
         elsif method == :chr and args.length == 0
           if target.type == :int
-            process s(:str, target.children.last.chr)
+            process S(:str, target.children.last.chr)
           else
-            process node.updated nil, [s(:const, nil, :String), :fromCharCode,
-              target]
+            process S(:send, s(:const, nil, :String), :fromCharCode, target)
           end
 
         elsif method == :empty? and args.length == 0
-          process s(:send, s(:attr, target, :length), :==, s(:int, 0))
+          process S(:send, S(:attr, target, :length), :==, s(:int, 0))
 
         elsif method == :nil? and args.length == 0
-          process s(:send, target, :==, s(:nil))
+          process S(:send, target, :==, s(:nil))
 
         elsif [:start_with?, :end_with?].include? method and args.length == 1
           if args.first.type == :str
-            length = s(:int, args.first.children.first.length)
+            length = S(:int, args.first.children.first.length)
           else
-            length = s(:attr, *args, :length)
+            length = S(:attr, *args, :length)
           end
 
           if method == :start_with?
-            process s(:send, s(:send, target, :substring, s(:int, 0), 
+            process S(:send, S(:send, target, :substring, s(:int, 0), 
               length), :==, *args)
           else
-            process s(:send, s(:send, target, :slice, 
-              s(:send, length, :-@)), :==, *args)
+            process S(:send, S(:send, target, :slice, 
+              S(:send, length, :-@)), :==, *args)
           end
 
         elsif method == :clear and args.length == 0 and node.is_method?
-          process s(:send, target, :length=, s(:int, 0))
+          process S(:send, target, :length=, s(:int, 0))
 
         elsif method == :replace and args.length == 1
-          process s(:begin, s(:send, target, :length=, s(:int, 0)),
-             s(:send, target, :push, s(:splat, node.children[2])))
+          process S(:begin, S(:send, target, :length=, s(:int, 0)),
+             S(:send, target, :push, s(:splat, node.children[2])))
 
         elsif method == :include? and args.length == 1
-          process s(:send, s(:send, target, :indexOf, args.first), :!=,
+          process S(:send, S(:send, target, :indexOf, args.first), :!=,
             s(:int, -1))
 
         elsif method == :respond_to? and args.length == 1
-          process s(:in?, args.first, target)
+          process S(:in?, args.first, target)
 
         elsif method == :each
-          process node.updated nil, [target, :forEach, *args]
+          process S(:send, target, :forEach, *args)
 
         elsif method == :downcase and args.length == 0
-          process node.updated nil, [target, :toLowerCase]
+          process S(:send, target, :toLowerCase)
 
         elsif method == :upcase and args.length == 0
-          process node.updated nil, [target, :toUpperCase]
+          process S(:send, target, :toUpperCase)
 
         elsif node.children[0..1] == [nil, :puts]
-          process s(:send, s(:attr, nil, :console), :log, *args)
+          process S(:send, s(:attr, nil, :console), :log, *args)
 
         elsif method == :first
           if node.children.length == 2
-            process node.updated nil, [target, :[], s(:int, 0)]
+            process S(:send, target, :[], s(:int, 0))
           elsif node.children.length == 3
-            process on_send node.updated nil, [target, :[], s(:erange,
-              s(:int, 0), node.children[2])]
+            process on_send S(:send, target, :[], s(:erange,
+              s(:int, 0), node.children[2]))
           else
             super
           end
 
         elsif method == :last
           if node.children.length == 2
-            process on_send node.updated nil, [target, :[], s(:int, -1)]
+            process on_send S(:send, target, :[], s(:int, -1))
           elsif node.children.length == 3
-            process node.updated nil, [target, :slice,
+            process S(:send, target, :slice,
               s(:send, s(:attr, target, :length), :-, node.children[2]),
-              s(:attr, target, :length)]
+              s(:attr, target, :length))
           else
             super
           end
@@ -159,7 +158,7 @@ module Ruby2JS
           # resolve negative literal indexes
           i = proc do |index|
             if index.type == :int and index.children.first < 0
-              process s(:send, s(:attr, target, :length), :-, 
+              process S(:send, S(:attr, target, :length), :-, 
                 s(:int, -index.children.first))
             else
               index
@@ -167,32 +166,32 @@ module Ruby2JS
           end
 
           if index.type == :regexp
-            process 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
-            process node.updated nil, [target, :[], i.(index)]
+            process S(:send, target, :[], i.(index))
 
           elsif index.type == :erange
             start, finish = index.children
-            process node.updated nil, [target, :slice, i.(start), i.(finish)]
+            process S(:send, target, :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, target, :length)
+                finish = S(:attr, target, :length)
               else
-                finish = i.(s(:int, finish.children.first+1))
+                finish = i.(S(:int, finish.children.first+1))
               end
             else
-              finish = s(:send, finish, :+, s(:int, 1))
+              finish = S(:send, finish, :+, s(:int, 1))
             end
-            process node.updated nil, [target, :slice, start, finish]
+            process S(:send, target, :slice, start, finish)
 
           else
             super
@@ -201,15 +200,15 @@ module Ruby2JS
         elsif method == :reverse! and node.is_method? 
           # input: a.reverse!
           # output: a.splice(0, a.length, *a.reverse)
-          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])))
+          process S(:send, target, :splice, s(:int, 0), 
+            s(:attr, target, :length), s(:splat, S(:send, target, 
+            :reverse, *node.children[2..-1])))
 
         elsif method == :each_with_index
-          process node.updated nil, [target, :forEach, *args]
+          process S(:send, target, :forEach, *args)
 
         elsif method == :inspect and args.length == 0
-          s(:send, s(:const, nil, :JSON), :stringify, process(target))
+          S(:send, s(:const, nil, :JSON), :stringify, process(target))
 
         else
           super
@@ -254,15 +253,15 @@ module Ruby2JS
           # 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,
+          process call.updated(: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]))))
+            *node.children[1..-1])))])
 
         elsif node.children[0..1] == [s(:send, nil, :loop), s(:args)]
           # input: loop {statements}
           # output: while(true) {statements}
-          s(:while, s(:true), node.children[2])
+          S(:while, s(:true), node.children[2])
 
         else
           super
@@ -278,15 +277,15 @@ module Ruby2JS
             body.any? {|statement| statement.type == :def and
             statement.children.first == :initialize}
           then
-            body.unshift s(:def, :initialize, s(:args, s(:arg, :message)),
-              s(:begin, s(:send, s(:self), :message=, s(:lvar, :message)),
-              s(:send, s(:self), :name=, s(:sym, name.children[1])),
-              s(:send, s(:self), :stack=, s(:send, s(:send, nil, :Error,
+            body.unshift S(:def, :initialize, s(:args, s(:arg, :message)),
+              s(:begin, S(:send, s(:self), :message=, s(:lvar, :message)),
+              S(:send, s(:self), :name=, s(:sym, name.children[1])),
+              S(:send, s(:self), :stack=, s(:send, s(:send, nil, :Error,
               s(:lvar, :message)), :stack))))
           end
 
           body = [s(:begin, *body)] if body.length > 1
-          s(:class, name, s(:const, nil, :Error), *body)
+          S(:class, name, s(:const, nil, :Error), *body)
         else
           super
         end

data/lib/ruby2js/filter/react.rb

@@ -66,16 +66,16 @@ module Ruby2JS
           body.select {|child| child.type == :defs}.each do |child|
             parent, mname, args, *block = child.children
             if child.is_method?
-              statics << s(:pair, s(:sym, mname), 
-                s(:block, s(:send, nil, :proc), args, s(:autoreturn, *block)))
+              statics << s(:pair, s(:sym, mname), child.updated(:block, 
+                [s(:send, nil, :proc), args, s(:autoreturn, *block)]))
             elsif 
               block.length == 1 and 
               Converter::EXPRESSIONS.include? block.first.type
             then
               statics << s(:pair, s(:sym, mname), *block)
             else
-              statics << s(:pair, s(:prop, mname), {get: 
-                s(:block, s(:send, nil, :proc), args, s(:autoreturn, *block))})
+              statics << s(:pair, s(:prop, mname), {get: child.updated(
+                :block, [s(:send, nil, :proc), args, s(:autoreturn, *block)])})
             end
           end
 
@@ -84,11 +84,27 @@ module Ruby2JS
             pairs << s(:pair, s(:sym, :statics), s(:hash, *statics))
           end
 
+          # create a default getInitialState method if there is no such method
+          # and there are references to instance variables.
+          if
+            not body.any? do |child|
+              child.type == :def and 
+              [:getInitialState, :initialize].include? child.children.first
+            end
+          then
+            @reactIvars = {pre: [], post: [], asgn: [], ref: []}
+            react_walk(node)
+            unless @reactIvars.values.flatten.empty?
+              body = [s(:def, :getInitialState, s(:args), 
+                s(:return, s(:hash))), *body]
+            end
+          end
+
           # add a proc/function for each method
           body.select {|child| child.type == :def}.each do |child|
             mname, args, *block = child.children
             @reactMethod = mname
-            @reactProps = s(:attr, s(:self), :props)
+            @reactProps = child.updated(:attr, [s(:self), :props])
 
             # analyze ivar usage
             @reactIvars = {pre: [], post: [], asgn: [], ref: []}
@@ -145,7 +161,7 @@ module Ruby2JS
             elsif mname == :componentWillReceiveProps
               if args.children.length == 0
                 args = s(:args, s(:arg, :"$$props"))
-                child = s(:def, mname, args, *block)
+                child = child.updated(:def, [mname, args, *block])
                 @reactProps = s(:lvar, :"$$props")
               else
                 @reactProps = s(:lvar, args.children.first.children.last)
@@ -179,9 +195,18 @@ module Ruby2JS
             end
 
             # add method to class
-            pairs << s(:pair, s(:sym, mname), s(:block, s(:send, nil, :proc), 
-              args, process(s((child.is_method? ? :begin : :autoreturn),
-              *block))))
+            type = (child.is_method? ? :begin : :autoreturn)
+            if block.length == 1 and Parser::AST::Node === block.first
+              type = :begin if block.first.type == :return
+            end
+
+            pairs << s(:pair, s(:sym, mname), child.updated(:block,
+              [s(:send, nil, :proc), args, process(s(type, *block))]))
+
+            # retain comment
+            unless @comments[child].empty?
+              @comments[pairs.last] = @comments[child]
+            end
           end
         ensure
           @react = react
@@ -190,8 +215,8 @@ module Ruby2JS
         end
 
         # emit a createClass statement
-        s(:casgn, nil, cname.children.last, 
-          s(:send, inheritance, :createClass, s(:hash, *pairs)))
+        node.updated(:casgn, [nil, cname.children.last, 
+          s(:send, inheritance, :createClass, s(:hash, *pairs))])
       end
 
       def on_send(node)
@@ -379,7 +404,8 @@ module Ruby2JS
           params.pop if params.last == s(:nil)
 
           # construct element using params
-          element = s(:send, s(:const, nil, :React), :createElement, *params)
+          element = node.updated(:send, [s(:const, nil, :React), 
+            :createElement, *params])
 
           if @reactApply
             # if apply is set, emit code that pushes result
@@ -528,7 +554,7 @@ module Ruby2JS
             end
 
             # collapse series of method calls into a single call
-            return process(s(:send, *node.children[0..1], *children))
+            return process(node.updated(nil, [*node.children[0..1], *children]))
           else
             super
           end
@@ -588,7 +614,8 @@ module Ruby2JS
         if child.children[0] == nil and child.children[1] =~ /^_\w/
           block = s(:block, s(:send, nil, :proc), s(:args),
             *node.children[2..-1])
-          return on_send s(:send, *node.children.first.children, block)
+          return on_send node.children.first.updated(:send, 
+            [*node.children.first.children, block])
         end
 
         super
@@ -604,9 +631,10 @@ module Ruby2JS
       def on_ivar(node)
         return super unless @reactClass
         if @reactMethod and @reactIvars[:capture].include? node.children.first
-          s(:lvar, "$#{node.children.first[1..-1]}")
+          node.updated(:lvar, ["$#{node.children.first[1..-1]}"])
         else
-          s(:attr, s(:attr, s(:self), :state), node.children.first.to_s[1..-1])
+          node.updated(:attr, [s(:attr, s(:self), :state), 
+            node.children.first.to_s[1..-1]])
         end
       end