cucumber-expressions 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f97682c81c4fc810b23bb199a01196191dba087
-  data.tar.gz: 7c29ceea697976f3de194014a9ff039f25478ffe
+  metadata.gz: d24725b82e154836aede4e4bb39e1c80ec664f0b
+  data.tar.gz: 91b3cc77505a06fd4ae831217b1ffe0155d33c14
 SHA512:
-  metadata.gz: e3a91aeeae161ea22e6114c17ed13b3160eec652de6927cc45241772dd7c8121d620558339db2eb992652da21fa788efd6645636629b259888d23f24acd615f3
-  data.tar.gz: 1f2ee3c5d76189bdf6c52c5bf86a2d485524ecaa2e8207cfe83d91ee7fafb1dda8c9f9d515ce6b8ee3326f59aa3d52a422da38dcf45be9c16e34483904b5cb1d
+  metadata.gz: f0450cd7e01c19b67ebbb1e4611340de9507ff2b7680bc2e07ba3a7d23ac39a0c18e528165e1ae61db2140329b85a1c3d452c6823f27eaec8a9422d2f71add4c
+  data.tar.gz: 49566f903a663bbbdc91ac517fe3a94340f6b333b417d19d1b6834cc149ace78da849ed9c8629315e1c349638f49bb4ff71ae1a51e72de7bb773491fe0093686

data/cucumber-expressions.gemspec

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

data/lib/cucumber/cucumber_expressions/argument.rb

@@ -4,16 +4,17 @@ require 'cucumber/cucumber_expressions/errors'
 module Cucumber
   module CucumberExpressions
     class Argument
-      def self.build(regexp, text, parameter_types)
-        m = regexp.match(text)
-        return nil if m.nil?
+      attr_reader :group
 
-        match_group = Group.new(m)
-        arg_groups = match_group.children
+      def self.build(tree_regexp, text, parameter_types)
+        group = tree_regexp.match(text)
+        return nil if group.nil?
+
+        arg_groups = 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"
+          raise CucumberExpressionError.new(
+              "Expression #{tree_regexp.regexp.inspect} has #{arg_groups.length} capture groups (#{arg_groups.map(&:value)}), but there were #{parameter_types.length} parameter types (#{parameter_types.map(&:name)})"
           )
         end
 
@@ -23,7 +24,6 @@ module Cucumber
       end
 
       def initialize(group, parameter_type)
-        raise "WTF" if Array === group
         @group, @parameter_type = group, parameter_type
       end
 

data/lib/cucumber/cucumber_expressions/cucumber_expression.rb

@@ -1,11 +1,11 @@
 require 'cucumber/cucumber_expressions/argument'
-require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/tree_regexp'
 require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
     class CucumberExpression
-      PARAMETER_REGEXP = /\{([^}]+)}/
+      PARAMETER_REGEXP = /{([^}]+)}/
       OPTIONAL_REGEXP = /\(([^)]+)\)/
       ALTERNATIVE_WORD_REGEXP = /([[:alpha:]]+)((\/[[:alpha:]]+)+)/
 
@@ -14,7 +14,7 @@ module Cucumber
       def initialize(expression, parameter_type_registry)
         @source = expression
         @parameter_types = []
-        regexp = "^"
+        regexp = '^'
         match_offset = 0
 
         # Escape Does not include (){} because they have special meaning
@@ -38,23 +38,31 @@ module Cucumber
           @parameter_types.push(parameter_type)
 
           text = expression.slice(match_offset...match.offset(0)[0])
-          capture_regexp = regexp(parameter_type.regexps)
+          capture_regexp = build_capture_regexp(parameter_type.regexps)
           match_offset = match.offset(0)[1]
           regexp += text
           regexp += capture_regexp
         end
         regexp += expression.slice(match_offset..-1)
-        regexp += "$"
-        @regexp = Regexp.new(regexp)
+        regexp += '$'
+        @tree_regexp = TreeRegexp.new(regexp)
       end
 
       def match(text)
-        Argument.build(@regexp, text, @parameter_types)
+        Argument.build(@tree_regexp, text, @parameter_types)
+      end
+
+      def regexp
+        @tree_regexp.regexp
+      end
+
+      def to_s
+        @source.inspect
       end
 
       private
 
-      def regexp(regexps)
+      def build_capture_regexp(regexps)
         return "(#{regexps[0]})" if regexps.size == 1
         capture_groups = regexps.map { |group| "(?:#{group})" }
         "(#{capture_groups.join('|')})"

data/lib/cucumber/cucumber_expressions/errors.rb

@@ -21,7 +21,7 @@ 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.
+2) Make one of the parameter types preferential and continue to use a Regular Expression.
 
         EOM
       end

data/lib/cucumber/cucumber_expressions/group.rb

@@ -1,66 +1,18 @@
 module Cucumber
   module CucumberExpressions
     class Group
-      attr_reader :children, :start, :end, :value
+      attr_reader :value, :start, :end, :children
 
-      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?
+      def initialize(value, start, _end, children)
+        @value = value
+        @start = start
+        @end = _end
+        @children = children
       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

data/lib/cucumber/cucumber_expressions/group_builder.rb

@@ -0,0 +1,36 @@
+require 'cucumber/cucumber_expressions/group'
+
+module Cucumber
+  module CucumberExpressions
+    class GroupBuilder
+      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
+    end
+  end
+end

data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -6,7 +6,7 @@ module Cucumber
   module CucumberExpressions
     class ParameterTypeRegistry
       INTEGER_REGEXPS = [/-?\d+/, /\d+/]
-      FLOAT_REGEXP = /-?\d*\.?\d+/
+      FLOAT_REGEXP = /-?\d*\.\d+/
       WORD_REGEXP = /\w+/
       STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/
 
@@ -50,7 +50,7 @@ module Cucumber
         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 prefer_for_regexp_match parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two prefer_for_regexp_match parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+            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!

data/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -1,5 +1,6 @@
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/tree_regexp'
 
 module Cucumber
   module CucumberExpressions
@@ -9,6 +10,7 @@ module Cucumber
       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)
@@ -26,7 +28,7 @@ module Cucumber
           parameter_type = @parameter_type_registry.lookup_by_regexp(parameter_type_regexp, @expression_regexp, text)
           if parameter_type.nil?
             parameter_type = ParameterType.new(
-                '*',
+                parameter_type_regexp,
                 parameter_type_regexp,
                 String,
                 lambda {|s| s},
@@ -38,12 +40,20 @@ module Cucumber
           parameter_types.push(parameter_type)
         end
 
-        Argument.build(@expression_regexp, text, parameter_types)
+        Argument.build(@tree_regexp, text, parameter_types)
       end
 
-      def source
+      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,46 @@
+require 'cucumber/cucumber_expressions/group_builder'
+
+module Cucumber
+  module CucumberExpressions
+    class TreeRegexp
+      attr_reader :regexp
+
+      def initialize(regexp)
+        @regexp = regexp.is_a?(Regexp) ? regexp : Regexp.new(regexp)
+
+        stack = [GroupBuilder.new]
+        last = nil
+        non_capturing_maybe = false
+        @regexp.source.split('').each do |c|
+          if c == '(' && last != '\\'
+            stack.push(GroupBuilder.new)
+            non_capturing_maybe = false
+          elsif c == ')' && last != '\\'
+            gb = stack.pop
+            if gb.capturing?
+              stack.last.add(gb)
+            else
+              gb.move_children_to(stack.last)
+            end
+            non_capturing_maybe = false
+          elsif c == '?' && last == '('
+            non_capturing_maybe = true
+          elsif c == ':' && non_capturing_maybe
+            stack.last.set_non_capturing!
+            non_capturing_maybe = false
+          end
+          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
+
+    end
+  end
+end

data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
       context "Regexp translation" do
         def assert_regexp(expression, regexp)
           cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
-          expect(regexp).to eq(cucumber_expression.instance_variable_get('@regexp'))
+          expect(regexp).to eq(cucumber_expression.regexp)
         end
 
         it "translates no arguments" do
@@ -27,7 +27,7 @@ module Cucumber
         it "translates parameters" do
           assert_regexp(
             "I have {float} cukes at {int} o'clock",
-            /^I have (-?\d*\.?\d+) cukes at ((?:-?\d+)|(?:\d+)) o'clock$/
+            /^I have (-?\d*\.\d+) cukes at ((?:-?\d+)|(?:\d+)) o'clock$/
           )
         end
 

data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -28,7 +28,7 @@ module Cucumber
           @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 prefer_for_regexp_match parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two prefer_for_regexp_match parameter types, {name} and {place}"
+                   "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
 
@@ -76,7 +76,7 @@ module Cucumber
                        "   {place} and {person}\n" +
                        "   {place} and {place}\n" +
                        "\n" +
-                       "2) Make one of the parameter types prefer_for_regexp_match and continue to use a Regular Expression.\n" +
+                       "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" +
                        "\n"
                )
       end

data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -29,11 +29,11 @@ module Cucumber
       end
 
       it "transforms float without integer part" do
-        expect( match(/(-?\d*\.?\d+)/, ".22") ).to eq([0.22])
+        expect( match(/(-?\d*\.\d+)/, ".22") ).to eq([0.22])
       end
 
       it "transforms float with sign" do
-        expect( match(/(-?\d*\.?\d+)/, "-1.22") ).to eq([-1.22])
+        expect( match(/(-?\d*\.\d+)/, "-1.22") ).to eq([-1.22])
       end
 
       it "returns nil when there is no match" do
@@ -42,14 +42,16 @@ module Cucumber
 
       it "ignores non capturing groups" do
         expect( match(
-          /(\S+) ?(can|cannot)? (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
+          /(\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 "exposes source" do
-        expr = /I have (\d+) cukes? in my (\+) now/
-        expect(RegularExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
+      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)

data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

@@ -0,0 +1,60 @@
+require 'cucumber/cucumber_expressions/tree_regexp'
+
+module Cucumber
+  module CucumberExpressions
+    describe TreeRegexp do
+      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 non-capturing groups' 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 '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 '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
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-expressions
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Aslak Hellesøy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-28 00:00:00.000000000 Z
+date: 2017-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,10 +89,12 @@ files:
 - 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
 - spec/capture_warnings.rb
 - spec/coverage.rb
 - spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
@@ -101,9 +103,9 @@ files:
 - 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/group_spec.rb
 - spec/cucumber/cucumber_expressions/parameter_type_registry_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
@@ -128,7 +130,7 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: cucumber-expressions-4.0.0
+summary: cucumber-expressions-4.0.1
 test_files:
 - spec/capture_warnings.rb
 - spec/coverage.rb
@@ -138,6 +140,6 @@ test_files:
 - 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/group_spec.rb
 - spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
 - spec/cucumber/cucumber_expressions/regular_expression_spec.rb
+- spec/cucumber/cucumber_expressions/tree_regexp_spec.rb

data/spec/cucumber/cucumber_expressions/group_spec.rb

@@ -1,34 +0,0 @@
-require 'cucumber/cucumber_expressions/group'
-
-module Cucumber
-  module CucumberExpressions
-    describe Group do
-      it 'matches optional group' do
-        regexp = /^Something( with an optional argument)?/
-        string = 'Something'
-        matches = regexp.match(string)
-        group = Group.new(matches, string)
-
-        expect(group.children[0].value).to eq(nil)
-      end
-
-      it 'matches nested groups' do
-        regexp = /^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))?/
-        string = 'A 5 thick line from 10,20,30 to 40,50,60'
-
-        matches = regexp.match(string)
-        group = Group.new(matches, string)
-
-        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
-    end
-  end
-end