cucumber-cucumber-expressions 8.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (42) hide show
  1. checksums.yaml +7 -0
  2. data/.github/ISSUE_TEMPLATE.md +5 -0
  3. data/.github/PULL_REQUEST_TEMPLATE.md +5 -0
  4. data/.rspec +1 -0
  5. data/.rsync +4 -0
  6. data/.subrepo +1 -0
  7. data/Gemfile +3 -0
  8. data/LICENSE +21 -0
  9. data/Makefile +1 -0
  10. data/README.md +5 -0
  11. data/Rakefile +27 -0
  12. data/cucumber-cucumber-expressions.gemspec +33 -0
  13. data/default.mk +70 -0
  14. data/examples.txt +31 -0
  15. data/lib/cucumber/cucumber_expressions/argument.rb +37 -0
  16. data/lib/cucumber/cucumber_expressions/combinatorial_generated_expression_factory.rb +49 -0
  17. data/lib/cucumber/cucumber_expressions/cucumber_expression.rb +119 -0
  18. data/lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb +105 -0
  19. data/lib/cucumber/cucumber_expressions/errors.rb +40 -0
  20. data/lib/cucumber/cucumber_expressions/generated_expression.rb +31 -0
  21. data/lib/cucumber/cucumber_expressions/group.rb +18 -0
  22. data/lib/cucumber/cucumber_expressions/group_builder.rb +42 -0
  23. data/lib/cucumber/cucumber_expressions/parameter_type.rb +81 -0
  24. data/lib/cucumber/cucumber_expressions/parameter_type_matcher.rb +59 -0
  25. data/lib/cucumber/cucumber_expressions/parameter_type_registry.rb +70 -0
  26. data/lib/cucumber/cucumber_expressions/regular_expression.rb +48 -0
  27. data/lib/cucumber/cucumber_expressions/tree_regexp.rb +76 -0
  28. data/scripts/update-gemspec +32 -0
  29. data/spec/capture_warnings.rb +74 -0
  30. data/spec/coverage.rb +7 -0
  31. data/spec/cucumber/cucumber_expressions/argument_spec.rb +17 -0
  32. data/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb +43 -0
  33. data/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb +231 -0
  34. data/spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb +57 -0
  35. data/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb +212 -0
  36. data/spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb +202 -0
  37. data/spec/cucumber/cucumber_expressions/expression_examples_spec.rb +30 -0
  38. data/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb +86 -0
  39. data/spec/cucumber/cucumber_expressions/parameter_type_spec.rb +15 -0
  40. data/spec/cucumber/cucumber_expressions/regular_expression_spec.rb +80 -0
  41. data/spec/cucumber/cucumber_expressions/tree_regexp_spec.rb +133 -0
  42. metadata +162 -0
@@ -0,0 +1,30 @@
1
+ require 'cucumber/cucumber_expressions/cucumber_expression'
2
+ require 'cucumber/cucumber_expressions/regular_expression'
3
+ require 'cucumber/cucumber_expressions/parameter_type_registry'
4
+ require 'json'
5
+
6
+ module Cucumber
7
+ module CucumberExpressions
8
+ describe 'examples.txt' do
9
+ def match(expression_text, text)
10
+ expression = expression_text =~ /\/(.*)\// ?
11
+ RegularExpression.new(Regexp.new($1), ParameterTypeRegistry.new) :
12
+ CucumberExpression.new(expression_text, ParameterTypeRegistry.new)
13
+
14
+ arguments = expression.match(text)
15
+ return nil if arguments.nil?
16
+ arguments.map { |arg| arg.value(nil) }
17
+ end
18
+
19
+ File.open(File.expand_path("../../../../examples.txt", __FILE__), "r:utf-8") do |io|
20
+ chunks = io.read.split(/^---/m)
21
+ chunks.each do |chunk|
22
+ expression_text, text, expected_args = *chunk.strip.split(/\n/m)
23
+ it "Works with: #{expression_text}" do
24
+ expect( match(expression_text, text).to_json ).to eq(expected_args)
25
+ end
26
+ end
27
+ end
28
+ end
29
+ end
30
+ end
@@ -0,0 +1,86 @@
1
+ require 'cucumber/cucumber_expressions/parameter_type_registry'
2
+ require 'cucumber/cucumber_expressions/parameter_type'
3
+ require 'cucumber/cucumber_expressions/errors'
4
+
5
+ module Cucumber
6
+ module CucumberExpressions
7
+
8
+ CAPITALISED_WORD = /[A-Z]+\w+/
9
+
10
+ class Name
11
+ end
12
+
13
+ class Person
14
+ end
15
+
16
+ class Place
17
+ end
18
+
19
+ describe ParameterTypeRegistry do
20
+ before do
21
+ @registry = ParameterTypeRegistry.new
22
+ end
23
+
24
+ it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
25
+ @registry.define_parameter_type(ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, true))
26
+ @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
27
+ expect do
28
+ @registry.define_parameter_type(ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, true))
29
+ end.to raise_error(
30
+ CucumberExpressionError,
31
+ "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}"
32
+ )
33
+ end
34
+
35
+ it 'looks up prefer_for_regexp_match parameter type by regexp' do
36
+ name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
37
+ person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
38
+ place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
39
+
40
+ @registry.define_parameter_type(name)
41
+ @registry.define_parameter_type(person)
42
+ @registry.define_parameter_type(place)
43
+
44
+ expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
45
+ end
46
+
47
+ it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
48
+ name = ParameterType.new("name", CAPITALISED_WORD, Name, lambda {|s| Name.new}, true, false)
49
+ person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
50
+ place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|s| Place.new}, true, false)
51
+
52
+ @registry.define_parameter_type(name)
53
+ @registry.define_parameter_type(person)
54
+ @registry.define_parameter_type(place)
55
+
56
+ expect do
57
+ expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, "Lisa and Bob")).to eq(person)
58
+ end.to raise_error(
59
+ CucumberExpressionError,
60
+ "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" +
61
+ "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n" +
62
+ " {name}\n" +
63
+ " {person}\n" +
64
+ " {place}\n" +
65
+ "\n" +
66
+ "I couldn't decide which one to use. You have two options:\n" +
67
+ "\n" +
68
+ "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n" +
69
+ " {name} and {name}\n" +
70
+ " {name} and {person}\n" +
71
+ " {name} and {place}\n" +
72
+ " {person} and {name}\n" +
73
+ " {person} and {person}\n" +
74
+ " {person} and {place}\n" +
75
+ " {place} and {name}\n" +
76
+ " {place} and {person}\n" +
77
+ " {place} and {place}\n" +
78
+ "\n" +
79
+ "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" +
80
+ "\n"
81
+ )
82
+ end
83
+ end
84
+ end
85
+ end
86
+
@@ -0,0 +1,15 @@
1
+ require 'cucumber/cucumber_expressions/parameter_type'
2
+
3
+ module Cucumber
4
+ module CucumberExpressions
5
+ describe ParameterType do
6
+ it 'does not allow ignore flag on regexp' do
7
+ expect do
8
+ ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
9
+ end.to raise_error(
10
+ CucumberExpressionError,
11
+ "ParameterType Regexps can't use option Regexp::IGNORECASE")
12
+ end
13
+ end
14
+ end
15
+ end
@@ -0,0 +1,80 @@
1
+ require 'cucumber/cucumber_expressions/regular_expression'
2
+ require 'cucumber/cucumber_expressions/parameter_type_registry'
3
+
4
+ module Cucumber
5
+ module CucumberExpressions
6
+ describe RegularExpression do
7
+ it "documents match arguments" do
8
+ parameter_type_registry = ParameterTypeRegistry.new
9
+
10
+ ### [capture-match-arguments]
11
+ expr = /I have (\d+) cukes? in my (\w*) now/
12
+ expression = RegularExpression.new(expr, parameter_type_registry)
13
+ args = expression.match("I have 7 cukes in my belly now")
14
+ expect( args[0].value(nil) ).to eq(7)
15
+ expect( args[1].value(nil) ).to eq("belly")
16
+ ### [capture-match-arguments]
17
+ end
18
+
19
+ it "does no transform by default" do
20
+ expect( match(/(\d\d)/, "22") ).to eq(["22"])
21
+ end
22
+
23
+ it "does not transform anonymous" do
24
+ expect( match(/(.*)/, "22") ).to eq(["22"])
25
+ end
26
+
27
+ it "transforms negative int" do
28
+ expect( match(/(-?\d+)/, "-22") ).to eq([-22])
29
+ end
30
+
31
+ it "transforms positive int" do
32
+ expect( match(/(\d+)/, "22") ).to eq([22])
33
+ end
34
+
35
+ it "returns nil when there is no match" do
36
+ expect( match(/hello/, "world") ).to be_nil
37
+ end
38
+
39
+ it "matches nested capture group without match" do
40
+ expect( match(/^a user( named "([^"]*)")?$/, 'a user') ).to eq([nil])
41
+ end
42
+
43
+ it "matches nested capture group with match" do
44
+ expect( match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"') ).to eq(['Charlie'])
45
+ end
46
+
47
+ it "ignores non capturing groups" do
48
+ expect( match(
49
+ /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
50
+ "I can cancel the 1st slide upload")
51
+ ).to eq(["I", "can", 1, "slide"])
52
+ end
53
+
54
+ it "matches capture group nested in optional one" do
55
+ regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
56
+ expect( match(regexp, 'a purchase') ).to eq([nil, nil])
57
+ expect( match(regexp, 'a purchase for $33') ).to eq([nil, 33])
58
+ expect( match(regexp, 'a pre buyer fee model purchase') ).to eq(['pre buyer fee model ', nil])
59
+ end
60
+
61
+ it "works with escaped parenthesis" do
62
+ expect( match(/Across the line\(s\)/, 'Across the line(s)') ).to eq([])
63
+ end
64
+
65
+ it "exposes source and regexp" do
66
+ regexp = /I have (\d+) cukes? in my (\+) now/
67
+ expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
68
+ expect(expression.regexp).to eq(regexp)
69
+ expect(expression.source).to eq(regexp.source)
70
+ end
71
+
72
+ def match(expression, text)
73
+ regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
74
+ arguments = regular_expression.match(text)
75
+ return nil if arguments.nil?
76
+ arguments.map { |arg| arg.value(nil) }
77
+ end
78
+ end
79
+ end
80
+ end
@@ -0,0 +1,133 @@
1
+ require 'cucumber/cucumber_expressions/tree_regexp'
2
+
3
+ module Cucumber
4
+ module CucumberExpressions
5
+ describe TreeRegexp do
6
+ it 'exposes group source' do
7
+ tr = TreeRegexp.new(/(a(?:b)?)(c)/)
8
+ expect(tr.group_builder.children.map{|gb| gb.source}).to eq(['a(?:b)?', 'c'])
9
+ end
10
+
11
+ it 'builds tree' do
12
+ tr = TreeRegexp.new(/(a(?:b)?)(c)/)
13
+ group = tr.match('ac')
14
+ expect(group.value).to eq('ac')
15
+ expect(group.children[0].value).to eq('a')
16
+ expect(group.children[0].children).to eq([])
17
+ expect(group.children[1].value).to eq('c')
18
+ end
19
+
20
+ it 'ignores `?:` as a non-capturing group' do
21
+ tr = TreeRegexp.new(/a(?:b)(c)/)
22
+ group = tr.match('abc')
23
+ expect(group.value).to eq('abc')
24
+ expect(group.children.length).to eq 1
25
+ end
26
+
27
+ it 'ignores `?!` as a non-capturing group' do
28
+ tr = TreeRegexp.new(/a(?!b)(.+)/)
29
+ group = tr.match('aBc')
30
+ expect(group.value).to eq('aBc')
31
+ expect(group.children.length).to eq 1
32
+ end
33
+
34
+ it 'ignores `?=` as a non-capturing group' do
35
+ tr = TreeRegexp.new(/a(?=b)(.+)$/)
36
+ group = tr.match('abc')
37
+ expect(group.value).to eq('abc')
38
+ expect(group.children[0].value).to eq('bc')
39
+ expect(group.children.length).to eq 1
40
+ end
41
+
42
+ it 'ignores `?<=` as a non-capturing group' do
43
+ tr = TreeRegexp.new(/a(.+)(?<=c)$/)
44
+ group = tr.match('abc')
45
+ expect(group.value).to eq('abc')
46
+ expect(group.children[0].value).to eq('bc')
47
+ expect(group.children.length).to eq 1
48
+ end
49
+
50
+ it 'ignores `?<!` as a non-capturing group' do
51
+ tr = TreeRegexp.new(/a(.+)(?<!b)$/)
52
+ group = tr.match('abc')
53
+ expect(group.value).to eq('abc')
54
+ expect(group.children[0].value).to eq('bc')
55
+ expect(group.children.length).to eq 1
56
+ end
57
+
58
+ it 'matches optional group' do
59
+ tr = TreeRegexp.new(/^Something( with an optional argument)?/)
60
+ group = tr.match('Something')
61
+ expect(group.children[0].value).to eq(nil)
62
+ end
63
+
64
+ it 'matches nested groups' do
65
+ tr = TreeRegexp.new(/^A (\d+) thick line from ((\d+),\s*(\d+),\s*(\d+)) to ((\d+),\s*(\d+),\s*(\d+))/)
66
+ group = tr.match('A 5 thick line from 10,20,30 to 40,50,60')
67
+
68
+ expect(group.children[0].value).to eq('5')
69
+ expect(group.children[1].value).to eq('10,20,30')
70
+ expect(group.children[1].children[0].value).to eq('10')
71
+ expect(group.children[1].children[1].value).to eq('20')
72
+ expect(group.children[1].children[2].value).to eq('30')
73
+ expect(group.children[2].value).to eq('40,50,60')
74
+ expect(group.children[2].children[0].value).to eq('40')
75
+ expect(group.children[2].children[1].value).to eq('50')
76
+ expect(group.children[2].children[2].value).to eq('60')
77
+ end
78
+
79
+ it 'detects multiple non capturing groups' do
80
+ tr = TreeRegexp.new(/(?:a)(:b)(\?c)(d)/)
81
+ group = tr.match("a:b?cd")
82
+ expect(group.children.length).to eq(3)
83
+ end
84
+
85
+ it 'works with escaped backslash' do
86
+ tr = TreeRegexp.new(/foo\\(bar|baz)/)
87
+ group = tr.match("foo\\bar")
88
+ expect(group.children.length).to eq(1)
89
+ end
90
+
91
+ it 'works with escaped slash' do
92
+ tr = TreeRegexp.new(/^I go to '\/(.+)'$/)
93
+ group = tr.match("I go to '/hello'")
94
+ expect(group.children.length).to eq(1)
95
+ end
96
+
97
+ it 'works with digit and word' do
98
+ tr = TreeRegexp.new(/^(\d) (\w+)$/)
99
+ group = tr.match("2 you")
100
+ expect(group.children.length).to eq(2)
101
+ end
102
+
103
+ it 'captures non capturing groups with capturing groups inside' do
104
+ tr = TreeRegexp.new(/the stdout(?: from "(.*?)")?/)
105
+ group = tr.match("the stdout")
106
+ expect(group.value).to eq("the stdout")
107
+ expect(group.children[0].value).to eq(nil)
108
+ expect(group.children.length).to eq(1)
109
+ end
110
+
111
+ it 'works with flags' do
112
+ tr = TreeRegexp.new(/HELLO/i)
113
+ group = tr.match("hello")
114
+ expect(group.value).to eq("hello")
115
+ end
116
+
117
+ it('does not consider parenthesis in character class as group') do
118
+ tr = TreeRegexp.new(/^drawings: ([A-Z_, ()]+)$/)
119
+ group = tr.match('drawings: ONE, TWO(ABC)')
120
+ expect(group.value).to eq('drawings: ONE, TWO(ABC)')
121
+ expect(group.children[0].value).to eq('ONE, TWO(ABC)')
122
+ expect(group.children.length).to eq(1)
123
+ end
124
+
125
+ it 'throws an error when there are named capture groups because they are buggy in Ruby' do
126
+ # https://github.com/cucumber/cucumber/issues/329
127
+ expect {
128
+ TreeRegexp.new(/^I am a person( named "(?<first_name>.+) (?<last_name>.+)")?$/)
129
+ }.to raise_error(/Named capture groups are not supported/)
130
+ end
131
+ end
132
+ end
133
+ end
metadata ADDED
@@ -0,0 +1,162 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: cucumber-cucumber-expressions
3
+ version: !ruby/object:Gem::Version
4
+ version: 8.3.1
5
+ platform: ruby
6
+ authors:
7
+ - Aslak Hellesøy
8
+ autorequire:
9
+ bindir: bin
10
+ cert_chain: []
11
+ date: 2020-01-10 00:00:00.000000000 Z
12
+ dependencies:
13
+ - !ruby/object:Gem::Dependency
14
+ name: rake
15
+ requirement: !ruby/object:Gem::Requirement
16
+ requirements:
17
+ - - "~>"
18
+ - !ruby/object:Gem::Version
19
+ version: '13.0'
20
+ - - ">="
21
+ - !ruby/object:Gem::Version
22
+ version: 13.0.1
23
+ type: :development
24
+ prerelease: false
25
+ version_requirements: !ruby/object:Gem::Requirement
26
+ requirements:
27
+ - - "~>"
28
+ - !ruby/object:Gem::Version
29
+ version: '13.0'
30
+ - - ">="
31
+ - !ruby/object:Gem::Version
32
+ version: 13.0.1
33
+ - !ruby/object:Gem::Dependency
34
+ name: rspec
35
+ requirement: !ruby/object:Gem::Requirement
36
+ requirements:
37
+ - - "~>"
38
+ - !ruby/object:Gem::Version
39
+ version: '3.9'
40
+ - - ">="
41
+ - !ruby/object:Gem::Version
42
+ version: 3.9.0
43
+ type: :development
44
+ prerelease: false
45
+ version_requirements: !ruby/object:Gem::Requirement
46
+ requirements:
47
+ - - "~>"
48
+ - !ruby/object:Gem::Version
49
+ version: '3.9'
50
+ - - ">="
51
+ - !ruby/object:Gem::Version
52
+ version: 3.9.0
53
+ - !ruby/object:Gem::Dependency
54
+ name: coveralls
55
+ requirement: !ruby/object:Gem::Requirement
56
+ requirements:
57
+ - - "~>"
58
+ - !ruby/object:Gem::Version
59
+ version: '0.8'
60
+ - - ">="
61
+ - !ruby/object:Gem::Version
62
+ version: 0.8.23
63
+ type: :development
64
+ prerelease: false
65
+ version_requirements: !ruby/object:Gem::Requirement
66
+ requirements:
67
+ - - "~>"
68
+ - !ruby/object:Gem::Version
69
+ version: '0.8'
70
+ - - ">="
71
+ - !ruby/object:Gem::Version
72
+ version: 0.8.23
73
+ description: Cucumber Expressions - a simpler alternative to Regular Expressions
74
+ email: cukes@googlegroups.com
75
+ executables: []
76
+ extensions: []
77
+ extra_rdoc_files: []
78
+ files:
79
+ - ".github/ISSUE_TEMPLATE.md"
80
+ - ".github/PULL_REQUEST_TEMPLATE.md"
81
+ - ".rspec"
82
+ - ".rsync"
83
+ - ".subrepo"
84
+ - Gemfile
85
+ - LICENSE
86
+ - Makefile
87
+ - README.md
88
+ - Rakefile
89
+ - cucumber-cucumber-expressions.gemspec
90
+ - default.mk
91
+ - examples.txt
92
+ - lib/cucumber/cucumber_expressions/argument.rb
93
+ - lib/cucumber/cucumber_expressions/combinatorial_generated_expression_factory.rb
94
+ - lib/cucumber/cucumber_expressions/cucumber_expression.rb
95
+ - lib/cucumber/cucumber_expressions/cucumber_expression_generator.rb
96
+ - lib/cucumber/cucumber_expressions/errors.rb
97
+ - lib/cucumber/cucumber_expressions/generated_expression.rb
98
+ - lib/cucumber/cucumber_expressions/group.rb
99
+ - lib/cucumber/cucumber_expressions/group_builder.rb
100
+ - lib/cucumber/cucumber_expressions/parameter_type.rb
101
+ - lib/cucumber/cucumber_expressions/parameter_type_matcher.rb
102
+ - lib/cucumber/cucumber_expressions/parameter_type_registry.rb
103
+ - lib/cucumber/cucumber_expressions/regular_expression.rb
104
+ - lib/cucumber/cucumber_expressions/tree_regexp.rb
105
+ - scripts/update-gemspec
106
+ - spec/capture_warnings.rb
107
+ - spec/coverage.rb
108
+ - spec/cucumber/cucumber_expressions/argument_spec.rb
109
+ - spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
110
+ - spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
111
+ - spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
112
+ - spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
113
+ - spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
114
+ - spec/cucumber/cucumber_expressions/expression_examples_spec.rb
115
+ - spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
116
+ - spec/cucumber/cucumber_expressions/parameter_type_spec.rb
117
+ - spec/cucumber/cucumber_expressions/regular_expression_spec.rb
118
+ - spec/cucumber/cucumber_expressions/tree_regexp_spec.rb
119
+ homepage: https://github.com/cucumber/cucumber-expressions-ruby#readme
120
+ licenses:
121
+ - MIT
122
+ metadata:
123
+ bug_tracker_uri: https://github.com/cucumber/cucumber/issues
124
+ changelog_uri: https://github.com/cucumber/cucumber/blob/master/cucumber-expressions/CHANGELOG.md
125
+ documentation_uri: https://cucumber.io/docs/cucumber/cucumber-expressions/
126
+ mailing_list_uri: https://groups.google.com/forum/#!forum/cukes
127
+ source_code_uri: https://github.com/cucumber/cucumber/blob/master/cucumber-expressions/ruby
128
+ post_install_message:
129
+ rdoc_options:
130
+ - "--charset=UTF-8"
131
+ require_paths:
132
+ - lib
133
+ required_ruby_version: !ruby/object:Gem::Requirement
134
+ requirements:
135
+ - - ">="
136
+ - !ruby/object:Gem::Version
137
+ version: '2.3'
138
+ required_rubygems_version: !ruby/object:Gem::Requirement
139
+ requirements:
140
+ - - ">="
141
+ - !ruby/object:Gem::Version
142
+ version: '0'
143
+ requirements: []
144
+ rubyforge_project:
145
+ rubygems_version: 2.7.6.2
146
+ signing_key:
147
+ specification_version: 4
148
+ summary: cucumber-expressions-8.3.1
149
+ test_files:
150
+ - spec/capture_warnings.rb
151
+ - spec/coverage.rb
152
+ - spec/cucumber/cucumber_expressions/argument_spec.rb
153
+ - spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb
154
+ - spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb
155
+ - spec/cucumber/cucumber_expressions/cucumber_expression_regexp_spec.rb
156
+ - spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb
157
+ - spec/cucumber/cucumber_expressions/custom_parameter_type_spec.rb
158
+ - spec/cucumber/cucumber_expressions/expression_examples_spec.rb
159
+ - spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb
160
+ - spec/cucumber/cucumber_expressions/parameter_type_spec.rb
161
+ - spec/cucumber/cucumber_expressions/regular_expression_spec.rb
162
+ - spec/cucumber/cucumber_expressions/tree_regexp_spec.rb