cucumber-tag-expressions 2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ace30f7929f56e9f7fb15e914f1cd2a505f7d8d45c938c26e4bbf02e21fbd5a
+  data.tar.gz: 39eeb518cb6cba26529321912bb3f81a889ef33387ee4e0bb4212615f5931872
+SHA512:
+  metadata.gz: db6b0596392018944363bd639303c1148ac1063e080f89bbb1d81c99b251a2637f1ef79d16b7c74f949069f974854a71ae75d03f95346497c15e4a5013677f84
+  data.tar.gz: e0e5c54580a07129712df9a3f1ae23314640576a34529046d942d6da84de71df73973410b07fc18d64e5cf1b0bfaaa766cf6137485338fdece12101a37617d17

data/LICENSE

@@ -0,0 +1,21 @@
+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/README.md

@@ -0,0 +1,3 @@
+# Cucumber Tag Expressions for Ruby
+
+[The docs are here](https://cucumber.io/docs/cucumber/api/#tag-expressions).

data/lib/cucumber/tag_expressions.rb

@@ -0,0 +1 @@
+require 'cucumber/tag_expressions/parser'

data/lib/cucumber/tag_expressions/expressions.rb

@@ -0,0 +1,65 @@
+module Cucumber
+  module TagExpressions
+    # Literal expression node
+    class Literal
+      def initialize(value)
+        @value = value.gsub(/\\\(/, '(').gsub(/\\\)/, ')')
+      end
+
+      def evaluate(variables)
+        variables.include?(@value)
+      end
+
+      def to_s
+        @value.gsub(/\(/, '\\(').gsub(/\)/, '\\)')
+      end
+    end
+
+    # Not expression node
+    class Not
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def evaluate(variables)
+        !@expression.evaluate(variables)
+      end
+
+      def to_s
+        "not ( #{@expression} )"
+      end
+    end
+
+    # Or expression node
+    class Or
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def evaluate(variables)
+        @left.evaluate(variables) || @right.evaluate(variables)
+      end
+
+      def to_s
+        "( #{@left} or #{@right} )"
+      end
+    end
+
+    # And expression node
+    class And
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def evaluate(variables)
+        @left.evaluate(variables) && @right.evaluate(variables)
+      end
+
+      def to_s
+        "( #{@left} and #{@right} )"
+      end
+    end
+  end
+end

data/lib/cucumber/tag_expressions/parser.rb

@@ -0,0 +1,137 @@
+require 'cucumber/tag_expressions/expressions.rb'
+
+module Cucumber
+  module TagExpressions
+    # Ruby tag expression parser
+    class Parser
+      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)
+        process_tokens!(infix_expression)
+        while @operators.any?
+          raise 'Syntax error. Unmatched (' if @operators.last == '('
+          push_expression(pop(@operators))
+        end
+        expression = pop(@expressions)
+        @expressions.empty? ? expression : raise('Not empty')
+      end
+
+      private
+
+      ############################################################################
+      # Helpers
+      #
+      def assoc_of(token, value)
+        @operator_types[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))
+      end
+
+      def operator?(token)
+        @operator_types[token][:type] == :unary_operator ||
+            @operator_types[token][:type] == :binary_operator
+      end
+
+      def precedence(token)
+        @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)
+          else
+            expected_token_type = handle_literal(token, expected_token_type)
+          end
+        end
+      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))
+        end
+      end
+
+      ############################################################################
+      # Handlers
+      #
+      def handle_unary_operator(token, expected_token_type)
+        check(expected_token_type, :operand)
+        @operators.push(token)
+        :operand
+      end
+
+      def handle_binary_operator(token, expected_token_type)
+        check(expected_token_type, :operator)
+        while @operators.any? && operator?(@operators.last) &&
+              lower_precedence?(token)
+          push_expression(pop(@operators))
+        end
+        @operators.push(token)
+        :operand
+      end
+
+      def handle_open_paren(token, expected_token_type)
+        check(expected_token_type, :operand)
+        @operators.push(token)
+        :operand
+      end
+
+      def handle_close_paren(_token, expected_token_type)
+        check(expected_token_type, :operator)
+        while @operators.any? && @operators.last != '('
+          push_expression(pop(@operators))
+        end
+        raise '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)
+        push_expression(token)
+        :operator
+      end
+
+      def check(expected_token_type, token_type)
+        if expected_token_type != token_type
+          raise "Syntax error. Expected #{expected_token_type}"
+        end
+      end
+
+      def pop(array, n = 1)
+        result = array.pop(n)
+        raise('Empty stack') if result.size != n
+        n == 1 ? result.first : result
+      end
+    end
+  end
+end

data/spec/capture_warnings.rb

@@ -0,0 +1,74 @@
+# 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/coverage.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require 'simplecov'
+formatters = [ SimpleCov::Formatter::HTMLFormatter ]
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(*formatters)
+SimpleCov.add_filter 'spec/'
+SimpleCov.start

data/spec/expressions_spec.rb

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,46 @@
+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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-tag-expressions
+version: !ruby/object:Gem::Version
+  version: 2.0.3
+platform: ruby
+authors:
+- Andrea Nodari
+- Aslak Hellesøy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.23
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.23
+description: Cucumber tag expressions for ruby
+email: cukes@googlegroups.com
+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/coverage.rb
+- spec/expressions_spec.rb
+- spec/parser_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/cucumber/blob/master/tag-expressions/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/cucumber/blob/master/tag-expressions/ruby
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: cucumber-tag-expressions-2.0.3
+test_files:
+- spec/capture_warnings.rb
+- spec/parser_spec.rb
+- spec/coverage.rb
+- spec/expressions_spec.rb