cuke_modeler 2.1.0 → 3.4.0

data/lib/cuke_modeler/models/table.rb

@@ -20,10 +20,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,12 +42,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_table.feature')
+      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

@@ -18,10 +18,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,9 +38,13 @@ 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
 
-      parsed_file.first['feature']['tags'].first
+    def populate_name(model, parsed_model_data)
+      model.name = parsed_model_data['name']
     end
 
   end

data/lib/cuke_modeler/named.rb

@@ -13,7 +13,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

@@ -12,30 +12,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

@@ -8,5 +8,13 @@ module CukeModeler
     # 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,39 +1,24 @@
 # 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 2.x, 8.x, 9.x
-  require 'gherkin'
-rescue LoadError
-  begin
-    require 'gherkin/parser'
-  rescue LoadError
-    # Gherkin 6.x, 7.x
-    require 'gherkin/gherkin'
-  end
-end
+# be determined and the rest of the needed files can be loaded.
+require 'gherkin'
 
 
-# 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.
+# 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.
 
-gherkin_version = Gem.loaded_specs['gherkin'].version.version
+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 6, 7, 8, 9
-    require 'gherkin/dialect'
-  when 3, 4, 5
-    require 'gherkin/parser'
-  when 2
-    require 'stringio'
-    require 'gherkin/formatter/json_formatter'
-    require 'gherkin'
-    require 'json'
-    require 'multi_json'
+  when 9, 10, 11, 12, 13, 14, 15
+    # 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"
 
@@ -57,20 +42,19 @@ 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
-        end
-
-        @dialects
+        @dialects ||= Gherkin::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)
+        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, 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
@@ -79,77 +63,73 @@ module CukeModeler
       end
 
 
-      gherkin_version = Gem.loaded_specs['gherkin'].version.version
+      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 9
+        when 13, 14, 15
+          # 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] }
+            error_message = messages.find { |message| message[:parse_error] }
             gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
 
-            if potential_error_message
-              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
-            end
+            raise error_message[:parse_error][:message] if error_message
 
             gherkin_ast_message[:gherkin_document]
           end
-        when 8
+        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)
+            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[:gherkinDocument] }
+            gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
 
-            if potential_error_message
-              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            if potential_error_message && potential_error_message[:attachment][:body] =~ /expected.*got/
+              raise potential_error_message[:attachment][:body]
             end
 
-            gherkin_ast_message[:gherkinDocument]
+            gherkin_ast_message[:gherkin_document]
           end
-        when 6, 7
+        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::Gherkin.from_source(filename, source_text).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[:gherkinDocument] }
+            gherkin_ast_message = messages.find { |message| message[:gherkin_document] }
 
-            if potential_error_message
-              raise potential_error_message[:attachment][:data] if potential_error_message[:attachment][:data] =~ /expected.*got/
+            if potential_error_message && potential_error_message[:attachment][:text] =~ /expected.*got/
+              raise potential_error_message[:attachment][:text]
             end
 
-            gherkin_ast_message[:gherkinDocument]
-          end
-        when 3, 4, 5
-          # todo - make these methods private?
-          # NOT A PART OF THE PUBLIC API
-          # 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 parsing_method(source_text, _filename)
-            Gherkin::Parser.new.parse(source_text)
-          end
-        when 2
-          # NOT A PART OF THE PUBLIC API
-          # The method to use for parsing Gherkin text
-          def 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)
+            gherkin_ast_message[:gherkin_document]
           end
         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
@@ -172,7 +152,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

data/lib/cuke_modeler/sourceable.rb

@@ -9,5 +9,13 @@ module CukeModeler
     # The line number where the element began in the source code
     attr_accessor :source_line
 
+
+    private
+
+
+    def populate_source_line(model, parsed_model_data)
+      model.source_line = parsed_model_data['line']
+    end
+
   end
 end

data/lib/cuke_modeler/stepped.rb

@@ -21,5 +21,13 @@ module CukeModeler
       step.to_s.split("\n").collect { |line| "  #{line}" }.join("\n")
     end
 
+    def populate_steps(model, parsed_model_data)
+      return unless parsed_model_data['steps']
+
+      parsed_model_data['steps'].each do |step_data|
+        model.steps << build_child_model(Step, step_data)
+      end
+    end
+
   end
 end

data/lib/cuke_modeler/taggable.rb

@@ -25,7 +25,15 @@ module CukeModeler
 
 
     def tag_output_string
-      tags.collect { |tag| tag.name }.join(' ')
+      tags.map(&:name).join(' ')
+    end
+
+    def populate_tags(model, parsed_model_data)
+      return unless parsed_model_data['tags']
+
+      parsed_model_data['tags'].each do |tag|
+        model.tags << build_child_model(Tag, tag)
+      end
     end
 
   end

data/lib/cuke_modeler/version.rb

@@ -1,4 +1,4 @@
 module CukeModeler
   # The gem version
-  VERSION = '2.1.0'
+  VERSION = '3.4.0'.freeze
 end

data/testing/cucumber/features/modeling/feature_modeling.feature

@@ -1,6 +1,8 @@
 Feature: Feature modeling
 
-Feature models are the top level element of the gherkin portion of the model tree. They expose several attributes of the feature that they represent, as well as containing models for any background, scenarios, or outlines that are present in that feature.
+Feature models are the top level element of the Gherkin portion of the model tree. They expose several attributes of the
+feature that they represent, as well as containing models for any background, scenarios, or outlines that are present in
+that feature.
 
 
   Background:
@@ -29,11 +31,18 @@ Feature models are the top level element of the gherkin portion of the model tre
         Scenario: Scenario 2
           * a step
 
-        Scenario Outline: Outline 2
-          * a step
-        Examples:
-          | param |
-          | value |
+        Rule: a rule
+
+          Scenario: Scenario 3
+            * a step
+
+        Rule: another rule
+
+          Scenario Outline: Outline 2
+            * a step
+          Examples:
+            | param |
+            | value |
       """
     And a feature model based on that gherkin
       """
@@ -75,7 +84,18 @@ Feature models are the top level element of the gherkin portion of the model tre
       """
     Then the model returns a model for the background "The background"
 
+  Scenario: Modeling a feature's rules
+    When the feature's rules are requested
+      """
+        @model.rules
+      """
+    Then the model returns models for the following rules:
+      | a rule       |
+      | another rule |
+
   Scenario: Modeling a feature's scenarios
+  Note: Scenarios under a Rule keyword are included in the corresponding Rule model instead of the Feature model
+
     When the feature's scenarios are requested
       """
         @model.scenarios
@@ -85,13 +105,14 @@ Feature models are the top level element of the gherkin portion of the model tre
       | Scenario 2 |
 
   Scenario: Modeling a feature's outlines
+  Note: Outlines under a Rule keyword are included in the corresponding Rule model instead of the Feature model
+
     When the feature's outlines are requested
       """
         @model.outlines
       """
     Then the model returns models for the following outlines:
       | Outline 1 |
-      | Outline 2 |
 
   Scenario: Modeling a feature's tags