cucumber-tag-expressions 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add075dc395b297351352601837188db90a7e347035845e63e8af7028ecc9d90
-  data.tar.gz: d9e1ed8d2291b2338c2a64303581e6cfa84854265aff0422d75bf8641f156c5e
+  metadata.gz: c0642b9d453a4744506946b51bbde89b079a8db597c0f0f67122340283c98c07
+  data.tar.gz: 9a5e50d412b6b352b6ee9c8276941471fa29b183edf76eedc59482671c40a732
 SHA512:
-  metadata.gz: 258a7f1a40ba0022491144dba178f8b6ac6a2e9c6180273e2c19244981b463651cb586c9ee6bf4acf4c34c42400f28305165d75571749be6de275fe9fb68d3ed
-  data.tar.gz: e03fbb76b4a951de7a8f4a1d6a3f60b3d47ed9c79b158e729ec153880b36bb28181bbc95c14125cd6ace08ab3578def4ca68781d90fbee64f455d04e4a6ad232
+  metadata.gz: c6dad5df3a70282c263c30ca2c89335752843f34960e89e49ff3d90490a3d15f1574cf14a6e2ac49016f6f682dce0abb66151bc8a45700d48c691864da516907
+  data.tar.gz: ce5a050cd9b6c2ae6f907cf5de61ec0a77c724a4361da2d46bfe507f9114bcec3ba2ae271105f41d1fc9a3d1c6684ab19348f6dc4bd5bd393afed8c78be44dfe

data/lib/cucumber/tag_expressions/expressions.rb

@@ -11,7 +11,11 @@ module Cucumber
       end
 
       def to_s
-        @value.gsub(/\\/, "\\\\\\\\").gsub(/\(/, "\\(").gsub(/\)/, "\\)")
+        @value
+          .gsub(/\\/, "\\\\\\\\")
+          .gsub(/\(/, "\\(")
+          .gsub(/\)/, "\\)")
+          .gsub(/\s/, "\\ ")
       end
     end
 
@@ -61,5 +65,15 @@ module Cucumber
         "( #{@left} and #{@right} )"
       end
     end
+
+    class True
+      def evaluate(variables)
+        true
+      end
+
+      def to_s
+        "true"
+      end
+    end
   end
 end

data/lib/cucumber/tag_expressions/parser.rb

@@ -18,9 +18,21 @@ module Cucumber
       end
 
       def parse(infix_expression)
-        process_tokens!(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
+        end
+
         while @operators.any?
-          raise 'Syntax error. Unmatched (' if @operators.last == '('
+          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched (.} if @operators.last == '('
           push_expression(pop(@operators))
         end
         expression = pop(@expressions)
@@ -52,48 +64,36 @@ module Cucumber
         @operator_types[token][:precedence]
       end
 
-      def tokens(infix_expression)
+      def tokenize(infix_expression)
+        tokens = []
         escaped = false
         token = ""
-        result = []
         infix_expression.chars.each do | ch |
-          if ch == '\\' && !escaped
-            escaped = true
-          else
-            if ch.match(/\s/)
-              if token.length > 0
-                result.push(token)
-                token = ""
-              end
+          if escaped
+            if ch == '(' || ch == ')' || ch == '\\' || ch.match(/\s/)
+              token += ch
+              escaped = false
             else
-              if (ch == '(' || ch == ')') && !escaped
-                if token.length > 0
-                  result.push(token)
-                  token = ""
-                end
-                result.push(ch)
-              else
-                token = token + ch
-              end
+              raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Illegal escape before "#{ch}".}
             end
-            escaped = false
+          elsif ch == '\\'
+            escaped = true
+          elsif ch == '(' || ch == ')' || ch.match(/\s/)
+            if token.length > 0
+              tokens.push(token)
+              token = ""
+            end
+            if !ch.match(/\s/)
+              tokens.push(ch)
+            end
+          else
+            token += ch
           end
         end
         if token.length > 0
-          result.push(token)
-        end
-        result
-      end
-
-      def process_tokens!(infix_expression)
-        expected_token_type = :operand
-        tokens(infix_expression).each do |token|
-          if @operator_types[token]
-            expected_token_type = send("handle_#{@operator_types[token][:type]}", token, expected_token_type)
-          else
-            expected_token_type = handle_literal(token, expected_token_type)
-          end
+          tokens.push(token)
         end
+        tokens
       end
 
       def push_expression(token)
@@ -112,14 +112,14 @@ module Cucumber
       ############################################################################
       # Handlers
       #
-      def handle_unary_operator(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_unary_operator(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         @operators.push(token)
         :operand
       end
 
-      def handle_binary_operator(token, expected_token_type)
-        check(expected_token_type, :operator)
+      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))
@@ -128,31 +128,31 @@ module Cucumber
         :operand
       end
 
-      def handle_open_paren(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_open_paren(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         @operators.push(token)
         :operand
       end
 
-      def handle_close_paren(_token, expected_token_type)
-        check(expected_token_type, :operator)
+      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 'Syntax error. Unmatched )' if @operators.empty?
+        raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Unmatched ).} if @operators.empty?
         pop(@operators) if @operators.last == '('
         :operator
       end
 
-      def handle_literal(token, expected_token_type)
-        check(expected_token_type, :operand)
+      def handle_literal(infix_expression, token, expected_token_type)
+        check(infix_expression, expected_token_type, :operand)
         push_expression(token)
         :operator
       end
 
-      def check(expected_token_type, token_type)
+      def check(infix_expression, expected_token_type, token_type)
         if expected_token_type != token_type
-          raise "Syntax error. Expected #{expected_token_type}"
+          raise %Q{Tag expression "#{infix_expression}" could not be parsed because of syntax error: Expected #{expected_token_type}.}
         end
       end
 

data/spec/errors_spec.rb

@@ -0,0 +1,13 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+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
+      expect { parser.parse(test['expression']) }.to raise_error(test['error'])
+    end
+  end
+end

data/spec/evaluations_spec.rb

@@ -0,0 +1,17 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+evaluations = YAML.load_file('../testdata/evaluations.yml')
+
+describe 'Evaluations' do
+  evaluations.each do |evaluation|
+    context evaluation['expression'] do
+      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
+    end
+  end
+end

data/spec/parsing_spec.rb

@@ -0,0 +1,14 @@
+require 'cucumber/tag_expressions/parser'
+require 'yaml'
+
+tests = YAML.load_file('../testdata/parsing.yml')
+
+describe 'Parsing' do
+  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'])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-tag-expressions
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Andrea Nodari
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2023-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -57,23 +57,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - README.md
 - lib/cucumber/tag_expressions.rb
 - lib/cucumber/tag_expressions/expressions.rb
 - lib/cucumber/tag_expressions/parser.rb
-- spec/capture_warnings.rb
-- spec/expressions_spec.rb
-- spec/parser_spec.rb
+- spec/errors_spec.rb
+- spec/evaluations_spec.rb
+- spec/parsing_spec.rb
 homepage: https://cucumber.io/docs/cucumber/api/#tag-expressions
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/cucumber/cucumber/issues
-  changelog_uri: https://github.com/cucumber/common/blob/main/tag-expressions/CHANGELOG.md
+  changelog_uri: https://github.com/cucumber/tag-expressions/blob/main/CHANGELOG.md
   documentation_uri: https://cucumber.io/docs/cucumber/api/#tag-expressions
   mailing_list_uri: https://groups.google.com/forum/#!forum/cukes
-  source_code_uri: https://github.com/cucumber/common/blob/main/tag-expressions/ruby
+  source_code_uri: https://github.com/cucumber/tag-expressions/tree/main/ruby
 post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
@@ -90,11 +89,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
-summary: cucumber-tag-expressions-4.1.0
+summary: cucumber-tag-expressions-5.0.0
 test_files:
-- spec/expressions_spec.rb
-- spec/capture_warnings.rb
-- spec/parser_spec.rb
+- spec/errors_spec.rb
+- spec/evaluations_spec.rb
+- spec/parsing_spec.rb

data/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Cucumber Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/spec/capture_warnings.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-# With thanks to @myronmarston
-# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
-
-module CaptureWarnings
-  def report_warnings(&block)
-    current_dir = Dir.pwd
-    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
-    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
-
-    if errors.any?
-      puts errors.join("\n")
-    end
-
-    if other_warnings.any?
-      puts "#{ other_warnings.count } warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
-      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
-    end
-
-    # Until they fix https://bugs.ruby-lang.org/issues/10661
-    if RUBY_VERSION == "2.2.0"
-      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
-    end
-
-    if project_warnings.any?
-      puts "#{ project_warnings.count } warnings detected"
-      print_warnings('cucumber-expressions', project_warnings)
-      fail "Please remove all cucumber-expressions warnings."
-    end
-
-    ensure_system_exit_if_required
-  end
-
-  def capture_error(&block)
-    old_stderr = STDERR.clone
-    pipe_r, pipe_w = IO.pipe
-    pipe_r.sync    = true
-    error          = String.new
-    reader = Thread.new do
-      begin
-        loop do
-          error << pipe_r.readpartial(1024)
-        end
-      rescue EOFError
-      end
-    end
-    STDERR.reopen(pipe_w)
-    block.call
-  ensure
-    capture_system_exit
-    STDERR.reopen(old_stderr)
-    pipe_w.close
-    reader.join
-    return error.split("\n")
-  end
-
-  def print_warnings(type, warnings)
-    puts
-    puts "-" * 30 + " #{type} warnings: " + "-" * 30
-    puts
-    puts warnings.join("\n")
-    puts
-    puts "-" * 75
-    puts
-  end
-
-  def ensure_system_exit_if_required
-    raise @system_exit if @system_exit
-  end
-
-  def capture_system_exit
-    @system_exit = $!
-  end
-end

data/spec/expressions_spec.rb

@@ -1,84 +0,0 @@
-require 'cucumber/tag_expressions/parser'
-
-describe 'Expression node' do
-  shared_examples 'expression node' do |infix_expression, data|
-    data.each do |tags, result|
-      it "#{infix_expression.inspect} with variables: #{tags.inspect}'" do
-        expression = Cucumber::TagExpressions::Parser.new.parse(infix_expression)
-        expect(expression.evaluate(tags)).to eq(result)
-      end
-    end
-  end
-
-  describe Cucumber::TagExpressions::Not do
-    context '#evaluate' do
-      infix_expression = 'not x'
-      data = [[%w(x), false],
-              [%w(y), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::And do
-    context '#evaluate' do
-      infix_expression = 'x and y'
-      data = [[%w(x y), true],
-              [%w(x), false],
-              [%w(y), false]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x or y'
-      data = [[%w(), false],
-              [%w(x), true],
-              [%w(y), true],
-              [%w(x q), true],
-              [%w(x y), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x\\(1\\) or (y\\(2\\))'
-      data = [[%w(), false],
-              [%w(x), false],
-              [%w(y), false],
-              [%w(x(1)), true],
-              [%w(y(2)), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x\\\\ or (y\\\\\\)) or (z\\\\)'
-      data = [[%w(), false],
-              [%w(x), false],
-              [%w(y\)), false],
-              [%w(z), false],
-              [%w(x\\), true],
-              [%w(y\\\)), true],
-              [%w(z\\), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = '\\x or y\\ or z\\'
-      data = [[%w(), false],
-              [%w(\\x), false],
-              [%w(y\\), false],
-              [%w(z\\), false],
-              [%w(x), true],
-              [%w(y), true],
-              [%w(z), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-end

data/spec/parser_spec.rb

@@ -1,50 +0,0 @@
-require 'cucumber/tag_expressions/parser'
-
-describe Cucumber::TagExpressions::Parser do
-  correct_test_data = [
-    ['a and b', '( a and b )'],
-    ['a or (b)', '( a or b )'],
-    ['not   a', 'not ( a )'],
-    ['( a and b ) or ( c and d )', '( ( a and b ) or ( c and d ) )'],
-    ['not a or b and not c or not d or e and f',
-     '( ( ( not ( a ) or ( b and not ( c ) ) ) or not ( d ) ) or ( e and f ) )'],
-    ['not a\\(\\) or b and not c or not d or e and f',
-     '( ( ( not ( a\\(\\) ) or ( b and not ( c ) ) ) or not ( d ) ) or ( e and f ) )'],
-     ['a\\\\ and b', '( a\\\\ and b )'],
-     ['\\a and b\\ and c\\', '( ( a and b ) and c )'],
-     ['(a and b\\\\)', '( a and b\\\\ )'],
-     ['a\\\\\\( and b\\\\\\)', '( a\\\\\\( and b\\\\\\) )']
-  ]
-
-  error_test_data = [
-    ['@a @b or', 'Syntax error. Expected operator'],
-    ['@a and (@b not)', 'Syntax error. Expected operator'],
-    ['@a and (@b @c) or', 'Syntax error. Expected operator'],
-    ['@a and or', 'Syntax error. Expected operand'],
-    ['or or', 'Syntax error. Expected operand'],
-    ['a b', 'Syntax error. Expected operator'],
-    ['( a and b ) )', 'Syntax error. Unmatched )'],
-    ['( ( a and b )', 'Syntax error. Unmatched ('],
-  ]
-
-  context '#parse' do
-    context 'with correct test data' do
-      correct_test_data.each do |infix_expression, to_string|
-        parser = Cucumber::TagExpressions::Parser.new
-        it "parses correctly #{infix_expression.inspect}" do
-          expect(parser.parse(infix_expression).to_s).to eq(to_string)
-        end
-      end
-    end
-
-    context 'with error test data' do
-      error_test_data.each do |infix_expression, message|
-        parser = Cucumber::TagExpressions::Parser.new
-        it "raises an error parsing #{infix_expression.inspect}" do
-          expect { parser.parse(infix_expression) }
-            .to raise_error(RuntimeError, message)
-        end
-      end
-    end
-  end
-end