cucumber-tag_expressions 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19bf8f6a97a5f34c6040463bbae25c1a0bfb6666
-  data.tar.gz: 954221878d37d62109793038d3d0aa41681a7522
+  metadata.gz: 2e5a0bcac8bfcc6f2dc1106c1137dc0680230ffb
+  data.tar.gz: ca8e096362f13513df653e454ad22978249acece
 SHA512:
-  metadata.gz: 4f1c563583f5a5cd596143818b39c598ef42881905563fe7a2cbb8d6cf14287980d7485a920935d50cf9878d602507100f7d03f52e05861a00c8cd9df9240e6f
-  data.tar.gz: 702f403529dd3b7b014e29750df7a3cde3242f591cf222dfdda677914b979f4be87251538b27337eafc6ffc2c009e0e765465308ce783b209180c5efffa95bbc
+  metadata.gz: 62fed4362ef18098c1640e13c73f1f7a241b29abe6e5aa07156871c1ccf596859158684874cb4e8528937fef53a8b54111a288317da32df57591a0fcc5eae1af
+  data.tar.gz: cc6d23a76a4d0ea419c01c451509acbfe798648287e49da4e65b9cff2dfa8618a8a900bfecc73c34795e7d1fb2f411488140ccd35ddda9c0112c4dc46fbbb901

data/bin/cucumber-tag-expressions

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+#
+# This script reads NDJSON-encoded Cucumber events from STDIN and prints
+# the location of each pickle (scenario) matching a tag expression. If
+# no tag expression is specified, all pickle locations are printed.
+#
+# Example:
+#
+#    gherkin features/*.feature | cucumber-tag-expressions "@foo and not @bar"
+#
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__),"../lib"))
+require 'cucumber/tag_expressions'
+
+tag_expression_parser = Cucumber::TagExpressions::Parser.new
+tag_expression = ARGV[0] ? tag_expression_parser.parse(ARGV[0]) : nil
+
+STDIN.each do |json|
+  event = JSON.parse(json)
+  if event['type'] == 'pickle'
+    tag_names = event['pickle']['tags'].map {|tag| tag['name']}
+    if tag_expression.nil? || tag_expression.evaluate(tag_names)
+      location = "#{event['uri']}:#{event['pickle']['locations'][0]['line']}"
+      puts location
+    end
+  end
+end

data/lib/cucumber/tag_expressions/expressions.rb

@@ -3,7 +3,7 @@ module Cucumber
     # Literal expression node
     class Literal
       def initialize(value)
-        @value = value
+        @value = value.gsub(/\\\(/, '(').gsub(/\\\)/, ')')
       end
 
       def evaluate(variables)
@@ -11,7 +11,7 @@ module Cucumber
       end
 
       def to_s
-        @value
+        @value.gsub(/\(/, '\\(').gsub(/\)/, '\\)')
       end
     end
 

data/lib/cucumber/tag_expressions/parser.rb

@@ -6,22 +6,22 @@ module Cucumber
     class Parser
       def initialize
         @expressions = []
-        @operations = []
-
-        @components = {
-          'or'  => { type: :operation,   precedence: 0, assoc: :left },
-          'and' => { type: :operation,   precedence: 1, assoc: :left },
-          'not' => { type: :operation,   precedence: 2, assoc: :right },
-          ')'   => { type: :close_paren, precedence: -1 },
-          '('   => { type: :open_paren,  precedence: 1 }
+        @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 @operations.any?
-          raise 'Unclosed (' if @operations.last == '('
-          push_expression(pop(@operations))
+        while @operators.any?
+          raise 'Syntax error. Unmatched (' if @operators.last == '('
+          push_expression(pop(@operators))
         end
         expression = pop(@expressions)
         @expressions.empty? ? expression : raise('Not empty')
@@ -33,34 +33,36 @@ module Cucumber
       # Helpers
       #
       def assoc_of(token, value)
-        @components[token][:assoc] == value
+        @operator_types[token][:assoc] == value
       end
 
       def lower_precedence?(operation)
         (assoc_of(operation, :left) &&
-         prec(operation) <= prec(@operations.last)) ||
+         precedence(operation) <= precedence(@operators.last)) ||
           (assoc_of(operation, :right) &&
-           prec(operation) < prec(@operations.last))
+           precedence(operation) < precedence(@operators.last))
       end
 
-      def operation?(token)
-        @components[token][:type] == :operation
+      def operator?(token)
+        @operator_types[token][:type] == :unary_operator ||
+            @operator_types[token][:type] == :binary_operator
       end
 
-      def prec(token)
-        @components[token][:precedence]
+      def precedence(token)
+        @operator_types[token][:precedence]
       end
 
       def tokens(infix_expression)
-        infix_expression.gsub(/\(/, ' ( ').gsub(/\)/, ' ) ').strip.split(/\s+/)
+        infix_expression.gsub(/(?<!\\)\(/, ' ( ').gsub(/(?<!\\)\)/, ' ) ').strip.split(/\s+/)
       end
 
       def process_tokens!(infix_expression)
+        expected_token_type = :operand
         tokens(infix_expression).each do |token|
-          if @components[token]
-            send("handle_#{@components[token][:type]}", token)
+          if @operator_types[token]
+            expected_token_type = send("handle_#{@operator_types[token][:type]}", token, expected_token_type)
           else
-            handle_literal(token)
+            expected_token_type = handle_literal(token, expected_token_type)
           end
         end
       end
@@ -81,28 +83,48 @@ module Cucumber
       ############################################################################
       # Handlers
       #
-      def handle_literal(token)
-        push_expression(token)
+      def handle_unary_operator(token, expected_token_type)
+        check(expected_token_type, :operand)
+        @operators.push(token)
+        :operand
       end
 
-      def handle_operation(token)
-        while @operations.any? && operation?(@operations.last) &&
+      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(@operations))
+          push_expression(pop(@operators))
         end
-        @operations.push(token)
+        @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)
-        while @operations.any? && @operations.last != '('
-          push_expression(pop(@operations))
+      def handle_close_paren(_token, expected_token_type)
+        check(expected_token_type, :operator)
+        while @operators.any? && @operators.last != '('
+          push_expression(pop(@operators))
         end
-        raise 'Unclosed (' if @operations.empty?
-        pop(@operations) if @operations.last == '('
+        raise 'Syntax error. Unmatched )' if @operators.empty?
+        pop(@operators) if @operators.last == '('
+        :operator
       end
 
-      def handle_open_paren(token)
-        @operations.push(token)
+      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)

data/spec/expressions_spec.rb

@@ -3,8 +3,8 @@ require 'cucumber/tag_expressions/parser'
 describe 'Expression node' do
   shared_examples 'expression node' do |infix_expression, data|
     data.each do |tags, result|
-      expression = Cucumber::TagExpressions::Parser.new.parse(infix_expression)
       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
@@ -40,4 +40,16 @@ describe 'Expression node' do
       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

@@ -7,15 +7,20 @@ describe Cucumber::TagExpressions::Parser do
     ['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',
+     '( ( ( not ( a\\(\\) ) or ( b and not ( c ) ) ) or not ( d ) ) or ( e and f ) )']
   ]
 
   error_test_data = [
-    ['( a and b ))', RuntimeError, 'Unclosed ('],
-    ['a not ( and )', RuntimeError, 'Empty stack'],
-    ['( ( a and b )', RuntimeError, 'Unclosed ('],
-    ['a b', RuntimeError, 'Not empty'],
-    ['or or', RuntimeError, 'Empty stack']
+    ['@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
@@ -29,11 +34,11 @@ describe Cucumber::TagExpressions::Parser do
     end
 
     context 'with error test data' do
-      error_test_data.each do |infix_expression, error_type, message|
+      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(error_type, message)
+            .to raise_error(RuntimeError, message)
         end
       end
     end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-tag_expressions
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrea Nodari
+- Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-28 00:00:00.000000000 Z
+date: 2017-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +45,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -68,18 +69,14 @@ dependencies:
         version: '0'
 description: Cucumber tag expressions for ruby
 email: cukes@googlegroups.com
-executables: []
+executables:
+- cucumber-tag-expressions
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".travis.yml"
-- Gemfile
 - LICENSE
-- Makefile
 - README.md
-- Rakefile
-- cucumber-tag_expressions.gemspec
+- bin/cucumber-tag-expressions
 - lib/cucumber/tag_expressions.rb
 - lib/cucumber/tag_expressions/expressions.rb
 - lib/cucumber/tag_expressions/parser.rb
@@ -110,8 +107,8 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: cucumber-tag_expressions-1.0.1
+summary: cucumber-tag_expressions-1.1.0
 test_files:
+- spec/parser_spec.rb
 - spec/coverage.rb
 - spec/expressions_spec.rb
-- spec/parser_spec.rb

data/.rspec

@@ -1 +0,0 @@
---color

data/.travis.yml

@@ -1,15 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.6
-  - jruby-9.1.7.0
-
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/5373e574ed4e88026838
-    on_success: change
-    on_failure: always
-    on_start: never

data/Gemfile

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-source 'https://rubygems.org'
-gemspec

data/Makefile

@@ -1,8 +0,0 @@
-default:
-	bundle install
-	bundle exec rake
-	bundle exec rake install
-.PHONY: default
-
-clean:
-.PHONY: clean

data/Rakefile

@@ -1,13 +0,0 @@
-# encoding: utf-8
-require 'rubygems'
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.ruby_opts = %w(-r./spec/coverage -w)
-end
-
-task default: ['spec']

data/cucumber-tag_expressions.gemspec

@@ -1,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-Gem::Specification.new do |s|
-  s.name        = 'cucumber-tag_expressions'
-  s.version     = '1.0.1'
-  s.authors     = ['Andrea Nodari']
-  s.description = 'Cucumber tag expressions for ruby'
-  s.summary     = "#{s.name}-#{s.version}"
-  s.email       = 'cukes@googlegroups.com'
-  s.homepage    = 'https://docs.cucumber.io/tag-expressions/'
-  s.platform    = Gem::Platform::RUBY
-  s.license     = 'MIT'
-  s.required_ruby_version = '>= 1.9.3'
-
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'rake',      '~> 10.5'
-  s.add_development_dependency 'rspec',     '~> 3.5'
-
-  # For coverage reports
-  s.add_development_dependency 'coveralls'
-
-  s.rubygems_version = '>= 1.6.1'
-  s.files            = `git ls-files`.split("\n").reject { |path| path =~ /\.gitignore$/ }
-  s.test_files       = `git ls-files -- spec/*`.split("\n")
-  s.rdoc_options     = ['--charset=UTF-8']
-  s.require_path     = 'lib'
-end