cucumber-cucumber-expressions 16.1.2 → 17.0.0

data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -40,54 +42,56 @@ module Cucumber
       end
     end
 
-    describe "Custom parameter type" do
+    describe 'Custom parameter type' do
       before do
         parameter_type_registry = ParameterTypeRegistry.new
-        parameter_type_registry.define_parameter_type(ParameterType.new(
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
             'color',                   # name
             /red|blue|yellow/,         # regexp
             Color,                     # type
-            lambda {|s| Color.new(s)}, # transform
+            ->(s) { Color.new(s)},     # transform
             true,                      # use_for_snippets
             false                      # prefer_for_regexp_match
-        ))
+          )
+        )
         @parameter_type_registry = parameter_type_registry
       end
 
-      it "throws exception for illegal character in parameter name" do
+      it 'throws exception for illegal character in parameter name' do
         expect do
           ParameterType.new(
-              '[string]',
-              /.*/,
-              String,
-              lambda {|s| s},
-              true,
-              false
+            '[string]',
+            /.*/,
+            String,
+            ->(s) { s},
+            true,
+            false
           )
         end.to raise_error("Illegal character in parameter name {[string]}. Parameter names may not contain '[]()$.|?*+'")
       end
 
       describe CucumberExpression do
-        it "matches parameters with custom parameter type" do
-          expression = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
-          transformed_argument_value = expression.match("I have a red ball")[0].value(nil)
+        it 'matches parameters with custom parameter type' do
+          expression = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+          transformed_argument_value = expression.match('I have a red ball')[0].value(nil)
+
           expect(transformed_argument_value).to eq(Color.new('red'))
         end
 
-        it "matches parameters with multiple capture groups" do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
+        it 'matches parameters with multiple capture groups' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'coordinate',
               /(\d+),\s*(\d+),\s*(\d+)/,
               Coordinate,
-              lambda {|x, y, z| Coordinate.new(x.to_i, y.to_i, z.to_i)},
+              ->(x, y, z) { Coordinate.new(x.to_i, y.to_i, z.to_i)},
               true,
               false
-          ))
-
-          expression = CucumberExpression.new(
-              'A {int} thick line from {coordinate} to {coordinate}',
-              @parameter_type_registry
+            )
           )
+
+          expression = CucumberExpression.new('A {int} thick line from {coordinate} to {coordinate}', @parameter_type_registry)
           args = expression.match('A 5 thick line from 10,20,30 to 40,50,60')
 
           thick = args[0].value(nil)
@@ -100,95 +104,110 @@ module Cucumber
           expect(to).to eq(Coordinate.new(40, 50, 60))
         end
 
-        it "matches parameters with custom parameter type using optional capture group" do
+        it 'matches parameters with custom parameter type using optional capture group' do
           parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(ParameterType.new(
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'color',
               [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
               Color,
-              lambda {|s| Color.new(s)},
+              ->(s) { Color.new(s)},
               true,
               false
-          ))
-          expression = CucumberExpression.new("I have a {color} ball", parameter_type_registry)
-          transformed_argument_value = expression.match("I have a dark red ball")[0].value(nil)
+            )
+          )
+          expression = CucumberExpression.new('I have a {color} ball', parameter_type_registry)
+          transformed_argument_value = expression.match('I have a dark red ball')[0].value(nil)
+
           expect(transformed_argument_value).to eq(Color.new('dark red'))
         end
 
-        it "defers transformation until queried from argument" do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
+        it 'defers transformation until queried from argument' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               'throwing',
               /bad/,
               CssColor,
-              lambda {|s| raise "Can't transform [#{s}]"},
+              ->(s) { raise "Can't transform [#{s}]"},
               true,
               false
-          ))
-          expression = CucumberExpression.new("I have a {throwing} parameter", @parameter_type_registry)
-          args = expression.match("I have a bad parameter")
+            )
+          )
+          expression = CucumberExpression.new('I have a {throwing} parameter', @parameter_type_registry)
+          args = expression.match('I have a bad parameter')
+
           expect {args[0].value(nil)}.to raise_error("Can't transform [bad]")
         end
 
-        describe "conflicting parameter type" do
-          it "is detected for type name" do
+        describe 'conflicting parameter type' do
+          it 'is detected for type name' do
             expect {
-              @parameter_type_registry.define_parameter_type(ParameterType.new(
+              @parameter_type_registry.define_parameter_type(
+                ParameterType.new(
                   'color',
                   /.*/,
                   CssColor,
-                  lambda {|s| CssColor.new(s)},
+                  ->(s) { CssColor.new(s)},
                   true,
                   false
-              ))
-            }.to raise_error("There is already a parameter with name color")
+                )
+              )
+            }.to raise_error('There is already a parameter with name color')
           end
 
-          it "is not detected for type" do
-            @parameter_type_registry.define_parameter_type(ParameterType.new(
+          it 'is not detected for type' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
                 'whatever',
                 /.*/,
                 Color,
-                lambda {|s| Color.new(s)},
+                ->(s) { Color.new(s)},
                 false,
                 false
-            ))
+              )
+            )
           end
 
-          it "is not detected for regexp" do
-            @parameter_type_registry.define_parameter_type(ParameterType.new(
+          it 'is not detected for regexp' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
                 'css-color',
                 /red|blue|yellow/,
                 CssColor,
-                lambda {|s| CssColor.new(s)},
+                ->(s) { CssColor.new(s)},
                 true,
                 false
-            ))
+              )
+            )
+            css_color = CucumberExpression.new('I have a {css-color} ball', @parameter_type_registry)
+            css_color_value = css_color.match('I have a blue ball')[0].value(nil)
 
-            css_color = CucumberExpression.new("I have a {css-color} ball", @parameter_type_registry)
-            css_color_value = css_color.match("I have a blue ball")[0].value(nil)
-            expect(css_color_value).to eq(CssColor.new("blue"))
+            expect(css_color_value).to eq(CssColor.new('blue'))
 
-            color = CucumberExpression.new("I have a {color} ball", @parameter_type_registry)
-            color_value = color.match("I have a blue ball")[0].value(nil)
-            expect(color_value).to eq(Color.new("blue"))
+            color = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+            color_value = color.match('I have a blue ball')[0].value(nil)
+
+            expect(color_value).to eq(Color.new('blue'))
           end
         end
       end
 
       describe RegularExpression do
-        it "matches arguments with custom parameter type without name" do
+        it 'matches arguments with custom parameter types without a name' do
           parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(ParameterType.new(
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
               nil,
               /red|blue|yellow/,
               Color,
-              lambda {|s| Color.new(s)},
+              ->(s) { Color.new(s)},
               true,
               false
-          ))
-
+            )
+          )
           expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
-          value = expression.match("I have a red ball")[0].value(nil)
+          value = expression.match('I have a red ball')[0].value(nil)
+
           expect(value).to eq(Color.new('red'))
         end
       end

data/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/expression_factory'
 
 module Cucumber

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -1,20 +1,16 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type_registry'
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
+    CAPITALISED_WORD = /[A-Z]+\w+/.freeze
 
-    CAPITALISED_WORD = /[A-Z]+\w+/
-
-    class Name
-    end
-
-    class Person
-    end
-
-    class Place
-    end
+    class Name; end
+    class Person; end
+    class Place; end
 
     describe ParameterTypeRegistry do
       before do
@@ -22,65 +18,64 @@ module Cucumber
       end
 
       it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
-        @registry.define_parameter_type(ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, true))
-        @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
+        @registry.define_parameter_type(ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new}, true, true))
+        @registry.define_parameter_type(ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new}, true, false))
         expect do
-          @registry.define_parameter_type(ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, true))
+          @registry.define_parameter_type(ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new}, true, true))
         end.to raise_error(
-                   CucumberExpressionError,
-                   "There can only be one preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two preferential parameter types, {name} and {place}"
-               )
+          CucumberExpressionError,
+          'There can only be one preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two preferential parameter types, {name} and {place}'
+        )
       end
 
       it 'looks up prefer_for_regexp_match parameter type by regexp' do
-        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new}, true, false)
+        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new}, true, true)
+        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new}, true, false)
 
         @registry.define_parameter_type(name)
         @registry.define_parameter_type(person)
         @registry.define_parameter_type(place)
 
-        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
       end
 
       it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
-        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new}, true, false)
+        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new}, true, false)
+        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new}, true, false)
 
         @registry.define_parameter_type(name)
         @registry.define_parameter_type(person)
         @registry.define_parameter_type(place)
 
         expect do
-          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
         end.to raise_error(
-                   CucumberExpressionError,
-                   "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" +
-                       "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n" +
-                       "   {name}\n" +
-                       "   {person}\n" +
-                       "   {place}\n" +
-                       "\n" +
-                       "I couldn't decide which one to use. You have two options:\n" +
-                       "\n" +
-                       "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n" +
-                       "   {name} and {name}\n" +
-                       "   {name} and {person}\n" +
-                       "   {name} and {place}\n" +
-                       "   {person} and {name}\n" +
-                       "   {person} and {person}\n" +
-                       "   {person} and {place}\n" +
-                       "   {place} and {name}\n" +
-                       "   {place} and {person}\n" +
-                       "   {place} and {place}\n" +
-                       "\n" +
-                       "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" +
-                       "\n"
-               )
+          CucumberExpressionError,
+          "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" \
+          "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n" \
+          "   {name}\n" \
+          "   {person}\n" \
+          "   {place}\n" \
+          "\n" \
+          "I couldn't decide which one to use. You have two options:\n" \
+          "\n" \
+          "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n" \
+          "   {name} and {name}\n" \
+          "   {name} and {person}\n" \
+          "   {name} and {place}\n" \
+          "   {person} and {name}\n" \
+          "   {person} and {person}\n" \
+          "   {person} and {place}\n" \
+          "   {place} and {name}\n" \
+          "   {place} and {person}\n" \
+          "   {place} and {place}\n" \
+          "\n" \
+          "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" \
+          "\n"
+        )
       end
     end
   end
 end
-

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 
 module Cucumber
@@ -5,7 +7,7 @@ module Cucumber
     describe ParameterType do
       it 'does not allow ignore flag on regexp' do
         expect do
-          ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
+          ParameterType.new('case-insensitive', /[a-z]+/i, String, ->(s) { s}, true, true)
         end.to raise_error(
           CucumberExpressionError,
           "ParameterType Regexps can't use option Regexp::IGNORECASE")

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -7,68 +9,74 @@ module Cucumber
     describe RegularExpression do
       Dir['../testdata/regular-expression/matching/*.yaml'].each do |path|
         expectation = YAML.load_file(path)
+
         it "matches #{path}" do
           parameter_registry = ParameterTypeRegistry.new
           expression = RegularExpression.new(Regexp.new(expectation['expression']), parameter_registry)
           matches = expression.match(expectation['text'])
           values = matches.map { |arg| arg.value(nil) }
+
           expect(values).to eq(expectation['expected_args'])
         end
       end
 
-      it "does no transform by default" do
-        expect( match(/(\d\d)/, "22") ).to eq(["22"])
+      it 'does not transform by default' do
+        expect(match(/(\d\d)/, '22')).to eq(['22'])
       end
 
-      it "does not transform anonymous" do
-        expect( match(/(.*)/, "22") ).to eq(["22"])
+      it 'does not transform anonymous' do
+        expect(match(/(.*)/, '22')).to eq(['22'])
       end
 
-      it "transforms negative int" do
-        expect( match(/(-?\d+)/, "-22") ).to eq([-22])
+      it 'transforms negative int' do
+        expect(match(/(-?\d+)/, '-22')).to eq([-22])
       end
 
-      it "transforms positive int" do
-        expect( match(/(\d+)/, "22") ).to eq([22])
+      it 'transforms positive int' do
+        expect(match(/(\d+)/, '22')).to eq([22])
       end
 
-      it "returns nil when there is no match" do
-        expect( match(/hello/, "world") ).to be_nil
+      it 'returns nil when there is no match' do
+        expect(match(/hello/, 'world')).to be_nil
       end
 
-      it "matches empty string when there is an empty string match" do
-        expect( match(/^The value equals "([^"]*)"$/, 'The value equals ""') ).to eq([''])
+      it 'matches empty string when there is an empty string match' do
+        expect(match(/^The value equals "([^"]*)"$/, 'The value equals ""')).to eq([''])
       end
 
-      it "matches nested capture group without match" do
-        expect( match(/^a user( named "([^"]*)")?$/, 'a user') ).to eq([nil])
+      it 'matches nested capture group without match' do
+        expect(match(/^a user( named "([^"]*)")?$/, 'a user')).to eq([nil])
       end
 
-      it "matches nested capture group with match" do
-        expect( match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"') ).to eq(['Charlie'])
+      it 'matches nested capture group with match' do
+        expect(match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"')).to eq(['Charlie'])
       end
 
-      it "ignores non capturing groups" do
-        expect( match(
-          /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
-          "I can cancel the 1st slide upload")
-        ).to eq(["I", "can", 1, "slide"])
+      it 'ignores non capturing groups' do
+        expect(
+          match(
+            /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
+            'I can cancel the 1st slide upload'
+          )
+        ).to eq(['I', 'can', 1, 'slide'])
       end
 
-      it "matches capture group nested in optional one" do
+      it 'matches capture group nested in optional one' do
         regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
-        expect( match(regexp, 'a purchase') ).to eq([nil, nil])
-        expect( match(regexp, 'a purchase for $33') ).to eq([nil, 33])
-        expect( match(regexp, 'a pre buyer fee model purchase') ).to eq(['pre buyer fee model ', nil])
+
+        expect(match(regexp, 'a purchase')).to eq([nil, nil])
+        expect(match(regexp, 'a purchase for $33')).to eq([nil, 33])
+        expect(match(regexp, 'a pre buyer fee model purchase')).to eq(['pre buyer fee model ', nil])
       end
 
-      it "works with escaped parenthesis" do
-        expect( match(/Across the line\(s\)/, 'Across the line(s)') ).to eq([])
+      it 'works with escaped parentheses' do
+        expect(match(/Across the line\(s\)/, 'Across the line(s)')).to eq([])
       end
 
-      it "exposes source and regexp" do
+      it 'exposes source and regexp' do
         regexp = /I have (\d+) cukes? in my (\+) now/
         expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
+
         expect(expression.regexp).to eq(regexp)
         expect(expression.source).to eq(regexp.source)
       end
@@ -77,6 +85,7 @@ module Cucumber
         regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
         arguments = regular_expression.match(text)
         return nil if arguments.nil?
+
         arguments.map { |arg| arg.value(nil) }
       end
     end

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/tree_regexp'
 
 module Cucumber
   module CucumberExpressions
     describe TreeRegexp do
-      it 'exposes group source' do
+      it 'exposes the group source' do
         tr = TreeRegexp.new(/(a(?:b)?)(c)/)
-        expect(tr.group_builder.children.map{|gb| gb.source}).to eq(['a(?:b)?', 'c'])
+        expect(tr.group_builder.children.map {|gb| gb.source}).to eq(['a(?:b)?', 'c'])
       end
 
-      it 'builds tree' do
+      it 'builds a tree' do
         tr = TreeRegexp.new(/(a(?:b)?)(c)/)
         group = tr.match('ac')
         expect(group.value).to eq('ac')
@@ -78,7 +80,7 @@ module Cucumber
         }.to raise_error(/Named capture groups are not supported/)
       end
 
-      it 'matches optional group' do
+      it 'matches an optional group' do
         tr = TreeRegexp.new(/^Something( with an optional argument)?/)
         group = tr.match('Something')
         expect(group.children[0].value).to eq(nil)
@@ -99,45 +101,45 @@ module Cucumber
         expect(group.children[2].children[2].value).to eq('60')
       end
 
-      it 'detects multiple non capturing groups' do
+      it 'detects multiple non-capturing groups' do
         tr = TreeRegexp.new(/(?:a)(:b)(\?c)(d)/)
-        group = tr.match("a:b?cd")
+        group = tr.match('a:b?cd')
         expect(group.children.length).to eq(3)
       end
 
-      it 'works with escaped backslash' do
+      it 'works with escaped backslashes' do
         tr = TreeRegexp.new(/foo\\(bar|baz)/)
-        group = tr.match("foo\\bar")
+        group = tr.match('foo\\bar')
         expect(group.children.length).to eq(1)
       end
 
-      it 'works with escaped slash' do
+      it 'works with escaped slashes' do
         tr = TreeRegexp.new(/^I go to '\/(.+)'$/)
         group = tr.match("I go to '/hello'")
         expect(group.children.length).to eq(1)
       end
 
-      it 'works with digit and word' do
+      it 'works with digit and word regexp metacharacters' do
         tr = TreeRegexp.new(/^(\d) (\w+)$/)
-        group = tr.match("2 you")
+        group = tr.match('2 you')
         expect(group.children.length).to eq(2)
       end
 
-      it 'captures non capturing groups with capturing groups inside' do
+      it 'captures non-capturing groups with capturing groups inside' do
         tr = TreeRegexp.new(/the stdout(?: from "(.*?)")?/)
-        group = tr.match("the stdout")
-        expect(group.value).to eq("the stdout")
+        group = tr.match('the stdout')
+        expect(group.value).to eq('the stdout')
         expect(group.children[0].value).to eq(nil)
         expect(group.children.length).to eq(1)
       end
 
       it 'works with flags' do
         tr = TreeRegexp.new(/HELLO/i)
-        group = tr.match("hello")
-        expect(group.value).to eq("hello")
+        group = tr.match('hello')
+        expect(group.value).to eq('hello')
       end
 
-      it('does not consider parenthesis in character class as group') do
+      it('does not consider parentheses in regexp character classes as a group') do
         tr = TreeRegexp.new(/^drawings: ([A-Z_, ()]+)$/)
         group = tr.match('drawings: ONE, TWO(ABC)')
         expect(group.value).to eq('drawings: ONE, TWO(ABC)')
@@ -152,14 +154,14 @@ module Cucumber
         expect(group.children.length).to eq 0
       end
 
-      it 'works with non capturing inline flags' do
+      it 'works with non-capturing inline flags' do
         tr = TreeRegexp.new(/(?i:HELLO)/)
         group = tr.match('hello')
         expect(group.value).to eq('hello')
         expect(group.children.length).to eq 0
       end
 
-      it 'works with empty capturing group' do
+      it 'works with empty capturing groups' do
         tr = TreeRegexp.new(/()/)
         group = tr.match('')
         expect(group.value).to eq('')
@@ -167,20 +169,19 @@ module Cucumber
         expect(group.children.length).to eq 1
       end
 
-      it 'works with empty non-capturing group' do
+      it 'works with empty non-capturing groups' do
         tr = TreeRegexp.new(/(?:)/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children.length).to eq 0
       end
 
-      it 'works with empty non-look ahead' do
+      it 'works with empty non-look ahead groups' do
         tr = TreeRegexp.new(/(?<=)/)
         group = tr.match('')
         expect(group.value).to eq('')
         expect(group.children.length).to eq 0
       end
-
     end
   end
 end