cucumber-cucumber-expressions 8.3.1

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -0,0 +1,48 @@
+require 'cucumber/cucumber_expressions/argument'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/tree_regexp'
+
+module Cucumber
+  module CucumberExpressions
+    class RegularExpression
+
+      def initialize(expression_regexp, parameter_type_registry)
+        @expression_regexp = expression_regexp
+        @parameter_type_registry = parameter_type_registry
+        @tree_regexp = TreeRegexp.new(@expression_regexp)
+      end
+
+      def match(text)
+        parameter_types = @tree_regexp.group_builder.children.map do |group_builder|
+          parameter_type_regexp = group_builder.source
+          @parameter_type_registry.lookup_by_regexp(
+            parameter_type_regexp,
+            @expression_regexp,
+            text
+          ) || ParameterType.new(
+            nil,
+            parameter_type_regexp,
+            String,
+            lambda {|*s| s[0]},
+            false,
+            false
+          )
+        end
+
+        Argument.build(@tree_regexp, text, parameter_types)
+      end
+
+      def regexp
+        @expression_regexp
+      end
+
+      def source
+        @expression_regexp.source
+      end
+
+      def to_s
+        regexp.inspect
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -0,0 +1,76 @@
+require 'cucumber/cucumber_expressions/group_builder'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    class TreeRegexp
+      attr_reader :regexp, :group_builder
+
+      def initialize(regexp)
+        @regexp = regexp.is_a?(Regexp) ? regexp : Regexp.new(regexp)
+        @stack = [GroupBuilder.new]
+        group_start_stack = []
+        last = nil
+        escaping = false
+        @non_capturing_maybe = false
+        @name_capturing_maybe = false
+        char_class = false
+
+        @regexp.source.each_char.with_index do |c, n|
+          if c == '[' && !escaping
+            char_class = true
+          elsif c == ']' && !escaping
+            char_class = false
+          elsif c == '(' && !escaping && !char_class
+            @stack.push(GroupBuilder.new)
+            group_start_stack.push(n + 1)
+            @non_capturing_maybe = false
+          elsif c == ')' && !escaping && !char_class
+            gb = @stack.pop
+            group_start = group_start_stack.pop
+            if gb.capturing?
+              gb.source = @regexp.source[group_start...n]
+              @stack.last.add(gb)
+            else
+              gb.move_children_to(@stack.last)
+            end
+            end_group
+          elsif c == '?' && last == '('
+            @non_capturing_maybe = true
+          elsif (c == '<') && @non_capturing_maybe
+            @name_capturing_maybe = true
+          elsif (c == ':' || c == '!' || c == '=') && last == '?' && @non_capturing_maybe
+            end_non_capturing_group
+          elsif (c == '=' || c == '!') && last == '<' && @name_capturing_maybe
+            end_non_capturing_group
+          elsif @name_capturing_maybe
+            raise CucumberExpressionError.new("Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329")
+          end
+
+          escaping = c == '\\' && !escaping
+          last = c
+        end
+        @group_builder = @stack.pop
+      end
+
+      def match(s)
+        match = @regexp.match(s)
+        return nil if match.nil?
+        group_indices = (0..match.length).to_a.to_enum
+        @group_builder.build(match, group_indices)
+      end
+
+      private
+
+      def end_non_capturing_group
+        @stack.last.set_non_capturing!
+        end_group
+      end
+
+      def end_group
+        @non_capturing_maybe = false
+        @name_capturing_maybe = false
+      end
+    end
+  end
+end

data/scripts/update-gemspec

@@ -0,0 +1,32 @@
+#!/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

@@ -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/cucumber/cucumber_expressions/argument_spec.rb

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

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

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