cuke_modeler 2.1.0 → 3.4.0

data/lib/cuke_modeler/containing.rb

@@ -1,3 +1,6 @@
+# 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
@@ -32,7 +35,6 @@ module CukeModeler
 
       model.parent_model = self
 
-
       model
     end
 
@@ -75,14 +77,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)
@@ -130,6 +129,15 @@ module CukeModeler
       populate_children(feature_object, parsed_feature_data)
     end
 
+    def populate_rule(rule_object, parsed_rule_data)
+      populate_parsing_data(rule_object, parsed_rule_data)
+      populate_source_line(rule_object, parsed_rule_data)
+      populate_keyword(rule_object, parsed_rule_data)
+      populate_name(rule_object, parsed_rule_data)
+      populate_description(rule_object, parsed_rule_data)
+      populate_children(rule_object, parsed_rule_data)
+    end
+
     def populate_directory(directory_object, processed_directory_data)
       directory_object.path = processed_directory_data['path']
 
@@ -146,7 +154,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)
@@ -194,7 +204,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)
@@ -213,87 +223,29 @@ module CukeModeler
       end
     end
 
-    def populate_children(feature_model, parsed_feature_data)
-      elements = parsed_feature_data['elements']
-
-      if elements
-        elements.each do |element|
-          case element['type']
-            when 'Scenario', 'scenario'
-              feature_model.tests << build_child_model(Scenario, element)
-            when 'ScenarioOutline', 'scenario_outline'
-              feature_model.tests << build_child_model(Outline, element)
-            when 'Background', 'background'
-              feature_model.background = build_child_model(Background, 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
-
-      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)
+    # It's not getting better any time soon
+    # rubocop:disable Metrics/AbcSize
+
+    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

@@ -19,11 +19,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

@@ -23,17 +23,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 +47,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,9 +62,9 @@ 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.first['feature']['elements'].first
+      parsed_file['feature']['elements'].first
     end
 
   end

data/lib/cuke_modeler/models/cell.rb

@@ -18,10 +18,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 +35,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.first['feature']['elements'].first['steps'].first['table']['rows'].first['cells'].first
+      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

@@ -18,10 +18,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,9 +38,9 @@ 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.first['comments'].last
+      parsed_file['comments'].last
     end
 
   end

data/lib/cuke_modeler/models/directory.rb

@@ -24,12 +24,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 +52,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 +63,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,8 +78,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

@@ -21,10 +21,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,12 +40,15 @@ 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.first['feature']['elements'].first['steps'].first['doc_string']
+      parsed_file['feature']['elements'].first['steps'].first['doc_string']
     end
 
     def content_type_output_string
@@ -53,7 +56,7 @@ module CukeModeler
     end
 
     def content_output_string
-      (content.nil? || content.empty?) ? '' : content.gsub('"""', '\"\"\"') + "\n"
+      content.nil? || content.empty? ? '' : content.gsub('"""', '\"\"\"') + "\n"
     end
 
   end

data/lib/cuke_modeler/models/example.rb

@@ -1,3 +1,6 @@
+# I'll take extra class length due to extra helper methods over having fewer but more complex methods
+# rubocop:disable Metrics/ClassLength
+
 module CukeModeler
 
   # A class modeling an example table of an outline.
@@ -27,10 +30,10 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_example_data = parse_source(source_text)
-        populate_example(self, parsed_example_data)
-      end
+      return unless source_text
+
+      parsed_example_data = parse_source(source_text)
+      populate_example(self, parsed_example_data)
     end
 
     # Adds a row to the example table. The row can be given as a Hash of
@@ -40,42 +43,39 @@ module CukeModeler
       raise('Cannot add a row. No parameters have been set.') if rows.empty?
 
       # A quick 'deep clone' so that the input isn't modified
-      row = Marshal::load(Marshal.dump(row))
-
-      case
-        when row.is_a?(Array)
-          # 'stringify' input
-          row.collect! { |value| value.to_s }
-
-          @rows << Row.new("|#{row.join('|')}|")
-        when row.is_a?(Hash)
-          # 'stringify' input
-          row = row.inject({}) { |hash, (key, value)| hash[key.to_s] = value.to_s; hash }
-
-          @rows << Row.new("|#{ordered_row_values(row).join('|')}|")
-        else
-          raise(ArgumentError, "Can only add row from a Hash or an Array but received #{row.class}")
-      end
+      row = Marshal.load(Marshal.dump(row))
+
+      values = if row.is_a?(Array)
+                 row
+               elsif row.is_a?(Hash)
+                 # There is no guarantee that the user built up their hash with the keys in the same order as
+                 # the parameter row and so the values have to be ordered by us. Additionally, the hash needs
+                 # to have string keys in order for #order_row_values to work
+                 ordered_row_values(stringify_keys(row))
+               else
+                 raise(ArgumentError, "Can only add row from a Hash or an Array but received #{row.class}")
+               end
+
+      @rows << Row.new("|#{values.join('|')}|")
     end
 
     # Removes a row from the example table. The row can be given as a Hash of
     # parameters and their corresponding values or as an Array of values
     # which will be assigned in order.
     def remove_row(row_removed)
-      return unless argument_rows
-
-      case
-        when row_removed.is_a?(Array)
-          location = argument_rows.index { |row| row.cells.collect { |cell| cell.value } == row_removed.collect { |value| value.strip } }
-        when row_removed.is_a?(Hash)
-          # Note: the hash value order has to be manually calculated because Ruby 1.8.7 does not have ordered 
-          # hash keys. Alternatively, the hash may have simply been built up 'willy nilly' by the user instead 
-          # of being built up in order according to the parameter order.
-          location = argument_rows.index { |row| row.cells.collect { |cell| cell.value } == ordered_row_values(row_removed.each_value { |value| value.strip! }) }
-        else
-          raise(ArgumentError, "Can only remove row from a Hash or an Array but received #{row_removed.class}")
-      end
-
+      return if argument_rows.empty?
+
+      values = if row_removed.is_a?(Array)
+                 row_removed
+               elsif row_removed.is_a?(Hash)
+                 # There is no guarantee that the user built up their hash with the keys in the same order as
+                 # the parameter row and so the values have to be ordered by us.
+                 ordered_row_values(row_removed)
+               else
+                 raise(ArgumentError, "Can only remove row from a Hash or an Array but received #{row_removed.class}")
+               end
+
+      location = index_for_values(values.map(&:to_s).map(&:strip))
       @rows.delete_at(location + 1) if location
     end
 
@@ -91,7 +91,7 @@ module CukeModeler
 
     # Returns the parameters of the example table
     def parameters
-      parameter_row ? parameter_row.cells.collect { |cell| cell.value } : []
+      parameter_row ? parameter_row.cells.map(&:value) : []
     end
 
     # Returns the model objects that belong to this model.
@@ -99,32 +99,40 @@ module CukeModeler
       rows + tags
     end
 
+    # Building strings just isn't pretty
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
     # Returns a string representation of this model. For an example model,
     # this will be Gherkin text that is equivalent to the example being modeled.
     def to_s
       text = ''
 
-      text << tag_output_string + "\n" unless tags.empty?
+      text << "#{tag_output_string}\n" unless tags.empty?
       text << "#{@keyword}:#{name_output_string}"
-      text << "\n" + description_output_string unless (description.nil? || description.empty?)
-      text << "\n" unless (rows.empty? || description.nil? || description.empty?)
-      text << "\n" + parameters_output_string if parameter_row
-      text << "\n" + rows_output_string unless argument_rows.empty?
+      text << "\n#{description_output_string}" unless no_description_to_output?
+      text << "\n" unless rows.empty? || no_description_to_output?
+      text << "\n#{parameters_output_string}" if parameter_row
+      text << "\n#{rows_output_string}" unless argument_rows.empty?
 
       text
     end
 
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
 
     private
 
 
     def parse_source(source_text)
-      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: Fake feature to parse\n#{dialect_outline_keyword}:\n#{dialect_step_keyword} fake step\n"
+      base_file_string = "# language: #{Parsing.dialect}
+      #{dialect_feature_keyword}: Fake feature to parse
+                            #{dialect_outline_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_example.feature')
+      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)
@@ -135,7 +143,7 @@ module CukeModeler
       text = ''
 
       unless parameter_row.nil?
-        text << "  |"
+        text << '  |'
         parameter_row.cells.count.times { |index| text << " #{string_for(parameter_row.cells, index)} |" }
       end
 
@@ -148,7 +156,7 @@ module CukeModeler
       unless argument_rows.empty?
 
         argument_rows.each do |row|
-          text << "  |"
+          text << '  |'
           row.cells.count.times { |index| text << " #{string_for(row.cells, index)} |" }
           text << "\n"
         end
@@ -164,8 +172,18 @@ module CukeModeler
     end
 
     def ordered_row_values(row_hash)
-      parameter_row.cells.collect { |cell| cell.value }.collect { |parameter| row_hash[parameter] }
+      parameter_row.cells.map(&:value).collect { |parameter| row_hash[parameter] }
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(key, value), new_hash| new_hash[key.to_s] = value }
+    end
+
+    def index_for_values(values)
+      argument_rows.index { |row| row.cells.map(&:value) == values }
     end
 
   end
 end
+
+# rubocop:enable Metrics/ClassLength