cucumber-tag_expressions 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c110df95d190c0a1d3b095047f4cb8a5405f24fe
+  data.tar.gz: e7aebcd8817b969606fd48198c4278cdf857bf12
+SHA512:
+  metadata.gz: 4fbb8f528b3aaa7a2834c507bacadd14280d5dd4fb6574bf70040de7e82557653e7d821687dbbd3d8469453fe36d5c7a486a563f3e63e2d2ec3ade5ed444d701
+  data.tar.gz: 8456e8c30676c993b153643658b77da11d5b31ef2a2faee2e3ce62f65c7901d3f26460a0aa5417db4effafe8876e53aaed6b467e97b717858e16dc4160e073cd

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,17 @@
+# manyrepo: cucumber/tag-expressions-ruby
+language: ruby
+sudo: false
+
+rvm:
+  - 2.3.1
+  - 2.2
+  - 2.1
+  - 2.0
+  - jruby-9.1.2.0
+
+before_install:
+  - gem update bundler
+
+notifications:
+  email:
+    - cukes-devs@googlegroups.com

data/Gemfile

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

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/Makefile

@@ -0,0 +1,8 @@
+LICENSE: ../../LICENSE
+	cp $< $@
+
+.PHONY: release
+release:
+	gem push cucumber-tag_expressions.gemspec
+	version=$$(cat cucumber-tag_expressions.gemspec | grep -m 1 ".version *= *" | sed "s/.*= *'\([^']*\)'.*/\1/"); \
+	git tag --annotate v$$version --message "Release $$version"

data/README.md

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

data/Rakefile

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

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'cucumber-tag_expressions'
+  s.version     = '1.0.0'
+  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', '>= 1.12.5'
+  s.add_development_dependency 'rake',    '>= 10.5.0'
+  s.add_development_dependency 'rspec',   '~> 3.5'
+
+  # For coverage reports
+  s.add_development_dependency 'coveralls', '~> 0.7'
+
+  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

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
+      end
+
+      def evaluate(variables)
+        variables.include?(@value)
+      end
+
+      def to_s
+        @value
+      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,115 @@
+require 'cucumber/tag_expressions/expressions.rb'
+
+module Cucumber
+  module TagExpressions
+    # Ruby tag expression parser
+    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 }
+        }
+      end
+
+      def parse(infix_expression)
+        process_tokens!(infix_expression)
+        while @operations.any?
+          raise 'Unclosed (' if @operations.last == '('
+          push_expression(pop(@operations))
+        end
+        expression = pop(@expressions)
+        @expressions.empty? ? expression : raise('Not empty')
+      end
+
+      private
+
+      ############################################################################
+      # Helpers
+      #
+      def assoc_of(token, value)
+        @components[token][:assoc] == value
+      end
+
+      def lower_precedence?(operation)
+        (assoc_of(operation, :left) &&
+         prec(operation) <= prec(@operations.last)) ||
+          (assoc_of(operation, :right) &&
+           prec(operation) < prec(@operations.last))
+      end
+
+      def operation?(token)
+        @components[token][:type] == :operation
+      end
+
+      def prec(token)
+        @components[token][:precedence]
+      end
+
+      def tokens(infix_expression)
+        infix_expression.gsub(/\(/, ' ( ').gsub(/\)/, ' ) ').strip.split(/\s+/)
+      end
+
+      def process_tokens!(infix_expression)
+        tokens(infix_expression).each do |token|
+          if @components[token]
+            send("handle_#{@components[token][:type]}", token)
+          else
+            handle_literal(token)
+          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_literal(token)
+        push_expression(token)
+      end
+
+      def handle_operation(token)
+        while @operations.any? && operation?(@operations.last) &&
+              lower_precedence?(token)
+          push_expression(pop(@operations))
+        end
+        @operations.push(token)
+      end
+
+      def handle_close_paren(_token)
+        while @operations.any? && @operations.last != '('
+          push_expression(pop(@operations))
+        end
+        raise 'Unclosed (' if @operations.empty?
+        pop(@operations) if @operations.last == '('
+      end
+
+      def handle_open_paren(token)
+        @operations.push(token)
+      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/coverage.rb

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

data/spec/expressions_spec.rb

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

data/spec/parser_spec.rb

@@ -0,0 +1,41 @@
+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 ) )']
+  ]
+
+  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']
+  ]
+
+  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, error_type, 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)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-tag_expressions
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrea Nodari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.12.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.12.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Cucumber tag expressions for ruby
+email: cukes@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- cucumber-tag_expressions.gemspec
+- lib/cucumber/tag_expressions.rb
+- lib/cucumber/tag_expressions/expressions.rb
+- lib/cucumber/tag_expressions/parser.rb
+- spec/coverage.rb
+- spec/expressions_spec.rb
+- spec/parser_spec.rb
+homepage: https://docs.cucumber.io/tag-expressions/
+licenses:
+- MIT
+metadata: {}
+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.5.1
+signing_key: 
+specification_version: 4
+summary: cucumber-tag_expressions-1.0.0
+test_files:
+- spec/coverage.rb
+- spec/expressions_spec.rb
+- spec/parser_spec.rb