cucumber-tag-expressions 5.0.6 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2921f3e5eb8490c6711546d8b6d1e236074ce2036c6c464a5f082bd1dc3bab09
-  data.tar.gz: 67b3f6cc7ba3563ab32f8e204dd1f87effde63f1be34a41270052645f774b7a2
+  metadata.gz: c0f706cda9810598cd7d38933b862a0e50e2870be4525012e64e4b0b6596b3b3
+  data.tar.gz: 40b6af7268af69b1af1406d567cf0e536bd00d6d28dd3a6693a29c822b4e4876
 SHA512:
-  metadata.gz: 2e4770f3da555bf14a5ebde668ca7b6b77d90f822e345fa4b9ed8ed4dae69ac05733765685496f91bee62a1eb71961cdd85eb35c0776f19c64dc671763df0f68
-  data.tar.gz: 9fa1bf6e37809314361dee320b4fe96fa81b0eee2755fa84901e39f5b59989a39979c6ff8ebce2f257a79f7d9a5d7688f058f09bec43c74e1be7dee3d0cbfaa6
+  metadata.gz: 838196e211cb93599402f1ae4f928ca91f039a2a3ae5cdf7b1245e1ad8dc5609edf5ca1ce6f6e56d722a642c37a3afa6a7d8c89ce8a0baf3de8f2ee551631287
+  data.tar.gz: 3ab907243a1fa9a2ab3330829650f6fdf8769dcc532b7fddb04bc70bf8acaaa51e5fa74426840975d1bfcf15fd32084a2fcccab0f950d374dd10775457d5d665

data/lib/cucumber/tag_expressions/expressions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module TagExpressions
     # Literal expression node
@@ -12,10 +14,10 @@ module Cucumber
 
       def to_s
         @value
-          .gsub(/\\/, "\\\\\\\\")
-          .gsub(/\(/, "\\(")
-          .gsub(/\)/, "\\)")
-          .gsub(/\s/, "\\ ")
+          .gsub(/\\/, '\\\\\\\\')
+          .gsub(/\(/, '\\(')
+          .gsub(/\)/, '\\)')
+          .gsub(/\s/, '\\ ')
       end
     end
 
@@ -30,8 +32,8 @@ module Cucumber
       end
 
       def to_s
-        if @expression.is_a?(And)|| @expression.is_a?(Or)
-          # -- HINT: Binary operatos provides already "( ... )"
+        if @expression.is_a?(And) || @expression.is_a?(Or)
+          # -- HINT: Binary operations already provide "( ... )"
           "not #{@expression}"
         else
           "not ( #{@expression} )"
@@ -72,12 +74,12 @@ module Cucumber
     end
 
     class True
-      def evaluate(variables)
+      def evaluate(_variables)
         true
       end
 
       def to_s
-        "true"
+        'true'
       end
     end
   end

data/lib/cucumber/tag_expressions/parser.rb

@@ -1,38 +1,39 @@
-require 'cucumber/tag_expressions/expressions.rb'
+# frozen_string_literal: true
+
+require 'cucumber/tag_expressions/expressions'
 
 module Cucumber
   module TagExpressions
-    # Ruby tag expression parser
     class Parser
       def initialize
         @expressions = []
         @operators = []
 
         @operator_types = {
-          'or'  => { type: :binary_operator,    precedence: 0, assoc: :left },
+          'or' => { type: :binary_operator,    precedence: 0, assoc: :left },
           'and' => { type: :binary_operator,   precedence: 1, assoc: :left },
           'not' => { type: :unary_operator,   precedence: 2, assoc: :right },
-          ')'   => { type: :close_paren,       precedence: -1 },
-          '('   => { type: :open_paren,        precedence: 1 }
+          ')' => { type: :close_paren,       precedence: -1 },
+          '(' => { type: :open_paren,        precedence: 1 }
         }
       end
 
       def parse(infix_expression)
         expected_token_type = :operand
-
         tokens = tokenize(infix_expression)
         return True.new if tokens.empty?
 
         tokens.each do |token|
           if @operator_types[token]
-            expected_token_type = send("handle_#{@operator_types[token][:type]}", infix_expression, token, expected_token_type)
+            expected_token_type = send("handle_#{@operator_types.dig(token, :type)}", infix_expression, token, expected_token_type)
           else
             expected_token_type = handle_literal(infix_expression, token, expected_token_type)
           end
         end
 
         while @operators.any?
-          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched (.} if @operators.last == '('
+          raise %{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched (.} if @operators.last == '('
+
           push_expression(pop(@operators))
         end
         expression = pop(@expressions)
@@ -41,77 +42,60 @@ module Cucumber
 
       private
 
-      ############################################################################
-      # Helpers
-      #
       def assoc_of(token, value)
-        @operator_types[token][:assoc] == value
+        @operator_types.dig(token, :assoc) == value
       end
 
       def lower_precedence?(operation)
-        (assoc_of(operation, :left) &&
-         precedence(operation) <= precedence(@operators.last)) ||
-          (assoc_of(operation, :right) &&
-           precedence(operation) < precedence(@operators.last))
+        (assoc_of(operation, :left) && precedence(operation) <= precedence(@operators.last)) ||
+          (assoc_of(operation, :right) && precedence(operation) < precedence(@operators.last))
       end
 
       def operator?(token)
-        @operator_types[token][:type] == :unary_operator ||
-            @operator_types[token][:type] == :binary_operator
+        [:unary_operator, :binary_operator].include?(@operator_types.dig(token, :type))
       end
 
       def precedence(token)
-        @operator_types[token][:precedence]
+        @operator_types.dig(token, :precedence)
       end
 
       def tokenize(infix_expression)
         tokens = []
         escaped = false
-        token = ""
-        infix_expression.chars.each do | ch |
+        token = +''
+        infix_expression.chars.each do |char|
           if escaped
-            if ch == '(' || ch == ')' || ch == '\\' || ch.match(/\s/)
-              token += ch
-              escaped = false
-            else
-              raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Illegal escape before "#{ch}".}
+            unless char == '(' || char == ')' || char == '\\' || whitespace?(char)
+              raise %(Tag expression "#{infix_expression}" could not be parsed because of syntax error: Illegal escape before "#{char}".)
             end
-          elsif ch == '\\'
+
+            token += char
+            escaped = false
+          elsif char == '\\'
             escaped = true
-          elsif ch == '(' || ch == ')' || ch.match(/\s/)
-            if token.length > 0
+          elsif char == '(' || char == ')' || whitespace?(char)
+            if token.length.positive?
               tokens.push(token)
-              token = ""
-            end
-            if !ch.match(/\s/)
-              tokens.push(ch)
+              token = +''
             end
+            tokens.push(char) unless whitespace?(char)
           else
-            token += ch
+            token += char
           end
         end
-        if token.length > 0
-          tokens.push(token)
-        end
+        tokens.push(token) if token.length.positive?
         tokens
       end
 
       def push_expression(token)
         case token
-        when 'and'
-          @expressions.push(And.new(*pop(@expressions, 2)))
-        when 'or'
-          @expressions.push(Or.new(*pop(@expressions, 2)))
-        when 'not'
-          @expressions.push(Not.new(pop(@expressions)))
-        else
-          @expressions.push(Literal.new(token))
+        when 'and'; @expressions.push(And.new(*pop(@expressions, 2)))
+        when 'or';  @expressions.push(Or.new(*pop(@expressions, 2)))
+        when 'not'; @expressions.push(Not.new(pop(@expressions)))
+        else        @expressions.push(Literal.new(token))
         end
       end
 
-      ############################################################################
-      # Handlers
-      #
       def handle_unary_operator(infix_expression, token, expected_token_type)
         check(infix_expression, expected_token_type, :operand)
         @operators.push(token)
@@ -120,10 +104,7 @@ module Cucumber
 
       def handle_binary_operator(infix_expression, token, expected_token_type)
         check(infix_expression, expected_token_type, :operator)
-        while @operators.any? && operator?(@operators.last) &&
-              lower_precedence?(token)
-          push_expression(pop(@operators))
-        end
+        push_expression(pop(@operators)) while @operators.any? && operator?(@operators.last) && lower_precedence?(token)
         @operators.push(token)
         :operand
       end
@@ -136,10 +117,9 @@ module Cucumber
 
       def handle_close_paren(infix_expression, _token, expected_token_type)
         check(infix_expression, expected_token_type, :operator)
-        while @operators.any? && @operators.last != '('
-          push_expression(pop(@operators))
-        end
-        raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched ).} if @operators.empty?
+        push_expression(pop(@operators)) while @operators.any? && @operators.last != '('
+        raise %{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched ).} if @operators.empty?
+
         pop(@operators) if @operators.last == '('
         :operator
       end
@@ -151,15 +131,20 @@ module Cucumber
       end
 
       def check(infix_expression, expected_token_type, token_type)
-        if expected_token_type != token_type
-          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Expected #{expected_token_type}.}
-        end
+        return if expected_token_type == token_type
+
+        raise %(Tag expression "#{infix_expression}" could not be parsed because of syntax error: Expected #{expected_token_type}.)
+      end
+
+      def pop(array, amount = 1)
+        result = array.pop(amount)
+        raise('Empty stack') if result.length != amount
+
+        amount == 1 ? result.first : result
       end
 
-      def pop(array, n = 1)
-        result = array.pop(n)
-        raise('Empty stack') if result.size != n
-        n == 1 ? result.first : result
+      def whitespace?(char)
+        char.match(/\s/)
       end
     end
   end

data/lib/cucumber/tag_expressions.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'cucumber/tag_expressions/parser'

data/spec/errors_spec.rb

@@ -1,12 +1,12 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 tests = YAML.load_file('../testdata/errors.yml')
 
 describe 'Errors' do
   tests.each do |test|
-    it %Q{fails to parse "#{test['expression']}" with "#{test['error']}"} do
-      parser = Cucumber::TagExpressions::Parser.new
+    let(:parser) { Cucumber::TagExpressions::Parser.new }
+
+    it "fails to parse '#{test['expression']}' with '#{test['error']}'" do
       expect { parser.parse(test['expression']) }.to raise_error(test['error'])
     end
   end

data/spec/evaluations_spec.rb

@@ -1,14 +1,14 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 evaluations = YAML.load_file('../testdata/evaluations.yml')
 
 describe 'Evaluations' do
   evaluations.each do |evaluation|
     context evaluation['expression'] do
+      let(:parser) { Cucumber::TagExpressions::Parser.new }
+
       evaluation['tests'].each do |test|
         it "evaluates [#{test['variables'].join(', ')}] to #{test['result']}" do
-          parser = Cucumber::TagExpressions::Parser.new
           expect(parser.parse(evaluation['expression']).evaluate(test['variables'])).to eq(test['result'])
         end
       end

data/spec/parsing_spec.rb

@@ -1,14 +1,13 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 tests = YAML.load_file('../testdata/parsing.yml')
 
 describe 'Parsing' do
+  let(:parser) { Cucumber::TagExpressions::Parser.new }
+
   tests.each do |test|
-    it %Q{parses "#{test['expression']}" into "#{test['formatted']}"} do
-      parser = Cucumber::TagExpressions::Parser.new
-      expression = parser.parse(test['expression'])
-      expect(expression.to_s).to eq(test['formatted'])
+    it "parses '#{test['expression']}' into '#{test['formatted']}'" do
+      expect(parser.parse(test['expression']).to_s).to eq(test['formatted'])
     end
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'cucumber/tag_expressions/parser'
+require 'yaml'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-tag-expressions
 version: !ruby/object:Gem::Version
-  version: 5.0.6
+  version: 6.1.0
 platform: ruby
 authors:
 - Andrea Nodari
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-13 00:00:00.000000000 Z
+date: 2024-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -37,20 +37,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: '3.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
-    - - ">="
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.79.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: 0.79.0
 description: Cucumber tag expressions for ruby
 email: cukes@googlegroups.com
 executables: []
@@ -64,6 +72,7 @@ files:
 - spec/errors_spec.rb
 - spec/evaluations_spec.rb
 - spec/parsing_spec.rb
+- spec/spec_helper.rb
 homepage: https://cucumber.io/docs/cucumber/api/#tag-expressions
 licenses:
 - MIT
@@ -82,18 +91,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.8
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: cucumber-tag-expressions-5.0.6
+summary: cucumber-tag-expressions-6.1.0
 test_files:
 - spec/errors_spec.rb
 - spec/evaluations_spec.rb
 - spec/parsing_spec.rb
+- spec/spec_helper.rb