cucumber-tag-expressions 6.0.0 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b23aa7415febd02e3545c001145ef554af7de2594b176b16ab95bfffca5abe8c
-  data.tar.gz: 8b9041d1da6912c98c7d59cbaf28fed24d60e6b6e85777a82b6edebeab616cfd
+  metadata.gz: 47563b3d91bae578ee83c3f510081724ba64d4322cb6196beaf0da543d4b21c0
+  data.tar.gz: 5bcf02d2e8b2e0aa0b7b2906ba9aecde5224f967b12fc7deb7f013e6defa5614
 SHA512:
-  metadata.gz: 2e582b9664b6195738dd38973b6bd45f99cad884a51774b02f78bfea17cb992ac441790f1d471589dc1a746307652f0bcd318245487ebe0c080df0fbc4f9963b
-  data.tar.gz: 15c98ae66cc3395bb8a252517988c336ed73cb5606ee043dbd4c4db60b3e99cb5afc06b1fe255c283b6e05ff0079a1823c89ec2d2f275e982efeeded5ba4f014
+  metadata.gz: 724e4dc685894201c18998973edd45866ebe13a75799119c847c19209c0f9b6b8c9042d81001d8faf2e6f922b926a5d14053b0672457394f5f6b8096cb2ccf9b
+  data.tar.gz: 64044f10e31c417e6348c02d7f21043e8f0aa223b6a0b892cbfe4a74b266007d85140c66c4b6528075d4cce1340a7292453810ecebfc28142e87df319d2edc16

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,4 +1,6 @@
-require 'cucumber/tag_expressions/expressions.rb'
+# frozen_string_literal: true
+
+require 'cucumber/tag_expressions/expressions'
 
 module Cucumber
   module TagExpressions
@@ -6,32 +8,19 @@ module Cucumber
       def initialize
         @expressions = []
         @operators = []
-
-        @operator_types = {
-          '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 }
-        }
       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)
-          else
-            expected_token_type = handle_literal(infix_expression, token, expected_token_type)
-          end
+          expected_token_type = handle_sequential_tokens(token, infix_expression, expected_token_type)
         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
@@ -42,67 +31,64 @@ module Cucumber
       private
 
       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
+        %i[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)))
+        when 'and' then @expressions.push(And.new(*pop(@expressions, 2)))
+        when 'or'  then @expressions.push(Or.new(*pop(@expressions, 2)))
+        when 'not' then @expressions.push(Not.new(pop(@expressions)))
+        else            @expressions.push(Literal.new(token))
+        end
+      end
+
+      def handle_sequential_tokens(token, infix_expression, expected_token_type)
+        if operator_types[token]
+          send("handle_#{operator_types.dig(token, :type)}", infix_expression, token, expected_token_type)
         else
-          @expressions.push(Literal.new(token))
+          handle_literal(infix_expression, token, expected_token_type)
         end
       end
 
@@ -114,10 +100,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
@@ -130,10 +113,8 @@ 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
@@ -146,16 +127,30 @@ 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, n = 1)
-        result = array.pop(n)
-        raise('Empty stack') if result.size != n
+      def pop(array, amount = 1)
+        result = array.pop(amount)
+        raise('Empty stack') if result.length != amount
+
+        amount == 1 ? result.first : result
+      end
+
+      def operator_types
+        {
+          '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 }
+        }
+      end
 
-        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,5 +1,4 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 tests = YAML.load_file('../testdata/errors.yml')
 
@@ -7,7 +6,7 @@ describe 'Errors' do
   tests.each do |test|
     let(:parser) { Cucumber::TagExpressions::Parser.new }
 
-    it %Q{fails to parse "#{test['expression']}" with "#{test['error']}"} do
+    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,5 +1,4 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 evaluations = YAML.load_file('../testdata/evaluations.yml')
 

data/spec/parsing_spec.rb

@@ -1,5 +1,4 @@
-require 'cucumber/tag_expressions/parser'
-require 'yaml'
+# frozen_string_literal: true
 
 tests = YAML.load_file('../testdata/parsing.yml')
 
@@ -7,7 +6,7 @@ describe 'Parsing' do
   let(:parser) { Cucumber::TagExpressions::Parser.new }
 
   tests.each do |test|
-    it %Q{parses "#{test['expression']}" into "#{test['formatted']}"} do
+    it "parses '#{test['expression']}' into '#{test['formatted']}'" do
       expect(parser.parse(test['expression']).to_s).to eq(test['formatted'])
     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: 6.0.0
+  version: 6.1.1
 platform: ruby
 authors:
 - Andrea Nodari
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-13 00:00:00.000000000 Z
+date: 2024-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -72,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
@@ -97,11 +98,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.0.8
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
-summary: cucumber-tag-expressions-6.0.0
+summary: cucumber-tag-expressions-6.1.1
 test_files:
 - spec/errors_spec.rb
 - spec/evaluations_spec.rb
 - spec/parsing_spec.rb
+- spec/spec_helper.rb