object_inspector 0.10.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1468942ef1aa4a276a2138a904f34329d8b1e9846b58e013c208fbfe4a9113da
-  data.tar.gz: a552ef57ab52b60f208bbe2fceac50f96be25a340cd3854864a5d6a54e3d886f
+  metadata.gz: 1a5678d0a60ea94fd380f64bac99e4c0f8e5f1a6752597ce934b2687a87d5f57
+  data.tar.gz: ca234feb9aa4dadd78fe1672f1bcbd897f6717597ab246d4b275140fd31de760
 SHA512:
-  metadata.gz: 2d02eab73350615584726ada8923bcdea3d428cf61d8e95abf17778b4b76836f828b2c12389dadf1aebe85e369106b4396da1e8501f81fe4e74b44a3031171b8
-  data.tar.gz: 1d044028f4889d0b6bd5615d5f035e19e5bf6ce7e5a30a30ce54a686edb403dd89a826bf8cfd0c4a89781c862af798d4e50ce9a1ed0080012f33a99ec4e477e1
+  metadata.gz: 3585d51c146f4013022e2c2cad959580643f92efd843461f06432f42f406f0a71d6f45e47671c288036d46a94ce4b9f754b37ef446d5fa1590922afbcab23ad4
+  data.tar.gz: f1d439874733a0596d63efe69da6eb95df1b8562b3321f14c468448d26a00fd22ee8e90febaf234cd11f9ebd1a9181bc68ba3c29156264ecdd770f4ebd663c08

data/README.md

@@ -60,12 +60,13 @@ Global/default values for Object Inspector can be configured via the [ObjectInsp
 
 # Default values are shown. Customize to your liking.
 ObjectInspector.configure do |config|
+  config.enabled = true
   config.formatter_class = ObjectInspector::TemplatingFormatter
   config.inspect_method_prefix = "inspect"
   config.default_scope = ObjectInspector::Scope.new(:self)
   config.wild_card_scope = "all"
   config.out_of_scope_placeholder = "*"
-  config.presenter_inspect_flags = " ⇨ "
+  config.presented_object_separator = " ⇨ "
   config.name_separator = " - "
   config.flags_separator = " / "
   config.issues_separator = " | "
@@ -75,48 +76,26 @@ end
 
 ## Usage
 
-Pass an object of any type into `ObjectInspector::Inspector.inspect`.
+Including `ObjectInspector::InspectBehaviors` into an object will cause `ObjectInspector::Inspector.inspect` to be called on `self` automatically.
 
 ```ruby
 class MyObject
-  def inspect
-    ObjectInspector::Inspector.inspect(self)
-  end
+  include ObjectInspector::InspectBehaviors
 end
 
-MyObject.new.inspect  # => "<MyObject>"
-```
-
-See: [Helper Usage](#helper-usage) for simpler usage.
-
-### Output Customization
+MyObject.new.inspect # =>
+"<MyObject>"
 
-Use the `identification`, `flags`, `issues`, `info`, and/or `name` options to customize inspect output.
-
-```ruby
-class MyObject
-  def inspect
-    ObjectInspector::Inspector.inspect(
-      self,
-      identification: "My Object",
-      flags: "FLAG1 / FLAG2",
-      issues: "ISSUE1",
-      info: "INFO",
-      name: "NAME")
-  end
-end
-
-MyObject.new.inspect
-# => "<My Object(FLAG1 / FLAG2) !!ISSUE1!! INFO :: NAME>"
+# NOTE: IRB's Pretty Print processor calls `inspect` and unwraps the quotes:
+MyObject.new # =>
+<MyObject>
 ```
 
-Or, define `inspect_identification`, `inspect_flags`, `inspect_issues`, `inspect_info`, and/or `inspect_name` (or `display_name`) as either public or private methods on Object.
+Build out the inspect String by defining any of: `inspect_identification`, `inspect_flags`, `inspect_issues`, `inspect_info`, and `inspect_name` (or `display_name`).
 
 ```ruby
 class MyObject
-  def inspect
-    ObjectInspector::Inspector.inspect(self)
-  end
+  include ObjectInspector::InspectBehaviors
 
   private
 
@@ -127,79 +106,21 @@ class MyObject
   def inspect_name = "NAME"  # Or: def display_name = "NAME"
 end
 
-MyObject.new.inspect
-# => "<My Object(FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>"
+MyObject.new # =>
+<My Object(FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>
 ```
 
-## Helper Usage
-
-To save some typing, include ObjectInspector::InspectHelper into an object and `ObjectInspector::Inspector.inspect` will be called on `self` automatically.
-
-```ruby
-class MyObject
-  include ObjectInspector::InspectorsHelper
-end
-
-MyObject.new.inspect  # => "<MyObject>"
-```
+### Customizing `ObjectInspector::InspectBehaviors`
 
-To access the ObjectInspector::Inspector's options via the helper, call into `super`.
-
-```ruby
-class MyObject
-  include ObjectInspector::InspectorsHelper
-
-  def inspect
-    super(identification: "My Object",
-          flags: "FLAG1",
-          issues: "ISSUE1 | ISSUE2",
-          info: "INFO",
-          name: "NAME")
-  end
-end
-
-MyObject.new.inspect
-# => "<My Object(FLAG1) !!ISSUE1 | ISSUE2!! INFO :: NAME>"
-```
-
-Or, define `inspect_identification`, `inspect_flags`, `inspect_info`, and/or `inspect_name` (or `display_name`) in Object.
-
-```ruby
-class MyObject
-  include ObjectInspector::InspectorsHelper
-
-  private
-
-  def inspect_identification = "My Object"
-  def inspect_flags = "FLAG1 / FLAG2"
-  def inspect_issues = "ISSUE1 | ISSUE2"
-  def inspect_info = "INFO"
-  def inspect_name = "NAME"  # Or: def display_name = "NAME"
-end
-
-MyObject.new.inspect
-# => "<My Object(FLAG1) !!ISSUE1 | ISSUE2!! INFO :: NAME>"
-```
-
-### Helper Inclusion
-
-It may be useful to conditionally include ObjectInspector::InspectorsHelper, as well as other similar methods, via a mix-in.
+Instead of including `ObjectInspector::InspectBehaviors` directly, it may be useful to define your own mix-in.
 
 ```ruby
 module ObjectInspectionBehaviors
-  extend ActiveSupport::Concern
-
-  included do
-    # If you'd like to preserve the original inspect method, here is your
-    # chance to.
-    alias_method :__inspect__, :inspect
+  include ObjectInspector::InspectBehaviors
 
-    include ObjectInspector::InspectorsHelper
-  end
-
-  # An example of another, similar style of method you may wish to utilize in
-  # this mix-in.
+  # For defining #inspect chains.
   def introspect
+    # { self => ... }
     self
   end
 end
@@ -207,31 +128,39 @@ end
 
 ## Scopes
 
-Use the `scope` option to define the scope of the `inspect_*` methods. The supplied value will be wrapped by the ObjectInspector::Scope helper object.
-The default value is `ObjectInspector::Scope.new(:self)`.
+Use the `scope` option to define when each of the `inspect_*` methods should be included. The default scope is `:self`, or `ObjectInspector::Scope.new(:self)`.
 
 ### Scope Names
 
-ObjectInspector::Scope acts like [ActiveSupport::StringInquirer](http://api.rubyonrails.org/classes/ActiveSupport/StringInquirer.html). This is a prettier way to test for a given type of "scope" within objects.
+ObjectInspector::Scope acts like an [ActiveSupport::StringInquirer](http://api.rubyonrails.org/classes/ActiveSupport/StringInquirer.html).
 
-The ObjectInspector::Scope objects in these examples are the same as specifying `<scope_name>` like this:
+Call `inspect` with a scope name like:
 
 ```ruby
 my_object.inspect(scope: <scope_name>)
 ```
 
-Options:
+#### Default Scope Names:
+
+The default scope is: `:self`.
+
+- `:self` (Default): Is meant to restrict object interrogation to self.
 
-- `:self` (Default)--Is meant to confine object interrogation to self (don't interrogate neighboring objects).
-- `:all`--Is meant to match on all scopes, regardless of their name.
-- `<custom>`--Anything else that makes sense for the object to key on.
+#### Custom Scope Names:
+
+Beyond just `:self`, any name can be used to define any scope that makes sense for your project. No need to provision them up front, just start using them! Suggested additional scope names include:
+
+- `:verbose`: For extra detail that may not normally be needed.
+- `:complex`: For revealing collaborating objects (used to prevent n+1 queries in the normal case)
 
 ```ruby
-scope = ObjectInspector::Scope.new
-scope.self?       # => true
-scope.verbose?    # => false
-scope.complex?    # => false
-scope.<anything>? # => false
+def inspect(scope:)
+  scope.inspect     # => <ObjectInspector::Scope :: ["self"]>
+  scope.self?       # => true
+  scope.verbose?    # => false
+  scope.complex?    # => false
+  scope.<anything>? # => false
+end
 ```
 
 #### Multiple Scope Names
@@ -239,10 +168,12 @@ scope.<anything>? # => false
 It is also possible to pass in multiple scope names to match on.
 
 ```ruby
-scope = ObjectInspector::Scope.new(%i[verbose complex])
-scope.self?     # => false
-scope.verbose?  # => true
-scope.complex?  # => true
+def inspect(scope: %i[verbose complex])
+  scope.inspect  # => <ObjectInspector::Scope :: ["complex", "verbose"]>
+  scope.self?    # => false
+  scope.verbose? # => true
+  scope.complex? # => true
+end
 ```
 
 #### The "Wild Card" Scope
@@ -250,14 +181,16 @@ scope.complex?  # => true
 Finally, `:all` is a "wild card" scope name, and will match on all scope names.
 
 ```ruby
-scope = ObjectInspector::Scope.new(:all)
-scope.self?     # => true
-scope.verbose?  # => true
-scope.complex?  # => true
-scope.all?      # => true
+def inspect(scope: :all)
+  scope.inspect  # => <ObjectInspector::Scope :: ["all"]>
+  scope.self?    # => true
+  scope.verbose? # => true
+  scope.complex? # => true
+  scope.all?     # => true
+end
 ```
 
-_**NOTE**_: Calling `#inspect!` on an object that mixes in `ObjectInspector::InspectorsHelper` is equivalent to passing in the "wild card" scope.
+_**NOTE**_: Calling `#inspect!` on an object that mixes in `ObjectInspector::InspectBehaviors` is equivalent to passing in the "wild card" scope.
 
 ### Scope blocks
 
@@ -265,8 +198,8 @@ Passing a block to a scope predicate falls back to the out-of-scope placeholder
 
 ```ruby
 scope = ObjectInspector::Scope.new(:verbose)
-scope.verbose? { "MATCH" }  # => "MATCH"
-scope.complex? { "MATCH" }  # => "*"
+scope.verbose? { "MATCH" } # => "MATCH"
+scope.complex? { "MATCH" } # => "*"
 ```
 
 ### Scope Joiners
@@ -274,10 +207,10 @@ scope.complex? { "MATCH" }  # => "*"
 ObjectInspector::Scope also offers helper methods for uniformly joining inspect elements:
 
 ```ruby
-join_name   # Joins name parts with ` - ` by default
-join_flags  # Joins flags with ` / ` by default
-join_issues # Joins issues with ` | ` by default
-join_info   # Joins info items with ` | ` by default
+scope.join_name   # Joins name parts with ` - ` by default
+scope.join_flags  # Joins flags with ` / ` by default
+scope.join_issues # Joins issues with ` | ` by default
+scope.join_info   # Joins info items with ` | ` by default
 ```
 
 For example:
@@ -294,7 +227,7 @@ scope.join_info([1, 2, 3, nil])   # => "1 | 2 | 3"
 
 ```ruby
 class MyObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   attr_reader :name,
               :a2
@@ -320,7 +253,8 @@ class MyObject
   private
 
   def inspect_identification
-    identify(:a2)
+    # Or use `identify(:a2)` from the Object Identifier gem (see Supporting Gems).
+    "#{self.class.name}[#{a2}]"
   end
 
   def inspect_flags(scope:)
@@ -377,16 +311,16 @@ my_object.inspect! # 👀 Same as passing in `scope: :all`
 # => "<MyObject[2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) !!I1 | VI2!! Default Info | Complex Info | Verbose Info :: Name>"
 
 ObjectInspector.configuration.default_scope = :complex
-my_object.inspect
-# => "<MyObject[2](DEFAULT_FLAG / *) !!I1 | *!! Default Info | Complex Info | * :: Name>"
+my_object # =>
+<MyObject[2](DEFAULT_FLAG / *) !!I1 | *!! Default Info | Complex Info | * :: Name>
 
 ObjectInspector.configuration.default_scope = %i[self complex verbose]
-my_object.inspect
-# => "<MyObject[2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) !!I1 | VI2!! Default Info | Complex Info | Verbose Info :: Name>"
+my_object # =>
+<MyObject[2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) !!I1 | VI2!! Default Info | Complex Info | Verbose Info :: Name>
 
 ObjectInspector.configuration.default_scope = :all
-my_object.inspect
-# => "<MyObject[2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) !!I1 | VI2!! Default Info | Complex Info | Verbose Info :: Name>"
+my_object # =>
+<MyObject[2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) !!I1 | VI2!! Default Info | Complex Info | Verbose Info :: Name>
 ```
 
 ## Wrapped Objects
@@ -395,7 +329,7 @@ If the Object being inspected wraps another object--i.e. defines #to_model and #
 
 ```ruby
 class MyWrapperObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def to_model
     @to_model ||= MyWrappedObject.new
@@ -408,7 +342,7 @@ class MyWrapperObject
 end
 
 class MyWrappedObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   private
 
@@ -417,11 +351,11 @@ class MyWrappedObject
   def inspect_issues(scope:) = scope.complex? { "CI1" }
 end
 
-MyWrapperObject.new.inspect
-# => "<MyWrapperObject(WRAPPER_FLAG1) !!*!!>  ⇨  <MyWrappedObject(FLAG1 / FLAG2) !!*!! INFO>"
+MyWrapperObject.new # =>
+<MyWrapperObject(WRAPPER_FLAG1) !!*!!> ⇨ <MyWrappedObject(FLAG1 / FLAG2) !!*!! INFO>
 
-MyWrapperObject.new.inspect!
-# => "<MyWrapperObject(WRAPPER_FLAG1) !!CI1!!>  ⇨  <MyWrappedObject(FLAG1 / FLAG2) !!CI1!! INFO>"
+MyWrapperObject.new.inspect! # =>
+<MyWrapperObject(WRAPPER_FLAG1) !!CI1!!> ⇨ <MyWrappedObject(FLAG1 / FLAG2) !!CI1!! INFO>
 ```
 
 This feature is recursive.
@@ -432,7 +366,7 @@ If the Object being inspected is wrapped by an object that delegates all unknown
 
 ```ruby
 class MyDelegatingWrapperObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def initialize(my_object)
     @my_object = my_object
@@ -463,7 +397,7 @@ class MyDelegatingWrapperObject
 end
 
 class MyWrappedObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def display_name
     "WRAPPED_OBJECT_NAME"
@@ -477,8 +411,8 @@ class MyWrappedObject
   def inspect_name = "NAME"
 end
 
-MyDelegatingWrapperObject.new(MyWrappedObject.new).inspect
-# => "<MyDelegatingWrapperObject>  ⇨  <MyWrappedObject(FLAG1) !!ISSUE1!! INFO :: NAME>"
+MyDelegatingWrapperObject.new(MyWrappedObject.new) # =>
+<MyDelegatingWrapperObject> ⇨ <MyWrappedObject(FLAG1) !!ISSUE1!! INFO :: NAME>
 ```
 
 ## On-the-fly Inspect Methods
@@ -487,7 +421,7 @@ When passed as an option (as opposed to being called via an Object-defined metho
 
 ```ruby
 class MyObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def my_method1 = "Result1"
   def my_method2 = "Result2"
@@ -495,9 +429,9 @@ class MyObject
   def inspect_info = :my_method2
 end
 
-MyObject.new.inspect(info: "my_method1")  # => "<MyObject my_method1>"
-MyObject.new.inspect(info: :my_method2)   # => "<MyObject Result2>"
-MyObject.new.inspect                      # => "<MyObject my_method2>"
+MyObject.new.inspect(info: "my_method1") # => "<MyObject my_method1>"
+MyObject.new.inspect(info: :my_method2)  # => "<MyObject Result2>"
+MyObject.new.inspect                     # => "<MyObject my_method2>"
 ```
 
 ## Clearing Output for Specified Inspect Method
@@ -506,7 +440,7 @@ Pass `nil` to any inspect method type to not display it:
 
 ```ruby
 class MyObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def inspect_identification = "My Object"
   def inspect_info = "INFO"
@@ -523,6 +457,38 @@ MyObject.new.inspect(identification: nil, info: nil, flags: nil, issues: nil, na
 # => "<MyObject>"
 ```
 
+## Temporarily Disabling ObjectInspector
+
+To disable / re-enable Object Inspector output for the current session:
+
+```ruby
+MyObject.new # =>
+<My Object(FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>
+
+ObjectInspector.configuration.disable # =>
+ -> ObjectInspector disabled
+MyObject.new # =>
+#<MyObject:0x000000012332c458>
+
+ObjectInspector.configuration.enable # =>
+ -> ObjectInspector enabled
+MyObject.new # =>
+<My Object(FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>
+```
+
+Or, simply toggle the current state:
+
+```ruby
+ObjectInspector.configuration.toggle; # =>
+ -> ObjectInspector disabled
+
+ObjectInspector.configuration.toggle; # =>
+ -> ObjectInspector enabled
+```
+
+_**NOTE**_: `#inspect!` ignores the enabled/disabled setting and still invokes Object
+Inspector -- using the wild-card (`:all`) scope.
+
 ## Custom Formatters
 
 A custom inspect formatter can be defined by implementing the interface defined by [ObjectInspector::BaseFormatter](https://github.com/pdobb/object_inspector/blob/master/lib/object_inspector/formatters/base_formatter.rb). Then, either override the ObjectInspector::Configuration#formatter_class value (see [Configuration](#configuration)) or just pass your custom class name into ObjectInspector::Inspector.new.
@@ -535,7 +501,7 @@ class MyCustomFormatter < ObjectInspector::BaseFormatter
 end
 
 class MyObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def inspect
     super(
@@ -547,8 +513,8 @@ class MyObject
   end
 end
 
-MyObject.new.inspect
-# => "[IDENTIFICATION Flags: FLAG1 / FLAG2 -- Info: INFO -- Name: NAME]"
+MyObject.new # =>
+[IDENTIFICATION Flags: FLAG1 / FLAG2 -- Info: INFO -- Name: NAME]
 ```
 
 See examples:
@@ -556,13 +522,42 @@ See examples:
 - [ObjectInspector::TemplatingFormatter]
 - [ObjectInspector::CombiningFormatter]
 
+## Help
+
+### How can I see the original inspect output on ActiveRecord objects?
+
+Simply [disable Object Inspector](#temporarily-disabling-objectinspector) and you'll see ActiveRecord's Pretty Print formatting shine through again. For example:
+
+```ruby
+class User < ApplicationRecord
+  include ObjectInspectionBehaviors # 👀 Defined above.
+
+  # ...
+end
+
+User.new # =>
+<User[1] :: John Smith>
+
+ObjectInspector.configuration.disable; # =>
+ -> ObjectInspector disabled
+
+User.new # =>
+#<User:0x0000000125ce9890
+ id: "6c6d6f4b-05fd-4d81-af3e-1947a6a38aa0",
+ first_name: "John",
+ last_name: "Smith",
+ time_zone: nil,
+ created_at: "2025-02-10 12:27:23.793833000 -0600",
+ updated_at: "2025-02-11 13:15:00.301991000 -0600">
+```
+
 ## Supporting Gems
 
 Object Inspector works great with the [Object Identifier](https://github.com/pdobb/object_identifier) gem.
 
 ```ruby
 class MyObject
-  include ObjectInspector::InspectorsHelper
+  include ObjectInspector::InspectBehaviors
 
   def my_method1
     1
@@ -584,15 +579,92 @@ class MyObject
   def inspect_name = "NAME"
 end
 
-MyObject.new.inspect
-# => "<MyObject[my_method1:1, my_method2:2](FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>"
+MyObject.new # =>
+<MyObject[my_method1:1, my_method2:2](FLAG1 / FLAG2) !!ISSUE1 | ISSUE2!! INFO :: NAME>
+```
+
+## Adding Utilities Methods to `.irbrc` / `.pryrc`
+
+One may wish to add some convenience methods to their project-local `.irbrc`/`.pryrc` file, and/or their global `~/.irbrc`/`~/.pryrc` file. For example:
+
+```ruby
+# OBJECT INSPECTOR GEM
+
+def toggle_object_inspector = ObjectInspector.configuration.toggle
+alias oit toggle_object_inspector
+
+def get_object_inspector_current_scope
+  ObjectInspector.configuration.default_scope
+end
+alias oi get_object_inspector_current_scope
+
+# :self is the gem's default inspection scope.
+def set_object_inspector_scope_self = set_object_inspector_scope(:self)
+alias ois set_object_inspector_scope_self
+
+def set_object_inspector_scope_complex = set_object_inspector_scope(:complex)
+alias oic set_object_inspector_scope_complex
+
+def set_object_inspector_scope_verbose = set_object_inspector_scope(:verbose)
+alias oiv set_object_inspector_scope_verbose
+
+# Set :all (wild-card) inspection scope.
+def set_object_inspector_scope_all = set_object_inspector_scope(:all)
+alias oia set_object_inspector_scope_all
+
+# Set a custom scope or set of scopes.
+#
+# @example
+#   set_object_inspector_scope(:my_custom_scope)
+#   set_object_inspector_scope(:complex, :verbose)
+#   set_object_inspector_scope(%i[complex verbose my_custom_scope])
+def set_object_inspector_scope(*names)
+  ObjectInspector.configuration.default_scope = *names
+  get_object_inspector_current_scope
+end
+alias oiset set_object_inspector_scope
+```
+
+## Default State
+
+> [!IMPORTANT]
+> ObjectInspector defaults to `enabled`. However, this implies an increased chance of causing additional queries/processing based on your usage.
+
+If your inspect methods reference other ActiveRecord models, you will be introducing Database queries into basic object inspection. While you can control this through careful use of `complex` scopes (see below), you may wish to default ObjectInspector to be `disabled` across the board for active web / background processes. Then, since ObjectInspector's utility really shines on the the Rails console, you can default it to `enabled` there.
+
+To set Object inspector to be `disabled` by default, but `enabled` on the Rails console:
+
+1. In an initializer, set [ObjectInspector::Configuration] to default to `disabled`:
+
+```ruby
+# config/initializers/object_inspector.rb
+ObjectInspector.configure do |config|
+  config.enabled = false
+end
+```
+
+2. Enable ObjectInspector via `.irbrc` (or `.pryrc`, or the like):
+
+```ruby
+# .irbrc:
+
+# ...
+
+ObjectInspector.configuration.enable
+# Note: ^ produces output: ` -> ObjectInspector enabled`
+
+# OR (silent version):
+
+ObjectInspector.configure do |config|
+  config.enabled = true
+end
 ```
 
 ## Performance
 
 ### Benchmarking Object Inspector
 
-ObjectInspetor is ~2.75x slower than Ruby's default inspect, in Ruby v3.4.
+ObjectInspector is ~2.75x slower than Ruby's default inspect, in Ruby v3.4.
 
 Performance of Object Inspector can be tested by playing the [Object Inspector Benchmarking Script](https://github.com/pdobb/object_inspector/blob/master/script/benchmarking/object_inspector.rb) in the IRB console for this gem.
 
@@ -679,7 +751,7 @@ To release a new version of this gem to RubyGems:
 
 1. Update the version number in `version.rb`
 2. Update `CHANGELOG.md`
-3. Run `bundle` to update Gemfile.lock with the latest version info
+3. Run `bundle install` to update Gemfile.lock with the latest version info
 4. Commit the changes. e.g. `Bump to vX.Y.Z`
 5. Run `rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
@@ -701,6 +773,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/pdobb/
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+[ObjectInspector::Configuration]: https://github.com/pdobb/object_inspector/blob/master/lib/object_inspector.rb
 [ObjectInspector::TemplatingFormatter]: https://github.com/pdobb/object_inspector/blob/master/lib/object_inspector/formatters/templating_formatter.rb
 [ObjectInspector::CombiningFormatter]: https://github.com/pdobb/object_inspector/blob/master/lib/object_inspector/formatters/combining_formatter.rb
 [Object Inspector Benchmarking Scripts]: https://github.com/pdobb/object_inspector/blob/master/script/benchmarking/object_inspector.rb

data/lib/object_inspector/conversions.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
-# ObjectInspector::Conversions defines conversion functions used by
-# ObjectInspector.
+# Defines general conversion functions used by ObjectInspector.
 module ObjectInspector::Conversions
   module_function
 
+  # :reek:UncommunicativeMethodName
+
   # Convert the passed in value to an {ObjectInspector::Scope} object.
   # Just returns the passed in value if it already is an
   # {ObjectInspector::Scope} object.
   #
-  # @return [ObjectInspector::Scope]
+  # @example
+  #   ObjectInspector::Conversions.Scope("test")
+  #   # => <ObjectInspector::Scope :: ["test"]>
   #
-  # :reek:UncommunicativeMethodName
+  #   ObjectInspector::Conversions.Scope(
+  #     ObjectInspector::Scope.new(:my_custom_scope),
+  #   )
+  #   # => <ObjectInspector::Scope :: ["my_custom_scope"]>
+  #
+  # @return [ObjectInspector::Scope]
   def Scope(value) # rubocop:disable Naming/MethodName
     case value
     when ObjectInspector::Scope