cucumber-tag-expressions 4.0.2 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d2dc32ca080c6d1a891598da9057b1c648002a770bb271b2836bd13e0c4440d
-  data.tar.gz: 33f531d5d359782af4f4f0c975c72cbf7a788f2be84a015b7befb31f8a818455
+  metadata.gz: c0642b9d453a4744506946b51bbde89b079a8db597c0f0f67122340283c98c07
+  data.tar.gz: 9a5e50d412b6b352b6ee9c8276941471fa29b183edf76eedc59482671c40a732
 SHA512:
-  metadata.gz: ee2697573e51ccc628b456682814a11bd89652f85d5859b0292e1286eda5403f21fcab77df1b597e5d0a3d8f8b73212665d658f04da8c10843a9e0df862351f4
-  data.tar.gz: de63fd74e729c530bc383ffed30a1783cf5f4381e9611390418c5259bee04e187f1ecd1c82066b1d5d013a75d6b67a8d3b0cca5db65fa85a7c16c076bbddecfe
+  metadata.gz: c6dad5df3a70282c263c30ca2c89335752843f34960e89e49ff3d90490a3d15f1574cf14a6e2ac49016f6f682dce0abb66151bc8a45700d48c691864da516907
+  data.tar.gz: ce5a050cd9b6c2ae6f907cf5de61ec0a77c724a4361da2d46bfe507f9114bcec3ba2ae271105f41d1fc9a3d1c6684ab19348f6dc4bd5bd393afed8c78be44dfe

data/lib/cucumber/tag_expressions/expressions.rb

@@ -3,7 +3,7 @@ module Cucumber
     # Literal expression node
     class Literal
       def initialize(value)
-        @value = value.gsub(/\\\(/, '(').gsub(/\\\)/, ')')
+        @value = value
       end
 
       def evaluate(variables)
@@ -11,7 +11,11 @@ module Cucumber
       end
 
       def to_s
-        @value.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,19 +64,36 @@ module Cucumber
         @operator_types[token][:precedence]
       end
 
-      def tokens(infix_expression)
-        infix_expression.gsub(/(?<!\\)\(/, ' ( ').gsub(/(?<!\\)\)/, ' ) ').strip.split(/\s+/)
-      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)
+      def tokenize(infix_expression)
+        tokens = []
+        escaped = false
+        token = ""
+        infix_expression.chars.each do | ch |
+          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}".}
+            end
+          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
-            expected_token_type = handle_literal(token, expected_token_type)
+            token += ch
           end
         end
+        if token.length > 0
+          tokens.push(token)
+        end
+        tokens
       end
 
       def push_expression(token)
@@ -83,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))
@@ -99,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.0.2
+  version: 5.0.0
 platform: ruby
 authors:
 - Andrea Nodari
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-13 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.0.2
+summary: cucumber-tag-expressions-5.0.0
 test_files:
-- spec/parser_spec.rb
-- spec/capture_warnings.rb
-- spec/expressions_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,55 +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
-end

data/spec/parser_spec.rb

@@ -1,46 +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 ) )']
-  ]
-
-  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