cuke_modeler 3.19.0 → 3.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 215d7b396a27b9dec6e5ce4bad0692446e754fd88021f85b570605f33854a324
-  data.tar.gz: 748e499b4bfe721cc8953d5e733652222b7fb019fd0ac232fb85621eb05c9f1a
+  metadata.gz: db68bd0813ac0151f45f174d89c95c5accb2c11a77df2321f859d18f62ecf06f
+  data.tar.gz: 5d9b7ee4ea5c98a8e90d4d8d6d657223150064be4e867a8ef444eb93b357a195
 SHA512:
-  metadata.gz: aa017464c7b23bfffc33a1e37c92c8823e0a5fd42c2505e251c36f9d092e444ff04d61457957d56a2a197f56030d5de0e73a4071226fc38e2e801ffd646bd2fd
-  data.tar.gz: 2c5a264af86979e6250d4763e5572e93a2136855f1c3c3572019d18374e7dfd7bf37669f814667c4c308e98553e2bb2287bf6aadddd9a04d98e59fe155b716e8
+  metadata.gz: a166c272417d15db4e3a04dcfb2057c0536a8412e7bce5810b9885998823d354667b42dbf9a49796d73498f469c1978779ea8a518ccd1ed92d2c9f6985c69f5e
+  data.tar.gz: c24f43b46820b37f16a0bf476e48d86c2a159ebc6b6a2b87da3194d7c6e0496b0ed25c7698a83c8a5f4bb1bc5fd77503c188492a19c3b8403298e994b03a5dab

data/CHANGELOG.md

@@ -8,6 +8,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+
+## [3.20.0] - 2023-9-21
+
+### Added
+- Support added for more versions of the `cucumber-gherkin` gem
+    - 27.x
+
+### Changed
+ - `#inspect` for models now returns a reasonably small set of details for the model instead of the potentially 
+   huge screen dump of information. Not considered a breaking change because the API never specified the behavior 
+   of `#inspect` (it was just using the default Ruby implementation). Default Ruby inspection can still be triggered, 
+   if desired (see documentation).
+
 ## [3.19.0] - 2023-1-22
 
 ### Added
@@ -442,7 +455,8 @@ Nothing yet...
  - Initial release
 
 
-[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.19.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_modeler/compare/v3.20.0...HEAD
+[3.20.0]: https://github.com/enkessler/cuke_modeler/compare/v3.19.0...v3.20.0
 [3.19.0]: https://github.com/enkessler/cuke_modeler/compare/v3.18.0...v3.19.0
 [3.18.0]: https://github.com/enkessler/cuke_modeler/compare/v3.17.0...v3.18.0
 [3.17.0]: https://github.com/enkessler/cuke_modeler/compare/v3.16.0...v3.17.0

data/cuke_modeler.gemspec

@@ -37,17 +37,19 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.3', '< 4.0'
 
-  spec.add_runtime_dependency 'cucumber-gherkin', '< 27.0'
+  spec.add_runtime_dependency 'cucumber-gherkin', '< 28.0'
 
   spec.add_development_dependency 'bundler', '< 3.0'
   spec.add_development_dependency 'childprocess', '< 5.0'
   spec.add_development_dependency 'ffi', '< 2.0' # This is an invisible dependency for the `childprocess` gem on Windows
   # Cucumber 4.x is the earliest version to use cucumber-gherkin
-  spec.add_development_dependency 'cucumber', '>= 4.0.0', '< 8.0.0'
+  spec.add_development_dependency 'cucumber', '>= 4.0.0', '< 10.0.0'
   spec.add_development_dependency 'rainbow', '< 4.0.0'
   spec.add_development_dependency 'rake', '< 14.0.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  # Running recent RuboCop versions requires a recent version of Ruby but it can still lint against Ruby 2.3 styles
+  # Running recent RuboCop versions requires a recent version of Ruby but it can still lint against Ruby 2.3 styles.
+  # Can't set a lower bound because RuboCop will still get installed in the testing environments for earlier Rubies,
+  # even if it never actually gets run. Current "minimum" version is 1.44.0.
   spec.add_development_dependency 'rubocop', '< 2.0'
   spec.add_development_dependency 'simplecov', '< 1.0'
   spec.add_development_dependency 'simplecov-lcov', '< 1.0'

data/lib/cuke_modeler/adapters/gherkin_27_adapter.rb

@@ -0,0 +1,13 @@
+require_relative 'gherkin_20_adapter'
+
+
+module CukeModeler
+
+  # NOT A PART OF THE PUBLIC API
+  # An adapter that can convert the output of version 27.x of the *cucumber-gherkin* gem into input that is consumable
+  # by this gem.
+
+  class Gherkin27Adapter < Gherkin20Adapter
+
+  end
+end

data/lib/cuke_modeler/models/background.rb

@@ -53,6 +53,16 @@ module CukeModeler
       text
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a background model, this will be the name of the
+    # background.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/cell.rb

@@ -30,6 +30,15 @@ module CukeModeler
       @value ? @value.gsub('\\', '\\\\\\').gsub('|', '\|') : ''
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a cell model, this will be the value of the cell.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @value: #{value.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/comment.rb

@@ -29,6 +29,15 @@ module CukeModeler
       text || ''
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a comment model, this will be the text of the comment.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @text: #{text.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/directory.rb

@@ -46,6 +46,16 @@ module CukeModeler
       path.to_s
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a directory model, this will be the path of the
+    # directory.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @path: #{@path.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/doc_string.rb

@@ -34,6 +34,16 @@ module CukeModeler
       text << '"""'
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a doc string model, this will be the content of
+    # the doc string.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @content: #{content.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/example.rb

@@ -44,7 +44,7 @@ module CukeModeler
       # A quick 'deep clone' so that the input isn't modified
       row = Marshal.load(Marshal.dump(row))
 
-      values = if row.is_a?(Array) # rubocop:disable Style/CaseLikeIf # False positive
+      values = if row.is_a?(Array)
                  row
                elsif row.is_a?(Hash)
                  # There is no guarantee that the user built up their hash with the keys in the same order as
@@ -64,7 +64,7 @@ module CukeModeler
     def remove_row(row_removed)
       return if argument_rows.empty?
 
-      values = if row_removed.is_a?(Array) # rubocop:disable Style/CaseLikeIf # False positive
+      values = if row_removed.is_a?(Array)
                  row_removed
                elsif row_removed.is_a?(Hash)
                  # There is no guarantee that the user built up their hash with the keys in the same order as
@@ -118,6 +118,15 @@ module CukeModeler
 
     # rubocop:enable Metrics/AbcSize
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For an example model, this will be the name of the example.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/feature.rb

@@ -99,6 +99,15 @@ module CukeModeler
 
     # rubocop:enable Metrics/AbcSize
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a feature model, this will be the name of the feature.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/feature_file.rb

@@ -47,6 +47,16 @@ module CukeModeler
       path.to_s
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a feature file model, this will be the path of
+    # the feature file.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @path: #{@path.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/model.rb

@@ -32,5 +32,13 @@ module CukeModeler
       []
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class and object ID.
+    def inspect(verbose: false)
+      return super() if verbose
+
+      "#<#{self.class.name}:#{object_id}>"
+    end
+
   end
 end

data/lib/cuke_modeler/models/outline.rb

@@ -66,6 +66,15 @@ module CukeModeler
 
     # rubocop:enable Metrics/AbcSize
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For an outline model, this will be the name of the outline.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/row.rb

@@ -37,6 +37,17 @@ module CukeModeler
       "| #{text_cells.join(' | ')} |"
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a row model, this will be the cells of the row.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      cell_output = @cells&.collect(&:value)
+
+      "#{super.chop} @cells: #{cell_output.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/rule.rb

@@ -74,6 +74,15 @@ module CukeModeler
       text
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a rule model, this will be the name of the rule.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{@name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/scenario.rb

@@ -61,6 +61,15 @@ module CukeModeler
 
     # rubocop:enable Metrics/AbcSize
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a scenario model, this will be the name of the scenario.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/step.rb

@@ -53,6 +53,15 @@ module CukeModeler
       text
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a step model, this will be the text of the step.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @text: #{@text.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/table.rb

@@ -36,6 +36,17 @@ module CukeModeler
       rows.empty? ? '' : rows.collect { |row| row_output_string(row) }.join("\n")
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a table model, this will be the rows of the table.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      row_output = @rows&.collect { |row| row.cells.collect(&:value) }
+
+      "#{super.chop} @rows: #{row_output.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/models/tag.rb

@@ -29,6 +29,15 @@ module CukeModeler
       name || ''
     end
 
+    # See `Object#inspect`. Returns some basic information about the
+    # object, including its class, object ID, and its most meaningful
+    # attribute. For a tag model, this will be the name of the tag.
+    def inspect(verbose: false)
+      return super(verbose: verbose) if verbose
+
+      "#{super.chop} @name: #{@name.inspect}>"
+    end
+
 
     private
 

data/lib/cuke_modeler/parsing.rb

@@ -9,7 +9,7 @@ require 'gherkin'
 # an 'adapter' appropriate to the version of the *cucumber-gherkin* gem that has been activated.
 gherkin_version = Gem.loaded_specs['cucumber-gherkin'].version.version
 gherkin_major_version = gherkin_version.match(/^(\d+)\./)[1].to_i
-supported_gherkin_versions = (9..26)
+supported_gherkin_versions = (9..27)
 
 raise("Unknown Gherkin version: '#{gherkin_version}'") unless supported_gherkin_versions.include?(gherkin_major_version)
 
@@ -63,7 +63,7 @@ module CukeModeler
       # inside of it, so I'm leaving this here in case it changes again
       # rubocop:disable Lint/DuplicateMethods
       case gherkin_major_version
-        when 20, 21, 22, 23, 24, 25, 26
+        when 20, 21, 22, 23, 24, 25, 26, 27
           # TODO: make these methods private?
           # NOT A PART OF THE PUBLIC API
           # The method to use for parsing Gherkin text
@@ -185,7 +185,7 @@ module CukeModeler
     end
 
     def get_word(word_set)
-      word_set = word_set.is_a?(Array) ? word_set : word_set.split('|')
+      word_set = word_set.split('|') unless word_set.is_a?(Array)
 
       word_set.first
     end

data/lib/cuke_modeler/version.rb

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

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

@@ -1,9 +1,10 @@
 Feature: Background output
 
-  A background model's string output is a Gherkin representation of itself. As such, output from a background model can be used as input for the same kind of model.
+  A background model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the background that it models.
 
 
-  Scenario: Outputting a background model
+  Background:
     Given the following gherkin:
       """
       Background: A background with everything that it could have
@@ -20,11 +21,14 @@ Feature: Background output
       """
     And a background model based on that gherkin
       """
-        @model = CukeModeler::Background.new(<source_text>)
+      @model = CukeModeler::Background.new(<source_text>)
       """
+
+
+  Scenario: Stringify a background model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -42,5 +46,15 @@ Feature: Background output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Background.new(@model.to_s)
+      CukeModeler::Background.new(@model.to_s)
+      """
+
+  Scenario: Inspect a background model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Background:<object_id> @name: "A background with everything that it could have">
       """

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

@@ -1,22 +1,36 @@
 Feature: Cell output
 
-  A cell model's string output is a Gherkin representation of itself.
+  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.
 
 
-  Scenario: Outputting a cell model
+  Background:
     Given the following gherkin:
       """
       foo
       """
     And a cell model based on that gherkin
       """
-        @model = CukeModeler::Cell.new(<source_text>)
+      @model = CukeModeler::Cell.new(<source_text>)
       """
+
+
+  Scenario: Stringify a cell model
     When the model is output as a string
       """
-        @model.to_s
+      @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_output.feature

@@ -1,20 +1,24 @@
 Feature: Comment output
 
-  A comment model's string output is a Gherkin representation of itself. As such, output from a comment model can be used as input for the same kind of model.
+  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.
 
 
-  Scenario: Outputting a comment model
+  Background:
     Given the following gherkin:
       """
       # a comment
       """
     And a comment model based on that gherkin
       """
-        @model = CukeModeler::Comment.new(<source_text>)
+      @model = CukeModeler::Comment.new(<source_text>)
       """
+
+
+  Scenario: Stringify a comment model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -22,5 +26,15 @@ Feature: Comment output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Comment.new(@model.to_s)
+      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_output.feature

@@ -1,16 +1,33 @@
 Feature: Directory output
 
-  A directory model's string output is simply the file path of the directory that it models. As such, output from a directory model can be used as input for the same kind of model.
+  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.
 
 
-  Scenario: Outputting a directory model
+  Background:
     Given a directory model based on "some_directory"
-    When it is outputted
+
+
+  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)
+      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_output.feature

@@ -1,9 +1,10 @@
 Feature: Doc string output
 
-  A doc string model's string output is a Gherkin representation of itself. As such, output from a doc string model can be used as input for the same kind of model.
+  A doc string model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the content of the doc string that it models.
 
 
-  Scenario: Outputting a doc string model
+  Background:
     Given the following gherkin:
       """
       \"\"\" type foo
@@ -15,11 +16,14 @@ Feature: Doc string output
       """
     And a doc string model based on that gherkin
       """
-        @model = CukeModeler::DocString.new(<source_text>)
+      @model = CukeModeler::DocString.new(<source_text>)
       """
+
+
+  Scenario: Stringify a doc string model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -32,5 +36,15 @@ Feature: Doc string output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::DocString.new(@model.to_s)
+      CukeModeler::DocString.new(@model.to_s)
+      """
+
+  Scenario: Inspect a doc string model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::DocString:<object_id> @content: "Some text\n\n  some more text\n">
       """

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

@@ -1,14 +1,15 @@
 Feature: Example output
 
-  An example model's string output is a Gherkin representation of itself. As such, output from an example model can be used as input for the same kind of model.
+  An example model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the example that it models.
 
 
-  Scenario: Outputting an example model
+  Background:
     Given the following gherkin:
       """
       @tag1
       @tag2 @tag3
-      Examples: an example with everything that it could have
+      Examples: An example with everything that it could have
 
       Some description.
       Some more description.
@@ -19,16 +20,19 @@ Feature: Example output
       """
     And an example model based on that gherkin
       """
-        @model = CukeModeler::Example.new(<source_text>)
+      @model = CukeModeler::Example.new(<source_text>)
       """
+
+
+  Scenario: Stringify an example model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
       @tag1 @tag2 @tag3
-      Examples: an example with everything that it could have
+      Examples: An example with everything that it could have
 
       Some description.
       Some more description.
@@ -39,5 +43,15 @@ Feature: Example output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Example.new(@model.to_s)
+      CukeModeler::Example.new(@model.to_s)
+      """
+
+  Scenario: Inspect an example model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Example:<object_id> @name: "An example with everything that it could have">
       """

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

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

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

@@ -1,9 +1,10 @@
 Feature: Feature output
 
-  A feature model's string output is a Gherkin representation of itself. As such, output from a feature model can be used as input for the same kind of model.
+  A feature model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the feature that it models.
 
 
-  Scenario: Outputting a feature model
+  Background:
     Given the following gherkin:
       """
       @tag1@tag2
@@ -28,7 +29,7 @@ Feature: Feature output
         some text
       \"\"\"
       Rule: a rule
-      Rule description 
+      Rule description
       Background: nested background
       * a step
       @outline_tag
@@ -53,11 +54,14 @@ Feature: Feature output
       """
     And a feature model based on that gherkin
       """
-        @model = CukeModeler::Feature.new(<source_text>)
+      @model = CukeModeler::Feature.new(<source_text>)
       """
+
+
+  Scenario: Stringify a feature model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -126,5 +130,15 @@ Feature: Feature output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Feature.new(@model.to_s)
+      CukeModeler::Feature.new(@model.to_s)
+      """
+
+  Scenario: Inspect a feature model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Feature:<object_id> @name: "A feature with everything it could have">
       """

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

@@ -1,13 +1,61 @@
 Feature: Model output
 
-  All models can be output in text form. For models that represent parts of the file structure, this text will be a path and for models that represent parts of a feature file, this text will be Gherkin (see the model output documentation for specific models for details).
+  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.
 
-  Scenario: Outputting a model
+  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
+    Then all of them can be output as text appropriate to the model type
       """
-        model = <model_class>.new
+      model = <model_class>.new
         
-        model.to_s
+      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/outline_output.feature

@@ -1,9 +1,10 @@
 Feature: Outline output
 
-  An outline model's string output is a Gherkin representation of itself. As such, output from an outline model can be used as input for the same kind of model.
+  An outline model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the outline that it models.
 
 
-  Scenario: Outputting an outline model
+  Background:
     Given the following gherkin:
       """
       @tag1@tag2
@@ -33,11 +34,14 @@ Feature: Outline output
       """
     And an outline model based on that gherkin
       """
-        @model = CukeModeler::Outline.new(<source_text>)
+      @model = CukeModeler::Outline.new(<source_text>)
       """
+
+
+  Scenario: Stringify an outline model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -69,5 +73,15 @@ Feature: Outline output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Outline.new(@model.to_s)
+      CukeModeler::Outline.new(@model.to_s)
+      """
+
+  Scenario: Inspect an outline model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Outline:<object_id> @name: "An outline with everything that it could have">
       """

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

@@ -1,20 +1,24 @@
 Feature: Row output
 
-  A row model's string output is a Gherkin representation of itself. As such, output from a row model can be used as input for the same kind of model.
+  A row model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the collection of cells of the row that it models.
 
 
-  Scenario: Outputting a row model
+  Background:
     Given the following gherkin:
       """
       |foo|bar|
       """
     And a row model based on that gherkin
       """
-        @model = CukeModeler::Row.new(<source_text>)
+      @model = CukeModeler::Row.new(<source_text>)
       """
+
+
+  Scenario: Stringify a row model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -22,5 +26,15 @@ Feature: Row output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Row.new(@model.to_s)
+      CukeModeler::Row.new(@model.to_s)
+      """
+
+  Scenario: Inspect a row model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Row:<object_id> @cells: ["foo", "bar"]>
       """

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

@@ -1,11 +1,11 @@
 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.
+  A rule model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the rule that it models.
 
 
   @gherkin_min_version_18
-  Scenario: Outputting a rule model
+  Scenario: Stringify a rule model
     Given the following gherkin:
       """
       @tag1@tag2
@@ -49,11 +49,11 @@ Feature: Rule output
       """
     And a rule model based on that gherkin
       """
-        @model = CukeModeler::Rule.new(<source_text>)
+      @model = CukeModeler::Rule.new(<source_text>)
       """
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -111,5 +111,26 @@ Feature: Rule output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Rule.new(@model.to_s)
+      CukeModeler::Rule.new(@model.to_s)
+      """
+
+  Scenario: Inspect a rule model
+    Given the following gherkin:
+      """
+      Rule: some rule
+
+        Scenario: a scenario
+          * a step
+      """
+    And a rule model based on that gherkin
+      """
+      @model = CukeModeler::Rule.new(<source_text>)
+      """
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Rule:<object_id> @name: "some rule">
       """

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

@@ -1,9 +1,10 @@
 Feature: Scenario output
 
-  A scenario model's string output is a Gherkin representation of itself. As such, output from a scenario model can be used as input for the same kind of model.
+  A scenario model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the scenario that it models.
 
 
-  Scenario: Outputting a scenario model
+  Background:
     Given the following gherkin:
       """
       @tag1@tag2
@@ -22,11 +23,14 @@ Feature: Scenario output
       """
     And a scenario model based on that gherkin
       """
-        @model = CukeModeler::Scenario.new(<source_text>)
+      @model = CukeModeler::Scenario.new(<source_text>)
       """
+
+
+  Scenario: Stringify a scenario model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -45,5 +49,15 @@ Feature: Scenario output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Scenario.new(@model.to_s)
+      CukeModeler::Scenario.new(@model.to_s)
+      """
+
+  Scenario: Inspect a scenario model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Scenario:<object_id> @name: "A scenario with everything that it could have">
       """

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

@@ -1,9 +1,10 @@
 Feature: Step output
 
-  A step model's string output is a Gherkin representation of itself. As such, output from a step model can be used as input for the same kind of model.
+  A step model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the text of the step that it models.
 
 
-  Scenario: Outputting a step model
+  Background:
 
   Note: Outputting a step that has a doc string is accomplished in the same manner
 
@@ -15,11 +16,14 @@ Feature: Step output
       """
     And a step model based on that gherkin
       """
-        @model = CukeModeler::Step.new(<source_text>)
+      @model = CukeModeler::Step.new(<source_text>)
       """
+
+
+  Scenario: Stringify a step model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -29,5 +33,15 @@ Feature: Step output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Step.new(@model.to_s)
+      CukeModeler::Step.new(@model.to_s)
+      """
+
+  Scenario: Inspect a step model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Step:<object_id> @text: "a step">
       """

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

@@ -1,9 +1,10 @@
 Feature: Table output
 
-  A table model's string output is a Gherkin representation of itself. As such, output from a table model can be used as input for the same kind of model.
+  A table model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the collection of rows of the table that it models.
 
 
-  Scenario: Outputting a table model
+  Background:
     Given the following gherkin:
       """
       |value1|value2|
@@ -11,8 +12,11 @@ Feature: Table output
       """
     And a table model based on that gherkin
       """
-        @model = CukeModeler::Table.new(<source_text>)
+      @model = CukeModeler::Table.new(<source_text>)
       """
+
+
+  Scenario: Stringify a table model
     When the model is output as a string
       """
         @model.to_s
@@ -24,5 +28,15 @@ Feature: Table output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Table.new(@model.to_s)
+      CukeModeler::Table.new(@model.to_s)
+      """
+
+  Scenario: Inspect a table model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Table:<object_id> @rows: [["value1", "value2"], ["value3", "value4"]]>
       """

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

@@ -1,20 +1,24 @@
 Feature: Tag output
 
-  A tag model's string output is a Gherkin representation of itself. As such, output from a tag model can be used as input for the same kind of model.
+  A tag model's string output is a Gherkin representation of itself and its most relevant attribute for
+  inspection is the name of the tag that it models.
 
 
-  Scenario: Outputting a tag model
+  Background:
     Given the following gherkin:
       """
       @a_tag
       """
     And a tag model based on that gherkin
       """
-        @model = CukeModeler::Tag.new(<source_text>)
+      @model = CukeModeler::Tag.new(<source_text>)
       """
+
+
+  Scenario: Stringify a tag model
     When the model is output as a string
       """
-        @model.to_s
+      @model.to_s
       """
     Then the following text is provided:
       """
@@ -22,5 +26,15 @@ Feature: Tag output
       """
     And the output can be used to make an equivalent model
       """
-        CukeModeler::Tag.new(@model.to_s)
+      CukeModeler::Tag.new(@model.to_s)
+      """
+
+  Scenario: Inspect a tag model
+    When the model is inspected
+      """
+      @model.inspect
+      """
+    Then the following text is provided:
+      """
+      #<CukeModeler::Tag:<object_id> @name: "@a_tag">
       """

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_modeler
 version: !ruby/object:Gem::Version
-  version: 3.19.0
+  version: 3.20.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-22 00:00:00.000000000 Z
+date: 2023-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-gherkin
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '27.0'
+        version: '28.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '27.0'
+        version: '28.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -75,7 +75,7 @@ dependencies:
         version: 4.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 10.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -85,7 +85,7 @@ dependencies:
         version: 4.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 10.0.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -233,6 +233,7 @@ files:
 - lib/cuke_modeler/adapters/gherkin_24_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_25_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_26_adapter.rb
+- lib/cuke_modeler/adapters/gherkin_27_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_9_adapter.rb
 - lib/cuke_modeler/adapters/gherkin_base_adapter.rb
 - lib/cuke_modeler/containing.rb