cucumber-expressions 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ec8564fdc53d2078266f3cfb82f7eb8db6e8957
-  data.tar.gz: 2bb4c9234813e74029bd93c6448ff41ae1a85abb
+  metadata.gz: 3f97682c81c4fc810b23bb199a01196191dba087
+  data.tar.gz: 7c29ceea697976f3de194014a9ff039f25478ffe
 SHA512:
-  metadata.gz: a3c592d0e6e4fad991e45fd27e1f54c466f418f204ba2f65f304c9f9400d9c5289b9472712e19a71637a71fedc762ccea4ef4bf3e00a7600d68dba2c02992dc4
-  data.tar.gz: 26195cf45a0624e6920e44fb1a6c99e05300603ec053be5cb13f99df70d55e48a98ecdfda78fb085cbeadaddc394ddceb2149bb244399d1bfde199ad498550d0
+  metadata.gz: e3a91aeeae161ea22e6114c17ed13b3160eec652de6927cc45241772dd7c8121d620558339db2eb992652da21fa788efd6645636629b259888d23f24acd615f3
+  data.tar.gz: 1f2ee3c5d76189bdf6c52c5bf86a2d485524ecaa2e8207cfe83d91ee7fafb1dda8c9f9d515ce6b8ee3326f59aa3d52a422da38dcf45be9c16e34483904b5cb1d

data/.rsync

@@ -0,0 +1,2 @@
+../../LICENSE LICENSE
+../examples.txt examples.txt

data/Makefile

@@ -1,12 +1,8 @@
-.PHONY: build
-build:
+default:
 	bundle install
 	bundle exec rake
+	bundle exec rake install
+.PHONY: default
 
-.PHONY: release
-release:
-	bundle install
-	bundle exec rake build release:guard_clean release:rubygem_push
-	version=$$(cat *.gemspec | grep -m 1 ".version *= *" | sed "s/.*= *'\([^']*\)'.*/\1/"); \
-	git tag --annotate v$$version --message "Release $$version"
-	git push --tags
+clean:
+.PHONY: clean

data/cucumber-expressions.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name        = 'cucumber-expressions'
-  s.version     = '3.0.0'
+  s.version     = '4.0.0'
   s.authors     = ["Aslak Hellesøy"]
   s.description = 'Cucumber Expressions - a simpler alternative to Regular Expressions'
   s.summary     = "cucumber-expressions-#{s.version}"

data/examples.txt

@@ -1,16 +1,12 @@
-I have {n} cuke(s) in my {bodypart} now
-I have 22 cukes in my belly now
-["22","belly"]
----
-I have {int} cuke(s) in my {bodypart} now
-I have 1 cuke in my belly now
-[1,"belly"]
+I have {int} cuke(s)
+I have 22 cukes
+[22]
 ---
-I have {int} cuke(s) and some \[]^$.|?*+ {something}
-I have 1 cuke and some \[]^$.|?*+ characters
-[1,"characters"]
+I have {int} cuke(s) and some \[]^$.|?*+
+I have 1 cuke and some \[]^$.|?*+
+[1]
 ---
-/I have (\d+) cukes? in my (.+) now/
+/I have (\d+) cukes? in my (\w+) now/
 I have 22 cukes in my belly now
 [22,"belly"]
 ---

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -1,14 +1,34 @@
+require 'cucumber/cucumber_expressions/group'
+require 'cucumber/cucumber_expressions/errors'
+
 module Cucumber
   module CucumberExpressions
     class Argument
-      attr_reader :offset, :value
+      def self.build(regexp, text, parameter_types)
+        m = regexp.match(text)
+        return nil if m.nil?
+
+        match_group = Group.new(m)
+        arg_groups = match_group.children
+
+        if arg_groups.length != parameter_types.length
+          raise CucumberExpressionException.new(
+              "Expression has #{arg_groups.length} arguments, but there were #{parameter_types.length} parameter types"
+          )
+        end
+
+        parameter_types.zip(arg_groups).map do |parameter_type, arg_group|
+          Argument.new(arg_group, parameter_type)
+        end
+      end
 
-      def initialize(offset, value, parameter_type)
-        @offset, @value, @parameter_type = offset, value, parameter_type
+      def initialize(group, parameter_type)
+        raise "WTF" if Array === group
+        @group, @parameter_type = group, parameter_type
       end
 
-      def transformed_value
-        @parameter_type.transform(@value)
+      def value
+        @parameter_type.transform(@group ? @group.values : nil)
       end
     end
   end

data/lib/cucumber/cucumber_expressions/combinatorial_generated_expression_factory.rb

@@ -0,0 +1,40 @@
+require('cucumber/cucumber_expressions/generated_expression')
+
+module Cucumber
+  module CucumberExpressions
+
+    class CombinatorialGeneratedExpressionFactory
+      def initialize(expression_template, parameter_type_combinations)
+        @expression_template = expression_template
+        @parameter_type_combinations = parameter_type_combinations
+      end
+
+      def generate_expressions
+        generated_expressions = []
+        generate_permutations(generated_expressions, 0, [])
+        generated_expressions
+      end
+
+      private
+
+      def generate_permutations(generated_expressions, depth, current_parameter_types)
+        if depth == @parameter_type_combinations.length
+          generated_expression = GeneratedExpression.new(@expression_template, current_parameter_types)
+          generated_expressions.push(generated_expression)
+          return
+        end
+
+        (0...@parameter_type_combinations[depth].length).each do |i|
+          new_current_parameter_types = current_parameter_types.dup # clone
+          new_current_parameter_types.push(@parameter_type_combinations[depth][i])
+          generate_permutations(
+              generated_expressions,
+              depth + 1,
+              new_current_parameter_types
+          )
+        end
+      end
+    end
+
+  end
+end

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,20 +1,20 @@
-require 'cucumber/cucumber_expressions/argument_builder'
+require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpression
-      PARAMETER_REGEXP = /\{([^}:]+)(:([^}]+))?}/
+      PARAMETER_REGEXP = /\{([^}]+)}/
       OPTIONAL_REGEXP = /\(([^)]+)\)/
       ALTERNATIVE_WORD_REGEXP = /([[:alpha:]]+)((\/[[:alpha:]]+)+)/
 
       attr_reader :source
 
-      def initialize(expression, types, parameter_type_registry)
+      def initialize(expression, parameter_type_registry)
         @source = expression
         @parameter_types = []
         regexp = "^"
-        type_index = 0
         match_offset = 0
 
         # Escape Does not include (){} because they have special meaning
@@ -31,28 +31,10 @@ module Cucumber
           match = PARAMETER_REGEXP.match(expression, match_offset)
           break if match.nil?
 
-          parameter_name = match[1]
-          parameter_type_name = match[3]
-          if parameter_type_name
-            $stderr.puts("Cucumber expression parameter syntax {#{parameter_name}:#{parameter_type_name}} is deprecated. Please use {#{parameter_type_name}} instead.")
-          end
+          type_name = match[1]
 
-          type = types.length <= type_index ? nil : types[type_index]
-          type_index += 1
-
-          parameter_type = nil
-          if type
-            parameter_type = parameter_type_registry.lookup_by_type(type)
-          end
-          if parameter_type.nil? && parameter_type_name
-            parameter_type = parameter_type_registry.lookup_by_name(parameter_type_name)
-          end
-          if parameter_type.nil?
-            parameter_type = parameter_type_registry.lookup_by_name(parameter_name)
-          end
-          if parameter_type.nil?
-            parameter_type = parameter_type_registry.create_anonymous_lookup(lambda {|s| s})
-          end
+          parameter_type = parameter_type_registry.lookup_by_type_name(type_name)
+          raise UndefinedParameterTypeError.new(type_name) if parameter_type.nil?
           @parameter_types.push(parameter_type)
 
           text = expression.slice(match_offset...match.offset(0)[0])
@@ -67,7 +49,7 @@ module Cucumber
       end
 
       def match(text)
-        ArgumentBuilder.build_arguments(@regexp, text, @parameter_types)
+        Argument.build(@regexp, text, @parameter_types)
       end
 
       private

data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb

@@ -1,5 +1,6 @@
 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
@@ -9,12 +10,13 @@ module Cucumber
       end
 
       def generate_expression(text)
-        parameter_names = []
-        parameter_type_matchers = create_parameter_type_matchers(text)
-        parameter_types = []
-        usage_by_name = Hash.new(0)
+        generate_expressions(text)[0]
+      end
 
-        expression = ""
+      def generate_expressions(text)
+        parameter_type_combinations = []
+        parameter_type_matchers = create_parameter_type_matchers(text)
+        expression_template = ""
         pos = 0
 
         loop do
@@ -29,14 +31,28 @@ module Cucumber
           if matching_parameter_type_matchers.any?
             matching_parameter_type_matchers = matching_parameter_type_matchers.sort
             best_parameter_type_matcher = matching_parameter_type_matchers[0]
-            parameter_type = best_parameter_type_matcher.parameter
-            parameter_types.push(parameter_type)
+            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_name = get_parameter_name(parameter_type.name, usage_by_name)
-            parameter_names.push(parameter_name)
+            parameter_type_combinations.push(parameter_types)
 
-            expression += text.slice(pos...best_parameter_type_matcher.start)
-            expression += "{#{parameter_type.name}}"
+            expression_template += text.slice(pos...best_parameter_type_matcher.start)
+            expression_template += "{%s}"
 
             pos = best_parameter_type_matcher.start + best_parameter_type_matcher.group.length
           else
@@ -48,21 +64,22 @@ module Cucumber
           end
         end
 
-        expression += text.slice(pos..-1)
-        GeneratedExpression.new(expression, parameter_names, parameter_types)
+        expression_template += text.slice(pos..-1)
+
+        CombinatorialGeneratedExpressionFactory.new(
+          expression_template,
+          parameter_type_combinations
+        ).generate_expressions
       end
 
     private
 
-      def get_parameter_name(name, usage_by_name)
-        count = (usage_by_name[name] += 1)
-        count == 1 ? name : "#{name}#{count}"
-      end
-
       def create_parameter_type_matchers(text)
         parameter_matchers = []
         @parameter_type_registry.parameter_types.each do |parameter_type|
-          parameter_matchers += create_parameter_type_matchers2(parameter_type, text)
+          if parameter_type.use_for_snippets?
+            parameter_matchers += create_parameter_type_matchers2(parameter_type, text)
+          end
         end
         parameter_matchers
       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 prefer_for_regexp_match 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

@@ -1,10 +1,30 @@
 module Cucumber
   module CucumberExpressions
     class GeneratedExpression
-      attr_reader :source, :parameter_names, :parameter_types
+      attr_reader :parameter_types
 
-      def initialize(source, parameter_names, parameters_types)
-        @source, @parameter_names, @parameter_types = source, parameter_names, parameters_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

data/lib/cucumber/cucumber_expressions/group.rb

@@ -0,0 +1,66 @@
+module Cucumber
+  module CucumberExpressions
+    class Group
+      attr_reader :children, :start, :end, :value
+
+      def initialize(*args)
+        @children = []
+
+        if MatchData === args[0]
+          match_data = args[0]
+          parse(match_data)
+        else
+          @start = args[0] || -1
+          @end = args[1] || -1
+          @value = args[2]
+        end
+      end
+
+      def contains?(group)
+        group.null? || (group.start >= @start && group.end <= @end)
+      end
+
+      def add(group)
+        @children.push(group)
+      end
+
+      def null?
+        @value.nil?
+      end
+
+      def values
+        (children.empty? ? [self] : children).map(&:value)
+      end
+
+      private
+
+      def parse(match_data)
+        if match_data.length == 1
+          @start = @end = -1
+          @value = nil
+          return
+        end
+
+        @start = match_data.offset(0)[0]
+        @end = match_data.offset(0)[1]
+        @value = match_data[0]
+
+        stack = []
+        stack.push(self)
+
+        (1...match_data.length).each do |group_index|
+          group = Group.new(
+              match_data.offset(group_index)[0],
+              match_data.offset(group_index)[1],
+              match_data[group_index]
+          )
+          while !stack.last.contains?(group)
+            stack.pop
+          end
+          stack.last.add(group)
+          stack.push(group)
+        end
+      end
+    end
+  end
+end