ruby2js 1.15.1 → 2.0.0

data/lib/ruby2js.rb

@@ -13,18 +13,40 @@ module Ruby2JS
       def s(type, *args)
         Parser::AST::Node.new type, args
       end
+
+      def S(type, *args)
+        @ast.updated(type, args)
+      end
     end
 
     class Processor < Parser::AST::Processor
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
+      def initialize(comments)
+        @comments = comments
+      end
+
       def options=(options)
         @options = options
       end
 
+      def process(node)
+        ast, @ast = @ast, node
+        replacement = super
+
+        if replacement != node and @comments[node]
+          @comments[replacement] = @comments[node]
+        end
+
+        replacement
+      ensure
+        @ast = ast
+      end
+
       # handle all of the 'invented' ast types
       def on_attr(node); on_send(node); end
       def on_autoreturn(node); on_return(node); end
+      def on_call(node); on_send(node); end
       def on_constructor(node); on_def(node); end
       def on_defp(node); on_defs(node); end
       def on_method(node); on_send(node); end
@@ -56,17 +78,19 @@ module Ruby2JS
   end
 
   def self.convert(source, options={})
-
     if Proc === source
       file,line = source.source_location
       source = File.read(file.dup.untaint).untaint
-      ast = find_block( parse(source), line )
-      options[:file] = file
+      ast, comments = parse(source)
+      comments = Parser::Source::Comment.associate(ast, comments) if ast
+      ast = find_block( ast, line )
+      options = options.merge(file => file) unless options[:file]
     elsif Parser::AST::Node === source
-      ast = source
+      ast, comments = source, {}
       source = ast.loc.expression.source_buffer.source
     else
-      ast = parse( source, options[:file] )
+      ast, comments = parse( source, options[:file] )
+      comments = Parser::Source::Comment.associate(ast, comments) if ast
     end
 
     filters = options[:filters] || Filter::DEFAULTS
@@ -76,12 +100,12 @@ module Ruby2JS
       filters.reverse.each do |mod|
         filter = Class.new(filter) {include mod} 
       end
-      filter = filter.new
+      filter = filter.new(comments)
       filter.options = options
       ast = filter.process(ast)
     end
 
-    ruby2js = Ruby2JS::Converter.new( ast )
+    ruby2js = Ruby2JS::Converter.new(ast, comments)
 
     ruby2js.binding = options[:binding]
     ruby2js.ivars = options[:ivars]
@@ -96,44 +120,20 @@ module Ruby2JS
 
     ruby2js.width = options[:width] if options[:width]
 
-    if source.include? "\n"
-      ruby2js.enable_vertical_whitespace 
-      lines = ruby2js.to_js.split("\n")
-      pre = []
-      pending = false
-      blank = true
-      lines.each do |line|
-        next if line.empty?
-
-        if ')}]'.include? line[0]
-          pre.pop
-          line.sub!(/([,;])$/,"\\1\n")
-          pending = true
-        else
-          pending = false
-        end
+    ruby2js.enable_vertical_whitespace if source.include? "\n"
 
-        line.insert 0, pre.join
-        if '({['.include? line[-1]
-          pre.push '  '
-          line.insert 0, "\n" unless blank or pending
-          pending = true
-        end
+    ruby2js.convert
 
-        blank = pending
-      end
+    ruby2js.timestamp options[:file]
 
-      lines.join("\n").gsub(/^  ( *(case.*|default):$)/, '\1')
-    else
-      ruby2js.to_js
-    end
+    ruby2js
   end
   
   def self.parse(source, file=nil)
     # workaround for https://github.com/whitequark/parser/issues/112
     buffer = Parser::Source::Buffer.new(file || '__SOURCE__')
     buffer.raw_source = source.encode('utf-8')
-    Parser::CurrentRuby.new.parse(buffer)
+    Parser::CurrentRuby.new.parse_with_comments(buffer)
   rescue Parser::SyntaxError => e
     split = source[0..e.diagnostic.location.begin_pos].split("\n")
     line, col = split.length, split.last.length

data/lib/ruby2js/converter.rb

@@ -1,7 +1,11 @@
 require 'parser/current'
 
+require 'ruby2js/serializer'
+
 module Ruby2JS
-  class Converter
+  class Converter < Serializer
+    attr_accessor :ast
+
     LOGICAL   = :and, :not, :or
     OPERATORS = [:[], :[]=], [:not, :!], [:*, :/, :%], [:+, :-], [:>>, :<<], 
       [:&], [:^, :|], [:<=, :<, :>, :>=], [:==, :!=, :===, :"!=="], [:and, :or]
@@ -20,14 +24,13 @@ module Ruby2JS
 
     attr_accessor :binding, :ivars
 
-    def initialize( ast, vars = {} )
-      @ast, @vars = ast, vars.dup
-      @sep = '; '
-      @nl = ''
-      @ws = ' '
+    def initialize( ast, comments, vars = {} )
+      super()
+
+      @ast, @comments, @vars = ast, comments, vars.dup
       @varstack = []
+      @scope = true
       @rbstack = []
-      @width = 80
       @next_token = :return
 
       @handlers = {}
@@ -35,12 +38,6 @@ module Ruby2JS
         @handlers[name] = method("on_#{name}")
       end
     end
-    
-    def enable_vertical_whitespace
-      @sep = ";\n"
-      @nl = "\n"
-      @ws = @nl
-    end
 
     def binding=(binding)
       @binding = binding
@@ -50,7 +47,7 @@ module Ruby2JS
       @width = width
     end
 
-    def to_js
+    def convert
       parse( @ast, :statement )
     end
 
@@ -59,11 +56,14 @@ module Ruby2JS
     end
     
     def scope( ast, args=nil )
-      @varstack.push @vars.dup
+      scope, @scope = @scope, true
+      @varstack.push @vars
       @vars = args if args
+      @vars = Hash[@vars.map {|key, value| [key, true]}]
       parse( ast, :statement )
     ensure
       @vars = @varstack.pop
+      @scope = scope
     end
 
     def s(type, *args)
@@ -78,22 +78,60 @@ module Ruby2JS
       end
     end
 
+    # extract comments that either precede or are included in the node.
+    # remove from the list this node may appear later in the tree.
+    def comments(ast)
+      if ast.loc and ast.loc.respond_to? :expression
+        expression = ast.loc.expression
+
+        list = @comments[ast].select do |comment|
+          expression.source_buffer == comment.loc.expression.source_buffer and
+          comment.loc.expression.begin_pos < expression.end_pos
+        end
+      else
+        list = @comments[ast]
+      end
+
+      @comments[ast] -= list
+
+      list.map do |comment|
+        comment.text.sub(/^#/, '//') + "\n"
+      end
+    end
+
     def parse(ast, state=:expression)
-      return ast unless ast
+      oldstate, @state = @state, state
+      oldast, @ast = @ast, ast
+      return unless ast
 
-      @state = state
-      @ast = ast
       handler = @handlers[ast.type]
 
       unless handler
         raise NotImplementedError, "unknown AST type #{ ast.type }"
       end
 
-      handler.call(*ast.children) if handler
+      if state == :statement and not @comments[ast].empty?
+        comments(ast).each {|comment| puts comment.chomp}
+      end
+
+      handler.call(*ast.children)
+    ensure
+      @ast = oldast
+    end
+
+    def parse_all(*args)
+      options = (Hash === args.last) ? args.pop : {}
+      sep = options[:join].to_s
+      state = options[:state] || :expression
+
+      args.each_with_index do |arg, index|
+        put sep unless index == 0
+        parse arg, state
+      end
     end
     
     def group( ast )
-      "(#{ parse ast })"
+      put '('; parse ast; put ')'
     end
   end
 end
@@ -103,6 +141,7 @@ module Parser
     class Node
       def is_method?
         return false if type == :attr
+        return true if type == :call
         return true unless loc
 
         if loc.respond_to? :selector

data/lib/ruby2js/converter/arg.rb

@@ -8,7 +8,7 @@ module Ruby2JS
 
     handle :arg, :blockarg do |arg, unknown=nil|
       raise NotImplementedError, "argument #{ unknown.inspect }" if unknown
-      arg
+      put arg
     end
 
     # (shadowarg :a)

data/lib/ruby2js/converter/args.rb

@@ -7,7 +7,7 @@ module Ruby2JS
    #   (blockarg :c))
 
     handle :args do |*args|
-      args.map { |arg| parse arg }.compact.join(', ')
+      parse_all *args, join: ', '
     end
   end
 end

data/lib/ruby2js/converter/array.rb

@@ -21,11 +21,10 @@ module Ruby2JS
             :concat, s(:array, *items[splat+1..-1]))
         end
       else
-        items.map! { |item| parse item }
-        if items.map {|item| item.length+2}.reduce(&:+).to_i < @width-8
-          "[#{ items.join(', ') }]"
+        if items.length <= 1
+          put '['; parse_all *items, join: ', '; put ']'
         else
-          "[#@nl#{ items.join(",#@ws") }#@nl]"
+          compact { puts '['; parse_all *items, join: ",#{@ws}"; sput ']' }
         end
       end
     end

data/lib/ruby2js/converter/begin.rb

@@ -28,7 +28,7 @@ module Ruby2JS
         statements.compact!
       end
 
-      statements.map{ |statement| parse statement, state }.join(@sep)
+      parse_all *statements, state: state, join: @sep
     end
 
     def combine_properties(body)
@@ -36,7 +36,21 @@ module Ruby2JS
         next unless body[i] and body[i].type == :prop
         for j in i+1...body.length
           break unless body[j] and body[j].type == :prop
+
           if body[i].children[0] == body[j].children[0]
+            # relocate property comment to first method
+            [body[i], body[j]].each do |node|
+              unless @comments[node].empty?
+                node.children[1].values.first.each do |key, value| 
+                  if [:get, :set].include? key and Parser::AST::Node === value
+                    @comments[value] = @comments[node]
+                    break
+                  end
+                end
+              end
+            end
+
+            # merge properties
             merge = Hash[(body[i].children[1].to_a+body[j].children[1].to_a).
               group_by {|name, value| name.to_s}.map {|name, values|
               [name, values.map(&:last).reduce(:merge)]}]

data/lib/ruby2js/converter/block.rb

@@ -17,13 +17,14 @@ module Ruby2JS
         var = args.children.first
         expression = call.children.first.children.first
         comp = (expression.type == :irange ? '<=' : '<')
-        "for (var #{parse var} = #{ parse expression.children.first }; " +
-          "#{ parse var } #{ comp } #{ parse expression.children.last }; " +
-          "#{ parse var } += #{ parse call.children[2] }) " +
-          "{#@nl#{ scope block }#@nl}"
+        put "for (var "; parse var; put " = "; parse expression.children.first
+        put "; "; parse var; put " #{comp} "; parse expression.children.last
+        put "; "; parse var; put " += "; parse call.children[2]; puts ") {"
+        scope block
+        sput "}"
       else
         block ||= s(:begin)
-        function = s(:def, nil, args, block)
+        function = @ast.updated(:def, [nil, args, block])
         parse s(:send, *call.children, function)
       end
     end

data/lib/ruby2js/converter/boolean.rb

@@ -5,7 +5,7 @@ module Ruby2JS
     # (false)
 
     handle :true, :false do
-      @ast.type.to_s
+      put @ast.type.to_s
     end
   end
 end

data/lib/ruby2js/converter/break.rb

@@ -7,7 +7,7 @@ module Ruby2JS
     handle :break do |n=nil|
       raise NotImplementedError, "break argument #{ n.inspect }" if n
       raise NotImplementedError, "break outside of loop" if @next_token == :return
-      'break'
+      put 'break'
     end
   end
 end

data/lib/ruby2js/converter/case.rb

@@ -9,15 +9,35 @@ module Ruby2JS
     #   (...))
 
     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, :statement }#{@sep}break#@sep"
-      end
+      begin
+        scope, @scope = @scope, false
+        mark = output_location
+
+        put 'switch ('; parse expr; puts ') {'
+
+        whens.each_with_index do |node, index|
+          puts '' unless index == 0
 
-      other = "#{@nl}default:#@ws#{ parse other, :statement }#@nl" if other
+          *values, code = node.children
+          values.each {|value| put 'case '; parse value; put ":#@ws"}
+          parse code, :statement
+          put "#{@sep}break#@sep" if other or index < whens.length-1
+        end
 
-      "switch (#{ parse expr }) {#@nl#{whens.join(@nl)}#{other}}"
+        (put "#{@nl}default:#@ws"; parse other, :statement) if other
+
+        sput '}'
+
+        if scope
+          vars = @vars.select {|key, value| value == :pending}.keys
+          unless vars.empty?
+            insert mark, "var #{vars.join(', ')}#{@sep}"
+            vars.each {|var| @vars[var] = true}
+          end
+        end
+      ensure
+        @scope = scope
+      end
     end
   end
 end

data/lib/ruby2js/converter/casgn.rb

@@ -6,8 +6,11 @@ module Ruby2JS
 
     handle :casgn do |cbase, var, value|
       begin
-        var = "#{ parse cbase }.var" if cbase
-        "var #{ var } = #{ parse value }"
+        put "var "
+
+        (parse cbase; put '.') if cbase
+
+        put "#{ var } = "; parse value
       ensure
         @vars[var] = true
       end

data/lib/ruby2js/converter/class.rb

@@ -12,7 +12,7 @@ module Ruby2JS
       if inheritance
         init = s(:def, :initialize, s(:args), s(:super))
       else
-        init = s(:def, :initialize, s(:args))
+        init = s(:def, :initialize, s(:args), nil)
       end
 
       body.compact!
@@ -24,7 +24,7 @@ module Ruby2JS
       body.compact!
       visible = {}
       body.map! do |m| 
-        if m.type == :def
+        node = if m.type == :def
           if m.children.first == :initialize
             # constructor: remove from body and overwrite init function
             init = m
@@ -43,7 +43,7 @@ module Ruby2JS
               s(:prop, s(:attr, name, :prototype), m.children.first =>
                   {enumerable: s(:true), configurable: s(:true),
                   get: s(:block, s(:send, nil, :proc), m.children[1],
-                    s(:autoreturn, *m.children[2..-1]))})
+                    m.updated(:autoreturn, m.children[2..-1]))})
             else
               # method: add to prototype
               s(:method, s(:attr, name, :prototype),
@@ -66,7 +66,7 @@ module Ruby2JS
             s(:prop, name, m.children[1].to_s =>
                 {enumerable: s(:true), configurable: s(:true),
                 get: s(:block, s(:send, nil, :proc), m.children[2],
-                  s(:autoreturn, *m.children[3..-1]))})
+                  m.updated(:autoreturn, m.children[3..-1]))})
           else
             # class method definition: add to prototype
             s(:prototype, s(:send, name, "#{m.children[1]}=",
@@ -134,6 +134,19 @@ module Ruby2JS
         else
           raise NotImplementedError, "class #{ m.type }"
         end
+
+        # associate comments
+        if node and @comments[m]
+          if Array === node
+            node[0] = m.updated(node.first.type, node.first.children)
+            @comments[node.first] = @comments[m]
+          else
+            node = m.updated(node.type, node.children)
+            @comments[node] = @comments[m]
+          end
+        end
+
+        node
       end
 
       body.flatten!
@@ -167,12 +180,23 @@ module Ruby2JS
         if methods > 1 or (methods == 1 and body[start].type == :prop)
           pairs = body[start...start+methods].map do |node|
             if node.type == :method
-              s(:pair, s(:str, node.children[1].to_s.chomp('=')),
-                node.children[2])
+              replacement = node.updated(:pair, [
+                s(:str, node.children[1].to_s.chomp('=')),
+                node.children[2]])
             else
-              node.children[1].map {|prop, descriptor|
-                s(:pair, s(:prop, prop), descriptor)}
+              replacement = node.children[1].map do |prop, descriptor|
+                node.updated(:pair, [s(:prop, prop), descriptor])
+              end
+            end
+
+            if @comments[node]
+              if Array === replacement
+                @comments[replacement.first] = @comments[node]
+              else
+                @comments[replacement] = @comments[node]
+              end
             end
+            replacement
           end
           body[start...start+methods] =
             s(:send, name, :prototype=, s(:hash, *pairs.flatten))
@@ -180,7 +204,9 @@ module Ruby2JS
       end
 
       # prepend constructor
-      body.unshift s(:constructor, parse(name), *init.children[1..-1])
+      constructor = init.updated(:constructor, [name, *init.children[1..-1]])
+      @comments[constructor] = @comments[init] unless @comments[init].empty?
+      body.unshift constructor
 
       begin
         # save class name
@@ -193,7 +219,7 @@ module Ruby2JS
         # add locally visible interfaces to rbstack.  See send.rb, const.rb
         @rbstack.push visible
 
-        parse s(:begin, *body.compact)
+        parse s(:begin, *body.compact), :statement
       ensure
         self.ivars = ivars
         @class_name = class_name
@@ -224,8 +250,12 @@ module Ruby2JS
           end
         elsif @ast.type == :method
           parse s(:send, *args)
+        elsif args.first.children.first
+          parse s(:send, args.first.children.first,
+            "#{args.first.children[1]}=", s(:block, s(:send, nil, :proc), 
+            *args[1..-1]))
         else
-          parse s(:def, *args)
+          parse s(:def, args.first.children[1], *args[1..-1])
         end
       ensure
         @instance_method = instance_method