cuke_modeler 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75c21d56686546ac790c590dda83628ca4eadd92
-  data.tar.gz: 6094f26c8873cfbf4040318ca163a34370432f20
+  metadata.gz: ae2a37ad321f1cf9ea164210a52981ed565a2f5c
+  data.tar.gz: 2eaf5c8db10ddfba8c9ff2a0a0b61198929d98f7
 SHA512:
-  metadata.gz: 78783c9af83fb27735e80bc5f327320224e6ee53260fed2ad89dbf925c4086eb6baac5c2bcbd0157ba6f93f3601b6a9d560c47a68437baa56eee779810d21ff3
-  data.tar.gz: d55ff4646b883721cba7cd0d0210657f39e874cf10a8795ba85061c026dbe4851edce5197d3c2f0ed977273a258959eda9f8276baedf5c54c1db0d10fef8a06e
+  metadata.gz: 9e43d4812d7bb826cc7fabc0a957c6ffd7f8a0b54f518c9ecdea9ebd24e7dd96f63ffb565ecbf58c487eb4c55d5c3953edbcaec7e2a8dce276a88e7bd2b23dd7
+  data.tar.gz: 738a51078b7c0b4551f5a31670f7c42ec5dece16a8d23ac272d2e25d16bd06244926cfb385f25abf4636b1b371c426ba941bd8009aab9b07438bb179208fbb14

data/History.md

@@ -1,3 +1,8 @@
+### Version 1.2.0 / 2016-11-23
+
+* The comments in a feature file are now a modeled element.
+
+
 ### Version 1.1.1 / 2016-10-28
 
 * Bug fix - Abstract instantiation of models when using a non-default dialect 

data/lib/cuke_modeler/adapters/gherkin_2_adapter.rb

@@ -6,14 +6,30 @@ module CukeModeler
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
+      parsed_data = {}
+
+      # The entire AST is just an array with one feature and we don't want to save any child data so...an empty array
+      parsed_data['cuke_modeler_parsing_data'] = []
+
+      # Comments are stored on child elements in gherkin 2.x
+      comments = []
+
       # An AST is just one feature
-      adapt_feature!(parsed_ast.first) if parsed_ast.first
+      adapt_feature!(parsed_ast.first, comments) if parsed_ast.first
+      parsed_data['feature'] = parsed_ast.first
+
+      # Adapt and store comments once they have all been gathered
+      comments.each do |comment|
+        adapt_comment!(comment)
+      end
+      parsed_data['comments'] = comments
 
-      parsed_ast
+
+      [parsed_data]
     end
 
     # Adapts the AST sub-tree that is rooted at the given feature node.
-    def adapt_feature!(parsed_feature)
+    def adapt_feature!(parsed_feature, gathered_comments)
       # Saving off the original data
       parsed_feature['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_feature))
 
@@ -21,8 +37,12 @@ module CukeModeler
       parsed_feature['cuke_modeler_parsing_data']['tags'] = nil
       parsed_feature['cuke_modeler_parsing_data']['elements'] = nil
 
+      if parsed_feature['comments']
+        parsed_feature['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_feature['comments'])
+      end
 
-      adapt_child_elements!(parsed_feature)
+      adapt_child_elements!(parsed_feature, gathered_comments)
 
       if parsed_feature['tags']
         parsed_feature['tags'].each do |tag|
@@ -32,22 +52,27 @@ module CukeModeler
     end
 
     # Adapts the AST sub-tree that is rooted at the given background node.
-    def adapt_background!(parsed_background)
+    def adapt_background!(parsed_background, gathered_comments)
       # Saving off the original data
       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
 
+      if parsed_background['comments']
+        parsed_background['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_background['comments'])
+      end
+
       if parsed_background['steps']
         parsed_background['steps'].each do |step|
-          adapt_step!(step)
+          adapt_step!(step, gathered_comments)
         end
       end
     end
 
     # Adapts the AST sub-tree that is rooted at the given scenario node.
-    def adapt_scenario!(parsed_scenario)
+    def adapt_scenario!(parsed_scenario, gathered_comments)
       # Saving off the original data
       parsed_scenario['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_scenario))
 
@@ -55,6 +80,10 @@ module CukeModeler
       parsed_scenario['cuke_modeler_parsing_data']['tags'] = nil
       parsed_scenario['cuke_modeler_parsing_data']['steps'] = nil
 
+      if parsed_scenario['comments']
+        parsed_scenario['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_scenario['comments'])
+      end
 
       if parsed_scenario['tags']
         parsed_scenario['tags'].each do |tag|
@@ -64,13 +93,13 @@ module CukeModeler
 
       if parsed_scenario['steps']
         parsed_scenario['steps'].each do |step|
-          adapt_step!(step)
+          adapt_step!(step, gathered_comments)
         end
       end
     end
 
     # Adapts the AST sub-tree that is rooted at the given outline node.
-    def adapt_outline!(parsed_outline)
+    def adapt_outline!(parsed_outline, gathered_comments)
       # Saving off the original data
       parsed_outline['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_outline))
 
@@ -79,6 +108,10 @@ module CukeModeler
       parsed_outline['cuke_modeler_parsing_data']['steps'] = nil
       parsed_outline['cuke_modeler_parsing_data']['examples'] = nil
 
+      if parsed_outline['comments']
+        parsed_outline['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_outline['comments'])
+      end
 
       if parsed_outline['tags']
         parsed_outline['tags'].each do |tag|
@@ -88,19 +121,19 @@ module CukeModeler
 
       if parsed_outline['steps']
         parsed_outline['steps'].each do |step|
-          adapt_step!(step)
+          adapt_step!(step, gathered_comments)
         end
       end
 
       if parsed_outline['examples']
         parsed_outline['examples'].each do |example|
-          adapt_example!(example)
+          adapt_example!(example, gathered_comments)
         end
       end
     end
 
     # Adapts the AST sub-tree that is rooted at the given example node.
-    def adapt_example!(parsed_example)
+    def adapt_example!(parsed_example, gathered_comments)
       # Saving off the original data
       parsed_example['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_example))
 
@@ -108,9 +141,13 @@ module CukeModeler
       parsed_example['cuke_modeler_parsing_data']['tags'] = nil
       parsed_example['cuke_modeler_parsing_data']['rows'] = nil
 
+      if parsed_example['comments']
+        parsed_example['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_example['comments'])
+      end
 
       parsed_example['rows'].each do |row|
-        adapt_table_row!(row)
+        adapt_table_row!(row, gathered_comments)
       end
 
       if parsed_example['tags']
@@ -126,8 +163,17 @@ module CukeModeler
       parsed_tag['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_tag))
     end
 
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete('value')
+      parsed_comment['line'] = parsed_comment.delete('line')
+    end
+
     # Adapts the AST sub-tree that is rooted at the given step node.
-    def adapt_step!(parsed_step)
+    def adapt_step!(parsed_step, gathered_comments)
       # Saving off the original data
       parsed_step['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step))
 
@@ -135,12 +181,16 @@ module CukeModeler
       parsed_step['cuke_modeler_parsing_data']['rows'] = nil if parsed_step['cuke_modeler_parsing_data']['rows']
       parsed_step['cuke_modeler_parsing_data']['doc_string'] = nil if parsed_step['cuke_modeler_parsing_data']['doc_string']
 
+      if parsed_step['comments']
+        parsed_step['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_step['comments'])
+      end
 
       adapt_doc_string!(parsed_step['doc_string']) if parsed_step['doc_string']
 
       if parsed_step['rows']
         parsed_step['table'] = {'rows' => parsed_step['rows']}
-        adapt_step_table!(parsed_step['table'])
+        adapt_step_table!(parsed_step['table'], gathered_comments)
       end
     end
 
@@ -151,7 +201,7 @@ module CukeModeler
     end
 
     # Adapts the AST sub-tree that is rooted at the given table node.
-    def adapt_step_table!(parsed_step_table)
+    def adapt_step_table!(parsed_step_table, gathered_comments)
       # Saving off the original data
       parsed_step_table['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_step_table['rows']))
 
@@ -162,18 +212,23 @@ module CukeModeler
       parsed_step_table['line'] = parsed_step_table['rows'].first['line']
 
       parsed_step_table['rows'].each do |row|
-        adapt_table_row!(row)
+        adapt_table_row!(row, gathered_comments)
       end
     end
 
     # Adapts the AST sub-tree that is rooted at the given row node.
-    def adapt_table_row!(parsed_table_row)
+    def adapt_table_row!(parsed_table_row, gathered_comments)
       # Saving off the original data
       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
 
+      if parsed_table_row['comments']
+        parsed_table_row['cuke_modeler_parsing_data']['comments'] = nil
+        gathered_comments.concat(parsed_table_row['comments'])
+      end
+
       parsed_table_row['cells'].collect! do |cell|
         create_cell_for(cell, parsed_table_row['line'])
       end
@@ -197,16 +252,16 @@ module CukeModeler
     private
 
 
-    def adapt_child_elements!(parsed_feature)
+    def adapt_child_elements!(parsed_feature, gathered_comments)
       if parsed_feature['elements']
         parsed_feature['elements'].each do |element|
           case element['type']
             when 'background'
-              adapt_background!(element)
+              adapt_background!(element, gathered_comments)
             when 'scenario'
-              adapt_scenario!(element)
+              adapt_scenario!(element, gathered_comments)
             when 'scenario_outline'
-              adapt_outline!(element)
+              adapt_outline!(element, gathered_comments)
             else
               raise("Unknown element type: #{element['type']}")
           end

data/lib/cuke_modeler/adapters/gherkin_3_adapter.rb

@@ -6,10 +6,24 @@ module CukeModeler
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
+      parsed_data = {}
+
+      # No data exists stored above feature level
+      parsed_data['cuke_modeler_parsing_data'] = nil
+
+      # Comments are stored on the feature in gherkin 3.x
+      parsed_data['comments'] = []
+      parsed_ast[:comments].each do |comment|
+        adapt_comment!(comment)
+      end
+      parsed_data['comments'].concat(parsed_ast.delete(:comments))
+
       # An AST is just one feature
       adapt_feature!(parsed_ast)
 
-      [parsed_ast]
+      parsed_data['feature'] = parsed_ast
+
+      [parsed_data]
     end
 
     # Adapts the AST sub-tree that is rooted at the given feature node.
@@ -21,6 +35,7 @@ module CukeModeler
       parsed_feature['cuke_modeler_parsing_data'][:tags] = nil
       parsed_feature['cuke_modeler_parsing_data'][:scenarioDefinitions] = nil
       parsed_feature['cuke_modeler_parsing_data'][:background] = nil
+      parsed_feature['cuke_modeler_parsing_data'][:comments] = nil
 
       parsed_feature['keyword'] = parsed_feature.delete(:keyword)
       parsed_feature['name'] = parsed_feature.delete(:name)
@@ -154,6 +169,15 @@ module CukeModeler
       parsed_tag['line'] = parsed_tag.delete(:location)[:line]
     end
 
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete(:text)
+      parsed_comment['line'] = parsed_comment.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

data/lib/cuke_modeler/adapters/gherkin_4_adapter.rb

@@ -6,9 +6,24 @@ module CukeModeler
 
     # Adapts the given AST into the shape that this gem expects
     def adapt(parsed_ast)
+      # Saving off the original data
+      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
+
+      # Comments are stored on the feature file in gherkin 4.x
+      parsed_ast['comments'] = []
+      parsed_ast[:comments].each do |comment|
+        adapt_comment!(comment)
+      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[:feature]].compact
+      [parsed_ast]
     end
 
     # Adapts the AST sub-tree that is rooted at the given feature node.
@@ -157,6 +172,15 @@ module CukeModeler
       parsed_tag['line'] = parsed_tag.delete(:location)[:line]
     end
 
+    # Adapts the AST sub-tree that is rooted at the given comment node.
+    def adapt_comment!(parsed_comment)
+      # Saving off the original data
+      parsed_comment['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_comment))
+
+      parsed_comment['text'] = parsed_comment.delete(:text)
+      parsed_comment['line'] = parsed_comment.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

data/lib/cuke_modeler/containing.rb

@@ -133,9 +133,14 @@ module CukeModeler
     end
 
     def populate_featurefile(feature_file_object, processed_feature_file_data)
+      populate_parsing_data(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?
+
+      processed_feature_file_data['comments'].each do |comment_data|
+        feature_file_object.comments << build_child_model(Comment, comment_data)
+      end
     end
 
     def populate_tag(tag_object, processed_tag_data)
@@ -144,6 +149,16 @@ module CukeModeler
       populate_source_line(tag_object, processed_tag_data)
     end
 
+    def populate_comment(comment_object, processed_comment_data)
+      populate_comment_text(comment_object, processed_comment_data)
+      populate_parsing_data(comment_object, processed_comment_data)
+      populate_source_line(comment_object, processed_comment_data)
+    end
+
+    def populate_comment_text(comment_model, parsed_comment_data)
+      comment_model.text = parsed_comment_data['text'].strip
+    end
+
     def populate_text(step_model, parsed_step_data)
       step_model.text = parsed_step_data['name']
     end

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['elements'].first
+      parsed_file.first['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['elements'].first['steps'].first['table']['rows'].first['cells'].first
+      parsed_file.first['feature']['elements'].first['steps'].first['table']['rows'].first['cells'].first
     end
 
   end

data/lib/cuke_modeler/models/comment.rb

@@ -0,0 +1,47 @@
+module CukeModeler
+
+  # A class modeling a comment in a feature file.
+
+  class Comment < Model
+
+    include Parsing
+    include Parsed
+    include Sourceable
+
+
+    # The text of the comment
+    attr_accessor :text
+
+
+    # Creates a new Comment object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      super(source_text)
+
+      if source_text
+        parsed_comment_data = parse_source(source_text)
+        populate_comment(self, parsed_comment_data)
+      end
+    end
+
+    # Returns a string representation of this model. For a comment model,
+    # this will be Gherkin text that is equivalent to the comment being modeled.
+    def to_s
+      text || ''
+    end
+
+
+    private
+
+
+    def parse_source(source_text)
+      base_file_string = "\n#{dialect_feature_keyword}: Fake feature to parse"
+      source_text = "# language: #{Parsing.dialect}\n" + source_text + base_file_string
+
+      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_comment.feature')
+
+      parsed_file.first['comments'].last
+    end
+
+  end
+end