cuke_modeler 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3287a6e2f6cc9ce0269ce039535fe37bbe9be5bc6251c170efd87bdfa6d25b5e
-  data.tar.gz: 9413347eaf273b881e62dd792a1a7110ccf30d89ee7ed1620ae53c882008310b
+  metadata.gz: 4b152c6307169c73e75c9e2b4798d29cab2c7b8ad7ed086c12a854739940d2eb
+  data.tar.gz: a50e43b9e28d514d22c0a756be7197e9a5395cdf38fcde50d34e8b1c0c41df53
 SHA512:
-  metadata.gz: cc3d0ee5ca02ca1b81fd3784e471488952c8e5fe88401ce12ea0e10360b32a667b80934db8480aeae7936463ddc9c04ff0a02702d88ef0eaf6957b69a16680c5
-  data.tar.gz: 4af05a8b47ab76911764ebef5f10524c525a8c88852193bd928ac868e779cb4244fa540f7978df08fa58af602e53f0b6db5fb515d216f40117e58f939d49f8c9
+  metadata.gz: 627d1c76575e4c2ed4b97ac2ee2db83c920997bc1296bdf6ecfc530ba92250d585c011fa9e315b2c52c28cd9c1f219da7cf1e79fe44e23d0ba868db3de48ffda
+  data.tar.gz: 3f1c554b800ed1a194d800d13ce9b39e5e4dd5655780e6e3ef007e7e2480d3139d5d8feec128d9db470cf3b8d0a996a5116af0a0770e80e20ee1899cbf661b3a

data/CHANGELOG.md

@@ -8,6 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [3.2.0] - 2020-07-27
+
+### Added
+ - The `Rule` keyword is now a modeled element.
+
+### Deprecated
+ - `Feature#test_case_count` will be removed on the next major release. It's a random analysis method in what is 
+ otherwise a purely abstraction layer library. The [CQL](https://github.com/enkessler/cql) gem is better suited to such tasks.  
+
 ## [3.1.0] - 2020-06-28
 
 ### Added
@@ -16,8 +25,8 @@ Nothing yet...
 
 ### Fixed
   - Text is converted to UTF-8 encoding before being passed to the underlying Gherkin gem. This is due to UTF-8 being 
-    the only encoding supported by Gherkin. The `gherkin` gem did the conversion automatically but the `cucumber-gherkin` 
-    gem does not.
+    the only encoding supported by Gherkin. The `gherkin` gem did the conversion automatically and so this conversion 
+    was not necessary previously but the `cucumber-gherkin` gem does not do any automatic conversion.
 
 ## [3.0.0] - 2020-06-08
 
@@ -314,7 +323,8 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.1.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.2.0...HEAD
+[3.2.0]: https://github.com/enkessler/cuke_modeler/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/enkessler/cuke_modeler/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/enkessler/cuke_modeler/compare/v2.1.0...v3.0.0
 [2.1.0]: https://github.com/enkessler/cuke_modeler/compare/v2.0.0...v2.1.0

data/README.md

@@ -82,7 +82,8 @@ and setting their attributes afterward.
 One could, if so inclined, use this method to dynamically edit or even create 
 an entire test suite!
 
-For more information on the different models and how to use them, see the 
+For more information on the different models (which more or less have the same relation 
+to each other as described in the AST [here](https://github.com/cucumber/cucumber/tree/master/gherkin#ast)) and how to use them, see the 
 [documentation](https://app.cucumber.pro/projects/cuke_modeler).
 
 ## Modeling dialects other than English

data/lib/cuke_modeler.rb

@@ -19,6 +19,7 @@ require 'cuke_modeler/models/model'
 require 'cuke_modeler/models/feature_file'
 require 'cuke_modeler/models/directory'
 require 'cuke_modeler/models/feature'
+require 'cuke_modeler/models/rule'
 require 'cuke_modeler/models/background'
 require 'cuke_modeler/models/scenario'
 require 'cuke_modeler/models/outline'

data/lib/cuke_modeler/adapters/gherkin_9_adapter.rb

@@ -80,6 +80,27 @@ module CukeModeler
       end
     end
 
+    # Adapts the AST sub-tree that is rooted at the given rule node.
+    def adapt_rule!(parsed_rule)
+      # Saving off the original data
+      parsed_rule['cuke_modeler_parsing_data'] = Marshal::load(Marshal.dump(parsed_rule))
+
+      # Removing parsed data for child elements in order to avoid duplicating data
+      parsed_rule['cuke_modeler_parsing_data'][:rule][:children] = nil if parsed_rule['cuke_modeler_parsing_data'][:rule][:children]
+
+      parsed_rule['type'] = 'Rule'
+      parsed_rule['keyword'] = parsed_rule[:rule].delete(:keyword)
+      parsed_rule['name'] = parsed_rule[:rule].delete(:name)
+      parsed_rule['description'] = parsed_rule[:rule].delete(:description) || ''
+      parsed_rule['line'] = parsed_rule[:rule].delete(:location)[:line]
+
+      parsed_rule['elements'] = []
+      if parsed_rule[:rule][:children]
+        adapt_child_elements!(parsed_rule[:rule][:children])
+        parsed_rule['elements'].concat(parsed_rule[:rule].delete(:children))
+      end
+    end
+
     # Adapts the AST sub-tree that is rooted at the given scenario node.
     def adapt_scenario!(parsed_test)
       # Removing parsed data for child elements in order to avoid duplicating data
@@ -286,14 +307,18 @@ module CukeModeler
 
     def adapt_child_elements!(parsed_children)
       background_child = parsed_children.find { |child| child[:background] }
+      rule_children = parsed_children.select { |child| child[:rule] }
+      remaining_children = parsed_children.reject { |child| child[:background] || child[:rule] }
 
-      if background_child
-        adapt_background!(background_child)
+      adapt_background!(background_child) if background_child
+      adapt_rules!(rule_children)
+      adapt_tests!(remaining_children)
+    end
 
-        remaining_children = parsed_children.reject { |child| child[:background] }
+    def adapt_rules!(parsed_rules)
+      parsed_rules.each do |rule|
+        adapt_rule!(rule)
       end
-
-      adapt_tests!(remaining_children || parsed_children)
     end
 
     def adapt_tests!(parsed_tests)

data/lib/cuke_modeler/containing.rb

@@ -32,7 +32,6 @@ module CukeModeler
 
       model.parent_model = self
 
-
       model
     end
 
@@ -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']
 
@@ -213,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/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
@@ -94,14 +101,18 @@ module CukeModeler
     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/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/version.rb

@@ -1,4 +1,4 @@
 module CukeModeler
   # The gem version
-  VERSION = '3.1.0'
+  VERSION = '3.2.0'
 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
 

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

@@ -11,23 +11,28 @@ Feature: Feature output
       Feature: A feature with everything it could have
       Including a description
       and then some.
-      Background:
+      Background: non-nested background
       Background
       description
       * a step
       |value1|
+      |value2|
       * another step
       @scenario_tag
-      Scenario:
+      Scenario: non-nested scenario
       Scenario
       description
       * a step
       * another step
-      \"\"\"
+      \"\"\" with content type
         some text
       \"\"\"
+      Rule: a rule
+      Rule description 
+      Background: nested background
+      * a step
       @outline_tag
-      Scenario Outline:
+      Scenario Outline: nested outline
       Outline
       description
       * a step
@@ -42,6 +47,9 @@ Feature: Feature output
       description
       |param|
       |value|
+      Examples: additional example
+      Rule: another rule
+      Which is empty
       """
     And a feature model based on that gherkin
       """
@@ -59,48 +67,62 @@ Feature: Feature output
       Including a description
       and then some.
 
-        Background:
+        Background: non-nested background
 
         Background
         description
 
           * a step
             | value1 |
+            | value2 |
           * another step
 
         @scenario_tag
-        Scenario:
+        Scenario: non-nested scenario
 
         Scenario
         description
 
           * a step
           * another step
-            \"\"\"
+            \"\"\" with content type
               some text
             \"\"\"
 
-        @outline_tag
-        Scenario Outline:
+        Rule: a rule
 
-        Outline
-        description
+        Rule description
 
-          * a step
-            | value2 |
-          * another step
-            \"\"\"
-              some text
-            \"\"\"
+          Background: nested background
+            * a step
 
-        @example_tag
-        Examples:
+          @outline_tag
+          Scenario Outline: nested outline
 
-        Example
-        description
+          Outline
+          description
+
+            * a step
+              | value2 |
+            * another step
+              \"\"\"
+                some text
+              \"\"\"
+
+          @example_tag
+          Examples:
+
+          Example
+          description
+
+            | param |
+            | value |
+
+          Examples: additional example
+
+        Rule: another rule
 
-          | param |
-          | value |
+        Which is empty
       """
     And the output can be used to make an equivalent model
       """

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

@@ -0,0 +1,108 @@
+Feature: Rule modeling
+
+Rule models Scenario portion of a feature. They expose several attributes of the rule that they represent, as well as
+containing models for any background, scenarios, or outlines that are present in that rule.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      Rule: Rule Foo
+
+          Some rule description.
+
+        Some more.
+            And some more.
+
+        Background: The background
+          * some setup step
+
+        Scenario: Scenario 1
+          * a step
+
+        Scenario Outline: Outline 1
+          * a step
+        Examples:
+          | param |
+          | value |
+
+        Scenario: Scenario 2
+          * a step
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Rule.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a rule's keyword
+    When the rule's keyword is requested
+      """
+        @model.keyword
+      """
+    Then the model returns "Rule"
+
+  Scenario: Modeling a rule's name
+    When the rule's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "Rule Foo"
+
+  Scenario: Modeling a rule's description
+    When the rule's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some rule description.
+
+      Some more.
+          And some more.
+      """
+
+  Scenario: Modeling a rule's background
+    When the rule's background is requested
+      """
+        @model.background
+      """
+    Then the model returns a model for the background "The background"
+
+  Scenario: Modeling a rule's scenarios
+    When the rule's scenarios are requested
+      """
+        @model.scenarios
+      """
+    Then the model returns models for the following scenarios:
+      | Scenario 1 |
+      | Scenario 2 |
+
+  Scenario: Modeling a rule's outlines
+    When the rule's outlines are requested
+      """
+        @model.outlines
+      """
+    Then the model returns models for the following outlines:
+      | Outline 1 |
+
+  Scenario: Modeling a rule's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Rule:
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the rule model of that feature model
+      """
+        @model = @model.rules.first
+      """
+    When the rule's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "3"

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

@@ -0,0 +1,111 @@
+Feature: Rule output
+
+  A rule model's string output is a Gherkin representation of itself. As such, output from a rule model can be used as
+  input for the same kind of model.
+
+
+  Scenario: Outputting a rule model
+    Given the following gherkin:
+      """
+      Rule: A rule with everything it could have
+      Including a description
+      and then some.
+      Background: a background
+      Background
+      description
+      * a step
+      |value1|
+      |value2|
+      * another step
+      @scenario_tag
+      Scenario: a scenario
+      Scenario
+      description
+      * a step
+      * another step
+      \"\"\" with content type
+        some text
+      \"\"\"
+      @outline_tag
+      Scenario Outline: an outline
+      Outline
+      description
+      * a step
+      |value2|
+      * another step
+      \"\"\"
+        some text
+      \"\"\"
+      @example_tag
+      Examples:
+      Example
+      description
+      |param|
+      |value|
+      Examples: additional example
+      """
+    And a rule model based on that gherkin
+      """
+        @model = CukeModeler::Rule.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      Rule: A rule with everything it could have
+
+      Including a description
+      and then some.
+
+        Background: a background
+
+        Background
+        description
+
+          * a step
+            | value1 |
+            | value2 |
+          * another step
+
+        @scenario_tag
+        Scenario: a scenario
+
+        Scenario
+        description
+
+          * a step
+          * another step
+            \"\"\" with content type
+              some text
+            \"\"\"
+
+        @outline_tag
+        Scenario Outline: an outline
+
+        Outline
+        description
+
+          * a step
+            | value2 |
+          * another step
+            \"\"\"
+              some text
+            \"\"\"
+
+        @example_tag
+        Examples:
+
+        Example
+        description
+
+          | param |
+          | value |
+
+        Examples: additional example
+      """
+    And the output can be used to make an equivalent model
+      """
+        CukeModeler::Rule.new(@model.to_s)
+      """

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_modeler
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-28 00:00:00.000000000 Z
+date: 2020-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-gherkin
@@ -187,6 +187,7 @@ files:
 - lib/cuke_modeler/models/model.rb
 - lib/cuke_modeler/models/outline.rb
 - lib/cuke_modeler/models/row.rb
+- lib/cuke_modeler/models/rule.rb
 - lib/cuke_modeler/models/scenario.rb
 - lib/cuke_modeler/models/step.rb
 - lib/cuke_modeler/models/table.rb
@@ -223,6 +224,8 @@ files:
 - testing/cucumber/features/modeling/outline_output.feature
 - testing/cucumber/features/modeling/row_modeling.feature
 - testing/cucumber/features/modeling/row_output.feature
+- testing/cucumber/features/modeling/rule_modeling.feature
+- testing/cucumber/features/modeling/rule_output.feature
 - testing/cucumber/features/modeling/scenario_modeling.feature
 - testing/cucumber/features/modeling/scenario_output.feature
 - testing/cucumber/features/modeling/step_modeling.feature