cuke_modeler 1.4.0 → 3.0.0

data/lib/cuke_modeler/adapters/gherkin_10_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 10.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin10Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_11_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 11.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin11Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_12_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 12.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin12Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/gherkin_13_adapter.rb

@@ -0,0 +1,12 @@
+require_relative 'gherkin_9_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 13.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
+
+  class Gherkin13Adapter < Gherkin9Adapter
+
+  end
+end

data/lib/cuke_modeler/adapters/{gherkin_6_adapter.rb → gherkin_9_adapter.rb}

@@ -1,8 +1,9 @@
 module CukeModeler
 
-  # An adapter that can convert the output of version 6.x of the *gherkin* gem into input that is consumable by this gem.
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 9.x of the *cucumber-gherkin* gem into input that is consumable by this gem.
 
-  class Gherkin6Adapter
+  class Gherkin9Adapter
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
@@ -10,20 +11,21 @@ module CukeModeler
       parsed_ast['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_ast))
 
       # Removing parsed data for child elements in order to avoid duplicating data
-      parsed_ast['cuke_modeler_parsing_data'][:feature] = nil
-      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil
+      parsed_ast['cuke_modeler_parsing_data'][:feature] = nil if parsed_ast['cuke_modeler_parsing_data'][:feature]
+      parsed_ast['cuke_modeler_parsing_data'][:comments] = nil if parsed_ast['cuke_modeler_parsing_data'][:comments]
 
-      # Comments are stored on the feature file in gherkin 4.x
       parsed_ast['comments'] = []
-      parsed_ast[:comments].each do |comment|
-        adapt_comment!(comment)
+      if parsed_ast[:comments]
+        parsed_ast[:comments].each do |comment|
+          adapt_comment!(comment)
+        end
+        parsed_ast['comments'].concat(parsed_ast.delete(:comments))
       end
-      parsed_ast['comments'].concat(parsed_ast.delete(:comments))
 
       adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
       parsed_ast['feature'] = parsed_ast.delete(:feature)
 
-      [parsed_ast]
+      parsed_ast
     end
 
     # Adapts the AST sub-tree that is rooted at the given feature node.
@@ -32,23 +34,27 @@ module CukeModeler
       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['cuke_modeler_parsing_data'][:tags] = nil if parsed_feature['cuke_modeler_parsing_data'][:tags]
+      parsed_feature['cuke_modeler_parsing_data'][:children] = nil if parsed_feature['cuke_modeler_parsing_data'][:children]
 
       parsed_feature['keyword'] = parsed_feature.delete(:keyword)
       parsed_feature['name'] = parsed_feature.delete(:name)
-      parsed_feature['description'] = parsed_feature.delete(:description)
+      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))
+      if parsed_feature[:children]
+        adapt_child_elements!(parsed_feature[:children])
+        parsed_feature['elements'].concat(parsed_feature.delete(:children))
+      end
 
       parsed_feature['tags'] = []
-      parsed_feature[:tags].each do |tag|
-        adapt_tag!(tag)
+      if parsed_feature[:tags]
+        parsed_feature[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_feature['tags'].concat(parsed_feature.delete(:tags))
       end
-      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
     end
 
     # Adapts the AST sub-tree that is rooted at the given background node.
@@ -57,76 +63,88 @@ module CukeModeler
       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'][:background][:steps] = nil
+      parsed_background['cuke_modeler_parsing_data'][:background][:steps] = nil if parsed_background['cuke_modeler_parsing_data'][:background][:steps]
 
       parsed_background['type'] = 'Background'
       parsed_background['keyword'] = parsed_background[:background].delete(:keyword)
       parsed_background['name'] = parsed_background[:background].delete(:name)
-      parsed_background['description'] = parsed_background[:background].delete(:description)
+      parsed_background['description'] = parsed_background[:background].delete(:description) || ''
       parsed_background['line'] = parsed_background[:background].delete(:location)[:line]
 
       parsed_background['steps'] = []
-      parsed_background[:background][:steps].each do |step|
-        adapt_step!(step)
+      if parsed_background[:background][:steps]
+        parsed_background[:background][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
       end
-      parsed_background['steps'].concat(parsed_background[:background].delete(:steps))
     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'][:scenario][:tags] = nil
-      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:tags]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:steps]
 
       parsed_test['type'] = 'Scenario'
       parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
       parsed_test['name'] = parsed_test[:scenario].delete(:name)
-      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description) || ''
       parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
 
       parsed_test['tags'] = []
-      parsed_test[:scenario][:tags].each do |tag|
-        adapt_tag!(tag)
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
       end
-      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
 
       parsed_test['steps'] = []
-      parsed_test[:scenario][:steps].each do |step|
-        adapt_step!(step)
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
       end
-      parsed_test['steps'].concat(parsed_test[:scenario].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'][:scenario][:tags] = nil
-      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil
-      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:tags] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:tags]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:steps] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:steps]
+      parsed_test['cuke_modeler_parsing_data'][:scenario][:examples] = nil if parsed_test['cuke_modeler_parsing_data'][:scenario][:examples]
 
       parsed_test['type'] = 'ScenarioOutline'
       parsed_test['keyword'] = parsed_test[:scenario].delete(:keyword)
       parsed_test['name'] = parsed_test[:scenario].delete(:name)
-      parsed_test['description'] = parsed_test[:scenario].delete(:description)
+      parsed_test['description'] = parsed_test[:scenario].delete(:description) || ''
       parsed_test['line'] = parsed_test[:scenario].delete(:location)[:line]
 
       parsed_test['tags'] = []
-      parsed_test[:scenario][:tags].each do |tag|
-        adapt_tag!(tag)
+      if parsed_test[:scenario][:tags]
+        parsed_test[:scenario][:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
       end
-      parsed_test['tags'].concat(parsed_test[:scenario].delete(:tags))
 
       parsed_test['steps'] = []
-      parsed_test[:scenario][:steps].each do |step|
-        adapt_step!(step)
+      if parsed_test[:scenario][:steps]
+        parsed_test[:scenario][:steps].each do |step|
+          adapt_step!(step)
+        end
+        parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
       end
-      parsed_test['steps'].concat(parsed_test[:scenario].delete(:steps))
 
       parsed_test['examples'] = []
-      parsed_test[:scenario][:examples].each do |step|
-        adapt_example!(step)
+      if parsed_test[:scenario][:examples]
+        parsed_test[:scenario][:examples].each do |step|
+          adapt_example!(step)
+        end
+        parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
       end
-      parsed_test['examples'].concat(parsed_test[:scenario].delete(:examples))
     end
 
     # Adapts the AST sub-tree that is rooted at the given example node.
@@ -135,14 +153,14 @@ module CukeModeler
       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'][:table_header] = nil
-      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil
+      parsed_example['cuke_modeler_parsing_data'][:tags] = nil if parsed_example['cuke_modeler_parsing_data'][:tags]
+      parsed_example['cuke_modeler_parsing_data'][:table_header] = nil if parsed_example['cuke_modeler_parsing_data'][:table_header]
+      parsed_example['cuke_modeler_parsing_data'][:table_body] = nil if parsed_example['cuke_modeler_parsing_data'][:table_body]
 
       parsed_example['keyword'] = parsed_example.delete(:keyword)
       parsed_example['name'] = parsed_example.delete(:name)
       parsed_example['line'] = parsed_example.delete(:location)[:line]
-      parsed_example['description'] = parsed_example.delete(:description)
+      parsed_example['description'] = parsed_example.delete(:description) || ''
 
       parsed_example['rows'] = []
 
@@ -152,19 +170,19 @@ module CukeModeler
       end
 
       if parsed_example[:table_body]
-
         parsed_example[:table_body].each do |row|
           adapt_table_row!(row)
         end
         parsed_example['rows'].concat(parsed_example.delete(:table_body))
       end
 
-
       parsed_example['tags'] = []
-      parsed_example[:tags].each do |tag|
-        adapt_tag!(tag)
+      if parsed_example[:tags]
+        parsed_example[:tags].each do |tag|
+          adapt_tag!(tag)
+        end
+        parsed_example['tags'].concat(parsed_example.delete(:tags))
       end
-      parsed_example['tags'].concat(parsed_example.delete(:tags))
     end
 
     # Adapts the AST sub-tree that is rooted at the given tag node.
@@ -191,14 +209,13 @@ module CukeModeler
       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'][:data_table] = nil
-      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil
+      parsed_step['cuke_modeler_parsing_data'][:data_table] = nil if parsed_step['cuke_modeler_parsing_data'][:data_table]
+      parsed_step['cuke_modeler_parsing_data'][:doc_string] = nil if parsed_step['cuke_modeler_parsing_data'][:doc_string]
 
       parsed_step['keyword'] = parsed_step.delete(:keyword)
       parsed_step['name'] = parsed_step.delete(:text)
       parsed_step['line'] = parsed_step.delete(:location)[:line]
 
-
       case
         when parsed_step[:doc_string]
           adapt_doc_string!(parsed_step[:doc_string])
@@ -217,7 +234,7 @@ module CukeModeler
       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(:content_type).strip # TODO: fix bug in Gherkin so that this whitespace is already trimmed off
+      parsed_doc_string['content_type'] = parsed_doc_string.delete(:media_type)
       parsed_doc_string['line'] = parsed_doc_string.delete(:location)[:line]
     end
 
@@ -245,7 +262,6 @@ module CukeModeler
       # 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'] = []
@@ -269,8 +285,6 @@ module CukeModeler
 
 
     def adapt_child_elements!(parsed_children)
-      return if parsed_children.empty?
-
       background_child = parsed_children.find { |child| child[:background] }
 
       if background_child
@@ -283,8 +297,6 @@ module CukeModeler
     end
 
     def adapt_tests!(parsed_tests)
-      return unless parsed_tests
-
       parsed_tests.each do |test|
         adapt_test!(test)
       end
@@ -294,9 +306,8 @@ module CukeModeler
       # Saving off the original data
       parsed_test['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_test))
 
-
       case
-        when parsed_test[:scenario] && parsed_test[:scenario][:examples].any?
+        when (parsed_test[:scenario] && parsed_test[:scenario][:examples]) || (parsed_test[:scenario] && Parsing.dialects[Parsing.dialect]['scenarioOutline'].include?(parsed_test[:scenario][:keyword]))
           adapt_outline!(parsed_test)
         when parsed_test[:scenario]
           adapt_scenario!(parsed_test)

data/lib/cuke_modeler/containing.rb

@@ -1,9 +1,25 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that contain other models.
 
   module Containing
 
+    # Executes the given code block with every model that is a child of this model.
+    def each_descendant(&block)
+      children.each do |child_model|
+        block.call(child_model)
+        child_model.each_descendant(&block) if child_model.respond_to?(:each_descendant)
+      end
+    end
+
+    # Executes the given code block with this model and every model that is a child of this model.
+    def each_model(&block)
+      block.call(self)
+
+      each_descendant(&block)
+    end
+
 
     private
 

data/lib/cuke_modeler/described.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that represent an element that has a description.
 
   module Described

data/lib/cuke_modeler/models/background.rb

@@ -64,7 +64,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_background.feature')
 
-      parsed_file.first['feature']['elements'].first
+      parsed_file['feature']['elements'].first
     end
 
   end

data/lib/cuke_modeler/models/cell.rb

@@ -41,7 +41,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_cell.feature')
 
-      parsed_file.first['feature']['elements'].first['steps'].first['table']['rows'].first['cells'].first
+      parsed_file['feature']['elements'].first['steps'].first['table']['rows'].first['cells'].first
     end
 
   end

data/lib/cuke_modeler/models/comment.rb

@@ -40,7 +40,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_comment.feature')
 
-      parsed_file.first['comments'].last
+      parsed_file['comments'].last
     end
 
   end

data/lib/cuke_modeler/models/directory.rb

@@ -82,8 +82,8 @@ module CukeModeler
     def process_feature_file(file_path)
       source_text = IO.read(file_path)
 
-      feature_file_data = Parsing::parse_text(source_text, file_path).first
-      feature_file_data = feature_file_data.merge({'path' => file_path})
+      feature_file_data = Parsing::parse_text(source_text, file_path)
+      feature_file_data = feature_file_data.merge({ 'path' => file_path })
 
       feature_file_data
     end

data/lib/cuke_modeler/models/doc_string.rb

@@ -45,7 +45,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_doc_string.feature')
 
-      parsed_file.first['feature']['elements'].first['steps'].first['doc_string']
+      parsed_file['feature']['elements'].first['steps'].first['doc_string']
     end
 
     def content_type_output_string

data/lib/cuke_modeler/models/example.rb

@@ -124,7 +124,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_example.feature')
 
-      parsed_file.first['feature']['elements'].first['examples'].first
+      parsed_file['feature']['elements'].first['examples'].first
     end
 
     def determine_buffer_size(index)

data/lib/cuke_modeler/models/feature.rb

@@ -90,7 +90,7 @@ module CukeModeler
     def parse_source(source_text)
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_feature.feature')
 
-      parsed_file.first['feature']
+      parsed_file['feature']
     end
 
     def background_output_string