parser 2.7.0.0 → 2.7.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c513c025d3466aaa344468699cb2b737a4d85ba3275b8702fe8cd7194e0fe74
-  data.tar.gz: 26b706425f418a7dbdb4063f7cd082e22633deb035c4444ca01dfe28c1a5c3d6
+  metadata.gz: 00a9bc5b2d70892e4743417168e53dc469c80328c3983e71b41f312becd116b0
+  data.tar.gz: 1abbc88751dc8d3b7c28d2df69b71a773533ed2d3726de50df8cfaaa79887aaa
 SHA512:
-  metadata.gz: a9743ae26ad02e463e5592cd53f0f6e2ab95ced23f687468fbd58df249971be181b7b69edafc69ca65e7a98048205940c0108aff96ceb7984c9220439e9e6d7f
-  data.tar.gz: 17afaecd6b1d3af320d62b570ccce3ebfb109ed845fc78059fd69a8561fe90630d01470f401370913a7ffc5e298f862580f7c302617432059d1afb8dd6ea13bc
+  metadata.gz: 32455424b4003ba1510d53b162aa8691bdaea5708b4d88d392d6c89cfa3b6479f1d47c9f42fedd40e663366192434aaf851dbe65cbd1a629c54b7681cfb37879
+  data.tar.gz: 0c464e9acd5cf95161e18552e4680230417a05e7ad14e805b8661e4bb2ee7a99f4ad2f4e0212c48b35bc9f3ed8549b6723925f0b194e0a57873a2eb472450dbb

data/.travis.yml

@@ -20,6 +20,9 @@ matrix:
     - name: 2.6.5 / Parser tests
       rvm: 2.6.5
       script: bundle exec rake test_cov
+    - name: 2.7.0 / Parser tests
+      rvm: 2.7.0
+      script: bundle exec rake test_cov
     - name: ruby-head / Parser tests
       rvm: ruby-head
       script: bundle exec rake test_cov
@@ -35,6 +38,9 @@ matrix:
     - name: 2.6.5 / Rubocop tests
       rvm: 2.6.5
       script: ./ci/run_rubocop_specs
+    - name: 2.7.0 / Rubocop tests
+      rvm: 2.7.0
+      script: ./ci/run_rubocop_specs
   allow_failures:
     - rvm: ruby-head
     - rvm: rbx-2

data/CHANGELOG.md

@@ -1,9 +1,36 @@
 Changelog
 =========
 
-Not released (2019-12-26)
+Not released (2020-03-20)
 -------------------------
 
+Features implemented:
+ * ruby27.y: fix array pattern with tail source map (#659) (Vladimir Dementyev)
+
+Bugs fixed:
+ * builder.rb: fix constant_pattern source map (#660) (Vladimir Dementyev)
+
+v2.7.0.4 (2020-03-02)
+---------------------
+
+Bugs fixed:
+ * lexer.rl: allow spaces before comments-before-leading-dot. (#654) (Ilya Bylich)
+
+v2.7.0.2 (2020-01-08)
+---------------------
+
+Bugs fixed:
+ * lexer.rl: fix paren_nest for curly braces (#646) (Ilya Bylich)
+
+v2.7.0.1 (2019-12-30)
+---------------------
+
+Bugs fixed:
+ * dedenter.rb: prevent `ArgumentError` when processing binary en… (#642) (Koichi ITO)
+
+v2.7.0.0 (2019-12-26)
+---------------------
+
 API modifications:
  * README.md: documented compatibility issue with EOF chars after… (#637) (Ilya Bylich)
  * ruby27.y: refactor logic around 'circular argument reference'(#628) (Ilya Bylich)

data/README.md

@@ -24,10 +24,11 @@ below for explanation of `emit_*` calls):
 
     require 'parser/current'
     # opt-in to most recent AST format:
-    Parser::Builders::Default.emit_lambda   = true
-    Parser::Builders::Default.emit_procarg0 = true
-    Parser::Builders::Default.emit_encoding = true
-    Parser::Builders::Default.emit_index    = true
+    Parser::Builders::Default.emit_lambda              = true
+    Parser::Builders::Default.emit_procarg0            = true
+    Parser::Builders::Default.emit_encoding            = true
+    Parser::Builders::Default.emit_index               = true
+    Parser::Builders::Default.emit_arg_inside_procarg0 = true
 
 Parse a chunk of code:
 
@@ -234,7 +235,7 @@ Parser implements the MacRuby 0.12 and RubyMotion mid-2015 parsers precisely. Ho
 
 ## Known issues
 
-Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occuring corner cases, this is not done.
+Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occurring corner cases, this is not done.
 
 Parser has been extensively tested; in particular, it parses almost entire [Rubygems][rg] corpus. For every issue, a breakdown of affected gems is offered.
 

data/doc/AST_FORMAT.md

@@ -1870,6 +1870,27 @@ Format:
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
 ~~~
 
+#### With empty else
+
+Empty `else` differs from the missing (or _implicit_) `else` for pattern matching, since
+the latter one raises a `NoMatchingPattern` exception. Thus, we need a way to distinguish this
+two cases in the resulting AST.
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (empty-else))
+"case "str"; in foo; bar; else; end"
+ ~~~~ keyword             ~~~~ else
+                                ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
 ### In clause
 
 Format:
@@ -2047,7 +2068,7 @@ so a single item match with comma gets interpreted as an array.
 (array-pattern-with-tail
   (match-var :foo))
 "in foo,"
-    ~~~ expression
+    ~~~~ expression
 ~~~
 
 ### Matching using hash pattern
@@ -2118,7 +2139,7 @@ Format:
 "in X[^foo bar]"
      ~ begin (const-pattern)
                ~ end (const-pattern)
-     ~~~~~~~~~~~ expression (const-pattern)
+    ~~~~~~~~~~~~ expression (const-pattern)
     ~ name (const-pattern.const)
     ~ expression (const-pattern.const)
 ~~~
@@ -2136,7 +2157,24 @@ Format:
 "in X[foo:, bar:]"
      ~ begin (const-pattern)
                 ~ end (const-pattern)
-     ~~~~~~~~~~~~ expression (const-pattern)
+    ~~~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With array pattern without elements
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern))
+"in X[]"
+     ~ begin (const-pattern)
+      ~ end (const-pattern)
+    ~~~ expression (const-pattern)
     ~ name (const-pattern.const)
     ~ expression (const-pattern.const)
+     ~~ expression (const-pattern.array_pattern)
 ~~~

data/lib/parser/ast/processor.rb

@@ -274,6 +274,10 @@ module Parser
           'Parser::AST::Processor#on_argument instead.'
         on_argument(node)
       end
+
+      def on_empty_else(node)
+        node
+      end
     end
   end
 end

data/lib/parser/builders/default.rb

@@ -1213,6 +1213,7 @@ module Parser
     #
 
     def case_match(case_t, expr, in_bodies, else_t, else_body, end_t)
+      else_body = n(:empty_else, nil, token_map(else_t)) if else_t && !else_body
       n(:case_match, [ expr, *(in_bodies << else_body)],
         condition_map(case_t, expr, nil, nil, else_t, else_body, end_t))
     end
@@ -1313,9 +1314,11 @@ module Parser
     end
 
     def array_pattern(lbrack_t, elements, rbrack_t)
+      return n(:array_pattern, nil, collection_map(lbrack_t, [], rbrack_t)) if elements.nil?
+
       trailing_comma = false
 
-      elements = elements.map do |element|
+      node_elements = elements.map do |element|
         if element.type == :match_with_trailing_comma
           trailing_comma = true
           element.children.first
@@ -1326,17 +1329,22 @@ module Parser
       end
 
       node_type = trailing_comma ? :array_pattern_with_tail : :array_pattern
-      n(node_type, elements,
+
+      n(node_type, node_elements,
         collection_map(lbrack_t, elements, rbrack_t))
     end
 
-    def match_with_trailing_comma(match)
-      n(:match_with_trailing_comma, [ match ], nil)
+    def match_with_trailing_comma(match, comma_t)
+      n(:match_with_trailing_comma, [ match ], expr_map(match.loc.expression.join(loc(comma_t))))
     end
 
     def const_pattern(const, ldelim_t, pattern, rdelim_t)
       n(:const_pattern, [const, pattern],
-        collection_map(ldelim_t, [pattern], rdelim_t))
+        Source::Map::Collection.new(
+          loc(ldelim_t), loc(rdelim_t),
+          const.loc.expression.join(loc(rdelim_t))
+        )
+      )
     end
 
     def pin(pin_t, var)
@@ -1369,11 +1377,13 @@ module Parser
         pair_keyword(label, value)
       else
         begin_t, parts, end_t = label
+        label_loc = loc(begin_t).join(loc(end_t))
 
         # quoted label like "label": value
         if (var_name = static_string(parts))
-          loc = loc(begin_t).join(loc(end_t))
-          check_duplicate_pattern_key(var_name, loc)
+          check_duplicate_pattern_key(var_name, label_loc)
+        else
+          diagnostic :error, :pm_interp_in_var_name, nil, label_loc
         end
 
         pair_quoted(begin_t, parts, end_t, value)

data/lib/parser/lexer.rl

@@ -1064,7 +1064,6 @@ class Parser::Lexer
           emit(:tRCURLY, '}'.freeze, p - 1, p)
           @cond.lexpop
           @cmdarg.lexpop
-          @paren_nest -= 1
         else
           emit(:tSTRING_DEND, '}'.freeze, p - 1, p)
         end
@@ -1079,6 +1078,8 @@ class Parser::Lexer
         fbreak;
       end
     end
+
+    @paren_nest -= 1
   };
 
   action extend_interp_code {
@@ -2165,6 +2166,9 @@ class Parser::Lexer
             emit_do
           end
         end
+        if tok == '{'.freeze
+          @paren_nest += 1
+        end
         @command_start = true
 
         fnext expr_value; fbreak;
@@ -2469,7 +2473,7 @@ class Parser::Lexer
 
       # Here we use '\n' instead of w_newline to not modify @newline_s
       # and eventually properly emit tNL
-      (w_space_comment '\n')+
+      (c_space* w_space_comment '\n')+
       => {
         if @version < 27
           # Ruby before 2.7 doesn't support comments before leading dot.

data/lib/parser/lexer/dedenter.rb

@@ -34,7 +34,11 @@ module Parser
     # Of course, lexer could do it but once again: it's all because of dedenting.
     #
     def dedent(string)
-      lines = string.split("\\\n")
+      original_encoding = string.encoding
+      # Prevent the following error when processing binary encoded source.
+      # "\xC0".split # => ArgumentError (invalid byte sequence in UTF-8)
+      lines = string.force_encoding(Encoding::BINARY).split("\\\n")
+      lines.map! {|s| s.force_encoding(original_encoding) }
 
       if @at_line_begin
         lines_to_dedent = lines

data/lib/parser/messages.rb

@@ -70,6 +70,7 @@ module Parser
     :circular_argument_reference  => 'circular argument reference %{var_name}',
     :pm_interp_in_var_name        => 'symbol literal with interpolation is not allowed',
     :lvar_name                    => "`%{name}' is not allowed as a local variable name",
+    :undefined_lvar               => "no such local variable: `%{name}'",
     :duplicate_variable_name      => 'duplicate variable name %{name}',
     :duplicate_pattern_key        => 'duplicate hash pattern key %{name}',
 

data/lib/parser/meta.rb

@@ -31,6 +31,7 @@ module Parser
         match_var pin match_alt match_as match_rest
         array_pattern match_with_trailing_comma array_pattern_with_tail
         hash_pattern const_pattern if_guard unless_guard match_nil_pattern
+        empty_else
       ).map(&:to_sym).to_set.freeze
 
   end # Meta

data/lib/parser/ruby27.y

@@ -1784,7 +1784,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like 1, 2,
                       # must be emitted as `array_pattern_with_tail`
-                      item = @builder.match_with_trailing_comma(val[0])
+                      item = @builder.match_with_trailing_comma(val[0], val[1])
                       result = @builder.array_pattern(nil, [ item ], nil)
                     }
                 | p_expr tCOMMA p_args
@@ -1841,7 +1841,8 @@ opt_block_args_tail:
                     }
                 | p_const tLPAREN2 rparen
                     {
-                      result = @builder.const_pattern(val[0], val[1], nil, val[2])
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
                     }
                 | p_const p_lbracket p_args rbracket
                     {
@@ -1857,7 +1858,8 @@ opt_block_args_tail:
                     }
                 | p_const tLBRACK2 rbracket
                     {
-                      result = @builder.const_pattern(val[0], val[1], nil, val[2])
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
                     }
                 | tLBRACK
                     {
@@ -1932,7 +1934,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like [1, 2,]
                       # must be emitted as `array_pattern_with_tail`
-                      item = @builder.match_with_trailing_comma(val[0])
+                      item = @builder.match_with_trailing_comma(val[0], val[1])
                       result = [ item ]
                     }
                 | p_args_head p_arg tCOMMA
@@ -1940,7 +1942,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like [1, 2,]
                       # must be emitted as `array_pattern_with_tail`
-                      last_item = @builder.match_with_trailing_comma(val[1])
+                      last_item = @builder.match_with_trailing_comma(val[1], val[2])
                       result = [ *val[0], last_item ]
                     }
 
@@ -2096,6 +2098,11 @@ opt_block_args_tail:
 
        p_var_ref: tCARET tIDENTIFIER
                     {
+                      name = val[1][0]
+                      unless static_env.declared?(name)
+                        diagnostic :error, :undefined_lvar, { :name => name }, val[1]
+                      end
+
                       lvar = @builder.accessible(@builder.ident(val[1]))
                       result = @builder.pin(val[0], lvar)
                     }

data/lib/parser/source/tree_rewriter/action.rb

@@ -56,11 +56,11 @@ module Parser
         if action.range == @range
           merge(action)
         else
-          place_in_hierachy(action)
+          place_in_hierarchy(action)
         end
       end
 
-      def place_in_hierachy(action)
+      def place_in_hierarchy(action)
         family = @children.group_by { |child| child.relationship_with(action) }
 
         if family[:fusible]

data/lib/parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parser
-  VERSION = '2.7.0.0'
+  VERSION = '2.7.0.5'
 end

data/parser.gemspec

@@ -13,6 +13,13 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/whitequark/parser'
   spec.license       = 'MIT'
 
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/whitequark/parser/issues',
+    'changelog_uri' => "https://github.com/whitequark/parser/blob/v#{spec.version}/CHANGELOG.md",
+    'documentation_uri' => "https://www.rubydoc.info/gems/parser/#{spec.version}",
+    'source_code_uri' => "https://github.com/whitequark/parser/tree/v#{spec.version}"
+  }
+
   spec.files         = `git ls-files`.split + %w(
                           lib/parser/lexer.rb
                           lib/parser/ruby18.rb

data/test/parse_helper.rb

@@ -127,6 +127,9 @@ module ParseHelper
 
     assert parser.instance_eval { @lexer }.cmdarg.empty?,
       "(#{version}) expected cmdarg to be empty after parsing"
+
+    assert_equal 0, parser.instance_eval { @lexer.instance_eval { @paren_nest } },
+      "(#{version}) expected paren_nest to be 0 after parsing"
   end
 
   # Use like this:

data/test/test_parser.rb

@@ -7644,12 +7644,26 @@ class TestParser < Minitest::Test
       %q{},
       SINCE_2_7)
 
+    assert_parses(
+      s(:send,
+        s(:send, nil, :a), :foo),
+      %Q{a #\n  #\n.foo\n},
+      %q{},
+      SINCE_2_7)
+
     assert_parses(
       s(:csend,
         s(:send, nil, :a), :foo),
       %Q{a #\n#\n&.foo\n},
       %q{},
       SINCE_2_7)
+
+    assert_parses(
+      s(:csend,
+        s(:send, nil, :a), :foo),
+      %Q{a #\n  #\n&.foo\n},
+      %q{},
+      SINCE_2_7)
   end
 
   def test_comments_before_leading_dot__before_27
@@ -8408,7 +8422,7 @@ class TestParser < Minitest::Test
         nil,
         s(:nil)),
       %q{in x, then nil},
-      %q{   ~ expression (in_pattern.array_pattern_with_tail)}
+      %q{   ~~ expression (in_pattern.array_pattern_with_tail)}
     )
 
     assert_parses_pattern_match(
@@ -8454,7 +8468,7 @@ class TestParser < Minitest::Test
         nil,
         s(:nil)),
       %q{in x, y, then nil},
-      %q{   ~~~~ expression (in_pattern.array_pattern_with_tail)}
+      %q{   ~~~~~ expression (in_pattern.array_pattern_with_tail)}
     )
 
     assert_parses_pattern_match(
@@ -8839,6 +8853,15 @@ class TestParser < Minitest::Test
     )
   end
 
+  def test_pattern_matching_hash_with_string_interpolation_keys
+    assert_diagnoses(
+      [:error, :pm_interp_in_var_name],
+      %q{case a; in "#{a}": 1; end},
+      %q{           ~~~~~~~ location},
+      SINCE_2_7
+    )
+  end
+
   def test_pattern_matching_keyword_variable
     assert_parses_pattern_match(
       s(:in_pattern,
@@ -8970,7 +8993,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A(1, 2) then true},
-      %q{    ~~~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |         ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -8986,7 +9009,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A(x:) then true},
-      %q{    ~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |       ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -8997,13 +9020,15 @@ class TestParser < Minitest::Test
       s(:in_pattern,
         s(:const_pattern,
           s(:const, nil, :A),
-          nil),
+          s(:array_pattern)),
         nil,
         s(:true)),
       %q{in A() then true},
-      %q{    ~~ expression (in_pattern.const_pattern)
+      %q{   ~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
-        |     ~ end (in_pattern.const_pattern)}
+        |     ~ end (in_pattern.const_pattern)
+        |   ~ expression (in_pattern.const_pattern.const)
+        |    ~~ expression (in_pattern.const_pattern.array_pattern)}
     )
 
     assert_parses_pattern_match(
@@ -9016,7 +9041,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A[1, 2] then true},
-      %q{    ~~~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |         ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -9032,7 +9057,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A[x:] then true},
-      %q{    ~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |       ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -9043,13 +9068,14 @@ class TestParser < Minitest::Test
       s(:in_pattern,
         s(:const_pattern,
           s(:const, nil, :A),
-          nil),
+          s(:array_pattern)),
         nil,
         s(:true)),
       %q{in A[] then true},
-      %q{    ~~ expression (in_pattern.const_pattern)
+      %q{   ~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
-        |     ~ end (in_pattern.const_pattern)}
+        |     ~ end (in_pattern.const_pattern)
+        |    ~~ expression (in_pattern.const_pattern.array_pattern)}
     )
   end
 
@@ -9093,6 +9119,20 @@ class TestParser < Minitest::Test
     )
   end
 
+  def test_pattern_matching_blank_else
+    assert_parses(
+      s(:case_match,
+        s(:int, 1),
+        s(:in_pattern,
+          s(:int, 2), nil,
+          s(:int, 3)),
+        s(:empty_else)),
+      %q{case 1; in 2; 3; else; end},
+      %q{                 ~~~~ else},
+      SINCE_2_7
+    )
+  end
+
   def assert_pattern_matching_defines_local_variables(match_code, lvar_names, versions = SINCE_2_7)
     code = "case 1; #{match_code}; then [#{lvar_names.join(', ')}]; end"
 
@@ -9294,4 +9334,24 @@ class TestParser < Minitest::Test
       %{     ^^ location},
       SINCE_2_7)
   end
+
+  def test_pattern_matching_required_bound_variable_before_pin
+    assert_diagnoses(
+      [:error, :undefined_lvar, { :name => 'a' }],
+      %{case 0; in ^a; true; end},
+      %{            ^ location},
+      SINCE_2_7)
+  end
+
+  def test_parser_bug_645
+    assert_parses(
+      s(:block,
+        s(:lambda),
+        s(:args,
+          s(:optarg, :arg,
+            s(:hash))), nil),
+      '-> (arg={}) {}',
+      %{},
+      SINCE_1_9)
+  end
 end

data/test/test_source_comment_associator.rb

@@ -31,16 +31,16 @@ class TestSourceCommentAssociator < Minitest::Test
     ast, associations = associate(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# class preceeding
-# another class preceeding
+# class preceding
+# another class preceding
 class Foo # class keyword line
-  # method foo preceeding
+  # method foo preceding
   def foo
     puts 'foo'
   end # method foo decorating
-  # method bar preceeding
+  # method bar preceding
   def bar
-    # expression preceeding
+    # expression preceding
     1 + # 1 decorating
       2
     # method bar sparse
@@ -58,8 +58,8 @@ end # class decorating
 
     assert_equal 6, associations.size
     assert_equal [
-      '# class preceeding',
-      '# another class preceeding',
+      '# class preceding',
+      '# another class preceding',
       '# class sparse',
       '# class decorating'
     ], associations[klass_node].map(&:text)
@@ -67,16 +67,16 @@ end # class decorating
       '# class keyword line'
     ], associations[klass_name_node].map(&:text)
     assert_equal [
-      '# method foo preceeding',
+      '# method foo preceding',
       '# method foo decorating'
     ], associations[foo_node].map(&:text)
     assert_equal [
-      '# method bar preceeding',
+      '# method bar preceding',
       '# method bar sparse',
       '# method bar decorating'
     ], associations[bar_node].map(&:text)
     assert_equal [
-      '# expression preceeding'
+      '# expression preceding'
     ], associations[expr_node].map(&:text)
     assert_equal [
       '# 1 decorating'
@@ -112,16 +112,16 @@ end
     ast, associations = associate_locations(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# class preceeding
-# another class preceeding
+# class preceding
+# another class preceding
 class Foo # class keyword line
-  # method foo preceeding
+  # method foo preceding
   def foo
     puts 'foo'
   end # method foo decorating
-  # method bar preceeding
+  # method bar preceding
   def bar
-    # expression preceeding
+    # expression preceding
     1 + # 1 decorating
       2
     # method bar sparse
@@ -139,8 +139,8 @@ end # class decorating
 
     assert_equal 6, associations.size
     assert_equal [
-      '# class preceeding',
-      '# another class preceeding',
+      '# class preceding',
+      '# another class preceding',
       '# class sparse',
       '# class decorating'
     ], associations[klass_node.loc].map(&:text)
@@ -148,16 +148,16 @@ end # class decorating
       '# class keyword line'
     ], associations[klass_name_node.loc].map(&:text)
     assert_equal [
-      '# method foo preceeding',
+      '# method foo preceding',
       '# method foo decorating'
     ], associations[foo_node.loc].map(&:text)
     assert_equal [
-      '# method bar preceeding',
+      '# method bar preceding',
       '# method bar sparse',
       '# method bar decorating'
     ], associations[bar_node.loc].map(&:text)
     assert_equal [
-      '# expression preceeding'
+      '# expression preceding'
     ], associations[expr_node.loc].map(&:text)
     assert_equal [
       '# 1 decorating'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.7.0.0
+  version: 2.7.0.5
 platform: ruby
 authors:
 - whitequark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-26 00:00:00.000000000 Z
+date: 2020-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -295,7 +295,11 @@ files:
 homepage: https://github.com/whitequark/parser
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/whitequark/parser/issues
+  changelog_uri: https://github.com/whitequark/parser/blob/v2.7.0.5/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/parser/2.7.0.5
+  source_code_uri: https://github.com/whitequark/parser/tree/v2.7.0.5
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -311,7 +315,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A Ruby parser written in pure Ruby.