ruby2js 1.0.0 → 1.1.0

data/lib/ruby2js/converter/andasgn.rb

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

data/lib/ruby2js/converter/arg.rb

@@ -0,0 +1,14 @@
+module Ruby2JS
+  class Converter
+
+    # (arg :a)
+    # (blockarg :b)
+
+    # NOTE: process_all appends a nil child for unknown reasons
+
+    handle :arg, :blockarg do |arg, unknown=nil|
+      raise NotImplementedError, "argument #{ unknown.inspect }" if unknown
+      arg
+    end
+  end
+end

data/lib/ruby2js/converter/args.rb

@@ -0,0 +1,13 @@
+module Ruby2JS
+  class Converter
+
+   # (args
+   #   (arg :a)
+   #   (restarg :b)
+   #   (blockarg :c))
+
+    handle :args do |*args|
+      args.map { |arg| parse arg }.join(', ')
+    end
+  end
+end

data/lib/ruby2js/converter/array.rb

@@ -0,0 +1,33 @@
+module Ruby2JS
+  class Converter
+
+    # (array
+    #   (int 1)
+    #   (int 2))
+
+    handle :array do |*items|
+      splat = items.rindex { |a| a.type == :splat }
+      if splat
+        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
+        items.map! { |item| parse item }
+        if items.map {|item| item.length+2}.reduce(&:+).to_i < 72
+          "[#{ items.join(', ') }]"
+        else
+          "[#@nl#{ items.join(",#@ws") }#@nl]"
+        end
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/begin.rb

@@ -0,0 +1,13 @@
+module Ruby2JS
+  class Converter
+
+    # (begin
+    #   (...)
+    #   (...))
+
+    handle :begin do |*statements|
+      state = @state
+      statements.map{ |statement| parse statement, state }.join(@sep)
+    end
+  end
+end

data/lib/ruby2js/converter/block.rb

@@ -0,0 +1,16 @@
+module Ruby2JS
+  class Converter
+
+    # (block
+    #   (send nil :x)
+    #   (args
+    #     (arg :a))
+    #   (lvar :a))
+
+    handle :block do |call, args, block|
+      block ||= s(:begin)
+      function = s(:def, nil, args, block)
+      parse s(:send, *call.children, function)
+    end
+  end
+end

data/lib/ruby2js/converter/blockpass.rb

@@ -0,0 +1,11 @@
+module Ruby2JS
+  class Converter
+
+    # (block-pass
+    #   (lvar :a))
+
+    handle :block_pass do |arg|
+      parse arg
+    end
+  end
+end

data/lib/ruby2js/converter/boolean.rb

@@ -0,0 +1,11 @@
+module Ruby2JS
+  class Converter
+
+    # (true)
+    # (false)
+
+    handle :true, :false do
+      @ast.type.to_s
+    end
+  end
+end

data/lib/ruby2js/converter/break.rb

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

data/lib/ruby2js/converter/case.rb

@@ -0,0 +1,23 @@
+module Ruby2JS
+  class Converter
+
+    # (case
+    #   (send nil :a)
+    #   (when
+    #      (int 1)
+    #      (...))
+    #   (...))
+
+    handle :case do |expr, *whens, other|
+      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}}"
+    end
+  end
+end

data/lib/ruby2js/converter/casgn.rb

@@ -0,0 +1,16 @@
+module Ruby2JS
+  class Converter
+
+    # (casgn nil :a
+    #   (int 1))
+
+    handle :casgn do |cbase, var, value|
+      begin
+        var = "#{ parse cbase }.var" if cbase
+        "const #{ var } = #{ parse value }"
+      ensure
+        @vars[var] = true
+      end
+    end
+  end
+end

data/lib/ruby2js/converter/class.rb

@@ -0,0 +1,75 @@
+module Ruby2JS
+  class Converter
+
+    # (class
+    #   (const nil :A)
+    #   (const nil :B)
+    #   (...)
+
+    handle :class do |name, inheritance, *body|
+      init = s(:def, :initialize, s(:args))
+      body.compact!
+
+      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))
+      else
+        # look for a sequence of methods
+        methods = 0
+        body.compact.each do |node|
+          break unless node and node.type == :send and node.children[0]
+          break unless node.children[0].type == :attr
+          break unless node.children[0].children[0..1] == [name, :prototype]
+          break unless node.children[1] =~ /=$/
+          methods += 1
+        end
+
+        # collapse sequence of methods to a single assignment
+        if methods > 1
+          pairs = body[0...methods].map do |node|
+            s(:pair, s(:str, node.children[1].chomp('=')), node.children[2])
+          end
+          body.shift(methods)
+          body.unshift s(:send, name, :prototype=, s(:hash, *pairs))
+        end
+      end
+
+      # prepend constructor
+      body.unshift s(:def, parse(name), *init.children[1..-1])
+
+      parse s(:begin, *body.compact)
+    end
+  end
+end

data/lib/ruby2js/converter/const.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  class Converter
+
+    # (const nil :C)
+
+    handle :const do |receiver, name|
+      "#{ parse receiver }#{ '.' if receiver }#{ name }"
+    end
+  end
+end

data/lib/ruby2js/converter/def.rb

@@ -0,0 +1,91 @@
+module Ruby2JS
+  class Converter
+
+    # (def :f
+    #   (args
+    #     (arg :x)
+    #   (...)
+
+    handle :def do |name, args, body=nil|
+      body ||= s(:begin)
+      if name =~ /[!?]$/
+        raise NotImplementedError, "invalid method name #{ name }"
+      end
+
+      vars = {}
+      vars.merge! @vars unless name
+      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
+
+       nl = @nl unless body == s(:begin)
+      "function#{ " #{name}" if name }(#{ parse args }) " +
+        "{#{nl}#{ scope body, vars}#{nl}}"
+    end
+  end
+end

data/lib/ruby2js/converter/defined.rb

@@ -0,0 +1,15 @@
+module Ruby2JS
+  class Converter
+
+    # (defined? :@a)
+
+    # (undefined? :@a)
+
+    # NOTE: undefined is not produced directly by Parser
+
+    handle :defined?, :undefined? do |var|
+      op = (@ast.type == :defined? ? "!==" : "===")
+      "typeof #{ parse var } #{ op } 'undefined'"
+    end
+  end
+end

data/lib/ruby2js/converter/dstr.rb

@@ -0,0 +1,16 @@
+module Ruby2JS
+  class Converter
+
+    # (dstr
+    #   (str 'a')
+    #   (...))
+
+    # (dsym
+    #   (str 'a')
+    #   (...))
+
+    handle :dstr, :dsym do |*children|
+      children.map{ |child| parse child }.join(' + ')
+    end
+  end
+end

data/lib/ruby2js/converter/for.rb

@@ -0,0 +1,19 @@
+module Ruby2JS
+  class Converter
+
+    # (xstr
+    #   (str 'a'))
+    # (for
+    #   (lvasgn :i)
+    #   (array
+    #     (int 1))
+    #   (...)
+
+    handle :for do |var, expression, block|
+      parse s(:block,
+        s(:send, expression, :forEach),
+        s(:args, s(:arg, var.children.last)),
+        block);
+    end
+  end
+end

data/lib/ruby2js/converter/hash.rb

@@ -0,0 +1,24 @@
+module Ruby2JS
+  class Converter
+
+    # (hash
+    #   (pair
+    #     (sym :name)
+    #     (str "value")))
+
+    handle :hash do |*pairs|
+      pairs.map! do |node|
+        left, right = node.children
+        key = parse left
+        key = $1 if key =~ /\A"([a-zA-Z_$][a-zA-Z_$0-9]*)"\Z/
+        "#{key}: #{parse right}"
+      end
+
+      if pairs.map {|item| item.length+2}.reduce(&:+).to_i < 72
+        "{#{ pairs.join(', ') }}"
+      else
+        "{#@nl#{ pairs.join(",#@ws") }#@nl}"
+      end
+    end
+  end
+end