cuke_modeler 2.1.0 → 3.4.0

data/lib/cuke_modeler/models/feature.rb

@@ -17,6 +17,9 @@ module CukeModeler
     # The Background object contained by the Feature
     attr_accessor :background
 
+    # The Rule objects contained by the Feature
+    attr_accessor :rules
+
     # The Scenario and Outline objects contained by the Feature
     attr_accessor :tests
 
@@ -25,21 +28,24 @@ module CukeModeler
     # object.
     def initialize(source_text = nil)
       @tags = []
+      @rules = []
       @tests = []
 
       super(source_text)
 
-      if source_text
-        parsed_feature_data = parse_source(source_text)
-        populate_feature(self, parsed_feature_data)
-      end
+      return unless source_text
+
+      parsed_feature_data = parse_source(source_text)
+      populate_feature(self, parsed_feature_data)
     end
 
     # Returns *true* if the feature contains a background, *false* otherwise.
-    def has_background?
+    def background?
       !@background.nil?
     end
 
+    alias has_background? background?
+
     # Returns the scenario models contained in the feature.
     def scenarios
       @tests.select { |test| test.is_a? Scenario }
@@ -50,58 +56,70 @@ module CukeModeler
       @tests.select { |test| test.is_a? Outline }
     end
 
+    # TODO: Remove this method on next major version release
+    # DEPRECATED
     # Returns the number of test cases contained in the feature. A test case is a
     # single set of test values, such as an individual scenario or one example row
     # of an outline.
     def test_case_count
-      scenarios.count + outlines.reduce(0) { |outline_sum, outline|
-        outline_sum += outline.examples.reduce(0) { |example_sum, example|
-          example_sum += example.argument_rows.count
-        }
-      }
+      scenarios.count + outlines.reduce(0) do |outline_sum, outline|
+        outline_sum + outline.examples.reduce(0) do |example_sum, example|
+          example_sum + example.argument_rows.count
+        end
+      end
     end
 
     # Returns the model objects that belong to this model.
     def children
-      models = tests + tags
+      models = rules + tests + tags
       models << background if background
 
       models
     end
 
+    # Building strings just isn't pretty
+    # rubocop:disable Metrics/AbcSize
+
     # Returns a string representation of this model. For a feature model,
     # this will be Gherkin text that is equivalent to the feature 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\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 << "\n\n#{rules_output_string}" unless rules.empty?
 
       text
     end
 
+    # rubocop:enable Metrics/AbcSize
+
 
     private
 
 
     def parse_source(source_text)
-      parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_feature.feature')
+      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
-      test_output_string(background)
+      child_element_output_string(background)
     end
 
     def tests_output_string
-      tests.collect { |test| test_output_string(test) }.join("\n\n")
+      tests.collect { |test| child_element_output_string(test) }.join("\n\n")
+    end
+
+    def rules_output_string
+      rules.collect { |rule| child_element_output_string(rule) }.join("\n\n")
     end
 
-    def test_output_string(model)
+    def child_element_output_string(model)
       model.to_s.split("\n").collect { |line| line.empty? ? '' : "  #{line}" }.join("\n")
     end
 

data/lib/cuke_modeler/models/feature_file.rb

@@ -25,13 +25,11 @@ module CukeModeler
 
       super(file_path)
 
-      if file_path
-        raise(ArgumentError, "Unknown file: #{file_path.inspect}") unless File.exists?(file_path)
-
-        processed_feature_file_data = process_feature_file(file_path)
-        populate_featurefile(self, processed_feature_file_data)
-      end
+      return unless file_path
+      raise(ArgumentError, "Unknown file: #{file_path.inspect}") unless File.exist?(file_path)
 
+      processed_feature_file_data = process_feature_file(file_path)
+      populate_featurefile(self, processed_feature_file_data)
     end
 
     # Returns the name of the modeled feature file.
@@ -57,8 +55,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/model.rb

@@ -11,7 +11,8 @@ module CukeModeler
     # Creates a new Model object and, if *source_text* is provided,
     # populates the object.
     def initialize(source_text = nil)
-      raise(ArgumentError, "Can only create models from Strings but was given a #{source_text.class}.") if source_text && !source_text.is_a?(String)
+      error_message = "Can only create models from Strings but was given a #{source_text.class}."
+      raise(ArgumentError, error_message) if source_text && !source_text.is_a?(String)
 
       # This should be overridden by a child class
     end

data/lib/cuke_modeler/models/outline.rb

@@ -29,17 +29,17 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_outline_data = parse_source(source_text)
-        populate_outline(self, parsed_outline_data)
-      end
+      return unless source_text
+
+      parsed_outline_data = parse_source(source_text)
+      populate_outline(self, parsed_outline_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,21 +47,26 @@ module CukeModeler
       examples + steps + tags
     end
 
+    # Building strings just isn't pretty
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
     # Returns a string representation of this model. For an outline model,
     # this will be Gherkin text that is equivalent to the outline 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\n" + examples_output_string unless examples.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 << "\n\n#{examples_output_string}" unless examples.empty?
 
       text
     end
 
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
 
     private
 
@@ -70,13 +75,13 @@ 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_outline.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_outline.feature')
 
-      parsed_file.first['feature']['elements'].first
+      parsed_file['feature']['elements'].first
     end
 
     def examples_output_string
-      examples.empty? ? '' : examples.collect { |example| example.to_s }.join("\n\n")
+      examples.empty? ? '' : examples.join("\n\n")
     end
 
   end

data/lib/cuke_modeler/models/row.rb

@@ -19,16 +19,16 @@ module CukeModeler
 
       super(source_text)
 
-      if source_text
-        parsed_row_data = parse_source(source_text)
-        populate_row(self, parsed_row_data)
-      end
+      return unless source_text
+
+      parsed_row_data = parse_source(source_text)
+      populate_row(self, parsed_row_data)
     end
 
     # Returns a string representation of this model. For a row model,
     # this will be Gherkin text that is equivalent to the row being modeled.
     def to_s
-      text_cells = cells.collect { |cell| cell.to_s }
+      text_cells = cells.map(&:to_s)
 
       "| #{text_cells.join(' | ')} |"
     end
@@ -38,12 +38,15 @@ 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#{dialect_step_keyword} fake step\n"
+      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_row.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_row.feature')
 
-      parsed_file.first['feature']['elements'].first['steps'].first['table']['rows'].first
+      parsed_file['feature']['elements'].first['steps'].first['table']['rows'].first
     end
 
   end

data/lib/cuke_modeler/models/rule.rb

@@ -0,0 +1,101 @@
+module CukeModeler
+
+  # A class modeling a rule in a Cucumber suite.
+
+  class Rule < Model
+
+    include Parsing
+    include Parsed
+    include Named
+    include Described
+    include Sourceable
+
+
+    # The keyword for the rule
+    attr_accessor :keyword
+
+    # The Background object contained by the Rule
+    attr_accessor :background
+
+    # The Scenario and Outline objects contained by the Rule
+    attr_accessor :tests
+
+
+    # Creates a new Rule object and, if *source_text* is provided, populates the
+    # object.
+    def initialize(source_text = nil)
+      @tests = []
+
+      super(source_text)
+
+      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 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 }
+    end
+
+    # Returns the outline models contained in the rule.
+    def outlines
+      @tests.select { |test| test.is_a? Outline }
+    end
+
+    # Returns the model objects that belong to this model.
+    def children
+      models = tests
+      models << background if background
+
+      models
+    end
+
+    # Returns a string representation of this model. For a rule model,
+    # this will be Gherkin text that is equivalent to the rule being modeled.
+    def to_s
+      text = ''
+
+      text << "#{@keyword}:#{name_output_string}"
+      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
+
+
+    private
+
+
+    def parse_source(source_text)
+      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['feature']['elements'].first
+    end
+
+    def background_output_string
+      test_output_string(background)
+    end
+
+    def tests_output_string
+      tests.collect { |test| test_output_string(test) }.join("\n\n")
+    end
+
+    def test_output_string(model)
+      model.to_s.split("\n").collect { |line| line.empty? ? '' : "  #{line}" }.join("\n")
+    end
+
+  end
+end

data/lib/cuke_modeler/models/scenario.rb

@@ -25,17 +25,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 +43,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,9 +70,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_scenario.feature')
+      parsed_file = Parsing.parse_text(source_text, 'cuke_modeler_stand_alone_scenario.feature')
 
-      parsed_file.first['feature']['elements'].first
+      parsed_file['feature']['elements'].first
     end
 
   end

data/lib/cuke_modeler/models/step.rb

@@ -24,20 +24,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 +49,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,12 +59,14 @@ 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.first['feature']['elements'].first['steps'].first
+      parsed_file['feature']['elements'].first['steps'].first
     end
 
     def text_matches?(other_step)
@@ -72,18 +74,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 +93,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