Class: CukeModeler::Gherkin2Adapter

Inherits:
Object
  • Object
show all
Defined in:
lib/cuke_modeler/adapters/gherkin_2_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_2_adapter.rb', line 5

def adapt(parsed_ast)
  # An AST is just one feature
  adapt_feature!(parsed_ast.first) if parsed_ast.first

  parsed_ast
end

#adapt_background!(parsed_background) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 43

def adapt_background!(parsed_background)
  # Saving off the original data
  parsed_background['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_background))

  if parsed_background['steps']
    parsed_background['steps'].each do |step|
      adapt_step!(step)
    end
  end
end

#adapt_child_elements!(parsed_feature) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 25

def adapt_child_elements!(parsed_feature)
  if parsed_feature['elements']
    parsed_feature['elements'].each do |element|
      case element['keyword']
        when 'Background'
          adapt_background!(element)
        when 'Scenario'
          adapt_scenario!(element)
        when 'Scenario Outline'
          adapt_outline!(element)
        else
          raise("Unknown element keyword: #{element['keyword']}")
      end

    end
  end
end

#adapt_doc_string!(parsed_doc_string) ⇒ Object 



126
127
128
129
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 126

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))
end

#adapt_example!(parsed_example) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 94

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['rows'].each do |row|
    adapt_table_row!(row)
  end

  if parsed_example['tags']
    parsed_example['tags'].each do |tag|
      adapt_tag!(tag)
    end
  end
end

#adapt_feature!(parsed_feature) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/cuke_modeler/adapters/gherkin_2_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))

  adapt_child_elements!(parsed_feature)

  if parsed_feature['tags']
    parsed_feature['tags'].each do |tag|
      adapt_tag!(tag)
    end
  end
end

#adapt_outline!(parsed_outline) ⇒ Object 



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

def adapt_outline!(parsed_outline)
  # Saving off the original data
  parsed_outline['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_outline))

  if parsed_outline['tags']
    parsed_outline['tags'].each do |tag|
      adapt_tag!(tag)
    end
  end

  if parsed_outline['steps']
    parsed_outline['steps'].each do |step|
      adapt_step!(step)
    end
  end

  if parsed_outline['examples']
    parsed_outline['examples'].each do |example|
      adapt_example!(example)
    end
  end
end

#adapt_scenario!(parsed_scenario) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 54

def adapt_scenario!(parsed_scenario)
  # Saving off the original data
  parsed_scenario['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_scenario))

  if parsed_scenario['tags']
    parsed_scenario['tags'].each do |tag|
      adapt_tag!(tag)
    end
  end

  if parsed_scenario['steps']
    parsed_scenario['steps'].each do |step|
      adapt_step!(step)
    end
  end
end

#adapt_step!(parsed_step) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 114

def adapt_step!(parsed_step)
  # Saving off the original data
  parsed_step['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step))

  adapt_doc_string!(parsed_step['doc_string']) if parsed_step['doc_string']

  if parsed_step['rows']
    parsed_step['rows'] = {'rows' => parsed_step['rows']}
    adapt_step_table!(parsed_step['rows'])
  end
end

#adapt_step_table!(parsed_step_table) ⇒ Object 



131
132
133
134
135
136
137
138
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 131

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['rows']))

  parsed_step_table['rows'].each do |row|
    adapt_table_row!(row)
  end
end

#adapt_table_row!(parsed_table_row) ⇒ Object 



140
141
142
143
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 140

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))
end

#adapt_tag!(parsed_tag) ⇒ Object 



109
110
111
112
 
# File 'lib/cuke_modeler/adapters/gherkin_2_adapter.rb', line 109

def adapt_tag!(parsed_tag)
  # Saving off the original data
  parsed_tag['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_tag))
end