parser 2.2.2.3 → 2.2.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab4cd18ca1c0a175a8631f5b33b00d1b74a87138
-  data.tar.gz: 84d9cd1a7216ab854b704080977bfec9dcd86023
+  metadata.gz: 710e70cbd335c48e5d33828e22465ed144bb89e1
+  data.tar.gz: f7b154226cd171fc3d7290a83636e292631c961a
 SHA512:
-  metadata.gz: cdf15aa367699423e2b475cc9e90c90eb52e6fdbd0c8560e63ea9f3e85ed8dd0963052f2413363460dda0b2adfde1738abf059cba398983c2937f3c5860fd4ac
-  data.tar.gz: 6be794d016744e9d7a0ffab004983bb6af6030c88ba1ccd11c31776d1108d8f45391fa2455d82fc14ca30b89d2c25951648ae3cf186111fc5397f6721978d17c
+  metadata.gz: f675cb69ce293a7f6787c6b08ce38d545393a7ca776a999f5c37cb607425a22aee2d2d2f24474792927e8bbc36e86125b8bcbe3c366cebb2c3fc785e2eaa5675
+  data.tar.gz: 02fb79c07b4473351667a166383345a235a756cea3ff7b0b718683fe5b6fab13c5f67ffc484e60f72402cf8c0b6e5130305157e1dac96a5d57353efe41d1af3c

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 Changelog
 =========
 
+v2.2.2.5 (2015-05-25)
+---------------------
+
+API modifications:
+ * Source::Comment::Associator: rework entirely; fixes #194 (Oleg Zubchenko)
+
+Features implemented:
+ * Source::Map: add last_line, last_column delegation (Oleg Zubchenko)
+ * Source::Range: add last_line, last_column methods (Oleg Zubchenko)
+
+Bugs fixed:
+ * AST::Processor: add missing on_block_pass (fixes #196) (whitequark)
+
 v2.2.2.3 (2015-05-17)
 ---------------------
 

data/lib/parser/ast/processor.rb

@@ -108,6 +108,7 @@ module Parser
       alias on_arg_expr       process_regular_node
       alias on_restarg_expr   process_regular_node
       alias on_blockarg_expr  process_regular_node
+      alias on_block_pass     process_regular_node
 
       alias on_module         process_regular_node
       alias on_class          process_regular_node

data/lib/parser/source/comment/associator.rb

@@ -54,11 +54,12 @@ module Parser
       end
 
       ##
-      # Compute a mapping between AST nodes and comments.
+      # Compute a mapping between AST nodes and comments.  Comment is
+      # associated with the node, if it is one of the following types:
       #
-      # A comment belongs to a certain node if it begins after end
-      # of the previous node (if one exists) and ends before beginning of
-      # the current node.
+      # - preceding comment, it ends before the node start
+      # - sparse comment, it is located inside the node, after all child nodes
+      # - decorating comment, it starts at the same line, where the node ends
       #
       # This rule is unambiguous and produces the result
       # one could reasonably expect; for example, this code
@@ -76,6 +77,9 @@ module Parser
       #         [#<Parser::Source::Comment (string):3:8 "# bar">]
       #     }
       #
+      # Note that comments after the end of the end of a passed tree range are
+      # ignored (except root decorating comment).
+      #
       # Note that {associate} produces unexpected result for nodes which are
       # equal but have distinct locations; comments for these nodes are merged.
       #
@@ -108,39 +112,35 @@ module Parser
 
         advance_through_directives if @skip_directives
 
-        @prev_node = nil
-        visit(@ast)
+        visit(@ast) if @ast
 
         @mapping
       end
 
       def visit(node)
-        process_node(node)
-
-        if node.children.length > 0
-          node.children.each do |child|
-            next unless child.is_a?(AST::Node) && child.loc && child.loc.expression
-            visit(child)
-          end
-          process_trailing_comments(node)
-          @prev_node = node
+        process_leading_comments(node)
+
+        node.children.each do |child|
+          next unless child.is_a?(AST::Node) && child.loc && child.loc.expression
+          visit(child)
         end
+
+        process_trailing_comments(node)
       end
 
-      def process_node(node)
-        return unless node.type != :begin
-        while current_comment_between?(@prev_node, node)
-          associate_and_advance_comment(@prev_node, node)
+      def process_leading_comments(node)
+        return if node.type == :begin
+        while current_comment_before?(node) # preceding comment
+          associate_and_advance_comment(node)
         end
-        @prev_node = node
       end
 
-      def process_trailing_comments(parent)
-        while current_comment_decorates?(@prev_node)
-          associate_and_advance_comment(@prev_node, nil)
+      def process_trailing_comments(node)
+        while current_comment_before_end?(node)
+          associate_and_advance_comment(node) # sparse comment
         end
-        while current_comment_before_end?(parent)
-          associate_and_advance_comment(@prev_node, nil)
+        while current_comment_decorates?(node)
+          associate_and_advance_comment(node) # decorating comment
         end
       end
 
@@ -149,40 +149,31 @@ module Parser
         @current_comment = @comments[@comment_num]
       end
 
-      def current_comment_between?(prev_node, next_node)
+      def current_comment_before?(node)
         return false if !@current_comment
         comment_loc = @current_comment.location.expression
 
-        if next_node
-          next_loc = next_node.location.expression
-          return false if comment_loc.end_pos > next_loc.begin_pos
-        end
-        if prev_node
-          prev_loc = prev_node.location.expression
-          return false if comment_loc.begin_pos < prev_loc.begin_pos
+        if node
+          node_loc = node.location.expression
+          return false if comment_loc.end_pos > node_loc.begin_pos
         end
         true
       end
 
-      def current_comment_decorates?(prev_node)
+      def current_comment_before_end?(node)
         return false if !@current_comment
-        @current_comment.location.line == prev_node.location.line
+        comment_loc = @current_comment.location.expression
+        node_loc = node.location.expression
+        comment_loc.end_pos <= node_loc.end_pos
       end
 
-      def current_comment_before_end?(parent)
+      def current_comment_decorates?(node)
         return false if !@current_comment
-        comment_loc = @current_comment.location.expression
-        parent_loc = parent.location.expression
-        comment_loc.end_pos <= parent_loc.end_pos
+        @current_comment.location.line == node.location.last_line
       end
 
-      def associate_and_advance_comment(prev_node, node)
-        if prev_node && node
-          owner_node = (@current_comment.location.line == prev_node.location.line) ? prev_node : node
-        else
-          owner_node = prev_node ? prev_node : node
-        end
-        key = @map_using_locations ? owner_node.location : owner_node
+      def associate_and_advance_comment(node)
+        key = @map_using_locations ? node.location : node
         @mapping[key] << @current_comment
         advance_comment
       end

data/lib/parser/source/map.rb

@@ -98,6 +98,8 @@ module Parser
         @expression.line
       end
 
+      alias_method :first_line, :line
+
       ##
       # A shortcut for `self.expression.column`.
       # @return [Integer]
@@ -106,6 +108,22 @@ module Parser
         @expression.column
       end
 
+      ##
+      # A shortcut for `self.expression.last_line`.
+      # @return [Integer]
+      #
+      def last_line
+        @expression.last_line
+      end
+
+      ##
+      # A shortcut for `self.expression.last_column`.
+      # @return [Integer]
+      #
+      def last_column
+        @expression.last_column
+      end
+
       ##
       # @api private
       #

data/lib/parser/source/range.rb

@@ -75,6 +75,8 @@ module Parser
         line
       end
 
+      alias_method :first_line, :line
+
       ##
       # @return [Integer] zero-based column number of the beginning of this range.
       #
@@ -84,6 +86,24 @@ module Parser
         column
       end
 
+      ##
+      # @return [Integer] line number of the end of this range.
+      #
+      def last_line
+        line, _ = @source_buffer.decompose_position(@end_pos)
+
+        line
+      end
+
+      ##
+      # @return [Integer] zero-based column number of the end of this range.
+      #
+      def last_column
+        _, column = @source_buffer.decompose_position(@end_pos)
+
+        column
+      end
+
       ##
       # @return [::Range] a range of columns spanned by this range.
       # @raise RangeError

data/lib/parser/version.rb

@@ -1,3 +1,3 @@
 module Parser
-  VERSION = '2.2.2.3'
+  VERSION = '2.2.2.5'
 end

data/test/test_source_comment_associator.rb

@@ -29,39 +29,56 @@ class TestSourceCommentAssociator < Minitest::Test
     ast, associations = associate(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# Class comment
-# another class comment
-class Foo
-  # attr_accessor comment
-  attr_accessor :foo
-
-  # method comment
+# class preceeding
+# another class preceeding
+class Foo # class keyword line
+  # method foo preceeding
+  def foo
+    puts 'foo'
+  end # method foo decorating
+  # method bar preceeding
   def bar
-    # expr comment
-    1 + # intermediate comment
+    # expression preceeding
+    1 + # 1 decorating
       2
-    # stray comment
-  end
-end
+    # method bar sparse
+  end # method bar decorating
+  # class sparse
+end # class decorating
     END
 
-    klass_node         = ast
-    attr_accessor_node = ast.children[2].children[0]
-    method_node        = ast.children[2].children[1] # def bar
-    expr_node          = method_node.children[2] # 1 + 2
-    intermediate_node  = expr_node.children[0] # 1
-
-    assert_equal 5, associations.size
-    assert_equal ['# Class comment', '# another class comment'],
-                 associations[klass_node].map(&:text)
-    assert_equal ['# attr_accessor comment'],
-                 associations[attr_accessor_node].map(&:text)
-    assert_equal ['# method comment'],
-                 associations[method_node].map(&:text)
-    assert_equal ['# expr comment', "# stray comment"],
-                 associations[expr_node].map(&:text)
-    assert_equal ['# intermediate comment'],
-                 associations[intermediate_node].map(&:text)
+    klass_node      = ast
+    klass_name_node = klass_node.children[0]
+    foo_node        = klass_node.children[2].children[0] # def foo
+    bar_node        = klass_node.children[2].children[1] # def bar
+    expr_node       = bar_node.children[2] # 1 + 2
+    one_node        = expr_node.children[0] # 1
+
+    assert_equal 6, associations.size
+    assert_equal [
+      '# class preceeding',
+      '# another class preceeding',
+      '# class sparse',
+      '# class decorating'
+    ], associations[klass_node].map(&:text)
+    assert_equal [
+      '# class keyword line'
+    ], associations[klass_name_node].map(&:text)
+    assert_equal [
+      '# method foo preceeding',
+      '# method foo decorating'
+    ], associations[foo_node].map(&:text)
+    assert_equal [
+      '# method bar preceeding',
+      '# method bar sparse',
+      '# method bar decorating'
+    ], associations[bar_node].map(&:text)
+    assert_equal [
+      '# expression preceeding'
+    ], associations[expr_node].map(&:text)
+    assert_equal [
+      '# 1 decorating'
+    ], associations[one_node].map(&:text)
   end
 
   # The bug below is fixed by using associate_locations
@@ -93,39 +110,56 @@ end
     ast, associations = associate_locations(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# Class comment
-# another class comment
-class Foo
-  # attr_accessor comment
-  attr_accessor :foo
-
-  # method comment
+# class preceeding
+# another class preceeding
+class Foo # class keyword line
+  # method foo preceeding
+  def foo
+    puts 'foo'
+  end # method foo decorating
+  # method bar preceeding
   def bar
-    # expr comment
-    1 + # intermediate comment
+    # expression preceeding
+    1 + # 1 decorating
       2
-    # stray comment
-  end
-end
+    # method bar sparse
+  end # method bar decorating
+  # class sparse
+end # class decorating
     END
 
-    klass_node         = ast
-    attr_accessor_node = ast.children[2].children[0]
-    method_node        = ast.children[2].children[1]
-    expr_node          = method_node.children[2]
-    intermediate_node  = expr_node.children[0]
-
-    assert_equal 5, associations.size
-    assert_equal ['# Class comment', '# another class comment'],
-                 associations[klass_node.loc].map(&:text)
-    assert_equal ['# attr_accessor comment'],
-                 associations[attr_accessor_node.loc].map(&:text)
-    assert_equal ['# method comment'],
-                 associations[method_node.loc].map(&:text)
-    assert_equal ['# expr comment', '# stray comment'],
-                 associations[expr_node.loc].map(&:text)
-    assert_equal ['# intermediate comment'],
-                 associations[intermediate_node.loc].map(&:text)
+    klass_node      = ast
+    klass_name_node = klass_node.children[0]
+    foo_node        = klass_node.children[2].children[0] # def foo
+    bar_node        = klass_node.children[2].children[1] # def bar
+    expr_node       = bar_node.children[2] # 1 + 2
+    one_node        = expr_node.children[0] # 1
+
+    assert_equal 6, associations.size
+    assert_equal [
+      '# class preceeding',
+      '# another class preceeding',
+      '# class sparse',
+      '# class decorating'
+    ], associations[klass_node.loc].map(&:text)
+    assert_equal [
+      '# class keyword line'
+    ], associations[klass_name_node.loc].map(&:text)
+    assert_equal [
+      '# method foo preceeding',
+      '# method foo decorating'
+    ], associations[foo_node.loc].map(&:text)
+    assert_equal [
+      '# method bar preceeding',
+      '# method bar sparse',
+      '# method bar decorating'
+    ], associations[bar_node.loc].map(&:text)
+    assert_equal [
+      '# expression preceeding'
+    ], associations[expr_node.loc].map(&:text)
+    assert_equal [
+      '# 1 decorating'
+    ], associations[one_node.loc].map(&:text)
   end
 
   def test_associate_locations_dupe_statement
@@ -164,6 +198,11 @@ end
                  associations[ast].map(&:text)
   end
 
+  def test_associate_empty_tree
+    ast, associations = associate("")
+    assert_equal 0, associations.size
+  end
+
   def test_associate_shebang_only
     ast, associations = associate(<<-END)
 #!ruby
@@ -183,6 +222,17 @@ end
     assert_equal 0, associations.size
   end
 
+  def test_associate_comments_after_root_node
+    ast, associations = associate(<<-END)
+class Foo
+end
+# not associated
+    END
+
+    assert_equal 0, associations.size
+  end
+
+
   def test_associate_stray_comment
     ast, associations = associate(<<-END)
 def foo

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.2.2.3
+  version: 2.2.2.5
 platform: ruby
 authors:
 - Peter Zotov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-17 00:00:00.000000000 Z
+date: 2015-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast