Class: CukeModeler::Gherkin3Adapter

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

Instance Method Summary collapse

Instance Method Details

#adapt(parsed_ast) ⇒ Object 



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

def adapt(parsed_ast)
  # An AST is just one feature

  adapt_feature!(parsed_ast)

  [parsed_ast]
end

#adapt_background!(parsed_background) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 37

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_feature) ⇒ Object 



32
33
34
35
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 32

def adapt_child_elements!(parsed_feature)
  adapt_background!(parsed_feature[:background]) if parsed_feature[:background]
  adapt_tests!(parsed_feature)
end

#adapt_doc_string!(parsed_doc_string) ⇒ Object 



174
175
176
177
178
179
180
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 174

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 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 118

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'] = []
  parsed_example['rows'] << adapt_table_row!(parsed_example.delete(:tableHeader))

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

  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 



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

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)
  parsed_feature['elements'].concat(parsed_feature.delete(:scenarioDefinitions))
  parsed_feature['elements'] << parsed_feature.delete(:background) if parsed_feature[:background]

  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 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 94

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 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 76

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 



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 149

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 



182
183
184
185
186
187
188
189
190
191
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 182

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 



193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 193

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 



141
142
143
144
145
146
147
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 141

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 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 59

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_feature) ⇒ Object 



53
54
55
56
57
 
# File 'lib/cuke_modeler/adapters/gherkin_3_adapter.rb', line 53

def adapt_tests!(parsed_feature)
  parsed_feature[:scenarioDefinitions].each do |test|
    adapt_test!(test)
  end
end