cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/adapters/gherkin_4_adapter.rb

@@ -1,16 +1,24 @@
 module CukeModeler
-  class Gherkin4Adapter
 
+  # An adapter that can convert the output of version 4.x of the *gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin4Adapter
 
+    # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
       adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
 
       [parsed_ast[:feature]].compact
     end
 
+    # Adapts the AST sub-tree that is rooted at the given feature node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_feature['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil
 
       parsed_feature['name'] = parsed_feature.delete(:name)
       parsed_feature['description'] = parsed_feature.delete(:description) || ''
@@ -27,21 +35,13 @@ module CukeModeler
       parsed_feature['tags'].concat(parsed_feature.delete(:tags))
     end
 
-    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
-
+    # Adapts the AST sub-tree that is rooted at the given background node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_background))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_background['cuke_modeler_parsing_data'][:steps] = nil
 
       parsed_background['keyword'] = parsed_background.delete(:type).to_s
       parsed_background['name'] = parsed_background.delete(:name)
@@ -55,32 +55,12 @@ module CukeModeler
       parsed_background['steps'].concat(parsed_background.delete(:steps))
     end
 
-    def adapt_tests!(parsed_tests)
-      return unless parsed_tests
-
-      parsed_tests.each do |test|
-        adapt_test!(test)
-      end
-    end
-
-    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
-
+    # Adapts the AST sub-tree that is rooted at the given scenario node.
     def adapt_scenario!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:steps] = nil
+
       parsed_test['name'] = parsed_test.delete(:name)
       parsed_test['description'] = parsed_test.delete(:description) || ''
       parsed_test['line'] = parsed_test.delete(:location)[:line]
@@ -98,7 +78,13 @@ module CukeModeler
       parsed_test['steps'].concat(parsed_test.delete(:steps))
     end
 
+    # Adapts the AST sub-tree that is rooted at the given outline node.
     def adapt_outline!(parsed_test)
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_test['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_test['cuke_modeler_parsing_data'][:steps] = nil
+      parsed_test['cuke_modeler_parsing_data'][:examples] = nil
+
       parsed_test['name'] = parsed_test.delete(:name)
       parsed_test['description'] = parsed_test.delete(:description) || ''
       parsed_test['line'] = parsed_test.delete(:location)[:line]
@@ -122,9 +108,15 @@ module CukeModeler
       parsed_test['examples'].concat(parsed_test.delete(:examples))
     end
 
+    # Adapts the AST sub-tree that is rooted at the given example node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_example))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_example['cuke_modeler_parsing_data'][:tags] = nil
+      parsed_example['cuke_modeler_parsing_data'][:tableHeader] = nil
+      parsed_example['cuke_modeler_parsing_data'][:tableBody] = nil
 
       parsed_example['name'] = parsed_example.delete(:name)
       parsed_example['line'] = parsed_example.delete(:location)[:line]
@@ -133,7 +125,8 @@ module CukeModeler
       parsed_example['rows'] = []
 
       if parsed_example[:tableHeader]
-        parsed_example['rows'] << adapt_table_row!(parsed_example.delete(:tableHeader))
+        adapt_table_row!(parsed_example[:tableHeader])
+        parsed_example['rows'] << parsed_example.delete(:tableHeader)
       end
 
       if parsed_example[:tableBody]
@@ -152,17 +145,22 @@ module CukeModeler
       parsed_example['tags'].concat(parsed_example.delete(:tags))
     end
 
+    # Adapts the AST sub-tree that is rooted at the given tag node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
 
       parsed_tag['name'] = parsed_tag.delete(:name)
       parsed_tag['line'] = parsed_tag.delete(:location)[:line]
     end
 
+    # Adapts the AST sub-tree that is rooted at the given step node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step['cuke_modeler_parsing_data'][:argument] = nil
 
       parsed_step['keyword'] = parsed_step.delete(:keyword)
       parsed_step['name'] = parsed_step.delete(:text)
@@ -178,42 +176,105 @@ module CukeModeler
             parsed_step['doc_string'] = parsed_step.delete(:argument)
           when :DataTable
             adapt_step_table!(step_argument)
-            parsed_step['rows'] = parsed_step.delete(:argument)
+            parsed_step['table'] = parsed_step.delete(:argument)
           else
             raise(ArgumentError, "Unknown step argument type: #{step_argument[:type]}")
         end
       end
     end
 
+    # Adapts the AST sub-tree that is rooted at the given doc string node.
     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['cuke_modeler_parsing_data'] = 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)
+      parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
     end
 
+    # Adapts the AST sub-tree that is rooted at the given table node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_step_table['cuke_modeler_parsing_data'][:rows] = nil
 
       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))
+      parsed_step_table['line'] = parsed_step_table.delete(:location)[:line]
     end
 
+    # Adapts the AST sub-tree that is rooted at the given row node.
     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['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      # Removing parsed data for child elements in order to avoid duplicating data which the child elements will themselves include
+      parsed_table_row['cuke_modeler_parsing_data'][:cells] = nil
+
 
       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['cells'] = []
+      parsed_table_row[:cells].each do |row|
+        adapt_table_cell!(row)
+      end
+      parsed_table_row['cells'].concat(parsed_table_row.delete(:cells))
+    end
+
+    # Adapts the AST sub-tree that is rooted at the given cell node.
+    def adapt_table_cell!(parsed_cell)
+      # Saving off the original data
+      parsed_cell['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_cell))
+
+      parsed_cell['value'] = parsed_cell.delete(:value)
+      parsed_cell['line'] = parsed_cell.delete(:location)[:line]
+    end
+
+
+    private
+
 
+    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
 
-      parsed_table_row
+    def adapt_tests!(parsed_tests)
+      return unless parsed_tests
+
+      parsed_tests.each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_parsing_data'] = 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
 
   end

data/lib/cuke_modeler/containing.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # A mix-in module containing methods used by models that contain other models.
 
   module Containing
 
@@ -7,11 +8,261 @@ module CukeModeler
     private
 
 
-    def build_child_element(clazz, element_data)
-      element = clazz.new(element_data)
-      element.parent_element = self
+    def build_child_model(clazz, model_data)
+      model = clazz.new
 
-      element
+      tiny_class = clazz.name.match(/::(\w+)/)[1].downcase
+      model.send("populate_#{tiny_class}", model, model_data)
+
+      model.parent_model = self
+
+
+      model
+    end
+
+    def populate_scenario(scenario_object, parsed_scenario_data)
+      populate_parsing_data(scenario_object, parsed_scenario_data)
+      populate_source_line(scenario_object, parsed_scenario_data)
+      populate_name(scenario_object, parsed_scenario_data)
+      populate_description(scenario_object, parsed_scenario_data)
+      populate_steps(scenario_object, parsed_scenario_data)
+      populate_tags(scenario_object, parsed_scenario_data)
+    end
+
+    def populate_outline(outline_object, parsed_outline_data)
+      populate_parsing_data(outline_object, parsed_outline_data)
+      populate_source_line(outline_object, parsed_outline_data)
+      populate_name(outline_object, parsed_outline_data)
+      populate_description(outline_object, parsed_outline_data)
+      populate_steps(outline_object, parsed_outline_data)
+      populate_tags(outline_object, parsed_outline_data)
+      populate_outline_examples(outline_object, parsed_outline_data['examples']) if parsed_outline_data['examples']
+    end
+
+    def populate_background(background_object, parsed_background_data)
+      populate_parsing_data(background_object, parsed_background_data)
+      populate_name(background_object, parsed_background_data)
+      populate_description(background_object, parsed_background_data)
+      populate_source_line(background_object, parsed_background_data)
+      populate_steps(background_object, parsed_background_data)
+    end
+
+    def populate_step(step_object, parsed_step_data)
+      populate_text(step_object, parsed_step_data)
+      populate_block(step_object, parsed_step_data)
+      populate_keyword(step_object, parsed_step_data)
+      populate_source_line(step_object, parsed_step_data)
+      populate_parsing_data(step_object, parsed_step_data)
+    end
+
+    def populate_block(step_object, parsed_step_data)
+      case
+        when parsed_step_data['table']
+          step_object.block = build_child_model(Table, parsed_step_data['table'])
+        when parsed_step_data['doc_string']
+          step_object.block = build_child_model(DocString, parsed_step_data['doc_string'])
+        else
+          step_object.block = nil
+      end
+    end
+
+    def populate_table(table_object, parsed_table_data)
+      populate_row_models(table_object, parsed_table_data)
+      populate_parsing_data(table_object, parsed_table_data)
+      populate_source_line(table_object, parsed_table_data)
+    end
+
+    def populate_tablerow(row_object, parsed_row_data)
+      populate_source_line(row_object, parsed_row_data)
+      populate_row_cells(row_object, parsed_row_data)
+      populate_parsing_data(row_object, parsed_row_data)
+    end
+
+    def populate_cell(cell_object, parsed_cell_data)
+      populate_cell_value(cell_object, parsed_cell_data)
+      populate_source_line(cell_object, parsed_cell_data)
+      populate_parsing_data(cell_object, parsed_cell_data)
+    end
+
+    def populate_docstring(doc_string_object, parsed_doc_string_data)
+      populate_content_type(doc_string_object, parsed_doc_string_data)
+      populate_content(doc_string_object, parsed_doc_string_data)
+      populate_parsing_data(doc_string_object, parsed_doc_string_data)
+      populate_source_line(doc_string_object, parsed_doc_string_data)
+    end
+
+    def populate_example(example_object, parsed_example_data)
+      populate_parsing_data(example_object, parsed_example_data)
+      populate_source_line(example_object, parsed_example_data)
+      populate_name(example_object, parsed_example_data)
+      populate_description(example_object, parsed_example_data)
+      populate_tags(example_object, parsed_example_data)
+      populate_example_rows(example_object, parsed_example_data)
+    end
+
+    def populate_row(row_object, parsed_row_data)
+      populate_source_line(row_object, parsed_row_data)
+      populate_row_cells(row_object, parsed_row_data)
+      populate_parsing_data(row_object, parsed_row_data)
+    end
+
+    def populate_feature(feature_object, parsed_feature_data)
+      populate_parsing_data(feature_object, parsed_feature_data)
+      populate_source_line(feature_object, parsed_feature_data)
+      populate_name(feature_object, parsed_feature_data)
+      populate_description(feature_object, parsed_feature_data)
+      populate_tags(feature_object, parsed_feature_data)
+      populate_children(feature_object, parsed_feature_data)
+    end
+
+    def populate_directory(directory_object, processed_directory_data)
+      directory_object.path = processed_directory_data['path']
+
+      processed_directory_data['directories'].each do |directory_data|
+        directory_object.directories << build_child_model(Directory, directory_data)
+      end
+
+      processed_directory_data['feature_files'].each do |feature_file_data|
+        directory_object.feature_files << build_child_model(FeatureFile, feature_file_data)
+      end
+    end
+
+    def populate_featurefile(feature_file_object, processed_feature_file_data)
+      feature_file_object.path = processed_feature_file_data['path']
+
+      feature_file_object.feature = build_child_model(Feature, processed_feature_file_data['feature']) unless processed_feature_file_data['feature'].nil?
+    end
+
+    def populate_tag(tag_object, processed_tag_data)
+      populate_name(tag_object, processed_tag_data)
+      populate_parsing_data(tag_object, processed_tag_data)
+      populate_source_line(tag_object, processed_tag_data)
+    end
+
+    def populate_text(step_model, parsed_step_data)
+      step_model.text = parsed_step_data['name']
+    end
+
+    def populate_keyword(step_model, parsed_step_data)
+      step_model.keyword = parsed_step_data['keyword'].strip
+    end
+
+    def populate_row_models(table_model, parsed_table_data)
+      parsed_table_data['rows'].each do |row_data|
+        table_model.rows << build_child_model(Row, row_data)
+      end
+    end
+
+    def populate_row_cells(row_model, parsed_row_data)
+      parsed_row_data['cells'].each do |cell_data|
+        row_model.cells << build_child_model(Cell, cell_data)
+      end
+    end
+
+    def populate_cell_value(cell_model, parsed_cell_data)
+      cell_model.value = parsed_cell_data['value']
+    end
+
+    def populate_content_type(doc_string_model, parsed_doc_string_data)
+      doc_string_model.content_type = parsed_doc_string_data['content_type'] == "" ? nil : parsed_doc_string_data['content_type']
+    end
+
+    def populate_content(doc_string_model, parsed_doc_string_data)
+      doc_string_model.content = parsed_doc_string_data['value']
+    end
+
+    def populate_outline_examples(outline_model, parsed_examples)
+      parsed_examples.each do |example_data|
+        outline_model.examples << build_child_model(Example, example_data)
+      end
+    end
+
+    def populate_example_rows(example_model, parsed_example_data)
+      parsed_example_data['rows'].each do |row_data|
+        example_model.rows << build_child_model(Row, row_data)
+      end
+    end
+
+    def populate_children(feature_model, parsed_feature_data)
+      elements = parsed_feature_data['elements']
+
+      if elements
+        elements.each do |element|
+          case element['keyword']
+            when 'Scenario'
+              feature_model.tests << build_child_model(Scenario, element)
+            when 'Scenario Outline'
+              feature_model.tests << build_child_model(Outline, element)
+            when 'Background'
+              feature_model.background = build_child_model(Background, element)
+            else
+              raise(ArgumentError, "Unknown keyword: #{element['keyword']}")
+          end
+        end
+      end
+    end
+
+    def populate_parsing_data(model, parsed_model_data)
+      model.parsing_data = parsed_model_data['cuke_modeler_parsing_data']
+    end
+
+    def populate_source_line(model, parsed_model_data)
+      model.source_line = parsed_model_data['line']
+    end
+
+    def populate_name(model, parsed_model_data)
+      model.name = parsed_model_data['name']
+    end
+
+    def populate_description(model, parsed_model_data)
+      model.description = trimmed_description(parsed_model_data['description'])
+    end
+
+    def trimmed_description(description)
+      description = description.split("\n")
+
+      trim_leading_blank_lines(description)
+      trim_trailing_blank_lines(description)
+      trim_leading_spaces(description)
+      trim_trailing_spaces(description)
+
+      description.join("\n")
+    end
+
+    def trim_leading_blank_lines(description)
+      description.replace(description.drop_while { |line| line !~ /\S/ })
+    end
+
+    def trim_trailing_blank_lines(description)
+      # Nothing to do. Already done by the parser but leaving this here in case that changes in future versions.
+    end
+
+    def trim_leading_spaces(description)
+      non_blank_lines = description.select { |line| line =~ /\S/ }
+
+      fewest_spaces = non_blank_lines.collect { |line| line[/^\s*/].length }.min || 0
+
+      description.each { |line| line.slice!(0..(fewest_spaces - 1)) } if fewest_spaces > 0
+    end
+
+    def trim_trailing_spaces(description)
+      description.map! { |line| line.rstrip }
+    end
+
+    def populate_tags(model, parsed_model_data)
+      if parsed_model_data['tags']
+        parsed_model_data['tags'].each do |tag|
+          model.tags << build_child_model(Tag, tag)
+        end
+      end
+    end
+
+    def populate_steps(model, parsed_model_data)
+      if parsed_model_data['steps']
+        parsed_model_data['steps'].each do |step_data|
+          model.steps << build_child_model(Step, step_data)
+        end
+      end
     end
 
   end