ruby2js 1.0.0 → 1.1.0

data/lib/ruby2js/converter/if.rb

@@ -0,0 +1,34 @@
+module Ruby2JS
+  class Converter
+
+    # (if
+    #   (true)
+    #   (...)
+    #   (...))
+
+    handle :if do |condition, then_block, else_block|
+      if else_block and not then_block
+        return parse(s(:if, s(:send, condition, :!), else_block, nil), @state) 
+      end
+
+      if @state == :statement
+        output = "if (#{ parse condition }) {#@nl#{ scope then_block }#@nl}"
+        while else_block and else_block.type == :if
+          condition, then_block, else_block = else_block.children
+          output <<  " else if (#{ parse condition }) " +
+            "{#@nl#{ scope then_block }#@nl}"
+        end
+        output << " else {#@nl#{ scope else_block }#@nl}" if else_block
+
+        # use short form when appropriate
+        unless output.length > 72 or else_block or then_block.type == :begin
+          output = "if (#{ parse condition }) #{ scope then_block }"
+        end
+
+        output
+      else
+        "(#{ parse condition } ? #{ parse then_block } : #{ parse else_block })"
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/ivar.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  class Converter
+
+    # (ivar :@a)
+
+    handle :ivar do |var|
+      var.to_s.sub('@', 'this._')
+    end
+  end
+end

data/lib/ruby2js/converter/ivasgn.rb

@@ -0,0 +1,11 @@
+module Ruby2JS
+  class Converter
+
+    # (ivasgn :@a
+    #   (int 1))
+
+    handle :ivasgn do |var, expression|
+      "#{ var.to_s.sub('@', 'this._') } = #{ parse expression }"
+    end
+  end
+end

data/lib/ruby2js/converter/kwbegin.rb

@@ -0,0 +1,44 @@
+module Ruby2JS
+  class Converter
+
+    # (kwbegin
+    #   (ensure
+    #     (rescue
+    #      (send nil :a)
+    #      (resbody nil nil
+    #        (send nil :b)) nil)
+    #    (send nil :c)))
+
+    handle :kwbegin do |*children|
+      block = 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}"
+
+      if recovery
+        output += " catch (#{ parse name }) {#@nl#{ parse recovery }#@nl}"
+      end
+
+      output += " finally {#@nl#{ parse finally }#@nl}" if finally
+
+      if recovery or finally
+        output
+      else
+        parse s(:begin, *children)
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/literal.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (int 1)
+    # (float 1.1)
+    # (str "1"))
+
+    handle :int, :float, :str do |value|
+      value.inspect
+    end
+  end
+end

data/lib/ruby2js/converter/logical.rb

@@ -0,0 +1,43 @@
+module Ruby2JS
+  class Converter
+
+    # (and
+    #   (...)
+    #   (...))
+
+    # (or
+    #   (...)
+    #   (...))
+
+    # (not
+    #   (...))
+
+    handle :and, :or, :not do |left, right=nil|
+      type = @ast.type
+      op_index = operator_index type
+
+      left = left.children.first if left and left.type == :begin
+      lgroup   = LOGICAL.include?( left.type ) && 
+        op_index <= operator_index( left.type )
+      left     = parse left
+      left     = "(#{ left })" if lgroup
+
+      if right
+        right = right.children.first if right.type == :begin
+        rgroup = LOGICAL.include?( right.type ) && 
+          op_index <= operator_index( right.type )
+        right    = parse right
+        right    = "(#{ right })" if rgroup
+      end
+
+      case type
+      when :and
+        "#{ left } && #{ right }"
+      when :or
+        "#{ left } || #{ right }"
+      else
+        "!#{ left }"
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/masgn.rb

@@ -0,0 +1,20 @@
+module Ruby2JS
+  class Converter
+
+    # (masgn
+    #   (mlhs
+    #     (lvasgn :a)
+    #     (lvasgn :b))
+    #   (array
+    #     (int 1)
+    #     (int 2)))
+
+    handle :masgn do |lhs, rhs|
+      block = []
+      lhs.children.zip rhs.children.zip do |var, val| 
+        block << s(var.type, *var.children, *val)
+      end
+      parse s(:begin, *block), @state
+    end
+  end
+end

data/lib/ruby2js/converter/next.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (next
+    #   (int 1))
+
+    handle :next do |n=nil|
+      raise NotImplementedError, "next argument #{ n.inspect }" if n
+      'continue'
+    end
+  end
+end

data/lib/ruby2js/converter/nil.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  class Converter
+
+    # (nil)
+
+    handle :nil do
+      'null'
+    end
+  end
+end

data/lib/ruby2js/converter/opasgn.rb

@@ -0,0 +1,20 @@
+module Ruby2JS
+  class Converter
+
+    # (op-asgn
+    #   (lvasgn :a) :+
+    #   (int 1))
+
+    handle :op_asgn do |var, op, value|
+      if [:+, :-].include?(op) and value.type==:int and value.children==[1]
+        if @state == :statement
+          "#{ parse var }#{ op }#{ op }"
+        else
+          "#{ op }#{ op }#{ parse var }"
+        end
+      else
+        "#{ parse var } #{ op }= #{ parse value }"
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/orasgn.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (or-asgn
+    #   (lvasgn :a
+    #   (int 1))
+
+    handle :or_asgn do |var, value|
+      "#{ parse var } = #{parse var} || #{ parse value }"
+    end
+  end
+end

data/lib/ruby2js/converter/regexp.rb

@@ -0,0 +1,21 @@
+module Ruby2JS
+  class Converter
+
+    # (regexp
+    #   (str "x")
+    #   (regopt :i))
+
+    handle :regexp do |str, opt|
+      str = str.children.first 
+      if str.include? '/'
+        if opt.children.empty?
+          "new RegExp(#{ str.inspect })"
+        else
+          "new RegExp(#{ str.inspect }, #{ opt.children.join.inspect})"
+        end
+      else
+        "/#{ str }/#{ opt.children.join }"
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/return.rb

@@ -0,0 +1,15 @@
+module Ruby2JS
+  class Converter
+
+    # (return
+    #   (int 1))
+
+    handle :return do |value=nil|
+      if value
+        "return #{ parse value }"
+      else
+        "return"
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/self.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  class Converter
+
+    # (self)
+
+    handle :self do
+      'this'
+    end
+  end
+end

data/lib/ruby2js/converter/send.rb

@@ -0,0 +1,98 @@
+module Ruby2JS
+  class Converter
+
+    # (send nil :puts
+    #   (int 1))
+
+    # (attr nil :puts
+    #   (int 1))
+
+    handle :send, :attr do |receiver, method, *args|
+      ast = @ast
+
+      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 not receiver and [:lambda, :proc].include? method
+        return parse args.first
+      end
+
+      op_index   = operator_index method
+      if op_index != -1
+        target = args.first 
+        target = target.children.first if target and target.type == :begin
+        receiver = receiver.children.first if receiver.type == :begin
+      end
+
+      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
+
+      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
+
+      elsif method == :[]
+        "#{ parse receiver }[#{ args.map {|arg| parse arg}.join(', ') }]"
+
+      elsif method == :[]=
+        "#{ parse receiver }[#{ args[0..-2].map {|arg| parse arg}.join(', ') }] = #{ parse args[-1] }"
+
+      elsif [:-@, :+@, :~].include? method
+        "#{ method.to_s[0] }#{ parse receiver }"
+
+      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) }"  
+
+      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(', ')
+        if args.length > 0 or is_method?(ast)
+          "new #{ parse receiver }(#{ args })"
+        else
+          "new #{ parse receiver }"
+        end
+
+      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)
+          if receiver
+            "#{ parse receiver }.#{ method }"
+          else
+            parse s(:lvasgn, method), @state
+          end
+        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 })"
+        end
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/sym.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  class Converter
+
+    # (sym :sym))
+
+    handle :sym do |sym|
+      sym.to_s.inspect
+    end
+  end
+end

data/lib/ruby2js/converter/undef.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (undef
+    #   (sym :foo)
+    #   (sym :bar))
+
+    handle :undef do |*syms|
+      syms.map {|sym| "delete #{sym.children.last}"}.join @sep
+    end
+  end
+end

data/lib/ruby2js/converter/until.rb

@@ -0,0 +1,12 @@
+module Ruby2JS
+  class Converter
+
+    # (until
+    #   (true)
+    #   (...))
+
+    handle :until do |condition, block|
+      parse s(:while, s(:send, condition, :!), block)
+    end
+  end
+end

data/lib/ruby2js/converter/untilpost.rb

@@ -0,0 +1,13 @@
+module Ruby2JS
+  class Converter
+
+    # (until-post
+    #   (true)
+    #   (kwbegin
+    #     (...)))
+
+    handle :until_post do |condition, block|
+      parse s(:while_post, s(:send, condition, :!), block)
+    end
+  end
+end