cuke_modeler 3.2.0 → 3.7.0

data/lib/cuke_modeler/models/rule.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a rule in a Cucumber suite.
-
   class Rule < Model
 
     include Parsing
@@ -28,17 +27,19 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_rule_data = parse_source(source_text)
-        populate_rule(self, parsed_rule_data)
-      end
+      return unless source_text
+
+      parsed_rule_data = parse_source(source_text)
+      populate_rule(self, parsed_rule_data)
     end
 
     # Returns *true* if the rule contains a background, *false* otherwise.
-    def has_background?
+    def background?
       !@background.nil?
     end
 
+    alias has_background? background?
+
     # Returns the scenario models contained in the rule.
     def scenarios
       @tests.select { |test| test.is_a? Scenario }
@@ -63,9 +64,9 @@ module CukeModeler
       text = ''
 
       text << "#{@keyword}:#{name_output_string}"
-      text << "\n" + description_output_string unless (description.nil? || description.empty?)
-      text << "\n\n" + background_output_string if background
-      text << "\n\n" + tests_output_string unless tests.empty?
+      text << "\n#{description_output_string}" unless no_description_to_output?
+      text << "\n\n#{background_output_string}" if background
+      text << "\n\n#{tests_output_string}" unless tests.empty?
 
       text
     end
@@ -78,7 +79,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_rule.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_rule.feature')
 
       parsed_file['feature']['elements'].first
     end

data/lib/cuke_modeler/models/scenario.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling an individual scenario of a Cucumber suite.
-
   class Scenario < Model
 
     include Parsing
@@ -25,17 +24,17 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_scenario_data = parse_source(source_text)
-        populate_scenario(self, parsed_scenario_data)
-      end
+      return unless source_text
+
+      parsed_scenario_data = parse_source(source_text)
+      populate_scenario(self, parsed_scenario_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.
@@ -43,20 +42,25 @@ module CukeModeler
       steps + tags
     end
 
+    # Building strings just isn't pretty
+    # rubocop:disable Metrics/AbcSize
+
     # Returns a string representation of this model. For a scenario model,
     # this will be Gherkin text that is equivalent to the scenario 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 (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
 
+    # rubocop:enable Metrics/AbcSize
+
 
     private
 
@@ -65,7 +69,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_scenario.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_scenario.feature')
 
       parsed_file['feature']['elements'].first
     end

data/lib/cuke_modeler/models/step.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a single step of a background, scenario, or outline.
-
   class Step < Model
 
     include Sourceable
@@ -24,20 +23,20 @@ module CukeModeler
     def initialize(source_text = nil)
       super(source_text)
 
-      if source_text
-        parsed_step_data = parse_source(source_text)
-        populate_step(self, parsed_step_data)
-      end
+      return unless source_text
+
+      parsed_step_data = parse_source(source_text)
+      populate_step(self, parsed_step_data)
     end
 
     # Returns *true* if the two steps have the same base text (i.e. minus any keyword,
     # table, or doc string and *false* otherwise.
-    def ==(other_step)
-      return false unless other_step.is_a?(CukeModeler::Step)
+    def ==(other)
+      return false unless other.is_a?(CukeModeler::Step)
 
-      text_matches?(other_step) &&
-          table_matches?(other_step) &&
-          doc_string_matches?(other_step)
+      text_matches?(other) &&
+        table_matches?(other) &&
+        doc_string_matches?(other)
     end
 
     # Returns the model objects that belong to this model.
@@ -49,7 +48,7 @@ module CukeModeler
     # this will be Gherkin text that is equivalent to the step being modeled.
     def to_s
       text = "#{keyword} #{self.text}"
-      text << "\n" + block.to_s.split("\n").collect { |line| "  #{line}" }.join("\n") if block
+      text << "\n#{block.to_s.split("\n").collect { |line| "  #{line}" }.join("\n")}" if block
 
       text
     end
@@ -59,10 +58,12 @@ module CukeModeler
 
 
     def parse_source(source_text)
-      base_file_string = "# language: #{Parsing.dialect}\n#{dialect_feature_keyword}: Fake feature to parse\n#{dialect_scenario_keyword}:\n"
+      base_file_string = "# language: #{Parsing.dialect}
+      #{dialect_feature_keyword}: Fake feature to parse
+                            #{dialect_scenario_keyword}:\n"
       source_text = base_file_string + source_text
 
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_step.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_step.feature')
 
       parsed_file['feature']['elements'].first['steps'].first
     end
@@ -72,18 +73,18 @@ module CukeModeler
     end
 
     def table_matches?(other_step)
-      return false if (!block.is_a?(CukeModeler::Table) || !other_step.block.is_a?(CukeModeler::Table)) && (block.is_a?(CukeModeler::Table) || other_step.block.is_a?(CukeModeler::Table))
-      return true unless block.is_a?(CukeModeler::Table) && other_step.block.is_a?(CukeModeler::Table)
+      return false if only_one_step_has_table?(other_step)
+      return true if neither_step_has_table?(other_step)
 
-      first_step_values  = block.rows.collect { |table_row| table_row.cells.map(&:value) }
+      first_step_values = block.rows.collect { |table_row| table_row.cells.map(&:value) }
       second_step_values = other_step.block.rows.collect { |table_row| table_row.cells.map(&:value) }
 
       first_step_values == second_step_values
     end
 
     def doc_string_matches?(other_step)
-      return false if (!block.is_a?(CukeModeler::DocString) || !other_step.block.is_a?(CukeModeler::DocString)) && (block.is_a?(CukeModeler::DocString) || other_step.block.is_a?(CukeModeler::DocString))
-      return true unless block.is_a?(CukeModeler::DocString) && other_step.block.is_a?(CukeModeler::DocString)
+      return false if only_one_step_has_doc_string?(other_step)
+      return true if neither_step_has_doc_string?(other_step)
 
       first_content       = block.content
       first_content_type  = block.content_type
@@ -91,7 +92,27 @@ module CukeModeler
       second_content_type = other_step.block.content_type
 
       (first_content == second_content) &&
-          (first_content_type == second_content_type)
+        (first_content_type == second_content_type)
+    end
+
+    def only_one_step_has_table?(other_step)
+      (!block.is_a?(CukeModeler::Table) || !other_step.block.is_a?(CukeModeler::Table)) &&
+        (block.is_a?(CukeModeler::Table) || other_step.block.is_a?(CukeModeler::Table))
+    end
+
+    def neither_step_has_table?(other_step)
+      !block.is_a?(CukeModeler::Table) &&
+        !other_step.block.is_a?(CukeModeler::Table)
+    end
+
+    def only_one_step_has_doc_string?(other_step)
+      (!block.is_a?(CukeModeler::DocString) || !other_step.block.is_a?(CukeModeler::DocString)) &&
+        (block.is_a?(CukeModeler::DocString) || other_step.block.is_a?(CukeModeler::DocString))
+    end
+
+    def neither_step_has_doc_string?(other_step)
+      !block.is_a?(CukeModeler::DocString) &&
+        !other_step.block.is_a?(CukeModeler::DocString)
     end
 
   end

data/lib/cuke_modeler/models/table.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a step's table.
-
   class Table < Model
 
     include Parsing
@@ -20,10 +19,10 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_table_data = parse_source(source_text)
-        populate_table(self, parsed_table_data)
-      end
+      return unless source_text
+
+      parsed_table_data = parse_source(source_text)
+      populate_table(self, parsed_table_data)
     end
 
     # Returns the model objects that belong to this model.
@@ -42,10 +41,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_table.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_table.feature')
 
       parsed_file['feature']['elements'].first['steps'].first['table']
     end

data/lib/cuke_modeler/models/tag.rb

@@ -1,7 +1,6 @@
 module CukeModeler
 
   # A class modeling a tag.
-
   class Tag < Model
 
     include Parsing
@@ -18,10 +17,10 @@ module CukeModeler
     def initialize(source_text = nil)
       super(source_text)
 
-      if source_text
-        parsed_tag_data = parse_source(source_text)
-        populate_tag(self, parsed_tag_data)
-      end
+      return unless source_text
+
+      parsed_tag_data = parse_source(source_text)
+      populate_tag(self, parsed_tag_data)
     end
 
     # Returns a string representation of this model. For a tag model,
@@ -38,10 +37,14 @@ 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_tag.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_tag.feature')
 
       parsed_file['feature']['tags'].first
     end
 
+    def populate_name(model, parsed_model_data)
+      model.name = parsed_model_data['name']
+    end
+
   end
 end

data/lib/cuke_modeler/named.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 name.
-
   module Named
 
     # The name of the element
@@ -13,7 +12,11 @@ module CukeModeler
 
 
     def name_output_string
-      (name.nil? || name.empty?) ? '' : " #{name}"
+      name.nil? || name.empty? ? '' : " #{name}"
+    end
+
+    def populate_name(model, parsed_model_data)
+      model.name = parsed_model_data['name']
     end
 
   end

data/lib/cuke_modeler/nested.rb

@@ -3,7 +3,6 @@ module CukeModeler
   # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that are nested inside
   # of other models.
-
   module Nested
 
     # The parent model that contains this model
@@ -12,30 +11,34 @@ module CukeModeler
 
     # Returns the ancestor model of this model that matches the given type.
     def get_ancestor(ancestor_type)
-      target_type = {:directory => [Directory],
-                     :feature_file => [FeatureFile],
-                     :feature => [Feature],
-                     :test => [Scenario, Outline, Background],
-                     :background => [Background],
-                     :scenario => [Scenario],
-                     :outline => [Outline],
-                     :step => [Step],
-                     :table => [Table],
-                     :example => [Example],
-                     :row => [Row]
-      }[ancestor_type]
+      target_classes = classes_for_type(ancestor_type)
 
-      raise(ArgumentError, "Unknown ancestor type '#{ancestor_type}'.") if target_type.nil?
+      raise(ArgumentError, "Unknown ancestor type '#{ancestor_type}'.") if target_classes.nil?
 
+      ancestor = parent_model
+      ancestor = ancestor.parent_model until target_classes.include?(ancestor.class) || ancestor.nil?
 
-      ancestor = self.parent_model
+      ancestor
+    end
 
-      until target_type.include?(ancestor.class) || ancestor.nil?
-        ancestor = ancestor.parent_model
-      end
 
+    private
 
-      ancestor
+
+    def classes_for_type(type)
+      {
+        directory: [Directory],
+        feature_file: [FeatureFile],
+        feature: [Feature],
+        test: [Scenario, Outline, Background],
+        background: [Background],
+        scenario: [Scenario],
+        outline: [Outline],
+        step: [Step],
+        table: [Table],
+        example: [Example],
+        row: [Row]
+      }[type]
     end
 
   end

data/lib/cuke_modeler/parsed.rb

@@ -2,11 +2,18 @@ module CukeModeler
 
   # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that are parsed from source text.
-
   module Parsed
 
     # The parsing data for this element that was generated by the parsing engine (i.e. the *gherkin* gem)
     attr_accessor :parsing_data
 
+
+    private
+
+
+    def populate_parsing_data(model, parsed_model_data)
+      model.parsing_data = parsed_model_data['cuke_modeler_parsing_data']
+    end
+
   end
 end

data/lib/cuke_modeler/parsing.rb

@@ -1,13 +1,6 @@
 # Have to at least load some version of the gem before which version of the gem has been loaded can
-# be determined and the rest of the needed files can be loaded. The entry points vary across versions,
-# so try them all until one of them works.
-begin
-  # Gherkin 9.x
-  require 'gherkin'
-rescue LoadError => e
-  # Add other entry points again if things change again
-  raise e
-end
+# be determined and the rest of the needed files can be loaded.
+require 'gherkin'
 
 
 # The *cucumber-gherkin* gem loads differently and has different grammar rules across major versions. Parsing
@@ -16,12 +9,16 @@ end
 gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
 gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
 
+# Previous versions of the gem did not use the conventional entry point, so I'm leaving this here in case it
+# changes again
+# rubocop:disable Lint/EmptyWhen
 case gherkin_major_version
-  when 9, 10, 11, 12, 13, 14
+  when 9, 10, 11, 12, 13, 14, 15, 16, 17
     # Currently nothing else to load beyond the entry point to the gem
   else
     raise("Unknown Gherkin version: '#{gherkin_version}'")
 end
+# rubocop:enable Lint/EmptyWhen
 
 require "cuke_modeler/adapters/gherkin_#{gherkin_major_version}_adapter"
 
@@ -29,7 +26,6 @@ require "cuke_modeler/adapters/gherkin_#{gherkin_major_version}_adapter"
 module CukeModeler
 
   # A module providing source text parsing functionality.
-
   module Parsing
 
     class << self
@@ -45,18 +41,16 @@ module CukeModeler
 
       # The dialects currently known by the gherkin gem
       def dialects
-        unless @dialects
-          @dialects = Gherkin::DIALECTS
-        end
-
-        @dialects
+        @dialects ||= Gherkin::DIALECTS
       end
 
       # Parses the Cucumber feature given in *source_text* and returns a hash representation of
       # its logical structure. This is a standardized AST that should remain consistent across
       # different versions of `cucumber-gherkin`
       def parse_text(source_text, filename = 'cuke_modeler_fake_file.feature')
-        raise(ArgumentError, "Text to parse must be a String but got #{source_text.class}") unless source_text.is_a?(String)
+        unless source_text.is_a?(String)
+          raise(ArgumentError, "Text to parse must be a String but got #{source_text.class}")
+        end
 
         begin
           parsed_result = parsing_method(source_text.encode('UTF-8'), filename)
@@ -71,13 +65,20 @@ module CukeModeler
       gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
       gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
 
+      # Previous versions of the gem had more variation between their parsing methods and so it was more
+      # understandable to have different methods instead of a single method with lots of conditional statements
+      # inside of it, so I'm leaving this here in case it changes again
+      # rubocop:disable Lint/DuplicateMethods
       case gherkin_major_version
-        when 13, 14
-          # todo - make these methods private?
+        when 13, 14, 15, 16, 17
+          # TODO: make these methods private?
           # NOT A PART OF THE PUBLIC API
           # The method to use for parsing Gherkin text
           def parsing_method(source_text, filename)
-            messages = Gherkin.from_source(filename, source_text, { :include_gherkin_document => true }).to_a.map(&:to_hash)
+            messages = Gherkin.from_source(filename,
+                                           source_text,
+                                           { include_gherkin_document: true })
+                              .to_a.map(&:to_hash)
 
             error_message = messages.find { |message| message[:parse_error] }
             gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
@@ -87,33 +88,39 @@ module CukeModeler
             gherkin_ast_message[:gherkin_document]
           end
         when 12
-          # todo - make these methods private?
+          # TODO: make these methods private?
           # NOT A PART OF THE PUBLIC API
           # The method to use for parsing Gherkin text
           def parsing_method(source_text, filename)
-            messages = Gherkin.from_source(filename, source_text, { :include_gherkin_document => true }).to_a.map(&:to_hash)
+            messages = Gherkin.from_source(filename,
+                                           source_text,
+                                           { include_gherkin_document: true })
+                              .to_a.map(&:to_hash)
 
             potential_error_message = messages.find { |message| message[:attachment] }
             gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
 
-            if potential_error_message
-              raise potential_error_message[:attachment][:body] if potential_error_message[:attachment][:body] =~ /expected.*got/
+            if potential_error_message && potential_error_message[:attachment][:body] =~ /expected.*got/
+              raise potential_error_message[:attachment][:body]
             end
 
             gherkin_ast_message[:gherkin_document]
           end
         when 9, 10, 11
-          # todo - make these methods private?
+          # TODO: make these methods private?
           # NOT A PART OF THE PUBLIC API
           # The method to use for parsing Gherkin text
           def parsing_method(source_text, filename)
-            messages = Gherkin.from_source(filename, source_text, { :include_gherkin_document => true }).to_a.map(&:to_hash)
+            messages = Gherkin.from_source(filename,
+                                           source_text,
+                                           { include_gherkin_document: true })
+                              .to_a.map(&:to_hash)
 
             potential_error_message = messages.find { |message| message[:attachment] }
             gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
 
-            if potential_error_message
-              raise potential_error_message[:attachment][:text] if potential_error_message[:attachment][:text] =~ /expected.*got/
+            if potential_error_message && potential_error_message[:attachment][:text] =~ /expected.*got/
+              raise potential_error_message[:attachment][:text]
             end
 
             gherkin_ast_message[:gherkin_document]
@@ -121,6 +128,7 @@ module CukeModeler
         else
           raise("Unknown Gherkin version: '#{gherkin_version}'")
       end
+      # rubocop:enable Lint/DuplicateMethods
 
       # NOT A PART OF THE PUBLIC API
       # The adapter to use when converting an AST to a standard internal shape
@@ -143,7 +151,8 @@ module CukeModeler
     end
 
     def dialect_outline_keyword
-      get_word(Parsing.dialects[Parsing.dialect]['scenarioOutline'] || Parsing.dialects[Parsing.dialect]['scenario_outline'])
+      get_word(Parsing.dialects[Parsing.dialect]['scenarioOutline'] ||
+                 Parsing.dialects[Parsing.dialect]['scenario_outline'])
     end
 
     def dialect_step_keyword