cuke_modeler 1.5.1 → 3.2.0

data/lib/cuke_modeler/containing.rb

@@ -1,5 +1,6 @@
 module CukeModeler
 
+  # NOT A PART OF THE PUBLIC API
   # A mix-in module containing methods used by models that contain other models.
 
   module Containing
@@ -31,7 +32,6 @@ module CukeModeler
 
       model.parent_model = self
 
-
       model
     end
 
@@ -129,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']
 
@@ -212,18 +221,20 @@ module CukeModeler
       end
     end
 
-    def populate_children(feature_model, parsed_feature_data)
+    def populate_children(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)
+              model.tests << build_child_model(Scenario, element)
             when 'ScenarioOutline', 'scenario_outline'
-              feature_model.tests << build_child_model(Outline, element)
+              model.tests << build_child_model(Outline, element)
             when 'Background', 'background'
-              feature_model.background = build_child_model(Background, element)
+              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

data/lib/cuke_modeler/described.rb

@@ -1,5 +1,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

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

data/lib/cuke_modeler/models/comment.rb

@@ -40,7 +40,7 @@ module CukeModeler
 
       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

@@ -82,8 +82,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

@@ -45,7 +45,7 @@ module CukeModeler
 
       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

data/lib/cuke_modeler/models/example.rb

@@ -124,7 +124,7 @@ module CukeModeler
 
       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)

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,6 +28,7 @@ module CukeModeler
     # object.
     def initialize(source_text = nil)
       @tags = []
+      @rules = []
       @tests = []
 
       super(source_text)
@@ -50,6 +54,8 @@ 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.
@@ -63,7 +69,7 @@ module CukeModeler
 
     # Returns the model objects that belong to this model.
     def children
-      models = tests + tags
+      models = rules + tests + tags
       models << background if background
 
       models
@@ -79,6 +85,7 @@ module CukeModeler
       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\n" + rules_output_string unless rules.empty?
 
       text
     end
@@ -90,18 +97,22 @@ module CukeModeler
     def parse_source(source_text)
       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

@@ -57,8 +57,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/outline.rb

@@ -72,7 +72,7 @@ module CukeModeler
 
       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

data/lib/cuke_modeler/models/row.rb

@@ -43,7 +43,7 @@ module CukeModeler
 
       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,99 @@
+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)
+
+      if source_text
+        parsed_rule_data = parse_source(source_text)
+        populate_rule(self, parsed_rule_data)
+      end
+    end
+
+    # Returns *true* if the rule contains a background, *false* otherwise.
+    def has_background?
+      !@background.nil?
+    end
+
+    # 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 (description.nil? || description.empty?)
+      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

@@ -67,7 +67,7 @@ module CukeModeler
 
       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

@@ -33,9 +33,11 @@ module CukeModeler
     # 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.respond_to?(:text)
+      return false unless other_step.is_a?(CukeModeler::Step)
 
-      text == other_step.text
+      text_matches?(other_step) &&
+          table_matches?(other_step) &&
+          doc_string_matches?(other_step)
     end
 
     # Returns the model objects that belong to this model.
@@ -62,7 +64,34 @@ module CukeModeler
 
       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)
+      text == other_step.text
+    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)
+
+      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)
+
+      first_content       = block.content
+      first_content_type  = block.content_type
+      second_content      = other_step.block.content
+      second_content_type = other_step.block.content_type
+
+      (first_content == second_content) &&
+          (first_content_type == second_content_type)
     end
 
   end

data/lib/cuke_modeler/models/table.rb

@@ -47,7 +47,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_table.feature')
 
-      parsed_file.first['feature']['elements'].first['steps'].first['table']
+      parsed_file['feature']['elements'].first['steps'].first['table']
     end
 
     def row_output_string(row)

data/lib/cuke_modeler/models/tag.rb

@@ -40,7 +40,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_tag.feature')
 
-      parsed_file.first['feature']['tags'].first
+      parsed_file['feature']['tags'].first
     end
 
   end

data/lib/cuke_modeler/named.rb

@@ -1,5 +1,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

data/lib/cuke_modeler/nested.rb

@@ -1,5 +1,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.
 

data/lib/cuke_modeler/parsed.rb

@@ -1,5 +1,6 @@
 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

data/lib/cuke_modeler/parsing.rb

@@ -1,107 +1,36 @@
-module CukeModeler
-
-  # A module providing source text parsing functionality.
-
-  module Parsing
-
-
-    # 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. Try the old one first and then the
-    # new one.
-    begin
-      require 'gherkin'
-    rescue LoadError
-      begin
-        require 'gherkin/parser'
-      rescue LoadError
-        # Gherkin 6.x
-        require 'gherkin/gherkin'
-      end
-    end
-
-
-    # The *gherkin* gem loads differently and has different grammar rules across major versions. Parsing
-    # will be done with an 'adapter' appropriate to the version of the *gherkin* gem that has been activated.
-
-    gherkin_version = Gem.loaded_specs['gherkin'].version.version
-
-    case gherkin_version
-      when /^6\./
-        require 'gherkin/gherkin'
-        require 'cuke_modeler/adapters/gherkin_6_adapter'
-
-        # The method to use for parsing Gherkin text
-        def self.parsing_method(source_text, filename)
-          messages = Gherkin::Gherkin.from_source(filename, source_text, {:default_dialect => CukeModeler::Parsing.dialect}).to_a
-
-          messages.map(&:to_hash).find { |message| message[:gherkinDocument] }[:gherkinDocument]
-        end
-
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin6Adapter
-        end
-
-      when /^[54]\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_4_adapter'
+# 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
 
 
-        # todo - make these methods private?
-        # The method to use for parsing Gherkin text
-        # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
-
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin4Adapter
-        end
+# The *cucumber-gherkin* gem loads differently and has different grammar rules across major versions. Parsing
+# will be done with an 'adapter' appropriate to the version of the *cucumber-gherkin* gem that has been activated.
 
-      when /^3\./
-        require 'gherkin/parser'
-        require 'cuke_modeler/adapters/gherkin_3_adapter'
+gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
+gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
 
+case gherkin_major_version
+  when 9, 10, 11, 12, 13, 14
+    # Currently nothing else to load beyond the entry point to the gem
+  else
+    raise("Unknown Gherkin version: '#{gherkin_version}'")
+end
 
-        # The method to use for parsing Gherkin text
-        # Filename isn't used by this version of Gherkin but keeping the parameter so that the calling method only has to know one method signature
-        def self.parsing_method(source_text, _filename)
-          Gherkin::Parser.new.parse(source_text)
-        end
+require "cuke_modeler/adapters/gherkin_#{gherkin_major_version}_adapter"
 
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin3Adapter
-        end
-      when /^2\./
-        require 'stringio'
-        require 'gherkin/formatter/json_formatter'
-        require 'gherkin'
-        require 'json'
-        require 'multi_json'
-        require 'cuke_modeler/adapters/gherkin_2_adapter'
-
-
-        # The method to use for parsing Gherkin text
-        def self.parsing_method(source_text, filename)
-          io = StringIO.new
-          formatter = Gherkin::Formatter::JSONFormatter.new(io)
-          parser = Gherkin::Parser::Parser.new(formatter)
-          parser.parse(source_text, filename, 0)
-          formatter.done
-          MultiJson.load(io.string)
-        end
 
-        # The adapter to use when converting an AST to a standard internal shape
-        def self.adapter_class
-          CukeModeler::Gherkin2Adapter
-        end
+module CukeModeler
 
-      else
-        raise("Unknown Gherkin version: '#{gherkin_version}'")
-    end
+  # A module providing source text parsing functionality.
 
+  module Parsing
 
     class << self
 
@@ -117,28 +46,86 @@ module CukeModeler
       # The dialects currently known by the gherkin gem
       def dialects
         unless @dialects
-          @dialects = Gem.loaded_specs['gherkin'].version.version[/^2\./] ? Gherkin::I18n::LANGUAGES : Gherkin::DIALECTS
+          @dialects = Gherkin::DIALECTS
         end
 
         @dialects
       end
 
-      # Parses the Cucumber feature given in *source_text* and returns an array
-      # containing the hash representation of its logical structure.
+      # 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)
 
-
         begin
-          parsed_result = parsing_method(source_text, filename)
+          parsed_result = parsing_method(source_text.encode('UTF-8'), filename)
         rescue => e
           raise(ArgumentError, "Error encountered while parsing '#{filename}'\n#{e.class} - #{e.message}")
         end
 
-        adapted_result = adapter_class.new.adapt(parsed_result)
+        adapter_class.new.adapt(parsed_result)
+      end
+
 
+      gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
+      gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
+
+      case gherkin_major_version
+        when 13, 14
+          # 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)
+
+            error_message = messages.find { |message| message[:parse_error] }
+            gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
+
+            raise error_message[:parse_error][:message] if error_message
+
+            gherkin_ast_message[:gherkin_document]
+          end
+        when 12
+          # 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)
+
+            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/
+            end
+
+            gherkin_ast_message[:gherkin_document]
+          end
+        when 9, 10, 11
+          # 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)
+
+            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/
+            end
+
+            gherkin_ast_message[:gherkin_document]
+          end
+        else
+          raise("Unknown Gherkin version: '#{gherkin_version}'")
+      end
 
-        adapted_result
+      # NOT A PART OF THE PUBLIC API
+      # The adapter to use when converting an AST to a standard internal shape
+      define_method('adapter_class') do
+        CukeModeler.const_get("Gherkin#{gherkin_major_version}Adapter")
       end
 
     end