[Ruby] - Upgraded Rubocop gems.

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+### Changed
+- [Ruby] Updated rubocop and rubocop gems (RSpec/Rake/Performance), also updated project files affected by the updated rules ([#342](https://github.com/cucumber/cucumber-expressions/pull/342))
 
 ## [18.0.1] - 2024-10-28
 ### Fixed

ruby/.rubocop.yml

@@ -1,4 +1,4 @@
-require:
+plugins:
   - rubocop-performance
   - rubocop-rake
   - rubocop-rspec
@@ -10,7 +10,7 @@ inherit_mode:
     - Exclude
 
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.7
   NewCops: enable
 
 # Disabled on our repo's to enable polyglot-release
@@ -29,6 +29,9 @@ Lint/MixedRegexpCaptureTypes:
 Style/Documentation:
   Enabled: false
 
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
 Style/RegexpLiteral:
   EnforcedStyle: slashes
   AllowInnerSlashes: true

ruby/cucumber-cucumber-expressions.gemspec

@@ -23,14 +23,14 @@ Gem::Specification.new do |s|
     'source_code_uri' => 'https://github.com/cucumber/cucumber-expressions/tree/main/ruby',
   }
 
-  s.add_runtime_dependency 'bigdecimal'
+  s.add_dependency 'bigdecimal'
 
   s.add_development_dependency 'rake', '~> 13.1'
   s.add_development_dependency 'rspec', '~> 3.13'
-  s.add_development_dependency 'rubocop', '~> 1.27.0'
-  s.add_development_dependency 'rubocop-performance', '~> 1.7.0'
-  s.add_development_dependency 'rubocop-rake', '~> 0.5.0'
-  s.add_development_dependency 'rubocop-rspec', '~> 2.0.0'
+  s.add_development_dependency 'rubocop', '~> 1.75.7'
+  s.add_development_dependency 'rubocop-performance', '~> 1.25.0'
+  s.add_development_dependency 'rubocop-rake', '~> 0.7.1'
+  s.add_development_dependency 'rubocop-rspec', '~> 3.6.0'
 
   s.files            = Dir['lib/**/*', 'CHANGELOG.md', 'CONTRIBUTING.md', 'LICENSE', 'README.md']
   s.rdoc_options     = ['--charset=UTF-8']

ruby/lib/cucumber/cucumber_expressions/argument.rb

@@ -33,7 +33,7 @@ def initialize(group, parameter_type)
       def value(self_obj = :nil)
         raise 'No self_obj' if self_obj == :nil
 
-        group_values = @group ? @group.values : nil
+        group_values = @group&.values
         @parameter_type.transform(self_obj, group_values)
       end
     end

ruby/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -103,17 +103,17 @@ def rewrite_expression(node)
       end
 
       def assert_not_empty(node, &raise_error)
-        text_nodes = node.nodes.select { |ast_node| NodeType::TEXT == ast_node.type }
+        text_nodes = node.nodes.select { |ast_node| ast_node.type == NodeType::TEXT }
         raise_error.call(node) if text_nodes.length == 0
       end
 
       def assert_no_parameters(node, &raise_error)
-        nodes = node.nodes.select { |ast_node| NodeType::PARAMETER == ast_node.type }
+        nodes = node.nodes.select { |ast_node| ast_node.type == NodeType::PARAMETER }
         raise_error.call(nodes[0]) if nodes.length > 0
       end
 
       def assert_no_optionals(node, &raise_error)
-        nodes = node.nodes.select { |ast_node| NodeType::OPTIONAL == ast_node.type }
+        nodes = node.nodes.select { |ast_node| ast_node.type == NodeType::OPTIONAL }
         raise_error.call(nodes[0]) if nodes.length > 0
       end
     end

ruby/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -83,10 +83,10 @@ def create_parameter_type_matchers2(parameter_type, text)
       end
 
       def escape(s)
-        s.gsub(/%/, '%%')
-         .gsub(/\(/, '\\(')
+        s.gsub('%', '%%')
+         .gsub('(', '\\(')
          .gsub(/{/, '\\{')
-         .gsub(/\//, '\\/')
+         .gsub('/', '\\/')
       end
     end
   end

ruby/lib/cucumber/cucumber_expressions/cucumber_expression_parser.rb

@@ -22,23 +22,23 @@ def parse(expression)
             return [0, nil]
           end
           # If configured correctly this will never happen
-          return [0, nil]
+          [0, nil]
         end
 
         # name := whitespace | .
         parse_name = lambda do |_, tokens, current|
           token = tokens[current]
           case token.type
           when TokenType::WHITE_SPACE, TokenType::TEXT
-            return [1, [Node.new(NodeType::TEXT, nil, token.text, token.start, token.end)]]
+            [1, [Node.new(NodeType::TEXT, nil, token.text, token.start, token.end)]]
           when TokenType::BEGIN_PARAMETER, TokenType::END_PARAMETER, TokenType::BEGIN_OPTIONAL, TokenType::END_OPTIONAL, TokenType::ALTERNATION
             raise InvalidParameterTypeNameInNode.new(expression, token)
           when TokenType::START_OF_LINE, TokenType::END_OF_LINE
             # If configured correctly this will never happen
-            return [0, nil]
+            [0, nil]
           else
             # If configured correctly this will never happen
-            return [0, nil]
+            [0, nil]
           end
         end
 
@@ -56,7 +56,7 @@ def parse(expression)
           return [0, nil] unless looking_at(tokens, current, TokenType::ALTERNATION)
 
           token = tokens[current]
-          return [1, [Node.new(NodeType::ALTERNATIVE, nil, token.text, token.start, token.end)]]
+          [1, [Node.new(NodeType::ALTERNATIVE, nil, token.text, token.start, token.end)]]
         end
 
         alternative_parsers = [
@@ -81,7 +81,7 @@ def parse(expression)
           start = tokens[current].start
           _end = tokens[sub_current].start
           # Does not consume right hand boundary token
-          return [consumed, [Node.new(NodeType::ALTERNATION, split_alternatives(start, _end, ast), nil, start, _end)]]
+          [consumed, [Node.new(NodeType::ALTERNATION, split_alternatives(start, _end, ast), nil, start, _end)]]
         end
 
         #
@@ -118,7 +118,7 @@ def parse_between(type, begin_token, end_token, parsers)
           _end = tokens[sub_current].end
           consumed = sub_current + 1 - current
           ast = [Node.new(type, ast, nil, start, _end)]
-          return [consumed, ast]
+          [consumed, ast]
         end
       end
 
@@ -171,7 +171,7 @@ def split_alternatives(start, _end, alternation)
         alternatives = []
         alternative = []
         alternation.each do |n|
-          if NodeType::ALTERNATIVE == n.type
+          if n.type == NodeType::ALTERNATIVE
             separators.push(n)
             alternatives.push(alternative)
             alternative = []

ruby/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -38,7 +38,7 @@ def match(s)
           return true
         end
 
-        if source[i + 3] == '=' || source[i + 3] == '!'
+        if ['=', '!'].include?(source[i + 3])
           # (?<=X)
           # (?<!X)
           return true

ruby/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -20,7 +20,7 @@ module CucumberExpressions
           else
             cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
             matches = cucumber_expression.match(expectation['text'])
-            values = matches.nil? ? nil : matches.map do |arg|
+            values = matches&.map do |arg|
               value = arg.value(nil)
               case value
               when BigDecimal
@@ -51,32 +51,32 @@ module CucumberExpressions
       end
 
       it 'matches float' do
-        expect(match('{float}', '')).to eq(nil)
-        expect(match('{float}', '.')).to eq(nil)
-        expect(match('{float}', ',')).to eq(nil)
-        expect(match('{float}', '-')).to eq(nil)
-        expect(match('{float}', 'E')).to eq(nil)
-        expect(match('{float}', '1,')).to eq(nil)
-        expect(match('{float}', ',1')).to eq(nil)
-        expect(match('{float}', '1.')).to eq(nil)
+        expect(match('{float}', '')).to be_nil
+        expect(match('{float}', '.')).to be_nil
+        expect(match('{float}', ',')).to be_nil
+        expect(match('{float}', '-')).to be_nil
+        expect(match('{float}', 'E')).to be_nil
+        expect(match('{float}', '1,')).to be_nil
+        expect(match('{float}', ',1')).to be_nil
+        expect(match('{float}', '1.')).to be_nil
 
         expect(match('{float}', '1')).to eq([1])
         expect(match('{float}', '-1')).to eq([-1])
         expect(match('{float}', '1.1')).to eq([1.1])
-        expect(match('{float}', '1,000')).to eq(nil)
-        expect(match('{float}', '1,000,0')).to eq(nil)
-        expect(match('{float}', '1,000.1')).to eq(nil)
-        expect(match('{float}', '1,000,10')).to eq(nil)
-        expect(match('{float}', '1,0.1')).to eq(nil)
-        expect(match('{float}', '1,000,000.1')).to eq(nil)
+        expect(match('{float}', '1,000')).to be_nil
+        expect(match('{float}', '1,000,0')).to be_nil
+        expect(match('{float}', '1,000.1')).to be_nil
+        expect(match('{float}', '1,000,10')).to be_nil
+        expect(match('{float}', '1,0.1')).to be_nil
+        expect(match('{float}', '1,000,000.1')).to be_nil
         expect(match('{float}', '-1.1')).to eq([-1.1])
 
         expect(match('{float}', '.1')).to eq([0.1])
         expect(match('{float}', '-.1')).to eq([-0.1])
         expect(match('{float}', '-.1000001')).to eq([-0.1000001])
         expect(match('{float}', '1E1')).to eq([10.0])
         expect(match('{float}', '.1E1')).to eq([1])
-        expect(match('{float}', 'E1')).to eq(nil)
+        expect(match('{float}', 'E1')).to be_nil
         expect(match('{float}', '-.1E-1')).to eq([-0.01])
         expect(match('{float}', '-.1E-2')).to eq([-0.001])
         expect(match('{float}', '-.1E+1')).to eq([-1])

ruby/spec/cucumber/cucumber_expressions/cucumber_expression_transformation_spec.rb

@@ -19,7 +19,7 @@ module CucumberExpressions
           else
             cucumber_expression = described_class.new(expectation['expression'], parameter_registry)
             matches = cucumber_expression.match(expectation['text'])
-            values = matches.nil? ? nil : matches.map { |arg| arg.value(nil) }
+            values = matches&.map { |arg| arg.value(nil) }
             expect(values).to eq(expectation['expected_args'])
           end
         end

ruby/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb

@@ -155,7 +155,7 @@ def ==(other)
             }.to raise_error('There is already a parameter with name color')
           end
 
-          it 'is not detected for type' do
+          it 'is not detected for type', skip: 'missing expectation' do
             @parameter_type_registry.define_parameter_type(
               ParameterType.new(
                 'whatever',

ruby/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -128,7 +128,7 @@ module CucumberExpressions
         tr = described_class.new(/the stdout(?: from "(.*?)")?/)
         group = tr.match('the stdout')
         expect(group.value).to eq('the stdout')
-        expect(group.children[0].value).to eq(nil)
+        expect(group.children[0].value).to be_nil
         expect(group.children.length).to eq(1)
       end