cucumber-cucumber-expressions 8.3.1

data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb

@@ -0,0 +1,30 @@
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'json'
+
+module Cucumber
+  module CucumberExpressions
+    describe 'examples.txt' do
+      def match(expression_text, text)
+        expression = expression_text =~ /\/(.*)\// ?
+          RegularExpression.new(Regexp.new($1), ParameterTypeRegistry.new) :
+          CucumberExpression.new(expression_text, ParameterTypeRegistry.new)
+
+        arguments = expression.match(text)
+        return nil if arguments.nil?
+        arguments.map { |arg| arg.value(nil) }
+      end
+
+      File.open(File.expand_path("../../../../examples.txt", __FILE__), "r:utf-8") do |io|
+        chunks = io.read.split(/^---/m)
+        chunks.each do |chunk|
+          expression_text, text, expected_args = *chunk.strip.split(/\n/m)
+          it "Works with: #{expression_text}" do
+            expect( match(expression_text, text).to_json ).to eq(expected_args)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -0,0 +1,86 @@
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+
+    CAPITALISED_WORD = /[A-Z]+\w+/
+
+    class Name
+    end
+
+    class Person
+    end
+
+    class Place
+    end
+
+    describe ParameterTypeRegistry do
+      before do
+        @registry = ParameterTypeRegistry.new
+      end
+
+      it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
+        @registry.define_parameter_type(ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, true))
+        @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
+        expect do
+          @registry.define_parameter_type(ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, true))
+        end.to raise_error(
+                   CucumberExpressionError,
+                   "There can only be one preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two preferential parameter types, {name} and {place}"
+               )
+      end
+
+      it 'looks up prefer_for_regexp_match parameter type by regexp' do
+        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
+        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
+        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+      end
+
+      it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
+        name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
+        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
+        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect do
+          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
+        end.to raise_error(
+                   CucumberExpressionError,
+                   "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" +
+                       "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n" +
+                       "   {name}\n" +
+                       "   {person}\n" +
+                       "   {place}\n" +
+                       "\n" +
+                       "I couldn't decide which one to use. You have two options:\n" +
+                       "\n" +
+                       "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n" +
+                       "   {name} and {name}\n" +
+                       "   {name} and {person}\n" +
+                       "   {name} and {place}\n" +
+                       "   {person} and {name}\n" +
+                       "   {person} and {person}\n" +
+                       "   {person} and {place}\n" +
+                       "   {place} and {name}\n" +
+                       "   {place} and {person}\n" +
+                       "   {place} and {place}\n" +
+                       "\n" +
+                       "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" +
+                       "\n"
+               )
+      end
+    end
+  end
+end
+

data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb

@@ -0,0 +1,15 @@
+require 'cucumber/cucumber_expressions/parameter_type'
+
+module Cucumber
+  module CucumberExpressions
+    describe ParameterType do
+      it 'does not allow ignore flag on regexp' do
+        expect do
+          ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
+        end.to raise_error(
+          CucumberExpressionError,
+          "ParameterType Regexps can't use option Regexp::IGNORECASE")
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -0,0 +1,80 @@
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe RegularExpression do
+      it "documents match arguments" do
+        parameter_type_registry = ParameterTypeRegistry.new
+
+        ### [capture-match-arguments]
+        expr = /I have (\d+) cukes? in my (\w*) now/
+        expression = RegularExpression.new(expr, parameter_type_registry)
+        args = expression.match("I have 7 cukes in my belly now")
+        expect( args[0].value(nil) ).to eq(7)
+        expect( args[1].value(nil) ).to eq("belly")
+        ### [capture-match-arguments]
+      end
+
+      it "does no transform by default" do
+        expect( match(/(\d\d)/, "22") ).to eq(["22"])
+      end
+
+      it "does not transform anonymous" do
+        expect( match(/(.*)/, "22") ).to eq(["22"])
+      end
+
+      it "transforms negative int" do
+        expect( match(/(-?\d+)/, "-22") ).to eq([-22])
+      end
+
+      it "transforms positive int" do
+        expect( match(/(\d+)/, "22") ).to eq([22])
+      end
+
+      it "returns nil when there is no match" do
+        expect( match(/hello/, "world") ).to be_nil
+      end
+
+      it "matches nested capture group without match" do
+        expect( match(/^a user( named "([^"]*)")?$/, 'a user') ).to eq([nil])
+      end
+
+      it "matches nested capture group with match" do
+        expect( match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"') ).to eq(['Charlie'])
+      end
+
+      it "ignores non capturing groups" do
+        expect( match(
+          /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
+          "I can cancel the 1st slide upload")
+        ).to eq(["I", "can", 1, "slide"])
+      end
+
+      it "matches capture group nested in optional one" do
+        regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
+        expect( match(regexp, 'a purchase') ).to eq([nil, nil])
+        expect( match(regexp, 'a purchase for $33') ).to eq([nil, 33])
+        expect( match(regexp, 'a pre buyer fee model purchase') ).to eq(['pre buyer fee model ', nil])
+      end
+
+      it "works with escaped parenthesis" do
+        expect( match(/Across the line\(s\)/, 'Across the line(s)') ).to eq([])
+      end
+
+      it "exposes source and regexp" do
+        regexp = /I have (\d+) cukes? in my (\+) now/
+        expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
+        expect(expression.regexp).to eq(regexp)
+        expect(expression.source).to eq(regexp.source)
+      end
+
+      def match(expression, text)
+        regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
+        arguments = regular_expression.match(text)
+        return nil if arguments.nil?
+        arguments.map { |arg| arg.value(nil) }
+      end
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -0,0 +1,133 @@
+require 'cucumber/cucumber_expressions/tree_regexp'
+
+module Cucumber
+  module CucumberExpressions
+    describe TreeRegexp do
+      it 'exposes group source' do
+        tr = TreeRegexp.new(/(a(?:b)?)(c)/)
+        expect(tr.group_builder.children.map{|gb| gb.source}).to eq(['a(?:b)?', 'c'])
+      end
+
+      it 'builds tree' do
+        tr = TreeRegexp.new(/(a(?:b)?)(c)/)
+        group = tr.match('ac')
+        expect(group.value).to eq('ac')
+        expect(group.children[0].value).to eq('a')
+        expect(group.children[0].children).to eq([])
+        expect(group.children[1].value).to eq('c')
+      end
+
+      it 'ignores `?:` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(?:b)(c)/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'ignores `?!` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(?!b)(.+)/)
+        group = tr.match('aBc')
+        expect(group.value).to eq('aBc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'ignores `?=` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(?=b)(.+)$/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children[0].value).to eq('bc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'ignores `?<=` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(.+)(?<=c)$/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children[0].value).to eq('bc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'ignores `?<!` as a non-capturing group' do
+        tr = TreeRegexp.new(/a(.+)(?<!b)$/)
+        group = tr.match('abc')
+        expect(group.value).to eq('abc')
+        expect(group.children[0].value).to eq('bc')
+        expect(group.children.length).to eq 1
+      end
+
+      it 'matches optional group' do
+        tr = TreeRegexp.new(/^Something( with an optional argument)?/)
+        group = tr.match('Something')
+        expect(group.children[0].value).to eq(nil)
+      end
+
+      it 'matches nested groups' do
+        tr = TreeRegexp.new(/^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))/)
+        group = tr.match('A 5 thick line from 10,20,30 to 40,50,60')
+
+        expect(group.children[0].value).to eq('5')
+        expect(group.children[1].value).to eq('10,20,30')
+        expect(group.children[1].children[0].value).to eq('10')
+        expect(group.children[1].children[1].value).to eq('20')
+        expect(group.children[1].children[2].value).to eq('30')
+        expect(group.children[2].value).to eq('40,50,60')
+        expect(group.children[2].children[0].value).to eq('40')
+        expect(group.children[2].children[1].value).to eq('50')
+        expect(group.children[2].children[2].value).to eq('60')
+      end
+
+      it 'detects multiple non capturing groups' do
+        tr = TreeRegexp.new(/(?:a)(:b)(\?c)(d)/)
+        group = tr.match("a:b?cd")
+        expect(group.children.length).to eq(3)
+      end
+
+      it 'works with escaped backslash' do
+        tr = TreeRegexp.new(/foo\\(bar|baz)/)
+        group = tr.match("foo\\bar")
+        expect(group.children.length).to eq(1)
+      end
+
+      it 'works with escaped slash' do
+        tr = TreeRegexp.new(/^I go to '\/(.+)'$/)
+        group = tr.match("I go to '/hello'")
+        expect(group.children.length).to eq(1)
+      end
+
+      it 'works with digit and word' do
+        tr = TreeRegexp.new(/^(\d) (\w+)$/)
+        group = tr.match("2 you")
+        expect(group.children.length).to eq(2)
+      end
+
+      it 'captures non capturing groups with capturing groups inside' do
+        tr = TreeRegexp.new(/the stdout(?: from "(.*?)")?/)
+        group = tr.match("the stdout")
+        expect(group.value).to eq("the stdout")
+        expect(group.children[0].value).to eq(nil)
+        expect(group.children.length).to eq(1)
+      end
+
+      it 'works with flags' do
+        tr = TreeRegexp.new(/HELLO/i)
+        group = tr.match("hello")
+        expect(group.value).to eq("hello")
+      end
+
+      it('does not consider parenthesis in character class as group') do
+        tr = TreeRegexp.new(/^drawings: ([A-Z_, ()]+)$/)
+        group = tr.match('drawings: ONE, TWO(ABC)')
+        expect(group.value).to eq('drawings: ONE, TWO(ABC)')
+        expect(group.children[0].value).to eq('ONE, TWO(ABC)')
+        expect(group.children.length).to eq(1)
+      end
+
+      it 'throws an error when there are named capture groups because they are buggy in Ruby' do
+        # https://github.com/cucumber/cucumber/issues/329
+        expect {
+          TreeRegexp.new(/^I am a person( named "(?<first_name>.+) (?<last_name>.+)")?$/)
+        }.to raise_error(/Named capture groups are not supported/)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-cucumber-expressions
+version: !ruby/object:Gem::Version
+  version: 8.3.1
+platform: ruby
+authors:
+- Aslak Hellesøy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-10 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 Expressions - a simpler alternative to Regular Expressions
+email: cukes@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/ISSUE_TEMPLATE.md"
+- ".github/PULL_REQUEST_TEMPLATE.md"
+- ".rspec"
+- ".rsync"
+- ".subrepo"
+- Gemfile
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- cucumber-cucumber-expressions.gemspec
+- default.mk
+- examples.txt
+- lib/cucumber/cucumber_expressions/argument.rb
+- lib/cucumber/cucumber_expressions/combinatorial_generated_expression_factory.rb
+- lib/cucumber/cucumber_expressions/cucumber_expression.rb
+- lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb
+- lib/cucumber/cucumber_expressions/errors.rb
+- lib/cucumber/cucumber_expressions/generated_expression.rb
+- lib/cucumber/cucumber_expressions/group.rb
+- lib/cucumber/cucumber_expressions/group_builder.rb
+- lib/cucumber/cucumber_expressions/parameter_type.rb
+- lib/cucumber/cucumber_expressions/parameter_type_matcher.rb
+- lib/cucumber/cucumber_expressions/parameter_type_registry.rb
+- lib/cucumber/cucumber_expressions/regular_expression.rb
+- lib/cucumber/cucumber_expressions/tree_regexp.rb
+- scripts/update-gemspec
+- spec/capture_warnings.rb
+- spec/coverage.rb
+- spec/cucumber/cucumber_expressions/argument_spec.rb
+- spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
+- spec/cucumber/cucumber_expressions/expression_examples_spec.rb
+- spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
+- spec/cucumber/cucumber_expressions/parameter_type_spec.rb
+- spec/cucumber/cucumber_expressions/regular_expression_spec.rb
+- spec/cucumber/cucumber_expressions/tree_regexp_spec.rb
+homepage: https://github.com/cucumber/cucumber-expressions-ruby#readme
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/cucumber/cucumber/issues
+  changelog_uri: https://github.com/cucumber/cucumber/blob/master/cucumber-expressions/CHANGELOG.md
+  documentation_uri: https://cucumber.io/docs/cucumber/cucumber-expressions/
+  mailing_list_uri: https://groups.google.com/forum/#!forum/cukes
+  source_code_uri: https://github.com/cucumber/cucumber/blob/master/cucumber-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: '2.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-expressions-8.3.1
+test_files:
+- spec/capture_warnings.rb
+- spec/coverage.rb
+- spec/cucumber/cucumber_expressions/argument_spec.rb
+- spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
+- spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
+- spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
+- spec/cucumber/cucumber_expressions/expression_examples_spec.rb
+- spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
+- spec/cucumber/cucumber_expressions/parameter_type_spec.rb
+- spec/cucumber/cucumber_expressions/regular_expression_spec.rb
+- spec/cucumber/cucumber_expressions/tree_regexp_spec.rb