cucumber-cucumber-expressions 8.3.1 → 19.0.0

data/default.mk

@@ -1,70 +0,0 @@
-SHELL := /usr/bin/env bash
-RUBY_SOURCE_FILES = $(shell find . -name "*.rb")
-GEMSPEC = $(shell find . -name "*.gemspec")
-LIBNAME := $(shell basename $$(dirname $$(pwd)))
-GEM := cucumber-$(LIBNAME)-$(NEW_VERSION).gem
-
-default: .tested
-.PHONY: default
-
-.deps: Gemfile.lock
-	touch $@
-
-Gemfile.lock: Gemfile $(GEMSPEC)
-	bundle install
-	touch $@
-
-.tested: .deps $(RUBY_SOURCE_FILES)
-	bundle exec rspec --color
-	touch $@
-
-update-dependencies:
-	./scripts/update-gemspec
-.PHONY: update-dependencies
-
-ifdef NEW_VERSION
-ifneq (,$(GEMSPEC))
-gem: $(GEM)
-else
-gem:
-	@echo "Not building gem because there is no gemspec"
-endif
-endif
-.PHONY: gem
-
-$(GEM): clean .tested
-	gem build $(GEMSPEC)
-	test -s "$(GEM)" || { echo "Gem not built: $(GEM)"; exit 1; }
-
-pre-release: update-version update-dependencies gem
-.PHONY: pre-release
-
-update-version:
-ifdef NEW_VERSION
-ifneq (,$(GEMSPEC))
-	sed -i "s/\(s\.version *= *'\)[0-9]*\.[0-9]*\.[0-9]*\('\)/\1$(NEW_VERSION)\2/" $(GEMSPEC)
-endif
-else
-	@echo -e "\033[0;31mNEW_VERSION is not defined. Can't update version :-(\033[0m"
-	exit 1
-endif
-.PHONY: update-version
-
-publish: gem
-ifneq (,$(GEMSPEC))
-	gem push $(GEM)
-else
-	@echo "Not publishing because there is no gemspec"
-endif
-.PHONY: publish
-
-post-release:
-	@echo "No post-release needed for ruby"
-.PHONY: post-release
-
-clean: clean-ruby
-.PHONY: clean
-
-clean-ruby:
-	rm -f .deps .linked .tested* Gemfile.lock *.gem
-.PHONY: clean-ruby

data/examples.txt

@@ -1,31 +0,0 @@
-I have {int} cuke(s)
-I have 22 cukes
-[22]
----
-I have {int} cuke(s) and some \[]^$.|?*+
-I have 1 cuke and some \[]^$.|?*+
-[1]
----
-/I have (\d+) cukes? in my (\w+) now/
-I have 22 cukes in my belly now
-[22,"belly"]
----
-/I have (-?\d+) cukes? in my (.*) now/
-I have 1 cuke in my belly now
-[1,"belly"]
----
-/^Something( with an optional argument)?$/
-Something
-[null]
----
-Привет, {word}!
-Привет, Мир!
-["Мир"]
----
-/I have (.*) cukes? in my (.*) now/
-I have 22 cukes in my belly now
-["22","belly"]
----
-I have {} cuke(s) in my {} now
-I have 22 cukes in my belly now
-["22","belly"]

data/scripts/update-gemspec

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-#
-# Updates the *.gemspec in the current directory to use the latest releases of gems
-#
-set -uf -o pipefail
-IFS=$'\n'
-
-gemspec=$(find . -type f -maxdepth 1 -name "*.gemspec")
-if [ "${gemspec}" = "" ]; then
-  exit 0
-fi
-add_dependency_lines=$(cat ${gemspec} | grep "s.add_[a-z_]*dependency '[^']*'")
-if [ $? -ne 0 ]; then
-  # No add_dependency_lines found - nothing to do
-  exit 0
-fi
-
-set -e
-
-gems=$(echo "${add_dependency_lines}" | tr -s ' ' | cut -d ' ' -f3 | cut -d"'" -f 2)
-while read -r gem; do
-  echo "upgrading ${gem}"
-  if [ "${gem}" = "bundler" ]; then
-    cat "${gemspec}" | sed "s/\(s.add_[a-z_]*dependency\) '${gem}'.*/\1 '${gem}', '>= 1.16.2'/" > ${gemspec}.tmp
-  else
-    gem_line=$(gem list "${gem}" --remote --all --no-prerelease | grep "^${gem}\s")
-    latest_patch_version=$(echo "${gem_line}" | cut -d'(' -f2 | cut -d')' -f1 | cut -d',' -f1 | cut -d' ' -f1)
-    latest_minor_version=$(echo "${latest_patch_version}" | cut -d. -f1,2)
-    cat "${gemspec}" | sed "s/\(s.add_[a-z_]*dependency\) '${gem}'.*/\1 '${gem}', '~> ${latest_minor_version}', '>= ${latest_patch_version}'/" > ${gemspec}.tmp
-  fi
-  mv ${gemspec}.tmp ${gemspec}
-done <<< "${gems}"

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/coverage.rb

@@ -1,7 +0,0 @@
-# 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/cucumber/cucumber_expressions/argument_spec.rb

@@ -1,17 +0,0 @@
-require 'cucumber/cucumber_expressions/argument'
-require 'cucumber/cucumber_expressions/tree_regexp'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe Argument do
-      it 'exposes parameter_type' do
-        tree_regexp = TreeRegexp.new(/three (.*) mice/)
-        parameter_type_registry = ParameterTypeRegistry.new
-        arguments = Argument.build(tree_regexp, "three blind mice", [parameter_type_registry.lookup_by_type_name("string")])
-        argument = arguments[0]
-        expect(argument.parameter_type.name).to eq("string")
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb

@@ -1,43 +0,0 @@
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
-
-module Cucumber
-  module CucumberExpressions
-
-    class Color; end
-    class CssColor; end
-    class Date; end
-    class DateTime; end
-    class Timestamp; end
-
-    describe CombinatorialGeneratedExpressionFactory do
-      it 'generates multiple expressions' do
-        parameter_type_combinations = [
-          [
-            ParameterType.new('color', /red|blue|yellow/, Color, lambda {|s| Color.new}, true, false),
-            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, lambda {|s| CssColor.new}, true, false)
-          ],
-          [
-            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, lambda {|s| Date.new}, true, false),
-            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, lambda {|s| DateTime.new}, true, false),
-            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, lambda {|s| Timestamp.new}, true, false)
-          ]
-        ]
-
-        factory = CombinatorialGeneratedExpressionFactory.new(
-          'I bought a {%s} ball on {%s}',
-          parameter_type_combinations
-        )
-        expressions = factory.generate_expressions.map {|ge| ge.source}
-        expect(expressions).to eq([
-            'I bought a {color} ball on {date}',
-            'I bought a {color} ball on {datetime}',
-            'I bought a {color} ball on {timestamp}',
-            'I bought a {csscolor} ball on {date}',
-            'I bought a {csscolor} ball on {datetime}',
-            'I bought a {csscolor} ball on {timestamp}',
-        ])
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -1,231 +0,0 @@
-require 'cucumber/cucumber_expressions/cucumber_expression_generator'
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpressionGenerator do
-      class Currency
-      end
-
-      before do
-        @parameter_type_registry = ParameterTypeRegistry.new
-        @generator = CucumberExpressionGenerator.new(@parameter_type_registry)
-      end
-
-      it "documents expression generation" do
-        parameter_registry = ParameterTypeRegistry.new
-        ### [generate-expression]
-        generator = CucumberExpressionGenerator.new(parameter_registry)
-        undefined_step_text = "I have 2 cucumbers and 1.5 tomato"
-        generated_expression = generator.generate_expression(undefined_step_text)
-        expect(generated_expression.source).to eq("I have {int} cucumbers and {float} tomato")
-        expect(generated_expression.parameter_types[1].type).to eq(Float)
-        ### [generate-expression]
-      end
-
-      it "generates expression for no args" do
-        assert_expression("hello", [], "hello")
-      end
-
-      it "generates expression with escaped left parenthesis" do
-        assert_expression(
-          "\\(iii)", [],
-          "(iii)")
-      end
-
-      it "generates expression with escaped left curly brace" do
-        assert_expression(
-          "\\{iii}", [],
-          "{iii}")
-      end
-
-      it "generates expression with escaped slashes" do
-        assert_expression(
-          "The {int}\\/{int}\\/{int} hey", ["int", "int2", "int3"],
-          "The 1814/05/17 hey")
-      end
-
-      it "generates expression for int float arg" do
-        assert_expression(
-          "I have {int} cukes and {float} euro", ["int", "float"],
-          "I have 2 cukes and 1.5 euro")
-      end
-
-      it "generates expression for strings" do
-        assert_expression(
-            "I like {string} and {string}", ["string", "string2"],
-            'I like "bangers" and \'mash\'')
-      end
-
-      it "generates expression with % sign" do
-        assert_expression(
-            "I am {int}% foobar", ["int"],
-            'I am 20% foobar')
-      end
-
-      it "generates expression for just int" do
-        assert_expression(
-          "{int}", ["int"],
-          "99999")
-      end
-
-      it "numbers only second argument when builtin type is not reserved keyword" do
-        assert_expression(
-          "I have {int} cukes and {int} euro", ["int", "int2"],
-          "I have 2 cukes and 5 euro")
-      end
-
-      it "numbers only second argument when type is not reserved keyword" do
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-          'currency',
-          '[A-Z]{3}',
-          Currency,
-          lambda {|s| Currency.new(s)},
-          true,
-          true
-        ))
-
-        assert_expression(
-          "I have a {currency} account and a {currency} account", ["currency", "currency2"],
-          "I have a EUR account and a GBP account")
-      end
-
-      it "exposes parameters in generated expression" do
-        expression = @generator.generate_expression("I have 2 cukes and 1.5 euro")
-        types = expression.parameter_types.map(&:type)
-        expect(types).to eq([Integer, Float])
-      end
-
-      it "matches parameter types with optional capture groups" do
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'optional-flight',
-            /(1st flight)?/,
-            String,
-            lambda {|s| s},
-            true,
-            false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'optional-hotel',
-            /(1 hotel)?/,
-            String,
-            lambda {|s| s},
-            true,
-            false
-        ))
-
-        expression = @generator.generate_expressions("I reach Stage 4: 1st flight -1 hotel")[0]
-        # While you would expect this to be `I reach Stage {int}: {optional-flight} -{optional-hotel}`
-        # the `-1` causes {int} to match just before {optional-hotel}.
-        expect(expression.source).to eq("I reach Stage {int}: {optional-flight} {int} hotel")
-      end
-
-      it "generates at most 256 expressions" do
-        for i in 0..3
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
-              "my-type-#{i}",
-              /([a-z] )*?[a-z]/,
-              String,
-              lambda {|s| s},
-              true,
-              false
-          ))
-        end
-        # This would otherwise generate 4^11=4194300 expressions and consume just shy of 1.5GB.
-        expressions = @generator.generate_expressions("a s i m p l e s t e p")
-        expect(expressions.length).to eq(256)
-      end
-
-      it "prefers expression with longest non empty match" do
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'zero-or-more',
-            /[a-z]*/,
-            String,
-            lambda {|s| s},
-            true,
-            false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'exactly-one',
-            /[a-z]/,
-            String,
-            lambda {|s| s},
-            true,
-            false
-        ))
-
-        expressions = @generator.generate_expressions("a simple step")
-        expect(expressions.length).to eq(2)
-        expect(expressions[0].source).to eq("{exactly-one} {zero-or-more} {zero-or-more}")
-        expect(expressions[1].source).to eq("{zero-or-more} {zero-or-more} {zero-or-more}")
-      end
-
-      context "does not suggest parameter when match is" do
-        before do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
-              'direction',
-              /(up|down)/,
-              String,
-              lambda {|s| s},
-              true,
-              false
-          ))
-        end
-
-        it "at the beginning of a word" do
-          expect(@generator.generate_expression("When I download a picture").source).not_to eq("When I {direction}load a picture")
-          expect(@generator.generate_expression("When I download a picture").source).to eq("When I download a picture")
-        end
-
-        it "inside a word" do
-          expect(@generator.generate_expression("When I watch the muppet show").source).not_to eq("When I watch the m{direction}pet show")
-          expect(@generator.generate_expression("When I watch the muppet show").source).to eq("When I watch the muppet show")
-        end
-
-        it "at the end of a word" do
-          expect(@generator.generate_expression("When I create a group").source).not_to eq("When I create a gro{direction}")
-          expect(@generator.generate_expression("When I create a group").source).to eq("When I create a group")
-        end
-      end
-
-      context "does suggest parameter when match is" do
-        before do
-          @parameter_type_registry.define_parameter_type(ParameterType.new(
-              'direction',
-              /(up|down)/,
-              String,
-              lambda {|s| s},
-              true,
-              false
-          ))
-        end
-
-        it "a full word" do
-          expect(@generator.generate_expression("When I go down the road").source).to eq("When I go {direction} the road")
-          expect(@generator.generate_expression("When I walk up the hill").source).to eq("When I walk {direction} the hill")
-          expect(@generator.generate_expression("up the hill, the road goes down").source).to eq("{direction} the hill, the road goes {direction}")
-        end
-
-        it 'wrapped around punctuation characters' do
-          expect(@generator.generate_expression("When direction is:down").source).to eq("When direction is:{direction}")
-          expect(@generator.generate_expression("Then direction is down.").source).to eq("Then direction is {direction}.")
-        end
-      end
-
-      def assert_expression(expected_expression, expected_argument_names, text)
-        generated_expression = @generator.generate_expression(text)
-        expect(generated_expression.parameter_names).to eq(expected_argument_names)
-        expect(generated_expression.source).to eq(expected_expression)
-
-        cucumber_expression = CucumberExpression.new(generated_expression.source, @parameter_type_registry)
-        match = cucumber_expression.match(text)
-        if match.nil?
-          raise "Expected text '#{text}' to match generated expression '#{generated_expression.source}'"
-        end
-        expect(match.length).to eq(expected_argument_names.length)
-      end
-    end
-  end
-end

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -1,57 +0,0 @@
-require 'cucumber/cucumber_expressions/cucumber_expression'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-
-module Cucumber
-  module CucumberExpressions
-    describe CucumberExpression do
-      context "Regexp translation" do
-        def assert_regexp(expression, regexp)
-          cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
-          expect(regexp).to eq(cucumber_expression.regexp)
-        end
-
-        it "translates no arguments" do
-          assert_regexp(
-            "I have 10 cukes in my belly now",
-            /^I have 10 cukes in my belly now$/
-          )
-        end
-
-        it "translates alternation" do
-          assert_regexp(
-            "I had/have a great/nice/charming friend",
-            /^I (?:had|have) a (?:great|nice|charming) friend$/
-          )
-        end
-
-        it "translates alternation with non-alpha" do
-          assert_regexp(
-            "I said Alpha1/Beta1",
-            /^I said (?:Alpha1|Beta1)$/
-          )
-        end
-
-        it "translates parameters" do
-          assert_regexp(
-            "I have {float} cukes at {int} o'clock",
-            /^I have ((?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?) cukes at ((?:-?\d+)|(?:\d+)) o'clock$/
-          )
-        end
-
-        it "translates parenthesis to non-capturing optional capture group" do
-          assert_regexp(
-            "I have many big(ish) cukes",
-            /^I have many big(?:ish)? cukes$/
-          )
-        end
-
-        it "translates parenthesis with alpha unicode" do
-          assert_regexp(
-            "Привет, Мир(ы)!",
-            /^Привет, Мир(?:ы)?!$/
-          )
-        end
-      end
-    end
-  end
-end