Class: CukeModeler::Gherkin4Adapter

Inherits:
Object
  • Object
show all
Defined in:
lib/cuke_modeler/adapters/gherkin_4_adapter.rb

Instance Method Summary collapse

Instance Method Details

#adapt(parsed_ast) ⇒ Object 



5
6
7
8
9
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 5

def adapt(parsed_ast)
  adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]

  [parsed_ast[:feature]].compact
end

#adapt_background!(parsed_background) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 42

def adapt_background!(parsed_background)
  # Saving off the original data

  parsed_background['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_background))

  parsed_background['keyword'] = parsed_background.delete(:type).to_s
  parsed_background['name'] = parsed_background.delete(:name)
  parsed_background['description'] = parsed_background.delete(:description) || ''
  parsed_background['line'] = parsed_background.delete(:location)[:line]

  parsed_background['steps'] = []
  parsed_background[:steps].each do |step|
    adapt_step!(step)
  end
  parsed_background['steps'].concat(parsed_background.delete(:steps))
end

#adapt_child_elements!(parsed_children) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 30

def adapt_child_elements!(parsed_children)
  return if parsed_children.empty?

  if parsed_children.first[:type] == :Background
    adapt_background!(parsed_children.first)

    remaining_children = parsed_children[1..-1]
  end

  adapt_tests!(remaining_children || parsed_children)
end

#adapt_doc_string!(parsed_doc_string) ⇒ Object 



188
189
190
191
192
193
194
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 188

def adapt_doc_string!(parsed_doc_string)
  # Saving off the original data

  parsed_doc_string['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_doc_string))

  parsed_doc_string['value'] = parsed_doc_string.delete(:content)
  parsed_doc_string['content_type'] = parsed_doc_string.delete(:contentType)
end

#adapt_example!(parsed_example) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 125

def adapt_example!(parsed_example)
  # Saving off the original data

  parsed_example['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_example))

  parsed_example['name'] = parsed_example.delete(:name)
  parsed_example['line'] = parsed_example.delete(:location)[:line]
  parsed_example['description'] = parsed_example.delete(:description) || ''

  parsed_example['rows'] = []

  if parsed_example[:tableHeader]
    parsed_example['rows'] << adapt_table_row!(parsed_example.delete(:tableHeader))
  end

  if parsed_example[:tableBody]

    parsed_example[:tableBody].each do |row|
      adapt_table_row!(row)
    end
    parsed_example['rows'].concat(parsed_example.delete(:tableBody))
  end


  parsed_example['tags'] = []
  parsed_example[:tags].each do |tag|
    adapt_tag!(tag)
  end
  parsed_example['tags'].concat(parsed_example.delete(:tags))
end

#adapt_feature!(parsed_feature) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 11

def adapt_feature!(parsed_feature)
  # Saving off the original data

  parsed_feature['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_feature))

  parsed_feature['name'] = parsed_feature.delete(:name)
  parsed_feature['description'] = parsed_feature.delete(:description) || ''
  parsed_feature['line'] = parsed_feature.delete(:location)[:line]

  parsed_feature['elements'] = []
  adapt_child_elements!(parsed_feature[:children])
  parsed_feature['elements'].concat(parsed_feature.delete(:children))

  parsed_feature['tags'] = []
  parsed_feature[:tags].each do |tag|
    adapt_tag!(tag)
  end
  parsed_feature['tags'].concat(parsed_feature.delete(:tags))
end

#adapt_outline!(parsed_test) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 101

def adapt_outline!(parsed_test)
  parsed_test['name'] = parsed_test.delete(:name)
  parsed_test['description'] = parsed_test.delete(:description) || ''
  parsed_test['line'] = parsed_test.delete(:location)[:line]

  parsed_test['tags'] = []
  parsed_test[:tags].each do |tag|
    adapt_tag!(tag)
  end
  parsed_test['tags'].concat(parsed_test.delete(:tags))

  parsed_test['steps'] = []
  parsed_test[:steps].each do |step|
    adapt_step!(step)
  end
  parsed_test['steps'].concat(parsed_test.delete(:steps))

  parsed_test['examples'] = []
  parsed_test[:examples].each do |step|
    adapt_example!(step)
  end
  parsed_test['examples'].concat(parsed_test.delete(:examples))
end

#adapt_scenario!(parsed_test) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 83

def adapt_scenario!(parsed_test)
  parsed_test['name'] = parsed_test.delete(:name)
  parsed_test['description'] = parsed_test.delete(:description) || ''
  parsed_test['line'] = parsed_test.delete(:location)[:line]

  parsed_test['tags'] = []
  parsed_test[:tags].each do |tag|
    adapt_tag!(tag)
  end
  parsed_test['tags'].concat(parsed_test.delete(:tags))

  parsed_test['steps'] = []
  parsed_test[:steps].each do |step|
    adapt_step!(step)
  end
  parsed_test['steps'].concat(parsed_test.delete(:steps))
end

#adapt_step!(parsed_step) ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 163

def adapt_step!(parsed_step)
  # Saving off the original data

  parsed_step['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step))

  parsed_step['keyword'] = parsed_step.delete(:keyword)
  parsed_step['name'] = parsed_step.delete(:text)
  parsed_step['line'] = parsed_step.delete(:location)[:line]


  step_argument = parsed_step[:argument]

  if step_argument
    case step_argument[:type]
      when :DocString
        adapt_doc_string!(step_argument)
        parsed_step['doc_string'] = parsed_step.delete(:argument)
      when :DataTable
        adapt_step_table!(step_argument)
        parsed_step['rows'] = parsed_step.delete(:argument)
      else
        raise(ArgumentError, "Unknown step argument type: #{step_argument[:type]}")
    end
  end
end

#adapt_step_table!(parsed_step_table) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 196

def adapt_step_table!(parsed_step_table)
  # Saving off the original data

  parsed_step_table['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step_table))

  parsed_step_table['rows'] = []
  parsed_step_table[:rows].each do |row|
    adapt_table_row!(row)
  end
  parsed_step_table['rows'].concat(parsed_step_table.delete(:rows))
end

#adapt_table_row!(parsed_table_row) ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 207

def adapt_table_row!(parsed_table_row)
  # Saving off the original data

  parsed_table_row['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_table_row))

  parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]

  parsed_table_row['cells'] = parsed_table_row.delete(:cells).collect { |cell| cell[:value] }


  parsed_table_row
end

#adapt_tag!(parsed_tag) ⇒ Object 



155
156
157
158
159
160
161
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 155

def adapt_tag!(parsed_tag)
  # Saving off the original data

  parsed_tag['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_tag))

  parsed_tag['name'] = parsed_tag.delete(:name)
  parsed_tag['line'] = parsed_tag.delete(:location)[:line]
end

#adapt_test!(parsed_test) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 66

def adapt_test!(parsed_test)
  # Saving off the original data

  parsed_test['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_test))

  parsed_test['keyword'] = parsed_test.delete(:type).to_s

  case parsed_test['keyword']
    when 'Scenario'
      adapt_scenario!(parsed_test)
    when 'ScenarioOutline'
      parsed_test['keyword'] = 'Scenario Outline'
      adapt_outline!(parsed_test)
    else
      raise(ArgumentError, "Unknown test type: #{parsed_test['keyword']}")
  end
end

#adapt_tests!(parsed_tests) ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/cuke_modeler/adapters/gherkin_4_adapter.rb', line 58

def adapt_tests!(parsed_tests)
  return unless parsed_tests

  parsed_tests.each do |test|
    adapt_test!(test)
  end
end