ruby2js 1.15.1 → 2.0.0

data/lib/ruby2js/filter/require.rb

@@ -45,7 +45,10 @@ module Ruby2JS
             end
 
             @options[:file2] = filename
-            process Ruby2JS.parse(File.read(filename), filename)
+            ast, comments = Ruby2JS.parse(File.read(filename), filename)
+            @comments.merge! Parser::Source::Comment.associate(ast, comments)
+            @comments[node] += @comments[ast]
+            process ast
           ensure
             if file2
               @options[:file2] = file2

data/lib/ruby2js/filter/underscore.rb

@@ -11,42 +11,42 @@ module Ruby2JS
         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])
+            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],
+          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],
+          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],
+            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],
+            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],
+          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],
+          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],
+          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],
+            process S(:send, s(:lvar, :_), :invoke, node.children[0],
               node.children.last.children.first,
               *node.children[2..-2])
           else
@@ -54,7 +54,7 @@ module Ruby2JS
           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],
+          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
@@ -62,7 +62,7 @@ module Ruby2JS
             # output: _.reduce(_.rest(a), 
             #                  proc {|memo, item| return memo+item},
             #                  a[0])
-            process s(:send, s(:lvar, :_), :reduce, 
+            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)),
@@ -75,7 +75,7 @@ module Ruby2JS
           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,
+            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), 
@@ -90,7 +90,7 @@ module Ruby2JS
           # input: a.compact!
           # output: a.splice(0, a.length, *a.compact)
           target = node.children.first
-          process s(:send, target, :splice, s(:int, 0), 
+          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
@@ -104,14 +104,14 @@ module Ruby2JS
           # 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,
+          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], 
+            process S(:block, s(:send, s(:lvar, :_), call.children[1], 
               call.children.first), node.children[1], 
               s(:autoreturn, node.children[2]))
           else
@@ -121,7 +121,7 @@ module Ruby2JS
         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], 
+          process S(:block, s(:send, s(:lvar, :_), call.children[1], 
             call.children.first), node.children[1], node.children[2])
 
         elsif call.children[1] == :reduce
@@ -130,7 +130,7 @@ module Ruby2JS
             # output: _.reduce(_.rest(a), 
             #                  proc {|memo, item| return memo+item},
             #                  a[0])
-            process s(:send, s(:lvar, :_), :reduce, 
+            process S(:call, 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])),
@@ -138,7 +138,7 @@ module Ruby2JS
           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,
+            process S(:call, s(:lvar, :_), :reduce, call.children.first,
               s(:block, s(:send, nil, :proc), 
                 node.children[1], s(:autoreturn, node.children[2])),
                 call.children[2])
@@ -149,7 +149,7 @@ module Ruby2JS
           # 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, 
+          process S(:call, 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]))))
@@ -165,10 +165,10 @@ module Ruby2JS
 
       def on_irange(node)
         if node.children.last.type == :int
-          process s(:send, s(:lvar, :_), :range, node.children.first,
+          process S(:call, s(:lvar, :_), :range, node.children.first,
             s(:int, node.children.last.children.last+1))
         else
-          process s(:send, s(:lvar, :_), :range, node.children.first,
+          process S(:call, s(:lvar, :_), :range, node.children.first,
             s(:send, node.children.last, :+, s(:int, 1)))
         end
       end

data/lib/ruby2js/serializer.rb

@@ -0,0 +1,347 @@
+module Ruby2JS
+  class Token < String
+    attr_accessor :loc
+    attr_accessor :ast
+
+    def initialize(string, ast)
+      super(string.to_s)
+      @ast = ast
+      @loc = ast.location if ast
+    end
+  end
+
+  class Line < Array
+    attr_accessor :indent
+
+    def initialize(*args)
+      super(args)
+      @indent = 0
+    end
+
+    def comment?
+      first = find {|token| !token.empty?}
+      first and first.start_with? '//'
+    end
+
+    def empty?
+      all? {|line| line.empty?}
+    end
+
+    def to_s
+      if empty?
+        ''
+      elsif ['case ', 'default:'].include? self[0]
+        ' ' * ([0,indent-2].max) + join
+      else
+        ' ' * indent + join
+      end
+    end
+  end
+
+  class Serializer
+    attr_reader :timestamps
+
+    def initialize
+      @sep = '; '
+      @nl = ''
+      @ws = ' '
+
+      @width = 80
+      @indent = 0
+
+      @lines = [Line.new]
+      @line = @lines.last
+      @timestamps = {}
+    end
+
+    def timestamp(file)
+      @timestamps[file] = File.mtime(file) if file and File.exist?(file)
+    end
+
+    def uptodate?
+      return false if @timestamps.empty?
+      return @timestamps.all? {|file, mtime| File.mtime(file) == mtime}
+    end
+
+    def mtime
+      return Time.now if @timestamps.empty?
+      return @timestamps.values.max
+    end
+
+    def enable_vertical_whitespace
+      @sep = ";\n"
+      @nl = "\n"
+      @ws = @nl
+      @indent = 2
+    end
+
+    # indent multi-line parameter lists, array constants, blocks
+    def reindent(lines)
+      indent = 0
+      lines.each do |line|
+        first = line.find {|token| !token.empty?}
+        if first
+          last = line[line.rindex {|token| !token.empty?}]
+          indent -= @indent if ')}]'.include? first[0]
+          line.indent = indent
+          indent += @indent if '({['.include? last[-1]
+        else
+          line.indent = indent
+        end
+      end
+    end
+
+    # add horizontal (indentation) and vertical (blank lines) whitespace
+    def respace
+      return if @indent == 0
+      reindent @lines
+
+      (@lines.length-3).downto(0) do |i|
+        if
+          @lines[i].length == 0
+        then
+          @lines.delete i
+        elsif
+          @lines[i+1].comment? and not @lines[i].comment? and
+          @lines[i].indent == @lines[i+1].indent
+        then
+          # before a comment
+          @lines.insert i+1, Line.new
+        elsif
+          @lines[i].indent == @lines[i+1].indent and 
+          @lines[i+1].indent < @lines[i+2].indent and
+          not @lines[i].comment?
+        then
+          # start of indented block
+          @lines.insert i+1, Line.new
+        elsif
+          @lines[i].indent > @lines[i+1].indent and 
+          @lines[i+1].indent == @lines[i+2].indent and
+          not @lines[i+2].empty?
+        then
+          # end of indented block
+          @lines.insert i+2, Line.new
+        end
+      end
+    end
+
+    # add a single token to the current line
+    def put(string)
+      unless String === string and string.include? "\n"
+        @line << Token.new(string, @ast)
+      else
+        parts = string.split("\n")
+        @line << Token.new(parts.shift, @ast)
+        @lines += parts.map {|part| Line.new(Token.new(part, @ast))}
+        @lines << Line.new if string.end_with?("\n")
+        @line = @lines.last
+      end
+    end
+
+    # add a single token to the current line and then advance to next line
+    def puts(string)
+      unless String === string and string.include? "\n"
+        @line << Token.new(string, @ast)
+      else
+        put string
+      end
+
+      @line = Line.new
+      @lines << @line
+    end
+
+    # advance to next line and then add a single token to the current line
+    def sput(string)
+      unless String === string and string.include? "\n"
+        @line = Line.new(Token.new(string, @ast))
+        @lines << @line
+      else
+        @line = Line.new
+        @lines << @line
+        put string
+      end
+    end
+
+    # current location: [line number, token number]
+    def output_location
+      [@lines.length-1, @line.length]
+    end
+
+    # insert a line into the output
+    def insert(mark, line)
+      if mark.last == 0
+        @lines.insert(mark.first, Line.new(Token.new(line.chomp, @ast)))
+      else
+        @lines[mark.first].insert(mark.last, Token.new(line, @ast))
+      end
+    end
+
+    # capture (and remove) tokens from the output stream
+    def capture(&block)
+      mark = output_location
+      block.call
+      lines = @lines.slice!(mark.first+1..-1)
+      @line = @lines.last
+
+      if lines.empty?
+        lines = [@line.slice!(mark.last..-1)]
+      elsif @line.length != mark.last
+        lines.unshift @line.slice!(mark.last..-1)
+      end
+
+      lines.map(&:join).join(@ws)
+    end
+
+    # wrap long statements in curly braces
+    def wrap
+      puts '{'
+      mark = output_location
+      yield
+
+      if
+        @lines.length > mark.first+1 or
+        @lines[mark.first-1].join.length + @line.join.length >= @width
+      then
+        sput '}'
+      else
+        @line = @lines[mark.first-1]
+        @line[-1..-1] = @lines.pop
+      end
+    end
+
+    # compact small expressions into a single line
+    def compact
+      mark = output_location
+      yield
+      return unless @lines.length - mark.first > 1
+      return if @indent == 0
+
+      # survey what we have to work with, keeping track of a possible
+      # split of the last argument or value
+      work = []
+      indent = len = 0
+      trail = split = nil
+      slice = @lines[mark.first..-1]
+      reindent(slice)
+      slice.each_with_index do |line, index|
+        if line.first.start_with? '//'
+          len += @width # comments are a deal breaker
+        else
+          (work.push ' '; len += 1) if trail == line.indent and @indent > 0
+          len += line.map(&:length).inject(&:+)
+          work += line
+
+          if trail == @indent and line.indent == @indent
+            split = [len, work.length, index]
+            break if len >= @width - 10
+          end
+          trail = line.indent
+        end
+      end
+
+      if len < @width - 10
+        # full collapse
+        @lines[mark.first..-1] = [Line.new(*work)]
+        @line = @lines.last
+      elsif split and split[0] < @width-10
+        if slice[split[2]].indent < slice[split[2]+1].indent
+          # collapse all but the last argument (typically a hash or function)
+          close = slice.pop
+          slice[-1].push *close
+          @lines[mark.first] = Line.new(*work[0..split[1]-1])
+          @lines[mark.first+1..-1] = slice[split[2]+1..-1]
+          @line = @lines.last
+        end
+      end
+    end
+
+    # return the output as a string
+    def to_s
+      return @str if @str
+      respace
+      @lines.map(&:to_s).join(@nl)
+    end
+
+    def to_str
+      @str ||= to_s
+    end
+
+    def +(value)
+      to_s+value
+    end
+
+    BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+    # https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+    def vlq(*mark)
+      if @mark[0] == mark[0]
+        return if @mark[-3..-1] == mark[-3..-1]
+        @mappings << ',' unless @mappings == ''
+      end
+
+      while @mark[0] < mark[0]
+        @mappings << ';'
+        @mark[0] += 1
+        @mark[1] = 0
+      end
+
+      diffs = mark.zip(@mark).map {|a,b| a-b}
+      @mark = mark
+
+      diffs[1..4].each do |diff|
+        if diff < 0
+          data = (-diff << 1) + 1
+        else
+          data = diff << 1
+        end
+
+        encoded = ''
+
+        begin
+          digit = data & 0b11111
+          data >>= 5
+          digit |= 0b100000 if data > 0
+          encoded << BASE64[digit]
+        end while data > 0
+
+        @mappings << encoded
+      end
+    end
+
+    def sourcemap
+      respace
+
+      @mappings = ''
+      sources = []
+      @mark = [0, 0, 0, 0, 0]
+
+      @lines.each_with_index do |line, row|
+        col = line.indent
+        line.each do |token|
+          if token != ' ' and token.loc
+            pos = token.loc.expression.begin_pos
+
+            buffer = token.loc.expression.source_buffer
+            source_index = sources.index(buffer)
+            if not source_index
+              source_index = sources.length
+              timestamp buffer.name
+              sources << buffer
+            end
+
+            split = buffer.source[0...pos].split("\n")
+            vlq row, col, source_index, split.length-1, split.last.to_s.length
+          end
+          col += token.length
+        end
+      end
+
+      @sourcemap = {
+        version: 3,
+        file: @ast.loc.expression.source_buffer.name,
+        sources: sources.map(&:name),
+        mappings: @mappings
+      }
+    end
+  end
+end