cucumber-cucumber-expressions 8.3.1

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -0,0 +1,105 @@
+require 'cucumber/cucumber_expressions/parameter_type_matcher'
+require 'cucumber/cucumber_expressions/generated_expression'
+require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
+
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpressionGenerator
+      def initialize(parameter_type_registry)
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      def generate_expression(text)
+        generate_expressions(text)[0]
+      end
+
+      def generate_expressions(text)
+        parameter_type_combinations = []
+        parameter_type_matchers = create_parameter_type_matchers(text)
+        expression_template = ""
+        pos = 0
+
+        loop do
+          matching_parameter_type_matchers = []
+          parameter_type_matchers.each do |parameter_type_matcher|
+            advanced_parameter_type_matcher = parameter_type_matcher.advance_to(pos)
+            if advanced_parameter_type_matcher.find
+              matching_parameter_type_matchers.push(advanced_parameter_type_matcher)
+            end
+          end
+
+          if matching_parameter_type_matchers.any?
+            matching_parameter_type_matchers = matching_parameter_type_matchers.sort
+            best_parameter_type_matcher = matching_parameter_type_matchers[0]
+            best_parameter_type_matchers = matching_parameter_type_matchers.select do |m|
+              (m <=> best_parameter_type_matcher).zero?
+            end
+
+            # Build a list of parameter types without duplicates. The reason there
+            # might be duplicates is that some parameter types have more than one regexp,
+            # which means multiple ParameterTypeMatcher objects will have a reference to the
+            # same ParameterType.
+            # We're sorting the list so prefer_for_regexp_match parameter types are listed first.
+            # Users are most likely to want these, so they should be listed at the top.
+            parameter_types = []
+            best_parameter_type_matchers.each do |parameter_type_matcher|
+              unless parameter_types.include?(parameter_type_matcher.parameter_type)
+                parameter_types.push(parameter_type_matcher.parameter_type)
+              end
+            end
+            parameter_types.sort!
+
+            parameter_type_combinations.push(parameter_types)
+
+            expression_template += escape(text.slice(pos...best_parameter_type_matcher.start))
+            expression_template += "{%s}"
+
+            pos = best_parameter_type_matcher.start + best_parameter_type_matcher.group.length
+          else
+            break
+          end
+
+          if pos >= text.length
+            break
+          end
+        end
+
+        expression_template += escape(text.slice(pos..-1))
+
+        CombinatorialGeneratedExpressionFactory.new(
+          expression_template,
+          parameter_type_combinations
+        ).generate_expressions
+      end
+
+    private
+
+      def create_parameter_type_matchers(text)
+        parameter_matchers = []
+        @parameter_type_registry.parameter_types.each do |parameter_type|
+          if parameter_type.use_for_snippets?
+            parameter_matchers += create_parameter_type_matchers2(parameter_type, text)
+          end
+        end
+        parameter_matchers
+      end
+
+      def create_parameter_type_matchers2(parameter_type, text)
+        result = []
+        regexps = parameter_type.regexps
+        regexps.each do |regexp|
+          regexp = Regexp.new("(#{regexp})")
+          result.push(ParameterTypeMatcher.new(parameter_type, regexp, text, 0))
+        end
+        result
+      end
+
+      def escape(s)
+        s.gsub(/%/, '%%')
+        .gsub(/\(/, '\\(')
+        .gsub(/\{/, '\\{')
+        .gsub(/\//, '\\/')
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/errors.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  module CucumberExpressions
+    class CucumberExpressionError < StandardError
+    end
+
+    class UndefinedParameterTypeError < CucumberExpressionError
+      def initialize(type_name)
+        super("Undefined parameter type {#{type_name}}")
+      end
+    end
+
+    class AmbiguousParameterTypeError < CucumberExpressionError
+      def initialize(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
+        super(<<-EOM)
+Your Regular Expression /#{expression_regexp.source}/
+matches multiple parameter types with regexp /#{parameter_type_regexp}/:
+   #{parameter_type_names(parameter_types)}
+
+I couldn't decide which one to use. You have two options:
+
+1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
+   #{expressions(generated_expressions)}
+
+2) Make one of the parameter types preferential and continue to use a Regular Expression.
+
+        EOM
+      end
+
+      private
+
+      def parameter_type_names(parameter_types)
+        parameter_types.map{|p| "{#{p.name}}"}.join("\n   ")
+      end
+
+      def expressions(generated_expressions)
+        generated_expressions.map{|ge| ge.source}.join("\n   ")
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/generated_expression.rb

@@ -0,0 +1,31 @@
+module Cucumber
+  module CucumberExpressions
+    class GeneratedExpression
+      attr_reader :parameter_types
+
+      def initialize(expression_template, parameters_types)
+        @expression_template, @parameter_types = expression_template, parameters_types
+      end
+
+      def source
+        sprintf(@expression_template, *@parameter_types.map(&:name))
+      end
+
+      def parameter_names
+        usage_by_type_name = Hash.new(0)
+        @parameter_types.map do |t|
+          get_parameter_name(t.name, usage_by_type_name)
+        end
+      end
+
+      private
+
+      def get_parameter_name(type_name, usage_by_type_name)
+        count = usage_by_type_name[type_name]
+        count += 1
+        usage_by_type_name[type_name] = count
+        count == 1 ? type_name : "#{type_name}#{count}"
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/group.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module CucumberExpressions
+    class Group
+      attr_reader :value, :start, :end, :children
+
+      def initialize(value, start, _end, children)
+        @value = value
+        @start = start
+        @end = _end
+        @children = children
+      end
+
+      def values
+        (children.empty? ? [self] : children).map(&:value).compact
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -0,0 +1,42 @@
+require 'cucumber/cucumber_expressions/group'
+
+module Cucumber
+  module CucumberExpressions
+    class GroupBuilder
+      attr_accessor :source
+
+      def initialize
+        @group_builders = []
+        @capturing = true
+      end
+
+      def add(group_builder)
+        @group_builders.push(group_builder)
+      end
+
+      def build(match, group_indices)
+        group_index = group_indices.next
+        children = @group_builders.map {|gb| gb.build(match, group_indices)}
+        Group.new(match[group_index], match.offset(group_index)[0], match.offset(group_index)[1], children)
+      end
+
+      def set_non_capturing!
+        @capturing = false
+      end
+
+      def capturing?
+        @capturing
+      end
+
+      def move_children_to(group_builder)
+        @group_builders.each do |child|
+          group_builder.add(child)
+        end
+      end
+
+      def children
+        @group_builders
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -0,0 +1,81 @@
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    class ParameterType
+      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/
+      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/
+
+      attr_reader :name, :type, :regexps
+
+      def self.check_parameter_type_name(type_name)
+        unescaped_type_name = type_name.gsub(UNESCAPE_PATTERN) do
+          $2
+        end
+        if ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name
+          raise CucumberExpressionError.new("Illegal character '#{$1}' in parameter name {#{unescaped_type_name}}")
+        end
+      end
+
+      def prefer_for_regexp_match?
+        @prefer_for_regexp_match
+      end
+
+      def use_for_snippets?
+        @use_for_snippets
+      end
+
+      # Create a new Parameter
+      #
+      # @param name the name of the parameter type
+      # @param regexp [Array] list of regexps for capture groups. A single regexp can also be used
+      # @param type the return type of the transformed
+      # @param transformer lambda that transforms a String to (possibly) another type
+      # @param use_for_snippets true if this should be used for snippet generation
+      # @param prefer_for_regexp_match true if this should be preferred over similar types
+      #
+      def initialize(name, regexp, type, transformer, use_for_snippets, prefer_for_regexp_match)
+        raise "regexp can't be nil" if regexp.nil?
+        raise "type can't be nil" if type.nil?
+        raise "transformer can't be nil" if transformer.nil?
+        raise "use_for_snippets can't be nil" if use_for_snippets.nil?
+        raise "prefer_for_regexp_match can't be nil" if prefer_for_regexp_match.nil?
+
+        self.class.check_parameter_type_name(name) unless name.nil?
+        @name, @type, @transformer, @use_for_snippets, @prefer_for_regexp_match = name, type, transformer, use_for_snippets, prefer_for_regexp_match
+        @regexps = string_array(regexp)
+      end
+
+      def transform(self_obj, group_values)
+        self_obj.instance_exec(*group_values, &@transformer)
+      end
+
+      def <=>(other)
+        return -1 if prefer_for_regexp_match? && !other.prefer_for_regexp_match?
+        return 1 if other.prefer_for_regexp_match? && !prefer_for_regexp_match?
+        return name <=> other.name
+      end
+
+      private
+
+      def string_array(regexps)
+        array = regexps.is_a?(Array) ? regexps : [regexps]
+        array.map {|regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp)}
+      end
+
+      def regexp_source(regexp)
+        [
+          'EXTENDED',
+          'IGNORECASE',
+          'MULTILINE'
+        ].each do |option_name|
+          option = Regexp.const_get(option_name)
+          if regexp.options & option != 0
+            raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}")
+          end
+        end
+        regexp.source
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/parameter_type_matcher.rb

@@ -0,0 +1,59 @@
+module Cucumber
+  module CucumberExpressions
+    class ParameterTypeMatcher
+      attr_reader :parameter_type
+
+      def initialize(parameter_type, regexp, text, match_position=0)
+        @parameter_type, @regexp, @text = parameter_type, regexp, text
+        @match = @regexp.match(@text, match_position)
+      end
+
+      def advance_to(new_match_position)
+        (new_match_position...@text.length).each {|advancedPos|
+          matcher = self.class.new(parameter_type, @regexp, @text, advancedPos)
+          if matcher.find && matcher.full_word?
+            return matcher
+          end
+        }
+
+        self.class.new(parameter_type, @regexp, @text, @text.length)
+      end
+
+      def find
+        !@match.nil? && !group.empty?
+      end
+
+      def full_word?
+        space_before_match_or_sentence_start? && space_after_match_or_sentence_end?
+      end
+
+      def start
+        @match.begin(0)
+      end
+
+      def group
+        @match.captures[0]
+      end
+
+      def <=>(other)
+        pos_comparison = start <=> other.start
+        return pos_comparison if pos_comparison != 0
+        length_comparison = other.group.length <=> group.length
+        return length_comparison if length_comparison != 0
+        0
+      end
+
+      private
+
+      def space_before_match_or_sentence_start?
+        match_begin = @match.begin(0)
+        match_begin == 0 || @text[match_begin - 1].match(/\s|\p{P}/)
+      end
+
+      def space_after_match_or_sentence_end?
+        match_end = @match.end(0)
+        match_end == @text.length || @text[match_end].match(/\s|\p{P}/)
+      end
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -0,0 +1,70 @@
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+
+module Cucumber
+  module CucumberExpressions
+    class ParameterTypeRegistry
+      INTEGER_REGEXPS = [/-?\d+/, /\d+/]
+      FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?/
+      WORD_REGEXP = /[^\s]+/
+      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/
+      ANONYMOUS_REGEXP = /.*/
+
+      def initialize
+        @parameter_type_by_name = {}
+        @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
+
+        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, true, true))
+        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, true, false))
+        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, lambda {|s = nil| s}, false, false))
+        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda {|s = nil| s && s.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
+        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, lambda {|s = nil| s}, false, true))
+      end
+
+      def lookup_by_type_name(name)
+        @parameter_type_by_name[name]
+      end
+
+      def lookup_by_regexp(parameter_type_regexp, expression_regexp, text)
+        parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
+        return nil if parameter_types.nil?
+        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match?
+          # We don't do this check on insertion because we only want to restrict
+          # ambiguity when we look up by Regexp. Users of CucumberExpression should
+          # not be restricted.
+          generated_expressions = CucumberExpressionGenerator.new(self).generate_expressions(text)
+          raise AmbiguousParameterTypeError.new(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
+        end
+        parameter_types.first
+      end
+
+      def parameter_types
+        @parameter_type_by_name.values
+      end
+
+      def define_parameter_type(parameter_type)
+        if parameter_type.name != nil
+          if @parameter_type_by_name.has_key?(parameter_type.name)
+            if parameter_type.name.length == 0
+              raise CucumberExpressionError.new("The anonymous parameter type has already been defined")
+            else
+              raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
+            end
+          end
+          @parameter_type_by_name[parameter_type.name] = parameter_type
+        end
+
+        parameter_type.regexps.each do |parameter_type_regexp|
+          parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
+          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match? && parameter_type.prefer_for_regexp_match?
+            raise CucumberExpressionError.new("There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two preferential parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+          end
+          parameter_types.push(parameter_type)
+          parameter_types.sort!
+        end
+      end
+
+    end
+  end
+end