cuke_modeler 3.27.0 → 3.28.0

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

@@ -1,61 +1,61 @@
-Feature: Model output
-
-  All models can be output in text form via `#to_s`. For models that represent parts of the file structure, this text
-  usually is a path. For models that represent parts of a feature file, this text usually is Gherkin. In any case, the
-  output is in a format that can be used to create the same kind of model.
-
-  Due to the nested nature of model relationships, the default output of `#inspect` can get...lengthy. For this reason,
-  all models override `#inspect` to make it provide a minimal but useful amount of information on the model object.
-  Switching between the minimal and the verbose (i.e. default Ruby behavior) version is controlled by a flag.
-
-  See the model output documentation for specific models for details.
-
-
-  Scenario: Stringify a model
-    Given the models provided by CukeModeler
-    Then all of them can be output as text appropriate to the model type
-      """
-      model = <model_class>.new
-        
-      model.to_s
-      """
-
-  Scenario: Inspect a model
-
-  Note: The base model class, `CukeModeler::Model` lacks any "meaningful attributes"
-
-    Given the models provided by CukeModeler
-    Then all of them can provide a custom inspection output
-      """
-      model = <model_class>.new
-
-      model.inspect
-      """
-    And the inspection values are of the form:
-      """
-      #<CukeModeler::<model_class>:<object_id> <some_meaningful_attribute>: <attribute_value>>
-      """
-    But the base model class inspection value is of the form:
-      """
-      #<CukeModeler::<model_class>:<object_id>>
-      """
-
-  Scenario: Controlling inspection output
-
-  Note: Non-verbose inspection is the default behavior for models
-
-    Given the models provided by CukeModeler
-    When using non-verbose inspection
-    """
-    model = <model_class>.new
-
-    model.inspect(verbose: false)
-    """
-    Then the custom model inspection is used
-    When using verbose inspection
-    """
-    model = <model_class>.new
-
-    model.inspect(verbose: true)
-    """
-    Then the default Ruby inspection is used
+Feature: Model output
+
+  All models can be output in text form via `#to_s`. For models that represent parts of the file structure, this text
+  usually is a path. For models that represent parts of a feature file, this text usually is Gherkin. In any case, the
+  output is in a format that can be used to create the same kind of model.
+
+  Due to the nested nature of model relationships, the default output of `#inspect` can get...lengthy. For this reason,
+  all models override `#inspect` to make it provide a minimal but useful amount of information on the model object.
+  Switching between the minimal and the verbose (i.e. default Ruby behavior) version is controlled by a flag.
+
+  See the model output documentation for specific models for details.
+
+
+  Scenario: Stringify a model
+    Given the models provided by CukeModeler
+    Then all of them can be output as text appropriate to the model type
+      """
+      model = <model_class>.new
+        
+      model.to_s
+      """
+
+  Scenario: Inspect a model
+
+  Note: The base model class, `CukeModeler::Model` lacks any "meaningful attributes"
+
+    Given the models provided by CukeModeler
+    Then all of them can provide a custom inspection output
+      """
+      model = <model_class>.new
+
+      model.inspect
+      """
+    And the inspection values are of the form:
+      """
+      #<CukeModeler::<model_class>:<object_id> <some_meaningful_attribute>: <attribute_value>>
+      """
+    But the base model class inspection value is of the form:
+      """
+      #<CukeModeler::<model_class>:<object_id>>
+      """
+
+  Scenario: Controlling inspection output
+
+  Note: Non-verbose inspection is the default behavior for models
+
+    Given the models provided by CukeModeler
+    When using non-verbose inspection
+    """
+    model = <model_class>.new
+
+    model.inspect(verbose: false)
+    """
+    Then the custom model inspection is used
+    When using verbose inspection
+    """
+    model = <model_class>.new
+
+    model.inspect(verbose: true)
+    """
+    Then the default Ruby inspection is used

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

@@ -1,42 +1,42 @@
-Feature: Model structure
-
-When modeling an existing test suite, that suite is parsed and models are created for each element of the suite. These models form a nested structure of parent and child models which has the same shape as whatever portion of the suite that they represent (see the documentation for specific models for details).
-
-However, all models can also be used in an 'abstract' manner. That is, they can be created without any input (such as a file path or snippet of Gherkin) that would normally be used for determining their structure and properties. In these cases, their parent/child relationships and properties can be set directly rather than being populated dynamically based on an actual test suite.
-
-
-  Scenario: Creating abstract models
-    Given the models provided by CukeModeler
-    Then  all of them can be created without further context
-      """
-        abstract_model = <model_class>.new
-      """
-
-  Scenario: Nesting models
-    Given the models provided by CukeModeler
-    Then  all of them can contain other models
-      """
-        child_model = <model_class>.new
-        parent_model = <model_class>.new
-
-        parent_model.children << child_model
-      """
-    And   all of them can be contained inside of another model
-      """
-        child_model = <model_class>.new
-        parent_model = <model_class>.new
-
-        child_model.parent_model = parent_model
-      """
-
-  Scenario: Accessing the parsing data
-
-  Note: Directory models do not store any parsing data because parsing Gherkin source text does not come into play until the feature file level of modeling.
-
-    Given the models provided by CukeModeler
-    Then  all of them provide access to the parsing data that was used to create them
-      """
-        model = <model_class>.new(<source_text>)
-
-        model.parsing_data
-      """
+Feature: Model structure
+
+When modeling an existing test suite, that suite is parsed and models are created for each element of the suite. These models form a nested structure of parent and child models which has the same shape as whatever portion of the suite that they represent (see the documentation for specific models for details).
+
+However, all models can also be used in an 'abstract' manner. That is, they can be created without any input (such as a file path or snippet of Gherkin) that would normally be used for determining their structure and properties. In these cases, their parent/child relationships and properties can be set directly rather than being populated dynamically based on an actual test suite.
+
+
+  Scenario: Creating abstract models
+    Given the models provided by CukeModeler
+    Then  all of them can be created without further context
+      """
+        abstract_model = <model_class>.new
+      """
+
+  Scenario: Nesting models
+    Given the models provided by CukeModeler
+    Then  all of them can contain other models
+      """
+        child_model = <model_class>.new
+        parent_model = <model_class>.new
+
+        parent_model.children << child_model
+      """
+    And   all of them can be contained inside of another model
+      """
+        child_model = <model_class>.new
+        parent_model = <model_class>.new
+
+        child_model.parent_model = parent_model
+      """
+
+  Scenario: Accessing the parsing data
+
+  Note: Directory models do not store any parsing data because parsing Gherkin source text does not come into play until the feature file level of modeling.
+
+    Given the models provided by CukeModeler
+    Then  all of them provide access to the parsing data that was used to create them
+      """
+        model = <model_class>.new(<source_text>)
+
+        model.parsing_data
+      """

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

@@ -1,175 +1,175 @@
-Feature: Outline modeling
-
-  Outline models represent a Scenario Outline portion of a feature. They expose several attributes of the outline that they represent, as well as containing models for the steps, tags, and examples that are present in that outline.
-
-
-  Background:
-    Given the following gherkin:
-      """
-      Scenario Outline: example outline
-
-          Some background description.
-
-        Some more.
-            Even more.
-
-
-          Given a <setup> step
-          When an action step
-          Then a <verification> step
-
-        Examples: example 1
-          | setup | verification |
-          | x     | y            |
-        Examples: example 2
-          | setup | verification |
-          | a     | b            |
-      """
-    And an outline model based on that gherkin
-      """
-        @model = CukeModeler::Outline.new(<source_text>)
-      """
-
-
-  Scenario: Modeling an outline's keyword
-    When the outline's keyword is requested
-      """
-        @model.keyword
-      """
-    Then the model returns "Scenario Outline"
-
-  Scenario: Modeling an outline's name
-    When the outline's name is requested
-      """
-        @model.name
-      """
-    Then the model returns "example outline"
-
-  Scenario: Modeling an outline's description
-    When the outline's description is requested
-      """
-        @model.description
-      """
-    Then the model returns
-      """
-        Some background description.
-
-      Some more.
-          Even more.
-      """
-
-  Scenario: Modeling an outline's steps
-    When the outline's steps are requested
-      """
-        @model.steps
-      """
-    Then the model returns models for the following steps:
-      | a <setup> step        |
-      | an action step        |
-      | a <verification> step |
-
-  Scenario: Modeling an outline's examples
-    When the outline's examples are requested
-      """
-        @model.examples
-      """
-    Then the model returns models for the following examples:
-      | example 1 |
-      | example 2 |
-
-  Scenario: Modeling an outline's tags
-    Given the following gherkin:
-      """
-      @feature_tag
-      Feature:
-
-        @outline_tag_1
-        @outline_tag_2
-        Scenario Outline:
-          Given a <setup> step
-          When an action step
-          Then a <verification> step
-
-        Examples:
-          | setup | verification |
-          | x     | y            |
-      """
-    And a feature model based on that gherkin
-      """
-        @model = CukeModeler::Feature.new(<source_text>)
-      """
-    And the outline model of that feature model
-      """
-        @model = @model.outlines.first
-      """
-    When the outline's tags are requested
-      """
-        @model.tags
-      """
-    Then the model returns models for the following tags:
-      | @outline_tag_1 |
-      | @outline_tag_2 |
-    When the outline's inherited tags are requested
-      """
-        @model.applied_tags
-      """
-    Then the model returns models for the following tags:
-      | @feature_tag |
-    When all of the outline's tags are requested
-      """
-        @model.all_tags
-      """
-    Then the model returns models for the following tags:
-      | @feature_tag   |
-      | @outline_tag_1 |
-      | @outline_tag_2 |
-
-  Scenario: Modeling an outline's source line
-    Given the following gherkin:
-      """
-      Feature:
-
-        Scenario Outline:
-          * a step
-        Examples:
-          | param |
-          | value |
-      """
-    And a feature model based on that gherkin
-      """
-        @model = CukeModeler::Feature.new(<source_text>)
-      """
-    And the outline model of that feature model
-      """
-        @model = @model.outlines.first
-      """
-    When the outline's source line is requested
-      """
-        @model.source_line
-      """
-    Then the model returns "3"
-
-  Scenario: Modeling an outline's source column
-    Given the following gherkin:
-      """
-      Feature:
-
-        Scenario Outline:
-          * a step
-        Examples:
-          | param |
-          | value |
-      """
-    And a feature model based on that gherkin
-      """
-        @model = CukeModeler::Feature.new(<source_text>)
-      """
-    And the outline model of that feature model
-      """
-        @model = @model.outlines.first
-      """
-    When the outline's source column is requested
-      """
-        @model.source_column
-      """
-    Then the model returns "3"
+Feature: Outline modeling
+
+  Outline models represent a Scenario Outline portion of a feature. They expose several attributes of the outline that they represent, as well as containing models for the steps, tags, and examples that are present in that outline.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      Scenario Outline: example outline
+
+          Some background description.
+
+        Some more.
+            Even more.
+
+
+          Given a <setup> step
+          When an action step
+          Then a <verification> step
+
+        Examples: example 1
+          | setup | verification |
+          | x     | y            |
+        Examples: example 2
+          | setup | verification |
+          | a     | b            |
+      """
+    And an outline model based on that gherkin
+      """
+        @model = CukeModeler::Outline.new(<source_text>)
+      """
+
+
+  Scenario: Modeling an outline's keyword
+    When the outline's keyword is requested
+      """
+        @model.keyword
+      """
+    Then the model returns "Scenario Outline"
+
+  Scenario: Modeling an outline's name
+    When the outline's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "example outline"
+
+  Scenario: Modeling an outline's description
+    When the outline's description is requested
+      """
+        @model.description
+      """
+    Then the model returns
+      """
+        Some background description.
+
+      Some more.
+          Even more.
+      """
+
+  Scenario: Modeling an outline's steps
+    When the outline's steps are requested
+      """
+        @model.steps
+      """
+    Then the model returns models for the following steps:
+      | a <setup> step        |
+      | an action step        |
+      | a <verification> step |
+
+  Scenario: Modeling an outline's examples
+    When the outline's examples are requested
+      """
+        @model.examples
+      """
+    Then the model returns models for the following examples:
+      | example 1 |
+      | example 2 |
+
+  Scenario: Modeling an outline's tags
+    Given the following gherkin:
+      """
+      @feature_tag
+      Feature:
+
+        @outline_tag_1
+        @outline_tag_2
+        Scenario Outline:
+          Given a <setup> step
+          When an action step
+          Then a <verification> step
+
+        Examples:
+          | setup | verification |
+          | x     | y            |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the outline model of that feature model
+      """
+        @model = @model.outlines.first
+      """
+    When the outline's tags are requested
+      """
+        @model.tags
+      """
+    Then the model returns models for the following tags:
+      | @outline_tag_1 |
+      | @outline_tag_2 |
+    When the outline's inherited tags are requested
+      """
+        @model.applied_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag |
+    When all of the outline's tags are requested
+      """
+        @model.all_tags
+      """
+    Then the model returns models for the following tags:
+      | @feature_tag   |
+      | @outline_tag_1 |
+      | @outline_tag_2 |
+
+  Scenario: Modeling an outline's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario Outline:
+          * a step
+        Examples:
+          | param |
+          | value |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the outline model of that feature model
+      """
+        @model = @model.outlines.first
+      """
+    When the outline's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "3"
+
+  Scenario: Modeling an outline's source column
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario Outline:
+          * a step
+        Examples:
+          | param |
+          | value |
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the outline model of that feature model
+      """
+        @model = @model.outlines.first
+      """
+    When the outline's source column is requested
+      """
+        @model.source_column
+      """
+    Then the model returns "3"