cuke_modeler 3.2.0 → 3.7.0

data/lib/cuke_modeler/containing.rb

@@ -1,11 +1,28 @@
+# It's the module that has functionality for every possible model type. So, yes, it's long.
+# rubocop:disable Metrics/ModuleLength
+
 module CukeModeler
 
   # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that contain other models.
-
   module Containing
 
+    include Enumerable
+
+    # Executes the given code block with this model and every model that is a child of this model. Exact
+    # order of model tree traversal is not guaranteed beyond the first model traversed, which will be the
+    # model that called this method. If no block is provided, an `Enumerator` is returned instead.
+    def each(&block)
+      if block
+        block.call(self)
+        children.each { |child| child.each(&block) }
+      else
+        to_enum(:each)
+      end
+    end
+
     # Executes the given code block with every model that is a child of this model.
+    # DEPRECATED: use `Enumerable` module methods instead
     def each_descendant(&block)
       children.each do |child_model|
         block.call(child_model)
@@ -14,6 +31,7 @@ module CukeModeler
     end
 
     # Executes the given code block with this model and every model that is a child of this model.
+    # DEPRECATED: use `Enumerable` module methods instead
     def each_model(&block)
       block.call(self)
 
@@ -74,14 +92,11 @@ module CukeModeler
     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
+      step_object.block = if parsed_step_data['table']
+                            build_child_model(Table, parsed_step_data['table'])
+                          elsif parsed_step_data['doc_string']
+                            build_child_model(DocString, parsed_step_data['doc_string'])
+                          end
     end
 
     def populate_table(table_object, parsed_table_data)
@@ -154,7 +169,9 @@ module CukeModeler
       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?
+      if processed_feature_file_data['feature']
+        feature_file_object.feature = build_child_model(Feature, processed_feature_file_data['feature'])
+      end
 
       processed_feature_file_data['comments'].each do |comment_data|
         feature_file_object.comments << build_child_model(Comment, comment_data)
@@ -202,7 +219,7 @@ module CukeModeler
     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']
+      doc_string_model.content_type = parsed_doc_string_data['content_type']
     end
 
     def populate_content(doc_string_model, parsed_doc_string_data)
@@ -221,89 +238,29 @@ module CukeModeler
       end
     end
 
-    def populate_children(model, parsed_feature_data)
-      elements = parsed_feature_data['elements']
-
-      if elements
-        elements.each do |element|
-          case element['type']
-            when 'Scenario', 'scenario'
-              model.tests << build_child_model(Scenario, element)
-            when 'ScenarioOutline', 'scenario_outline'
-              model.tests << build_child_model(Outline, element)
-            when 'Background', 'background'
-              model.background = build_child_model(Background, element)
-            when 'Rule'
-              model.rules << build_child_model(Rule, element)
-            else
-              raise(ArgumentError, "Unknown element type: #{element['type']}")
-          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
+    # It's not getting better any time soon
+    # rubocop:disable Metrics/AbcSize
 
-      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)
+    def populate_children(model, parsed_feature_data)
+      return unless parsed_feature_data['elements']
+
+      parsed_feature_data['elements'].each do |element|
+        case element['type']
+          when 'Scenario', 'scenario'
+            model.tests << build_child_model(Scenario, element)
+          when 'ScenarioOutline', 'scenario_outline'
+            model.tests << build_child_model(Outline, element)
+          when 'Background', 'background'
+            model.background = build_child_model(Background, element)
+          when 'Rule'
+            model.rules << build_child_model(Rule, element)
+          else
+            raise(ArgumentError, "Unknown element type: #{element['type']}")
         end
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/cuke_modeler/described.rb

@@ -2,7 +2,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
 
     # The description of the element
@@ -19,11 +18,50 @@ module CukeModeler
         description_lines = description.split("\n")
 
         text << "\n" if description_lines.first =~ /\S/
-        text << description_lines.collect { |line| "#{line}" }.join("\n")
+        text << description_lines.join("\n")
       end
 
       text
     end
 
+    def no_description_to_output?
+      description.nil? || description.empty?
+    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.positive?
+    end
+
+    def trim_trailing_spaces(description)
+      description.map!(&:rstrip)
+    end
+
   end
 end

data/lib/cuke_modeler/models/background.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a feature's background.
-
   class Background < Model
 
     include Parsing
@@ -23,17 +22,17 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_background_data = parse_source(source_text)
-        populate_background(self, parsed_background_data)
-      end
+      return unless source_text
+
+      parsed_background_data = parse_source(source_text)
+      populate_background(self, parsed_background_data)
     end
 
     # Returns *true* if the two models have equivalent steps and *false* otherwise.
-    def ==(other_model)
-      return false unless other_model.respond_to?(:steps)
+    def ==(other)
+      return false unless other.respond_to?(:steps)
 
-      steps == other_model.steps
+      steps == other.steps
     end
 
     # Returns the model objects that belong to this model.
@@ -47,9 +46,9 @@ module CukeModeler
       text = ''
 
       text << "#{@keyword}:#{name_output_string}"
-      text << "\n" + description_output_string unless (description.nil? || description.empty?)
-      text << "\n" unless (steps.empty? || description.nil? || description.empty?)
-      text << "\n" + steps_output_string unless steps.empty?
+      text << "\n#{description_output_string}" unless no_description_to_output?
+      text << "\n" unless steps.empty? || no_description_to_output?
+      text << "\n#{steps_output_string}" unless steps.empty?
 
       text
     end
@@ -62,7 +61,7 @@ module CukeModeler
       base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: Fake feature to parse\n"
       source_text = base_file_string + source_text
 
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_background.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_background.feature')
 
       parsed_file['feature']['elements'].first
     end

data/lib/cuke_modeler/models/cell.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a single cell of a row.
-
   class Cell < Model
 
     include Sourceable
@@ -18,10 +17,10 @@ module CukeModeler
     def initialize(source_text = nil)
       super(source_text)
 
-      if source_text
-        parsed_cell_data = parse_source(source_text)
-        populate_cell(self, parsed_cell_data)
-      end
+      return unless source_text
+
+      parsed_cell_data = parse_source(source_text)
+      populate_cell(self, parsed_cell_data)
     end
 
     # Returns a string representation of this model. For a cell model,
@@ -35,14 +34,20 @@ module CukeModeler
     private
 
 
+    # It's only considered complex because of how deeply nested cells are in the tree. It's not REALLY complex.
+    # rubocop:disable Metrics/AbcSize
     def parse_source(source_text)
-      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: Fake feature to parse\n#{dialect_scenario_keyword}:\n#{dialect_step_keyword} fake step\n"
-      source_text = base_file_string + '|' + source_text + '|'
+      base_file_string = "# language: #{Parsing.dialect}
+      #{dialect_feature_keyword}: Fake feature to parse
+                            #{dialect_scenario_keyword}:
+                              #{dialect_step_keyword} fake step\n"
+      source_text = "#{base_file_string}|#{source_text}|"
 
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_cell.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_cell.feature')
 
       parsed_file['feature']['elements'].first['steps'].first['table']['rows'].first['cells'].first
     end
+    # rubocop:enable Metrics/AbcSize
 
   end
 

data/lib/cuke_modeler/models/comment.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a comment in a feature file.
-
   class Comment < Model
 
     include Parsing
@@ -18,10 +17,10 @@ module CukeModeler
     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
+      return unless source_text
+
+      parsed_comment_data = parse_source(source_text)
+      populate_comment(self, parsed_comment_data)
     end
 
     # Returns a string representation of this model. For a comment model,
@@ -38,7 +37,7 @@ module CukeModeler
       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 = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_comment.feature')
 
       parsed_file['comments'].last
     end

data/lib/cuke_modeler/models/directory.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a directory in a Cucumber suite.
-
   class Directory < Model
 
 
@@ -24,12 +23,11 @@ module CukeModeler
 
       super(directory_path)
 
-      if directory_path
-        raise(ArgumentError, "Unknown directory: #{directory_path.inspect}") unless File.exists?(directory_path)
+      return unless directory_path
+      raise(ArgumentError, "Unknown directory: #{directory_path.inspect}") unless File.exist?(directory_path)
 
-        processed_directory_data = process_directory(directory_path)
-        populate_directory(self, processed_directory_data)
-      end
+      processed_directory_data = process_directory(directory_path)
+      populate_directory(self, processed_directory_data)
     end
 
     # Returns the name of the modeled directory.
@@ -53,10 +51,9 @@ module CukeModeler
 
 
     def process_directory(directory_path)
-      directory_data = {'path' => directory_path,
-                        'directories' => [],
-                        'feature_files' => []
-      }
+      directory_data = { 'path'          => directory_path,
+                         'directories'   => [],
+                         'feature_files' => [] }
 
       entries = Dir.entries(directory_path)
       entries.delete '.'
@@ -65,13 +62,11 @@ module CukeModeler
       entries.each do |entry|
         entry = "#{directory_path}/#{entry}"
 
-        case
-          when File.directory?(entry)
-            directory_data['directories'] << process_directory(entry)
-          when entry =~ /\.feature$/
-            directory_data['feature_files'] << process_feature_file(entry)
-          else
-            # Ignore anything that isn't a directory or a feature file
+        # Ignore anything that isn't a directory or a feature file
+        if File.directory?(entry)
+          directory_data['directories'] << process_directory(entry)
+        elsif entry =~ /\.feature$/
+          directory_data['feature_files'] << process_feature_file(entry)
         end
       end
 
@@ -82,7 +77,7 @@ module CukeModeler
     def process_feature_file(file_path)
       source_text = IO.read(file_path)
 
-      feature_file_data = Parsing::parse_text(source_text, 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

data/lib/cuke_modeler/models/doc_string.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a step's doc string.
-
   class DocString < Model
 
     include Parsing
@@ -21,10 +20,10 @@ module CukeModeler
     def initialize(source_text = nil)
       super(source_text)
 
-      if source_text
-        parsed_doc_string_data = parse_source(source_text)
-        populate_docstring(self, parsed_doc_string_data)
-      end
+      return unless source_text
+
+      parsed_doc_string_data = parse_source(source_text)
+      populate_docstring(self, parsed_doc_string_data)
     end
 
     # Returns a string representation of this model. For a doc string model,
@@ -40,10 +39,13 @@ module CukeModeler
 
 
     def parse_source(source_text)
-      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}:\n#{dialect_scenario_keyword}:\n#{dialect_step_keyword} step\n"
+      base_file_string = "# language: #{Parsing.dialect}
+      #{dialect_feature_keyword}:
+                            #{dialect_scenario_keyword}:
+                              #{dialect_step_keyword} step\n"
       source_text = base_file_string + source_text
 
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_doc_string.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_doc_string.feature')
 
       parsed_file['feature']['elements'].first['steps'].first['doc_string']
     end
@@ -53,7 +55,7 @@ module CukeModeler
     end
 
     def content_output_string
-      (content.nil? || content.empty?) ? '' : content.gsub('"""', '\"\"\"') + "\n"
+      content.nil? || content.empty? ? '' : content.gsub('"""', '\"\"\"') + "\n"
     end
 
   end