gherkin 3.2.0 → 4.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (17) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +1 -1
  3. data/Makefile +5 -1
  4. data/bin/gherkin-generate-ast +2 -1
  5. data/bin/gherkin-generate-pickles +2 -1
  6. data/bin/gherkin-generate-tokens +2 -1
  7. data/gherkin-ruby.razor +4 -4
  8. data/gherkin.gemspec +1 -1
  9. data/lib/gherkin/ast_builder.rb +24 -10
  10. data/lib/gherkin/dialect.rb +1 -1
  11. data/lib/gherkin/gherkin-languages.json +1 -0
  12. data/lib/gherkin/parser.rb +561 -154
  13. data/lib/gherkin/pickles/compiler.rb +22 -22
  14. data/lib/gherkin/token_matcher.rb +2 -2
  15. data/lib/gherkin/token_scanner.rb +2 -2
  16. data/spec/gherkin/parser_spec.rb +204 -70
  17. metadata +3 -3
data/lib/gherkin/pickles/compiler.rb CHANGED
@@ -1,20 +1,21 @@
1
- require_relative '../dialect'
2
-
3
1
  module Gherkin
4
2
  module Pickles
5
3
  class Compiler
6
- def compile(feature, path)
4
+ def compile(gherkin_document, path)
7
5
  pickles = []
8
- dialect = Dialect.for(feature[:language])
9
6
 
7
+ return pickles unless gherkin_document[:feature]
8
+ feature = gherkin_document[:feature]
10
9
  feature_tags = feature[:tags]
11
- background_steps = get_background_steps(feature[:background], path)
10
+ background_steps = []
12
11
 
13
- feature[:scenarioDefinitions].each do |scenario_definition|
14
- if(scenario_definition[:type] == :Scenario)
15
- compile_scenario(feature_tags, background_steps, scenario_definition, dialect, path, pickles)
12
+ feature[:children].each do |scenario_definition|
13
+ if(scenario_definition[:type] == :Background)
14
+ background_steps = pickle_steps(scenario_definition, path)
15
+ elsif(scenario_definition[:type] == :Scenario)
16
+ compile_scenario(feature_tags, background_steps, scenario_definition, path, pickles)
16
17
  else
17
- compile_scenario_outline(feature_tags, background_steps, scenario_definition, dialect, path, pickles)
18
+ compile_scenario_outline(feature_tags, background_steps, scenario_definition, path, pickles)
18
19
  end
19
20
  end
20
21
  return pickles
@@ -22,7 +23,9 @@ module Gherkin
22
23
 
23
24
  private
24
25
 
25
- def compile_scenario(feature_tags, background_steps, scenario, dialect, path, pickles)
26
+ def compile_scenario(feature_tags, background_steps, scenario, path, pickles)
27
+ return if scenario[:steps].empty?
28
+
26
29
  steps = [].concat(background_steps)
27
30
 
28
31
  tags = [].concat(feature_tags).concat(scenario[:tags])
@@ -33,16 +36,17 @@ module Gherkin
33
36
 
34
37
  pickle = {
35
38
  tags: pickle_tags(tags, path),
36
- name: scenario[:keyword] + ": " + scenario[:name],
39
+ name: scenario[:name],
37
40
  locations: [pickle_location(scenario[:location], path)],
38
41
  steps: steps
39
42
  }
40
43
  pickles.push(pickle)
41
44
  end
42
45
 
43
- def compile_scenario_outline(feature_tags, background_steps, scenario_outline, dialect, path, pickles)
44
- keyword = dialect.scenario_keywords[0]
45
- scenario_outline[:examples].each do |examples|
46
+ def compile_scenario_outline(feature_tags, background_steps, scenario_outline, path, pickles)
47
+ return if scenario_outline[:steps].empty?
48
+
49
+ scenario_outline[:examples].reject { |examples| examples[:tableHeader].nil? }.each do |examples|
46
50
  variable_cells = examples[:tableHeader][:cells]
47
51
  examples[:tableBody].each do |values|
48
52
  value_cells = values[:cells]
@@ -64,7 +68,7 @@ module Gherkin
64
68
  end
65
69
 
66
70
  pickle = {
67
- name: keyword + ": " + interpolate(scenario_outline[:name], variable_cells, value_cells),
71
+ name: interpolate(scenario_outline[:name], variable_cells, value_cells),
68
72
  steps: steps,
69
73
  tags: pickle_tags(tags, path),
70
74
  locations: [
@@ -115,13 +119,9 @@ module Gherkin
115
119
  name
116
120
  end
117
121
 
118
- def get_background_steps(background, path)
119
- if(background)
120
- background[:steps].map do |step|
121
- pickle_step(step, path)
122
- end
123
- else
124
- []
122
+ def pickle_steps(scenario_definition, path)
123
+ scenario_definition[:steps].map do |step|
124
+ pickle_step(step, path)
125
125
  end
126
126
  end
127
127
 
data/lib/gherkin/token_matcher.rb CHANGED
@@ -1,5 +1,5 @@
1
- require_relative 'dialect'
2
- require_relative 'errors'
1
+ require 'gherkin/dialect'
2
+ require 'gherkin/errors'
3
3
 
4
4
  module Gherkin
5
5
  class TokenMatcher
data/lib/gherkin/token_scanner.rb CHANGED
@@ -1,6 +1,6 @@
1
1
  require 'stringio'
2
- require_relative 'token'
3
- require_relative 'gherkin_line'
2
+ require 'gherkin/token'
3
+ require 'gherkin/gherkin_line'
4
4
 
5
5
  module Gherkin
6
6
  # The scanner reads a gherkin doc (typically read from a .feature file) and
data/spec/gherkin/parser_spec.rb CHANGED
@@ -12,45 +12,167 @@ module Gherkin
12
12
  scanner = TokenScanner.new("Feature: test")
13
13
  ast = parser.parse(scanner)
14
14
  expect(ast).to eq({
15
- type: :Feature,
16
- tags: [],
17
- location: {line: 1, column: 1},
18
- language: "en",
19
- keyword: "Feature",
20
- name: "test",
21
- scenarioDefinitions: [],
22
- comments: []
15
+ feature: {
16
+ type: :Feature,
17
+ tags: [],
18
+ location: {line: 1, column: 1},
19
+ language: "en",
20
+ keyword: "Feature",
21
+ name: "test",
22
+ children: []
23
+ },
24
+ comments: [],
25
+ type: :GherkinDocument
23
26
  })
24
27
  end
25
28
 
29
+ it "parses a complex feature" do
30
+ # This should include every significant type of thing within the language
31
+ feature_text = "@feature_tag\n" +
32
+ "Feature: feature name\n" +
33
+ " feature description\n" +
34
+ "\n" +
35
+ " Background: background name\n" +
36
+ " background description\n" +
37
+ " * a step\n" +
38
+ "\n" +
39
+ " @scenario_tag\n" +
40
+ " Scenario: scenario name\n" +
41
+ " scenario description\n" +
42
+ " * a step with a table\n" +
43
+ " | a table |\n" +
44
+ "\n" +
45
+ " @outline_tag\n" +
46
+ " Scenario Outline: outline name\n" +
47
+ " outline description\n" +
48
+ " * a step with a doc string\n" +
49
+ " \"\"\" content_type\n" +
50
+ " lots of text\n" +
51
+ " \"\"\"\n" +
52
+ " # Random file comment\n" +
53
+ " @example_tag\n" +
54
+ " Examples: examples name\n" +
55
+ " examples description\n" +
56
+ " | param |\n" +
57
+ " | value |\n"
58
+
59
+ parser = Parser.new
60
+ scanner = TokenScanner.new(feature_text)
61
+ ast = parser.parse(scanner)
62
+
63
+ expect(ast).to eq({
64
+ feature: {type: :Feature,
65
+ tags: [{type: :Tag,
66
+ location: {line: 1, column: 1},
67
+ name: "@feature_tag"}],
68
+ location: {line: 2, column: 1},
69
+ language: "en",
70
+ keyword: "Feature",
71
+ name: "feature name",
72
+ description: " feature description",
73
+ children: [{type: :Background,
74
+ location: {line: 5, column: 4},
75
+ keyword: "Background",
76
+ name: "background name",
77
+ description: " background description",
78
+ steps: [{type: :Step,
79
+ location: {line: 7, column: 5},
80
+ keyword: "* ",
81
+ text: "a step"}]},
82
+ {type: :Scenario,
83
+ tags: [{type: :Tag,
84
+ location: {line: 9, column: 3},
85
+ name: "@scenario_tag"}],
86
+ location: {line: 10, column: 3},
87
+ keyword: "Scenario",
88
+ name: "scenario name",
89
+ description: " scenario description",
90
+ steps: [{type: :Step,
91
+ location: {line: 12, column: 5},
92
+ keyword: "* ",
93
+ text: "a step with a table",
94
+ argument: {type: :DataTable,
95
+ location: {line: 13, column: 7},
96
+ rows: [{type: :TableRow,
97
+ location: {line: 13, column: 7},
98
+ cells: [{type: :TableCell,
99
+ location: {line: 13, column: 9},
100
+ value: "a table"}]}]}}]},
101
+ {type: :ScenarioOutline,
102
+ tags: [{type: :Tag,
103
+ location: {line: 15, column: 3},
104
+ name: "@outline_tag"}],
105
+ location: {line: 16, column: 3},
106
+ keyword: "Scenario Outline",
107
+ name: "outline name",
108
+ description: " outline description",
109
+ steps: [{type: :Step,
110
+ location: {line: 18, column: 5},
111
+ keyword: "* ",
112
+ text: "a step with a doc string",
113
+ argument: {type: :DocString,
114
+ location: {line: 19, column: 7},
115
+ contentType: "content_type",
116
+ content: " lots of text"}}],
117
+ examples: [{type: :Examples,
118
+ tags: [{type: :Tag,
119
+ location: {line: 23, column: 3},
120
+ name: "@example_tag"}],
121
+ location: {line: 24, column: 3},
122
+ keyword: "Examples",
123
+ name: "examples name",
124
+ description: " examples description",
125
+ tableHeader: {type: :TableRow,
126
+ location: {line: 26, column: 5},
127
+ cells: [{type: :TableCell,
128
+ location: {line: 26, column: 7},
129
+ value: "param"}]},
130
+ tableBody: [{type: :TableRow,
131
+ location: {line: 27, column: 5},
132
+ cells: [{type: :TableCell,
133
+ location: {line: 27, column: 7},
134
+ value: "value"}]}]}]}],
135
+ },
136
+ comments: [{type: :Comment,
137
+ location: {line: 22, column: 1},
138
+ text: " # Random file comment"}],
139
+ type: :GherkinDocument}
140
+ )
141
+ end
142
+
26
143
  it "parses string feature" do
27
144
  parser = Parser.new
28
145
  ast = parser.parse("Feature: test")
29
146
  expect(ast).to eq({
30
- type: :Feature,
31
- tags: [],
32
- location: {line: 1, column: 1},
33
- language: "en",
34
- keyword: "Feature",
35
- name: "test",
36
- scenarioDefinitions: [],
37
- comments: []
147
+ feature: {
148
+ type: :Feature,
149
+ tags: [],
150
+ location: {line: 1, column: 1},
151
+ language: "en",
152
+ keyword: "Feature",
153
+ name: "test",
154
+ children: []
155
+ },
156
+ comments: [],
157
+ type: :GherkinDocument
38
158
  })
39
159
  end
40
160
 
41
161
  it "parses io feature" do
42
162
  parser = Parser.new
43
163
  ast = parser.parse(StringIO.new("Feature: test"))
44
-
45
164
  expect(ast).to eq({
46
- type: :Feature,
47
- tags: [],
48
- location: {line: 1, column: 1},
49
- language: "en",
50
- keyword: "Feature",
51
- name: "test",
52
- scenarioDefinitions: [],
53
- comments: []
165
+ feature: {
166
+ type: :Feature,
167
+ tags: [],
168
+ location: {line: 1, column: 1},
169
+ language: "en",
170
+ keyword: "Feature",
171
+ name: "test",
172
+ children: []
173
+ },
174
+ comments: [],
175
+ type: :GherkinDocument
54
176
  })
55
177
  end
56
178
 
@@ -60,24 +182,30 @@ module Gherkin
60
182
  ast2 = parser.parse(TokenScanner.new("Feature: test2"))
61
183
 
62
184
  expect(ast1).to eq({
63
- type: :Feature,
64
- tags: [],
65
- location: {line: 1, column: 1},
66
- language: "en",
67
- keyword: "Feature",
68
- name: "test",
69
- scenarioDefinitions: [],
70
- comments: []
185
+ feature: {
186
+ type: :Feature,
187
+ tags: [],
188
+ location: {line: 1, column: 1},
189
+ language: "en",
190
+ keyword: "Feature",
191
+ name: "test",
192
+ children: []
193
+ },
194
+ comments: [],
195
+ type: :GherkinDocument
71
196
  })
72
197
  expect(ast2).to eq({
73
- type: :Feature,
74
- tags: [],
75
- location: {line: 1, column: 1},
76
- language: "en",
77
- keyword: "Feature",
78
- name: "test2",
79
- scenarioDefinitions: [],
80
- comments: []
198
+ feature: {
199
+ type: :Feature,
200
+ tags: [],
201
+ location: {line: 1, column: 1},
202
+ language: "en",
203
+ keyword: "Feature",
204
+ name: "test2",
205
+ children: []
206
+ },
207
+ comments: [],
208
+ type: :GherkinDocument
81
209
  })
82
210
  end
83
211
 
@@ -102,27 +230,30 @@ module Gherkin
102
230
  matcher)
103
231
 
104
232
  expect(ast).to eq({
105
- type: :Feature,
106
- tags: [],
107
- location: {line: 1, column: 1},
108
- language: "en",
109
- keyword: "Feature",
110
- name: "Foo",
111
- scenarioDefinitions: [{
112
- :type=>:Scenario,
113
- :tags=>[],
114
- :location=>{:line=>2, :column=>3},
115
- :keyword=>"Scenario",
116
- :name=>"Bar",
117
- :steps=>[{
118
- :type=>:Step,
119
- :location=>{:line=>3, :column=>5},
120
- :keyword=>"Given ",
121
- :text=>"x",
122
- :argument=>{:type=>:DocString,
123
- :location=>{:line=>4, :column=>7},
124
- :content=>"closed docstring"}}]}],
125
- comments: []
233
+ feature: {
234
+ type: :Feature,
235
+ tags: [],
236
+ location: {line: 1, column: 1},
237
+ language: "en",
238
+ keyword: "Feature",
239
+ name: "Foo",
240
+ children: [{
241
+ :type=>:Scenario,
242
+ :tags=>[],
243
+ :location=>{:line=>2, :column=>3},
244
+ :keyword=>"Scenario",
245
+ :name=>"Bar",
246
+ :steps=>[{
247
+ :type=>:Step,
248
+ :location=>{:line=>3, :column=>5},
249
+ :keyword=>"Given ",
250
+ :text=>"x",
251
+ :argument=>{:type=>:DocString,
252
+ :location=>{:line=>4, :column=>7},
253
+ :content=>"closed docstring"}}]}]
254
+ },
255
+ comments: [],
256
+ type: :GherkinDocument
126
257
  })
127
258
  end
128
259
 
@@ -132,14 +263,17 @@ module Gherkin
132
263
  scanner = TokenScanner.new("Egenskap: i18n support")
133
264
  ast = parser.parse(scanner, matcher)
134
265
  expect(ast).to eq({
135
- type: :Feature,
136
- tags: [],
137
- location: {line: 1, column: 1},
138
- language: "no",
139
- keyword: "Egenskap",
140
- name: "i18n support",
141
- scenarioDefinitions: [],
142
- comments: []
266
+ feature: {
267
+ type: :Feature,
268
+ tags: [],
269
+ location: {line: 1, column: 1},
270
+ language: "no",
271
+ keyword: "Egenskap",
272
+ name: "i18n support",
273
+ children: []
274
+ },
275
+ comments: [],
276
+ type: :GherkinDocument
143
277
  })
144
278
  end
145
279
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: gherkin
3
3
  version: !ruby/object:Gem::Version
4
- version: 3.2.0
4
+ version: 4.0.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Gáspár Nagy
@@ -10,7 +10,7 @@ authors:
10
10
  autorequire:
11
11
  bindir: bin
12
12
  cert_chain: []
13
- date: 2016-01-12 00:00:00.000000000 Z
13
+ date: 2016-04-10 00:00:00.000000000 Z
14
14
  dependencies:
15
15
  - !ruby/object:Gem::Dependency
16
16
  name: bundler
@@ -131,7 +131,7 @@ rubyforge_project:
131
131
  rubygems_version: 2.4.5
132
132
  signing_key:
133
133
  specification_version: 4
134
- summary: gherkin-3.2.0
134
+ summary: gherkin-4.0.0
135
135
  test_files:
136
136
  - spec/capture_warnings.rb
137
137
  - spec/coverage.rb