parser 2.3.0.pre.4 → 2.3.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fea7f55530b85f44e316648564958c278fbaa263
-  data.tar.gz: 311a216bc1414b18713a9de80866a848354f1c24
+  metadata.gz: 8603dec71087cb78e504f3ed0175962f075dde01
+  data.tar.gz: 518d432e89bce2f3a03f9cbabc1e5917040e2c2c
 SHA512:
-  metadata.gz: 8057a5681f5d217d455a618a2e8706ed5a6333976b57019005c2355339e40d5932753eb7ae3b8acc1dc52e48e6529d15b0f1a7f62f00d8d1b4b5513fd9449fee
-  data.tar.gz: 2f3d4d028c517bcd42f6498251d4fd264da703e60d9d9ef910b4a91138dc6896920ccfcc4210fcb22b8722e1a6cc1a33cbafb8cb6dee0239f23057ae21724c7b
+  metadata.gz: 10f802d02d6a4e4a80deb6e427fc68d123e86b51e00bdda09e06cbb30e4c33c795b11de47e58e5e370e0117bceca458c9660e416c0489e4601e680bf1c296f2b
+  data.tar.gz: 94dbc707d086703b9060687dceb6c7d806ad01c17619e4be7fd379bdbfb4dbe56212ac289443c513a4ba0c097f469390284e93dbd7708faf7b75dca4daa45158

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 Changelog
 =========
 
+v2.3.0.pre.5 (2015-12-16)
+-------------------------
+
+API modifications:
+ * Source::Diagnostic: output ^^^^^ instead of ^~~~~ (like clang). (whitequark)
+
 v2.3.0.pre.4 (2015-11-26)
 -------------------------
 

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in parser.gemspec
 gemspec
+
+# Workaround for bug in Bundler on JRuby
+# See https://github.com/bundler/bundler/issues/4157
+gem 'ast', '>= 1.1', '< 3.0'

data/Rakefile

@@ -30,12 +30,12 @@ GENERATED_FILES = %w(lib/parser/lexer.rb
 
 CLEAN.include(GENERATED_FILES)
 
-desc 'Generate the Ragel lexer and Bison parser.'
+desc 'Generate the Ragel lexer and Racc parser.'
 task :generate => GENERATED_FILES do
   Rake::Task[:ragel_check].invoke
   GENERATED_FILES.each do |filename|
     content = File.read(filename)
-    content = "# -*- encoding:utf-8; warn-indent:false -*-\n" + content
+    content = "# -*- encoding:utf-8; warn-indent:false; frozen_string_literal: true  -*-\n" + content
 
     File.open(filename, 'w') do |io|
       io.write content
@@ -45,7 +45,7 @@ end
 
 task :regenerate => [:clean, :generate]
 
-desc 'Generate the Ragel lexer and Bison parser in release mode.'
+desc 'Generate the Ragel lexer and Racc parser in release mode.'
 task :generate_release => [:clean_env, :regenerate]
 
 task :clean_env do

data/lib/parser/diagnostic.rb

@@ -82,23 +82,79 @@ module Parser
     # @return [Array<String>]
     #
     def render
-      source_line    = @location.source_line
+      if @location.line != @location.last_line
+        # multi-line diagnostic
+        first_line = first_line_only(@location)
+        last_line  = last_line_only(@location)
+        buffer     = @location.source_buffer
+
+        last_lineno, last_column = buffer.decompose_position(@location.end_pos)
+        ["#{@location}-#{last_lineno}:#{last_column}: #{@level}: #{message}"] +
+          render_line(first_line, true, false) +
+          render_line(last_line, false, true)
+      else
+        ["#{@location}: #{@level}: #{message}"] + render_line(@location)
+      end
+    end
+
+    private
+
+    ##
+    # Renders one source line in clang diagnostic style, with highlights.
+    #
+    # @return [Array<String>]
+    #
+    def render_line(range, range_start=false, range_end=false)
+      source_line    = range.source_line
       highlight_line = ' ' * source_line.length
 
-      @highlights.each do |hilight|
-        range = hilight.column_range
-        highlight_line[range] = '~' * hilight.size
+      @highlights.each do |highlight|
+       line_range = range.source_buffer.line_range(range.line)
+        if highlight = highlight.intersect(line_range)
+          highlight_line[highlight.column_range] = '~' * highlight.size
+        end
+      end
+
+      if !range_end && range.size >= 1
+        highlight_line[range.column_range] = '^' + '~' * (range.size - 1)
+      else
+        highlight_line[range.column_range] = '~' * range.size
       end
 
-      range = @location.column_range
-      highlight_line[range] = '^' * @location.size
+      if range_start
+        highlight_line += '...'
+      end
 
-      [
-        "#{@location.to_s}: #{@level}: #{message}",
-        source_line,
-        highlight_line,
-      ]
+      [source_line, highlight_line].
+        map { |line| "#{range.source_buffer.name}:#{range.line}: #{line}" }
     end
-  end
 
+    ##
+    # If necessary, shrink a `Range` so as to include only the first line.
+    #
+    # @return [Parser::Source::Range]
+    #
+    def first_line_only(range)
+      if range.line != range.last_line
+        range.resize(range.source =~ /\n/)
+      else
+        range
+      end
+    end
+
+    ##
+    # If necessary, shrink a `Range` so as to include only the last line.
+    #
+    # @return [Parser::Source::Range]
+    #
+    def last_line_only(range)
+      if range.line != range.last_line
+        Source::Range.new(range.source_buffer,
+                          range.begin_pos + (range.source =~ /[^\n]*\Z/),
+                          range.end_pos)
+      else
+        range
+      end
+    end
+  end
 end

data/lib/parser/lexer.rl

@@ -190,7 +190,7 @@ class Parser::Lexer
 
         # This is a workaround for 1.9.2, which (without force_encoding)
         # would convert the result to UTF-8 (source encoding of lexer.rl).
-        @source    += "\0".force_encoding(@encoding)
+        @source    += "\0".dup.force_encoding(@encoding)
       else
         @source    += "\0"
       end

data/lib/parser/source/buffer.rb

@@ -210,6 +210,26 @@ module Parser
         @lines.fetch(lineno - @first_line).dup
       end
 
+      ##
+      # Extract line `lineno` as a new `Range`, taking `first_line` into account.
+      #
+      # @param  [Integer] lineno
+      # @return [Range]
+      # @raise  [IndexError] if `lineno` is out of bounds
+      #
+      def line_range(lineno)
+        index = lineno - @first_line + 1
+        if index <= 0 || index > line_begins.size
+          raise IndexError, 'Parser::Source::Buffer: range for line ' \
+            "#{lineno} requested, valid line numbers are #{@first_line}.." \
+            "#{@first_line + line_begins.size - 1}"
+        elsif index == line_begins.size
+          Range.new(self, line_begins[-index][1], @source.size)
+        else
+          Range.new(self, line_begins[-index][1], line_begins[-index - 1][1] - 1)
+        end
+      end
+
       private
 
       def line_begins

data/lib/parser/source/range.rb

@@ -31,6 +31,10 @@ module Parser
       # @param [Integer] end_pos
       #
       def initialize(source_buffer, begin_pos, end_pos)
+        if end_pos < begin_pos
+          raise ArgumentError, 'Parser::Source::Range: end_pos must not be less than begin_pos'
+        end
+
         @source_buffer       = source_buffer
         @begin_pos, @end_pos = begin_pos, end_pos
 
@@ -184,6 +188,27 @@ module Parser
             [@end_pos,   other.end_pos].max)
       end
 
+      ##
+      # @param [Range] other
+      # @return [Range] overlapping region of this range and `other`, or `nil`
+      #   if they do not overlap
+      #
+      def intersect(other)
+        unless disjoint?(other)
+          Range.new(@source_buffer,
+            [@begin_pos, other.begin_pos].max,
+            [@end_pos,   other.end_pos].min)
+        end
+      end
+
+      ##
+      # @param [Range] other
+      # @return [Boolean] `true` if this range and `other` do not overlap
+      #
+      def disjoint?(other)
+        @begin_pos >= other.end_pos || other.begin_pos >= @end_pos
+      end
+
       ##
       # Compares ranges.
       # @return [Boolean]

data/lib/parser/source/rewriter.rb

@@ -159,7 +159,33 @@ module Parser
       private
 
       def append(action)
-        if (clobber_action = clobbered?(action.range))
+        if (clobber_actions = clobbered?(action.range))
+          handle_clobber(action, clobber_actions)
+        else
+          clobber(action.range)
+          active_queue << action
+        end
+
+        self
+      end
+
+      def clobber(range)
+        self.active_clobber = active_clobber | (2 ** range.size - 1) << range.begin_pos
+      end
+
+      def clobbered?(range)
+        if active_clobber & ((2 ** range.size - 1) << range.begin_pos) != 0
+          active_queue.select do |action|
+            action.range.end_pos > range.begin_pos &&
+              range.end_pos > action.range.begin_pos
+          end
+        end
+      end
+
+      def handle_clobber(action, existing)
+        if can_merge?(action, existing)
+          merge_actions!(action, existing)
+        else
           # cannot replace 3 characters with "foobar"
           diagnostic = Diagnostic.new(:error,
                                       :invalid_action,
@@ -170,30 +196,56 @@ module Parser
           # clobbered by: remove 3 characters
           diagnostic = Diagnostic.new(:note,
                                       :clobbered,
-                                      { :action => clobber_action },
-                                      clobber_action.range)
+                                      { :action => existing[0] },
+                                      existing[0].range)
           @diagnostics.process(diagnostic)
 
           raise ClobberingError, "Parser::Source::Rewriter detected clobbering"
-        else
-          clobber(action.range)
+        end
+      end
 
-          active_queue << action
+      def can_merge?(action, existing)
+        existing.all? do |other|
+          overlap       = action.range.intersect(other.range)
+          action_offset = overlap.begin_pos - action.range.begin_pos
+          other_offset  = overlap.begin_pos - other.range.begin_pos
+
+          replacement1 = action.replacement[action_offset, overlap.size] || ''
+          replacement2 = other.replacement[other_offset, overlap.size] || ''
+          replacement1 == replacement2
         end
+      end
 
-        self
+      def merge_actions!(action, existing)
+        actions      = existing.push(action).sort_by { |a| a.range.begin_pos }
+        merged_begin = actions.map { |act| act.range.begin_pos }.min
+        merged_end   = actions.map { |act| act.range.end_pos }.max
+        range        = Source::Range.new(@source_buffer,
+                                         merged_begin,
+                                         merged_end)
+        clobber(range)
+
+        replacement = merge_replacements(actions)
+        replace_actions(actions, Rewriter::Action.new(range, replacement))
       end
 
-      def clobber(range)
-        self.active_clobber = active_clobber | (2 ** range.size - 1) << range.begin_pos
+      def replace_actions(old, updated)
+        old.each { |act| active_queue.delete(act) }
+        active_queue << updated
       end
 
-      def clobbered?(range)
-        if active_clobber & ((2 ** range.size - 1) << range.begin_pos) != 0
-          active_queue.find do |action|
-            action.range.to_a & range.to_a
-          end
+      def merge_replacements(actions)
+        # `actions` must be sorted by beginning position
+        begin_pos = actions.first.range.begin_pos
+        result    = ''
+
+        actions.each do |act|
+          offset = result.size - act.range.begin_pos + begin_pos
+          next if offset < 0 || offset >= act.replacement.size
+          result << act.replacement[offset..-1]
         end
+
+        result
       end
 
       def in_transaction?

data/lib/parser/version.rb

@@ -1,3 +1,3 @@
 module Parser
-  VERSION = '2.3.0.pre.4'
+  VERSION = '2.3.0.pre.5'
 end

data/test/helper.rb

@@ -8,7 +8,7 @@ if ENV.include?('COVERAGE') && SimpleCov.usable?
   if defined?(TracePoint)
     require_relative 'racc_coverage_helper'
 
-    RaccCoverage.start(%w(ruby18.y ruby19.y ruby20.y ruby21.y),
+    RaccCoverage.start(%w(ruby18.y ruby19.y ruby20.y ruby21.y ruby22.y ruby23.y),
                        File.expand_path('../../lib/parser', __FILE__))
 
     # Report results faster.
@@ -33,7 +33,7 @@ if ENV.include?('COVERAGE') && SimpleCov.usable?
 
     # Exclude generated files.
     add_filter do |source_file|
-      source_file.filename =~ %r{/lib/parser/(lexer|ruby\d+)\.rb$}
+      source_file.filename =~ %r{/lib/parser/(lexer|ruby\d+|macruby|rubymotion)\.rb$}
     end
   end
 end

data/test/test_diagnostic.rb

@@ -42,8 +42,31 @@ class TestDiagnostic < Minitest::Test
                                    location, highlights)
     assert_equal([
       "(string):1:27: error: unexpected `+'",
-      'if (this is some bad code + bugs)',
-      '                     ~~~~ ^ ~~~~ '
+      '(string):1: if (this is some bad code + bugs)',
+      '(string):1:                      ~~~~ ^ ~~~~ '
+    ], diag.render)
+  end
+
+  def test_multiline_render
+    @buffer = Parser::Source::Buffer.new('(string)')
+    @buffer.source = "abc abc abc\ndef def def\nghi ghi ghi\n"
+
+    location = Parser::Source::Range.new(@buffer, 4, 27)
+
+    highlights = [
+      Parser::Source::Range.new(@buffer, 0, 3),
+      Parser::Source::Range.new(@buffer, 28, 31)
+    ]
+
+    diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'ghi' },
+                                  location, highlights)
+
+    assert_equal([
+      "(string):1:5-3:3: error: unexpected token ghi",
+      '(string):1: abc abc abc',
+      '(string):1: ~~~ ^~~~~~~...',
+      '(string):3: ghi ghi ghi',
+      '(string):3: ~~~ ~~~    '
     ], diag.render)
   end
 end

data/test/test_source_buffer.rb

@@ -100,4 +100,20 @@ class TestSourceBuffer < Minitest::Test
     assert_equal '1', @buffer.source_line(5)
     assert_equal 'foo', @buffer.source_line(6)
   end
+
+  def test_line_range
+    @buffer = Parser::Source::Buffer.new('(string)', 5)
+    @buffer.source = "abc\ndef\nghi\n"
+
+    assert_raises IndexError do
+      @buffer.line_range(4)
+    end
+    assert_equal 'abc', @buffer.line_range(5).source
+    assert_equal 'def', @buffer.line_range(6).source
+    assert_equal 'ghi', @buffer.line_range(7).source
+    assert_equal '', @buffer.line_range(8).source
+    assert_raises IndexError do
+      @buffer.line_range(9)
+    end
+  end
 end

data/test/test_source_range.rb

@@ -18,6 +18,12 @@ class TestSourceRange < Minitest::Test
     assert_equal 2, sr.size
   end
 
+  def test_bad_size
+    assert_raises ArgumentError do
+      Parser::Source::Range.new(@buf, 2, 1)
+    end
+  end
+
   def test_join
     sr1 = Parser::Source::Range.new(@buf, 1, 2)
     sr2 = Parser::Source::Range.new(@buf, 5, 8)
@@ -27,6 +33,28 @@ class TestSourceRange < Minitest::Test
     assert_equal 8, sr.end_pos
   end
 
+  def test_intersect
+    sr1 = Parser::Source::Range.new(@buf, 1, 3)
+    sr2 = Parser::Source::Range.new(@buf, 2, 6)
+    sr3 = Parser::Source::Range.new(@buf, 5, 8)
+
+    assert_equal 2, sr1.intersect(sr2).begin_pos
+    assert_equal 3, sr1.intersect(sr2).end_pos
+    assert_equal 5, sr2.intersect(sr3).begin_pos
+    assert_equal 6, sr2.intersect(sr3).end_pos
+    assert sr1.intersect(sr3) == nil
+  end
+
+  def test_disjoint
+    sr1 = Parser::Source::Range.new(@buf, 1, 3)
+    sr2 = Parser::Source::Range.new(@buf, 2, 6)
+    sr3 = Parser::Source::Range.new(@buf, 5, 8)
+
+    assert sr1.disjoint?(sr3)
+    assert !sr1.disjoint?(sr2)
+    assert !sr2.disjoint?(sr3)
+  end
+
   def test_line
     sr = Parser::Source::Range.new(@buf, 7, 8)
     assert_equal 2, sr.line

data/test/test_source_rewriter.rb

@@ -111,6 +111,42 @@ class TestSourceRewriter < Minitest::Test
     assert rescued
   end
 
+  def test_overlapping_delete
+    assert_equal 'faz',
+                 @rewriter.
+                   remove(range(1, 4)).
+                   remove(range(6, 3)).
+                   remove(range(4, 3)).
+                   process
+  end
+
+  def test_overlapping_replace
+    assert_equal 'flippin flyin flapjackz',
+                 @rewriter.
+                   replace(range(1, 4), 'lippin f').
+                   replace(range(4, 4), 'pin flyin flap').
+                   replace(range(7, 3), ' flyin flapjack').
+                   process
+  end
+
+  def test_subsuming_delete
+    assert_equal 'foo',
+                 @rewriter.
+                   remove(range(6, 3)).
+                   remove(range(7, 2)).
+                   remove(range(3, 8)).
+                   process
+  end
+
+  def test_subsuming_replace
+    assert_equal 'freebie',
+                 @rewriter.
+                   replace(range(3, 3), 'ebi').
+                   replace(range(1, 10), 'reebie').
+                   replace(range(5, 2), 'ie').
+                   process
+  end
+
   def test_transaction_returns_self
     assert_equal @rewriter, @rewriter.transaction {}
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.3.0.pre.4
+  version: 2.3.0.pre.5
 platform: ruby
 authors:
 - whitequark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-26 00:00:00.000000000 Z
+date: 2015-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast