cucumber-cucumber-expressions 16.1.2 → 17.0.2

data/lib/cucumber/cucumber_expressions/errors.rb

@@ -1,24 +1,19 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/ast'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpressionError < StandardError
-
-      def build_message(
-          index,
-          expression,
-          pointer,
-          problem,
-          solution
-      )
-        m = <<-EOF
-This Cucumber Expression has a problem at column #{index + 1}:
-
-#{expression}
-#{pointer}
-#{problem}.
-#{solution}
-        EOF
+      def build_message(index, expression, pointer, problem, solution)
+        m = <<~ERROR
+          This Cucumber Expression has a problem at column #{index + 1}:
+
+          #{expression}
+          #{pointer}
+          #{problem}.
+          #{solution}
+        ERROR
         m.strip
       end
 
@@ -40,86 +35,100 @@ This Cucumber Expression has a problem at column #{index + 1}:
 
     class AlternativeMayNotExclusivelyContainOptionals < CucumberExpressionError
       def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An alternative may not exclusively contain optionals',
-                  "If you did not mean to use an optional you can use '\\(' to escape the the '('"
-              ))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An alternative may not exclusively contain optionals',
+            "If you did not mean to use an optional you can use '\\(' to escape the '('"
+          )
+        )
       end
     end
 
     class AlternativeMayNotBeEmpty < CucumberExpressionError
       def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'Alternative may not be empty',
-                  "If you did not mean to use an alternative you can use '\\/' to escape the the '/'"
-              ))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'Alternative may not be empty',
+            "If you did not mean to use an alternative you can use '\\/' to escape the '/'"
+          )
+        )
       end
     end
 
     class CantEscape < CucumberExpressionError
       def initialize(expression, index)
-        super(build_message(
-                  index,
-                  expression,
-                  point_at(index),
-                  "Only the characters '{', '}', '(', ')', '\\', '/' and whitespace can be escaped",
-                  "If you did mean to use an '\\' you can use '\\\\' to escape it"
-              ))
+        super(
+          build_message(
+            index,
+            expression,
+            point_at(index),
+            "Only the characters '{', '}', '(', ')', '\\', '/' and whitespace can be escaped",
+            "If you did mean to use an '\\' you can use '\\\\' to escape it"
+          )
+        )
       end
     end
 
     class OptionalMayNotBeEmpty < CucumberExpressionError
       def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional must contain some text',
-                  "If you did not mean to use an optional you can use '\\(' to escape the the '('"
-              ))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional must contain some text',
+            "If you did not mean to use an optional you can use '\\(' to escape the '('"
+          )
+        )
       end
     end
 
     class ParameterIsNotAllowedInOptional < CucumberExpressionError
       def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional may not contain a parameter type',
-                  "If you did not mean to use an parameter type you can use '\\{' to escape the the '{'"
-              ))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional may not contain a parameter type',
+            "If you did not mean to use an parameter type you can use '\\{' to escape the '{'"
+          )
+        )
       end
     end
 
     class OptionalIsNotAllowedInOptional < CucumberExpressionError
       def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional may not contain an other optional',
-                  "If you did not mean to use an optional type you can use '\\(' to escape the the '('. For more complicated expressions consider using a regular expression instead."
-              ))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            'An optional may not contain an other optional',
+            "If you did not mean to use an optional type you can use '\\(' to escape the '('. For more complicated expressions consider using a regular expression instead."
+          )
+        )
       end
     end
 
     class TheEndOfLineCannotBeEscaped < CucumberExpressionError
       def initialize(expression)
         index = expression.codepoints.length - 1
-        super(build_message(
-                  index,
-                  expression,
-                  point_at(index),
-                  'The end of line can not be escaped',
-                  "You can use '\\\\' to escape the the '\\'"
-              ))
+        super(
+          build_message(
+            index,
+            expression,
+            point_at(index),
+            'The end of line can not be escaped',
+            "You can use '\\\\' to escape the '\\'"
+          )
+        )
       end
     end
 
@@ -128,45 +137,50 @@ This Cucumber Expression has a problem at column #{index + 1}:
         begin_symbol = Token::symbol_of(begin_token)
         end_symbol = Token::symbol_of(end_token)
         purpose = Token::purpose_of(begin_token)
-        super(build_message(
-                  current.start,
-                  expression,
-                  point_at_located(current),
-                  "The '#{begin_symbol}' does not have a matching '#{end_symbol}'",
-                  "If you did not intend to use #{purpose} you can use '\\#{begin_symbol}' to escape the #{purpose}"
-              ))
+
+        super(
+          build_message(
+            current.start,
+            expression,
+            point_at_located(current),
+            "The '#{begin_symbol}' does not have a matching '#{end_symbol}'",
+            "If you did not intend to use #{purpose} you can use '\\#{begin_symbol}' to escape the #{purpose}"
+          )
+        )
       end
     end
 
     class AlternationNotAllowedInOptional < CucumberExpressionError
       def initialize(expression, current)
-        super(build_message(
-                  current.start,
-                  expression,
-                  point_at_located(current),
-                  "An alternation can not be used inside an optional",
-                  "You can use '\\/' to escape the the '/'"
-              ))
+        super(
+          build_message(
+            current.start,
+            expression,
+            point_at_located(current),
+            'An alternation can not be used inside an optional',
+            "If you did not mean to use an alternation you can use '\\/' to escape the '/'. Otherwise rephrase your expression or consider using a regular expression instead."
+          )
+        )
       end
     end
 
     class InvalidParameterTypeName < CucumberExpressionError
       def initialize(type_name)
-        super("Illegal character in parameter name {#{type_name}}. " +
-                  "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'")
+        super("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '{', '}', '(', ')', '\\' or '/'")
       end
     end
 
-
     class InvalidParameterTypeNameInNode < CucumberExpressionError
       def initialize(expression, token)
-        super(build_message(
-                  token.start,
-                  expression,
-                  point_at_located(token),
-                  "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
-                  "Did you mean to use a regular expression?"
-              ))
+        super(
+          build_message(
+            token.start,
+            expression,
+            point_at_located(token),
+            "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
+            'Did you mean to use a regular expression?'
+          )
+        )
       end
     end
 
@@ -174,30 +188,34 @@ This Cucumber Expression has a problem at column #{index + 1}:
       attr_reader :undefined_parameter_type_name
 
       def initialize(node, expression, undefined_parameter_type_name)
-        super(build_message(node.start,
-                            expression,
-                            point_at_located(node),
-                            "Undefined parameter type '#{undefined_parameter_type_name}'",
-                            "Please register a ParameterType for '#{undefined_parameter_type_name}'"))
+        super(
+          build_message(
+            node.start,
+            expression,
+            point_at_located(node),
+            "Undefined parameter type '#{undefined_parameter_type_name}'",
+            "Please register a ParameterType for '#{undefined_parameter_type_name}'"
+          )
+        )
         @undefined_parameter_type_name = undefined_parameter_type_name
       end
     end
 
     class AmbiguousParameterTypeError < CucumberExpressionError
       def initialize(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
-        super(<<-EOM)
-Your Regular Expression /#{expression_regexp.source}/
-matches multiple parameter types with regexp /#{parameter_type_regexp}/:
-   #{parameter_type_names(parameter_types)}
+        super(<<~ERROR)
+          Your Regular Expression /#{expression_regexp.source}/
+          matches multiple parameter types with regexp /#{parameter_type_regexp}/:
+             #{parameter_type_names(parameter_types)}
 
-I couldn't decide which one to use. You have two options:
+          I couldn't decide which one to use. You have two options:
 
-1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
-   #{expressions(generated_expressions)}
+          1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
+             #{expressions(generated_expressions)}
 
-2) Make one of the parameter types preferential and continue to use a Regular Expression.
+          2) Make one of the parameter types preferential and continue to use a Regular Expression.
 
-        EOM
+        ERROR
       end
 
       private

data/lib/cucumber/cucumber_expressions/expression_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/errors'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'

data/lib/cucumber/cucumber_expressions/generated_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class GeneratedExpression

data/lib/cucumber/cucumber_expressions/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class Group

data/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group'
 
 module Cucumber
@@ -16,7 +18,7 @@ module Cucumber
 
       def build(match, group_indices)
         group_index = group_indices.next
-        children = @group_builders.map {|gb| gb.build(match, group_indices)}
+        children = @group_builders.map { |gb| gb.build(match, group_indices) }
         Group.new(match[group_index], match.offset(group_index)[0], match.offset(group_index)[1], children)
       end
 

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -1,34 +1,24 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
     class ParameterType
-      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/
-      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/
+      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/.freeze
+      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/.freeze
 
-      attr_reader :name, :type, :regexps
+      attr_reader :name, :type, :transformer, :use_for_snippets, :prefer_for_regexp_match, :regexps
 
       def self.check_parameter_type_name(type_name)
-        unless is_valid_parameter_type_name(type_name)
-          raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'")
-        end
+        raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'") unless is_valid_parameter_type_name(type_name)
       end
 
       def self.is_valid_parameter_type_name(type_name)
-        unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) do
-          $2
-        end
+        unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) { Regexp.last_match(2) }
         !(ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name)
       end
 
-      def prefer_for_regexp_match?
-        @prefer_for_regexp_match
-      end
-
-      def use_for_snippets?
-        @use_for_snippets
-      end
-
       # Create a new Parameter
       #
       # @param name the name of the parameter type
@@ -55,14 +45,14 @@ module Cucumber
       end
 
       def <=>(other)
-        return -1 if prefer_for_regexp_match? && !other.prefer_for_regexp_match?
-        return 1 if other.prefer_for_regexp_match? && !prefer_for_regexp_match?
+        return -1 if prefer_for_regexp_match && !other.prefer_for_regexp_match
+        return 1 if other.prefer_for_regexp_match && !prefer_for_regexp_match
+
         return name <=> other.name
       end
 
       private
 
-
       def string_array(regexps)
         array = regexps.is_a?(Array) ? regexps : [regexps]
         array.map { |regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp) }
@@ -70,14 +60,12 @@ module Cucumber
 
       def regexp_source(regexp)
         [
-            'EXTENDED',
-            'IGNORECASE',
-            'MULTILINE'
+          'EXTENDED',
+          'IGNORECASE',
+          'MULTILINE'
         ].each do |option_name|
           option = Regexp.const_get(option_name)
-          if regexp.options & option != 0
-            raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}")
-          end
+          raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}") if regexp.options & option != 0
         end
         regexp.source
       end

data/lib/cucumber/cucumber_expressions/parameter_type_matcher.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class ParameterTypeMatcher
       attr_reader :parameter_type
 
-      def initialize(parameter_type, regexp, text, match_position=0)
+      def initialize(parameter_type, regexp, text, match_position = 0)
         @parameter_type, @regexp, @text = parameter_type, regexp, text
         @match = @regexp.match(@text, match_position)
       end
 
       def advance_to(new_match_position)
-        (new_match_position...@text.length).each {|advancedPos|
-          matcher = self.class.new(parameter_type, @regexp, @text, advancedPos)
-          if matcher.find && matcher.full_word?
-            return matcher
-          end
-        }
+        (new_match_position...@text.length).each do |advanced_position|
+          matcher = self.class.new(parameter_type, @regexp, @text, advanced_position)
+          return matcher if matcher.find && matcher.full_word?
+        end
 
         self.class.new(parameter_type, @regexp, @text, @text.length)
       end
@@ -38,8 +38,10 @@ module Cucumber
       def <=>(other)
         pos_comparison = start <=> other.start
         return pos_comparison if pos_comparison != 0
+
         length_comparison = other.group.length <=> group.length
         return length_comparison if length_comparison != 0
+
         0
       end
 

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/errors'
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
@@ -6,27 +8,27 @@ require 'bigdecimal'
 module Cucumber
   module CucumberExpressions
     class ParameterTypeRegistry
-      INTEGER_REGEXPS = [/-?\d+/, /\d+/]
-      FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?/
-      WORD_REGEXP = /[^\s]+/
-      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/
-      ANONYMOUS_REGEXP = /.*/
+      INTEGER_REGEXPS = [/-?\d+/, /\d+/].freeze
+      FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?/.freeze
+      WORD_REGEXP = /[^\s]+/.freeze
+      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/.freeze
+      ANONYMOUS_REGEXP = /.*/.freeze
 
       def initialize
         @parameter_type_by_name = {}
-        @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
+        @parameter_types_by_regexp = Hash.new { |hash, regexp| hash[regexp] = [] }
 
-        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, true, true))
-        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, true, false))
-        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, lambda {|s = nil| s}, false, false))
-        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda { |s1, s2| arg = s1 != nil ? s1 : s2; arg.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
-        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, lambda {|s = nil| s}, false, true))
-        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, lambda {|s = nil| BigDecimal(s)}, false, false))
-        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, false, false))
+        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, true, true))
+        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, true, false))
+        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, ->(s = nil) { s }, false, false))
+        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, ->(s1, s2) { arg = s1 != nil ? s1 : s2; arg.gsub('\\"', '"').gsub("\\'", "'") }, true, false))
+        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, ->(s = nil) { s }, false, true))
+        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, ->(s = nil) { BigDecimal(s) }, false, false))
+        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, false, false))
       end
 
       def lookup_by_type_name(name)
@@ -36,7 +38,8 @@ module Cucumber
       def lookup_by_regexp(parameter_type_regexp, expression_regexp, text)
         parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
         return nil if parameter_types.nil?
-        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match?
+
+        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match
           # We don't do this check on insertion because we only want to restrict
           # ambiguity when we look up by Regexp. Users of CucumberExpression should
           # not be restricted.
@@ -54,7 +57,7 @@ module Cucumber
         if parameter_type.name != nil
           if @parameter_type_by_name.has_key?(parameter_type.name)
             if parameter_type.name.length == 0
-              raise CucumberExpressionError.new("The anonymous parameter type has already been defined")
+              raise CucumberExpressionError.new('The anonymous parameter type has already been defined')
             else
               raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
             end
@@ -64,14 +67,16 @@ module Cucumber
 
         parameter_type.regexps.each do |parameter_type_regexp|
           parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
-          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match? && parameter_type.prefer_for_regexp_match?
-            raise CucumberExpressionError.new("There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two preferential parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match && parameter_type.prefer_for_regexp_match
+            raise CucumberExpressionError.new(
+              "There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two: {#{parameter_types[0].name}} and {#{parameter_type.name}}"
+            )
           end
+
           parameter_types.push(parameter_type)
           parameter_types.sort!
         end
       end
-
     end
   end
 end

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/tree_regexp'
@@ -5,7 +7,6 @@ require 'cucumber/cucumber_expressions/tree_regexp'
 module Cucumber
   module CucumberExpressions
     class RegularExpression
-
       def initialize(expression_regexp, parameter_type_registry)
         @expression_regexp = expression_regexp
         @parameter_type_registry = parameter_type_registry
@@ -23,7 +24,7 @@ module Cucumber
             nil,
             parameter_type_regexp,
             String,
-            lambda {|*s| s[0]},
+            ->(*s) { s[0] },
             false,
             false
           )

data/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group_builder'
 require 'cucumber/cucumber_expressions/errors'
 
@@ -14,18 +16,19 @@ module Cucumber
       def match(s)
         match = @regexp.match(s)
         return nil if match.nil?
+
         group_indices = (0..match.length).to_a.to_enum
         @group_builder.build(match, group_indices)
       end
 
       private def is_non_capturing(source, i)
         # Regex is valid. Bounds check not required.
-        if source[i+1] != '?'
+        if source[i + 1] != '?'
           # (X)
           return false
         end
 
-        if source[i+2] != '<'
+        if source[i + 2] != '<'
           # (?:X)
           # (?idmsuxU-idmsuxU)
           # (?idmsux-idmsux:X)
@@ -35,14 +38,14 @@ module Cucumber
           return true
         end
 
-        if source[i+3] == '=' || source[i+3] == '!'
+        if source[i + 3] == '=' || source[i + 3] == '!'
           # (?<=X)
           # (?<!X)
           return true
         end
 
         # (?<name>X)
-        raise CucumberExpressionError.new("Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329")
+        raise CucumberExpressionError.new('Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329')
       end
 
       private def create_group_builder(regexp)
@@ -60,9 +63,7 @@ module Cucumber
             group_start_stack.push(i)
             group_builder = GroupBuilder.new
             non_capturing = is_non_capturing(source, i)
-            if non_capturing
-              group_builder.set_non_capturing!
-            end
+            group_builder.set_non_capturing! if non_capturing
             stack.push(group_builder)
           elsif c == ')' && !escaping && !char_class
             gb = stack.pop

data/spec/cucumber/cucumber_expressions/argument_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/tree_regexp'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -8,9 +10,9 @@ module Cucumber
       it 'exposes parameter_type' do
         tree_regexp = TreeRegexp.new(/three (.*) mice/)
         parameter_type_registry = ParameterTypeRegistry.new
-        arguments = Argument.build(tree_regexp, "three blind mice", [parameter_type_registry.lookup_by_type_name("string")])
+        arguments = described_class.build(tree_regexp, 'three blind mice', [parameter_type_registry.lookup_by_type_name('string')])
         argument = arguments[0]
-        expect(argument.parameter_type.name).to eq("string")
+        expect(argument.parameter_type.name).to eq('string')
       end
     end
   end