cuke_modeler 3.27.0 → 3.28.0

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

@@ -1,36 +1,36 @@
-Feature: Cell output
-
-  A cell model's string output is a Gherkin representation of itself and its most relevant attribute for
-  inspection is the value of the cell that it models.
-
-
-  Background:
-    Given the following gherkin:
-      """
-      foo
-      """
-    And a cell model based on that gherkin
-      """
-      @model = CukeModeler::Cell.new(<source_text>)
-      """
-
-
-  Scenario: Stringify a cell model
-    When the model is output as a string
-      """
-      @model.to_s
-      """
-    Then the following text is provided:
-      """
-      foo
-      """
-
-  Scenario: Inspect a cell model
-    When the model is inspected
-      """
-      @model.inspect
-      """
-    Then the following text is provided:
-      """
-      #<CukeModeler::Cell:<object_id> @value: "foo">
-      """
+Feature: Cell output
+
+  A cell model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the value of the cell that it models.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      foo
+      """
+    And a cell model based on that gherkin
+      """
+      @model = CukeModeler::Cell.new(<source_text>)
+      """
+
+
+  Scenario: Stringify a cell model
+    When the model is output as a string
+      """
+      @model.to_s
+      """
+    Then the following text is provided:
+      """
+      foo
+      """
+
+  Scenario: Inspect a cell model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Cell:<object_id> @value: "foo">
+      """

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

@@ -1,62 +1,62 @@
-Feature: Comment modeling
-
-  Comment models represent a comment portion of a feature. They expose several attributes of the comment that they represent.
-
-
-  Background:
-    Given the following gherkin:
-      """
-      # a comment
-      """
-    And a comment model based on that gherkin
-      """
-        @model = CukeModeler::Comment.new(<source_text>)
-      """
-
-
-  Scenario: Modeling a comments text
-    When the comment's text is requested
-      """
-        @model.text
-      """
-    Then the model returns "# a comment"
-
-  Scenario: Modeling a comment's source line
-    Given a feature file with the following gherkin:
-      """
-      # a comment
-      Feature:
-      """
-    And a feature file model based on that file
-      """
-        @model = CukeModeler::FeatureFile.new(<file_path>)
-      """
-    And the comment model of that feature file model
-      """
-        @model = @model.comments.first
-      """
-    When the comment's source line is requested
-      """
-        @model.source_line
-      """
-    Then the model returns "1"
-
-  Scenario: Modeling a comment's source column
-    Given a feature file with the following gherkin:
-      """
-      # a comment
-      Feature:
-      """
-    And a feature file model based on that file
-      """
-        @model = CukeModeler::FeatureFile.new(<file_path>)
-      """
-    And the comment model of that feature file model
-      """
-        @model = @model.comments.first
-      """
-    When the comment's source column is requested
-      """
-        @model.source_column
-      """
-    Then the model returns "1"
+Feature: Comment modeling
+
+  Comment models represent a comment portion of a feature. They expose several attributes of the comment that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      # a comment
+      """
+    And a comment model based on that gherkin
+      """
+        @model = CukeModeler::Comment.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a comments text
+    When the comment's text is requested
+      """
+        @model.text
+      """
+    Then the model returns "# a comment"
+
+  Scenario: Modeling a comment's source line
+    Given a feature file with the following gherkin:
+      """
+      # a comment
+      Feature:
+      """
+    And a feature file model based on that file
+      """
+        @model = CukeModeler::FeatureFile.new(<file_path>)
+      """
+    And the comment model of that feature file model
+      """
+        @model = @model.comments.first
+      """
+    When the comment's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "1"
+
+  Scenario: Modeling a comment's source column
+    Given a feature file with the following gherkin:
+      """
+      # a comment
+      Feature:
+      """
+    And a feature file model based on that file
+      """
+        @model = CukeModeler::FeatureFile.new(<file_path>)
+      """
+    And the comment model of that feature file model
+      """
+        @model = @model.comments.first
+      """
+    When the comment's source column is requested
+      """
+        @model.source_column
+      """
+    Then the model returns "1"

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

@@ -1,40 +1,40 @@
-Feature: Comment output
-
-  A comment model's string output is a Gherkin representation of itself and its most relevant attribute for
-  inspection is the text of the comment that it models.
-
-
-  Background:
-    Given the following gherkin:
-      """
-      # a comment
-      """
-    And a comment model based on that gherkin
-      """
-      @model = CukeModeler::Comment.new(<source_text>)
-      """
-
-
-  Scenario: Stringify a comment model
-    When the model is output as a string
-      """
-      @model.to_s
-      """
-    Then the following text is provided:
-      """
-      # a comment
-      """
-    And the output can be used to make an equivalent model
-      """
-      CukeModeler::Comment.new(@model.to_s)
-      """
-
-  Scenario: Inspect a comment model
-    When the model is inspected
-      """
-      @model.inspect
-      """
-    Then the following text is provided:
-      """
-      #<CukeModeler::Comment:<object_id> @text: "# a comment">
-      """
+Feature: Comment output
+
+  A comment model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the text of the comment that it models.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      # a comment
+      """
+    And a comment model based on that gherkin
+      """
+      @model = CukeModeler::Comment.new(<source_text>)
+      """
+
+
+  Scenario: Stringify a comment model
+    When the model is output as a string
+      """
+      @model.to_s
+      """
+    Then the following text is provided:
+      """
+      # a comment
+      """
+    And the output can be used to make an equivalent model
+      """
+      CukeModeler::Comment.new(@model.to_s)
+      """
+
+  Scenario: Inspect a comment model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Comment:<object_id> @text: "# a comment">
+      """

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

@@ -1,62 +1,62 @@
-Feature: Directory modeling
-
-  Directory models are the top level element of a model tree. They expose several attributes of the directory that they represent, as well as containing models for any feature files or subdirectories that are present in the directory that they represent.
-
-
-  Background: An existing test suite
-    Given the directory "test_directory"
-    And the file "test_directory/test_file_1.feature"
-    And the file "test_directory/test_file_2.feature"
-    And the file "test_directory/random.file"
-    And the directory "test_directory/nested_directory"
-
-
-  Scenario: Modeling a directory's path
-    Given a directory is modeled
-      """
-        @model = CukeModeler::Directory.new('<path_to>/test_directory')
-      """
-    When the directory's path is requested
-      """
-        @model.path
-      """
-    Then the model returns "path_to/test_directory"
-
-  Scenario: Modeling a directory's name
-    Given a directory is modeled
-      """
-        @model = CukeModeler::Directory.new('<path_to>/test_directory')
-      """
-    When the directory's name is requested
-      """
-        @model.name
-      """
-    Then the model returns "test_directory"
-
-  Scenario: Modeling a directory's feature files
-
-  Note: Files that are not .feature files are not modeled
-
-    Given a directory is modeled
-      """
-        @model = CukeModeler::Directory.new('<path_to>/test_directory')
-      """
-    When the directory's feature files are requested
-      """
-        @model.feature_files
-      """
-    Then the model returns models for the following feature files:
-      | test_file_1.feature |
-      | test_file_2.feature |
-
-  Scenario: Modeling a directory's directories
-    Given a directory is modeled
-      """
-        @model = CukeModeler::Directory.new('<path_to>/test_directory')
-      """
-    When the directory's directories are requested
-      """
-        @model.directories
-      """
-    Then the model returns models for the following directories:
-      | nested_directory |
+Feature: Directory modeling
+
+  Directory models are the top level element of a model tree. They expose several attributes of the directory that they represent, as well as containing models for any feature files or subdirectories that are present in the directory that they represent.
+
+
+  Background: An existing test suite
+    Given the directory "test_directory"
+    And the file "test_directory/test_file_1.feature"
+    And the file "test_directory/test_file_2.feature"
+    And the file "test_directory/random.file"
+    And the directory "test_directory/nested_directory"
+
+
+  Scenario: Modeling a directory's path
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's path is requested
+      """
+        @model.path
+      """
+    Then the model returns "path_to/test_directory"
+
+  Scenario: Modeling a directory's name
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "test_directory"
+
+  Scenario: Modeling a directory's feature files
+
+  Note: Files that are not .feature files are not modeled
+
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's feature files are requested
+      """
+        @model.feature_files
+      """
+    Then the model returns models for the following feature files:
+      | test_file_1.feature |
+      | test_file_2.feature |
+
+  Scenario: Modeling a directory's directories
+    Given a directory is modeled
+      """
+        @model = CukeModeler::Directory.new('<path_to>/test_directory')
+      """
+    When the directory's directories are requested
+      """
+        @model.directories
+      """
+    Then the model returns models for the following directories:
+      | nested_directory |

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

@@ -1,33 +1,33 @@
-Feature: Directory output
-
-  A directory model's string output is simply the file path of the directory that it models and its
-  most relevant attribute for inspection is the path of the directory that it models.
-
-
-  Background:
-    Given a directory model based on "some_directory"
-
-
-  Scenario: Stringify a directory model
-    When the model is output as a string
-      """
-      @model.to_s
-      """
-    Then the following text is provided:
-      """
-      <path_to>/some_directory
-      """
-    And the output can be used to make an equivalent model
-      """
-      CukeModeler::Directory.new(@model.to_s)
-      """
-
-  Scenario: Inspect a directory model
-    When the model is inspected
-      """
-      @model.inspect
-      """
-    Then the following text is provided:
-      """
-      #<CukeModeler::Directory:<object_id> @path: "<path_to>/some_directory">
-      """
+Feature: Directory output
+
+  A directory model's string output is simply the file path of the directory that it models and its
+  most relevant attribute for inspection is the path of the directory that it models.
+
+
+  Background:
+    Given a directory model based on "some_directory"
+
+
+  Scenario: Stringify a directory model
+    When the model is output as a string
+      """
+      @model.to_s
+      """
+    Then the following text is provided:
+      """
+      <path_to>/some_directory
+      """
+    And the output can be used to make an equivalent model
+      """
+      CukeModeler::Directory.new(@model.to_s)
+      """
+
+  Scenario: Inspect a directory model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Directory:<object_id> @path: "<path_to>/some_directory">
+      """

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

@@ -1,85 +1,85 @@
-Feature: Doc string modeling
-
-  Doc string models represent the doc string argument to a step. They expose several attributes of the doc string that they represent.
-
-
-  Background:
-    Given the following gherkin:
-      """
-      \"\"\" type foo
-      content bar
-      \"\"\"
-      """
-    And a doc string model based on that gherkin
-      """
-        @model = CukeModeler::DocString.new(<source_text>)
-      """
-
-
-  Scenario: Modeling a doc string's content type
-    When the doc string's name is requested
-      """
-        @model.content_type
-      """
-    Then the model returns "type foo"
-
-  Scenario: Modeling a doc string's content
-    When the doc string's content is requested
-      """
-        @model.content
-      """
-    Then the model returns
-      """
-      content bar
-      """
-
-  Scenario: Modeling a doc string's source line
-    Given the following gherkin:
-      """
-      Feature:
-
-        Scenario:
-          * a step
-            \"\"\"
-            foo
-            \"\"\"
-      """
-    And a feature model based on that gherkin
-      """
-        @model = CukeModeler::Feature.new(<source_text>)
-      """
-    And the doc string model inside of that feature model
-      """
-        @model = @model.tests.first.steps.first.block
-      """
-    When the doc string's source line is requested
-      """
-        @model.source_line
-      """
-    Then the model returns "5"
-
-
-  Scenario: Modeling a doc string's source column
-    Given the following gherkin:
-      """
-      Feature:
-
-        Scenario:
-          * a step
-            \"\"\"
-            foo
-            \"\"\"
-      """
-    And a feature model based on that gherkin
-      """
-        @model = CukeModeler::Feature.new(<source_text>)
-      """
-    And the doc string model inside of that feature model
-      """
-        @model = @model.tests.first.steps.first.block
-      """
-    When the doc string's source column is requested
-      """
-        @model.source_column
-      """
-    Then the model returns "7"
+Feature: Doc string modeling
+
+  Doc string models represent the doc string argument to a step. They expose several attributes of the doc string that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      \"\"\" type foo
+      content bar
+      \"\"\"
+      """
+    And a doc string model based on that gherkin
+      """
+        @model = CukeModeler::DocString.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a doc string's content type
+    When the doc string's name is requested
+      """
+        @model.content_type
+      """
+    Then the model returns "type foo"
+
+  Scenario: Modeling a doc string's content
+    When the doc string's content is requested
+      """
+        @model.content
+      """
+    Then the model returns
+      """
+      content bar
+      """
+
+  Scenario: Modeling a doc string's source line
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+            \"\"\"
+            foo
+            \"\"\"
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the doc string model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first.block
+      """
+    When the doc string's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "5"
+
+
+  Scenario: Modeling a doc string's source column
+    Given the following gherkin:
+      """
+      Feature:
+
+        Scenario:
+          * a step
+            \"\"\"
+            foo
+            \"\"\"
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the doc string model inside of that feature model
+      """
+        @model = @model.tests.first.steps.first.block
+      """
+    When the doc string's source column is requested
+      """
+        @model.source_column
+      """
+    Then the model returns "7"