object_inspector 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f80de3b28fe43b95e5fb12538a371807689aa29da9bf7d8a91eb9c4b8b4086c
-  data.tar.gz: 775cecd797055357a8b4fb1c97d7c02a2821b8fbfbb0482f5a646f68da6a3710
+  metadata.gz: 93cdfccb3e1e30286035a4c152053794eb78ba6b99e3bf7b6d5679ca60c8f8fb
+  data.tar.gz: e551588d9bc978dd5676a14188787a55eed91b0e81c31c44479ac88559f350bc
 SHA512:
-  metadata.gz: 3a0a0c78c42099cc7ea4b03276f6d06182ccad7e4ff657a4875cbe6690f7e277c3861fe7e5f00ebd8f7059516abb064f50ef78bf73ce26fd929f22a23143fddb
-  data.tar.gz: 136d08a468531350650e48585f4471948cfdbd877ea4d462d07c11acdb381b276855c9520367dd1fc00ed8a21924b96a561e32b06d7dd51292a8705127221378
+  metadata.gz: 2ed62b8237dff20c6de7157c1c6475b08643396cc0fc1b71f2c334a562ca9253ee8da911949fc63c0549bad881e8f2704817c6c28bc265b6fd596ca5c5e47ad8
+  data.tar.gz: 6ff191c8ed79769432a2792b3c0c88d7ff6aae372d5ce323e455b6e890caecdb131dcf25ccdfd704fb9ec26bf416413330535d169dbe2d0f38d48c40485a3310

data/CHANGELOG.md

@@ -1,18 +1,24 @@
-#### TODO
-* Add "placeholder" symbol (*) for scope exclusions.
-* Add gem defaults configuration.
+### 0.3.0 - 2018-04-14
+
+- Remove optional dependency on ActiveSupport::StringInquirer. [Scopes are now objects](https://github.com/pdobb/object_inspector/blob/master/lib/object_inspector/scope.rb) that act like ActiveSupport::StringInquirer objects.
+- Add ObjectInspector::Scope.join_flags helper method.
+- Add ObjectInspector::Scope.join_info helper method.
+- Scope: Show an out-of-scope-placeholder symbol (*) when predicate is not matched and a block is given.
+- Scope: Add wild-card "all" scope that is always evaluated as true / a match.
+- Add ability to specify multiple scopes. e.g. my_object.inspect(scope: %i[verbose complex])
+- Add gem defaults configuration.
 
 
 ### 0.2.0 - 2018-04-12
 
-* Automatically inspect wrapped Objects, if applicable.
-* Use `display_name` if defined on object, in place of `inspect_name`.
-* Add on-the-fly inspect methods when Symbols are passed in to #inspect.
-* Update the `flags` and `info` demarcation symbols.
-* Add ObjectInspector::TemplatingFormatter, and use it as the new default since it's faster.
-* Rename ObjectInspector::DefaultFormatter to ObjectInspector::CombiningFormatter.
+- Automatically inspect wrapped Objects, if applicable.
+- Use `display_name` if defined on object, in place of `inspect_name`.
+- Add on-the-fly inspect methods when Symbols are passed in to #inspect.
+- Update the `flags` and `info` demarcation symbols.
+- Add ObjectInspector::TemplatingFormatter, and use it as the new default since it's faster.
+- Rename ObjectInspector::DefaultFormatter to ObjectInspector::CombiningFormatter.
 
 
 ### 0.1.0 - 2018-04-09
 
-* Initial release!
+- Initial release!

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    object_inspector (0.1.0)
+    object_inspector (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -20,6 +20,7 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    object_identifier (0.1.0)
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -43,6 +44,7 @@ DEPENDENCIES
   byebug (~> 10.0)
   minitest (~> 5.0)
   minitest-reporters (~> 1.2)
+  object_identifier (~> 0.1)
   object_inspector!
   pry (~> 0.11)
   pry-byebug (~> 3.6)

data/README.md

@@ -1,7 +1,7 @@
 # ObjectInspector
 
 [![Gem Version](https://badge.fury.io/rb/object_inspector.svg)](https://badge.fury.io/rb/object_inspector)
-[![Build Status](https://travis-ci.org/objects-on-rails/display-case.svg?branch=master)](https://travis-ci.org/objects-on-rails/display-case)
+[![Build Status](https://travis-ci.org/pdobb/object_inspector.svg?branch=master)](https://travis-ci.org/pdobb/object_inspector)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/34e821263d9e0c33d536/test_coverage)](https://codeclimate.com/github/pdobb/object_inspector/test_coverage)
 [![Maintainability](https://api.codeclimate.com/v1/badges/34e821263d9e0c33d536/maintainability)](https://codeclimate.com/github/pdobb/object_inspector/maintainability)
 
@@ -32,6 +32,24 @@ Tested MRI Ruby Versions:
 * 2.3.7
 * 2.4.4
 * 2.5.1
+* edge
+
+
+## Configuration
+
+Global/default values for ObjectInspector can be configured via the ObjectInspector::Configuration object.
+
+_Note: In a Rails app, the following would go in e.g. `config/initializers/object_inspector.rb`_
+
+```ruby
+# Default values are shown.
+ObjectInspector.configure do |config|
+  config.wild_card_scope = "all"
+  config.out_of_scope_placeholder = "*"
+  config.flags_separator = " / "
+  config.info_separator = " | "
+end
+```
 
 
 ## Usage
@@ -60,13 +78,13 @@ class MyObject
   def inspect
     ObjectInspector::Inspector.inspect(self,
                                        identification: "My Object",
-                                       flags: "FLAG1",
+                                       flags: "FLAG1 / FLAG2",
                                        info: "INFO",
                                        name: "NAME")
   end
 end
 
-MyObject.new.inspect  # => "<My Object(FLAG1) INFO :: NAME>"
+MyObject.new.inspect  # => "<My Object(FLAG1 / FLAG2) INFO :: NAME>"
 ```
 
 Or, define `inspect_identification`, `inspect_flags`, `inspect_info`, and `inspect_name` as either public or private methods on Object.
@@ -80,12 +98,12 @@ class MyObject
 private
 
   def inspect_identification; "My Object" end
-  def inspect_flags; "FLAG1" end
+  def inspect_flags; "FLAG1 / FLAG2" end
   def inspect_info; "INFO" end
   def inspect_name; "NAME" end
 end
 
-MyObject.new.inspect  # => "<My Object(FLAG1) INFO :: NAME>"
+MyObject.new.inspect  # => "<My Object(FLAG1 / FLAG2) INFO :: NAME>"
 ```
 
 
@@ -118,7 +136,7 @@ end
 MyObject.new.inspect  # => "<My Object(FLAG1) INFO :: NAME>"
 ```
 
-Or, define `inspect_identification`, `inspect_flags`, `inspect_info`, and `inspect_name` in Object.
+Or, define `inspect_identification`, `inspect_flags`, `inspect_info`, and `inspect_name` (or `display_name`) in Object.
 
 ```ruby
 class MyObject
@@ -127,61 +145,181 @@ class MyObject
 private
 
   def inspect_identification; "My Object" end
-  def inspect_flags; "FLAG1" end
+  def inspect_flags; "FLAG1 / FLAG2" end
   def inspect_info; "INFO" end
-  def inspect_name; "NAME" end
+  def inspect_name; "NAME" end  # Or: def display_name; "NAME" end
 end
 
-MyObject.new.inspect  # => "<My Object(FLAG1) INFO :: NAME>"
+MyObject.new.inspect  # => "<My Object(FLAG1 / FLAG2) INFO :: NAME>"
 ```
 
 
-## On-the-fly Inspect Methods
+## Scopes
 
-When passed as an option (as opposed to being called via an Object-defined method) symbols will be called/evaluated on Object on the fly.
+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)`.
+
+
+### 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.
+
+The ObjectInspector::Scope objects in these examples are the same as specifying `<scope_name>` like this:
 
 ```ruby
-class MyObject
-  include ObjectInspector::InspectorsHelper
+my_object.inspect(scope: <scope_name>)
+```
 
-  def my_method1; "Result1" end
-  def my_method2; "Result2" end
 
-  def inspect_info; :my_method2 end
-end
+Options:
+- `: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.
 
-MyObject.new.inspect(info: "my_method1")  # => "<MyObject my_method1>"
-MyObject.new.inspect(info: :my_method2)   # => "<MyObject Result2>"
-MyObject.new.inspect                      # => "<MyObject my_method2>"
+```ruby
+scope = ObjectInspector::Scope.new
+scope.self?     # => true
+scope.verbose?  # => false
+scope.complex?  # => false
+```
+
+
+#### Multiple Scope Names
+
+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
+```
+
+
+#### The "Wild Card" Scope
+
+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 blocks
+
+Passing a block to a scope predicate falls back to the out-of-scope placeholder (`*` by default) if the scope does not match.
+
+```ruby
+scope = ObjectInspector::Scope.new(:verbose)
+scope.verbose? { "MATCH" }  # => "MATCH"
+scope.complex? { "MATCH" }  # => "*"
+```
+
+
+### Scope Joiners
+
+ObjectInspector::Scope also offers helper methods for uniformly joining inspect elements:
+- `join_flags` -- Joins flags with ` / ` by default
+- `join_info` -- Joins info items with ` | ` by default
+
+```ruby
+scope = ObjectInspector::Scope.new(:verbose)
+scope.join_flags([1, 2, 3])  # => "1 / 2 / 3"
+scope.join_info([1, 2, 3])   # => "1 | 2 | 3"
 ```
 
 
-#### Scope
+### Conversion to ObjectInspector::Scope
 
-Use the `scope` option to define the scope of the `inspect_*` methods.
+ObjectInspector::Conversions.Scope() is available for proper conversion to ObjectInspector::Scope objects. Though this should rarely be necessary as conversion is performed automatically when calling `<my_object>.inspect(scope: <scope_name>)`.
+
+```ruby
+ObjectInspector::Conversions.Scope(:self)
+# => #<ObjectInspector::Scope:0x007ff78ab8e7f8 @name="self">
+
+scope = ObjectInspector::Scope.new(:verbose)
+result = ObjectInspector::Conversions.Scope(scope)
+# => #<ObjectInspector::Scope:0x007ff78ac9c140 @name="verbose">
+
+scope.object_id == result.object_id  # => true
+```
 
-If ActiveSupport::StringInquirer is defined then the default `scope` is `"self".inquiry`.
-The default value is `:self` if ActiveSupport::StringInquirer is not defined.
+
+## Full Example
 
 ```ruby
 class MyObject
   include ObjectInspector::InspectorsHelper
 
-  def inspect_flags(scope:, separator: " / ".freeze)
-    flags = ["FLAG1"]
+  attr_reader :name,
+              :a2
+
+  def initialize(name, a2 = 2)
+    @name = name
+    @a2 = a2
+  end
+
+  def associated_object1
+    OpenStruct.new(flags: "AO1_FLAG1")
+  end
+
+  def associated_object2
+    OpenStruct.new(flags: "AO2_FLAG1")
+  end
+
+private
 
-    # If ActiveSupport::StringInquirer is defined, use this:
-    # flags << "FLAG2" if scope.all?
+  def inspect_identification
+    identify(:a2)
+  end
 
-    # If ActiveSupport::StringInquirer is not defined, use this:
-    flags << "FLAG2" if scope == :all
+  def inspect_flags(scope:)
+    flags = ["DEFAULT_FLAG"]
 
-    flags.join(separator)
+    flags <<
+      scope.verbose? {
+        [
+          associated_object1.flags,
+          associated_object2.flags,
+        ]
+      }
+
+    scope.join_flags(flags)
+  end
+
+  def inspect_info(scope:)
+    info = ["Default Info"]
+    info << "Complex Info" if scope.complex?
+    info << scope.verbose? { "Verbose Info" }
+
+    scope.join_info(info)
+  end
+
+  # Or `def inspect_name`
+  def display_name
+    name
   end
 end
 
-MyObject.new.inspect               # => "<MyObject(FLAG1)>"
-MyObject.new.inspect(scope: :all)  # => "<MyObject(FLAG1 / FLAG2)>"
+my_object = MyObject.new("Name")
+
+my_object.inspect
+# => "<MyObject[a2:2](DEFAULT_FLAG / *) Default Info | * :: Name>"
+
+my_object.inspect(scope: :complex)
+# => "<MyObject[a2:2](DEFAULT_FLAG / *) Default Info | Complex Info | * :: Name>"
+
+my_object.inspect(scope: :verbose)
+# => "<MyObject[a2:2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) Default Info | Verbose Info :: Name>"
+
+my_object.inspect(scope: %i[self complex verbose])
+# => "<MyObject[a2:2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) Default Info | Complex Info | Verbose Info :: Name>"
+
+my_object.inspect(scope: :all)
+# => "<MyObject[a2:2](DEFAULT_FLAG / AO1_FLAG1 / AO2_FLAG1) Default Info | Complex Info | Verbose Info :: Name>"
 ```
 
 
@@ -207,17 +345,37 @@ class MyWrappedObject
 
 private
 
-  def inspect_flags; "FLAG1" end
+  def inspect_flags; "FLAG1 / FLAG2" end
   def inspect_info; "INFO" end
 end
 
 MyWrapperObject.new.inspect
-# => "<MyWrapperObject(WRAPPER_FLAG1)> ⇨ <MyWrappedObject(FLAG1) INFO>"
+# => "<MyWrapperObject(WRAPPER_FLAG1)> ⇨ <MyWrappedObject(FLAG1 / FLAG2) INFO>"
 ```
 
 This feature is recursive.
 
 
+## On-the-fly Inspect Methods
+
+When passed as an option (as opposed to being called via an Object-defined method) symbols will be called/evaluated on Object on the fly.
+
+```ruby
+class MyObject
+  include ObjectInspector::InspectorsHelper
+
+  def my_method1; "Result1" end
+  def my_method2; "Result2" end
+
+  def inspect_info; :my_method2 end
+end
+
+MyObject.new.inspect(info: "my_method1")  # => "<MyObject my_method1>"
+MyObject.new.inspect(info: :my_method2)   # => "<MyObject Result2>"
+MyObject.new.inspect                      # => "<MyObject my_method2>"
+```
+
+
 ## 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) and then passing that into ObjectInspector::Inspector.new.
@@ -235,18 +393,19 @@ class MyObject
   def inspect
     super(formatter: MyCustomFormatter,
           identification: "IDENTIFICATION",
-          flags: "FLAG1 | FLAG2",
+          flags: "FLAG1 / FLAG2",
           info: "INFO",
           name: "NAME")
   end
 end
 
 MyObject.new.inspect
-# => "[IDENTIFICATION Flags: FLAG1 | FLAG2 -- Info: INFO -- Name: NAME]"
+# => "[IDENTIFICATION Flags: FLAG1 / FLAG2 -- Info: INFO -- Name: NAME]"
 ```
 
-See also: [ObjectInspector::TemplatingFormatter].
-See also: [ObjectInspector::CombiningFormatter].
+See examples:
+- [ObjectInspector::TemplatingFormatter]
+- [ObjectInspector::CombiningFormatter]
 
 
 ## Performance
@@ -283,6 +442,7 @@ play scripts/benchmarking/formatters.rb
 # == Done
 ```
 
+
 #### Benchmarking Custom Formatters
 
 Custom Formatters may be similarly gauged for comparison by adding them to the `custom_formatter_klasses` array before playing the script.
@@ -312,23 +472,26 @@ class MyObject
   include ObjectInspector::InspectorsHelper
 
   def my_method1
-    "Result1"
+    1
   end
 
   def my_method2
-    "Result2"
+    2
   end
 
 private
 
-  def inspect_identification; identify(:my_method1, :my_method2) end
-  def inspect_flags; "FLAG1" end
+  def inspect_identification
+    identify(:my_method1, :my_method2)
+  end
+
+  def inspect_flags; "FLAG1 / FLAG2" end
   def inspect_info; "INFO" end
   def inspect_name; "NAME" end
 end
 
 MyObject.new.inspect
-# => "<MyObject[my_method1:Result1, my_method2:Result2](FLAG1) INFO :: NAME>"
+# => "<MyObject[my_method1:1, my_method2:2](FLAG1 / FLAG2) INFO :: NAME>"
 ```
 
 

data/bin/console

@@ -2,6 +2,8 @@
 
 require "bundler/setup"
 require "object_inspector"
+require "object_identifier"
+require "ostruct"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/object_inspector/conversions.rb

@@ -0,0 +1,22 @@
+module ObjectInspector
+  # ObjectInspector::Conversions defines conversion functions used by
+  # ObjectInspector.
+  module Conversions
+
+  module_function
+
+    # Convert the passed in value to an {ObjectInspector::Scope} object.
+    # Just returns the pass in value if it already is an
+    # {ObjectInspector::Scope} object.
+    #
+    # @return [ObjectInspector::Scope]
+    def Scope(value)
+      case value
+      when ObjectInspector::Scope
+        value
+      else
+        ObjectInspector::Scope.new(value)
+      end
+    end
+  end
+end

data/lib/object_inspector/inspector.rb

@@ -5,26 +5,18 @@ module ObjectInspector
   #
   # @attr object [Object] the object being inspected
   # @attr scope [Symbol] Object inspection type. For example:
-  #   :self (default) -- Means: Only interrogate self; Don't interrogate
-  #                      neighboring objects
-  #   :all            -- Means: Interrogate self as well as neighboring objects
-  #   <custom>        -- Any value that {#object} recognizes can mean anything
-  #                      that makes sense for {#object}
-  # @attr formatter [ObjectInspector::BaseFormatter] the formatter object to use
-  #   for combining the output of into the inspect String
-  # @attr kargs [Hash] options to be sent to {#object}
+  #   :self (default) -- Means: Only interrogate self. Don't visit neighbors.
+  #   <custom>        -- Anything else that makes sense for {#object} to key on
+  # @attr formatter [ObjectInspector::BaseFormatter] the formatter object type
+  #   to use for formatting the inspect String
+  # @attr kargs [Hash] options to be sent to {#object} via the
+  #   {ObjectInspector::ObjectInterrogator} when calling the `inspect_*` methods
   class Inspector
     attr_reader :object,
                 :scope,
                 :formatter_klass,
                 :kargs
 
-    # The prefix for all methods called on {#object} for inspect
-    # details/strings.
-    def self.object_inspect_method_prefix
-      "inspect".freeze
-    end
-
     # Shortcuts the instantiation -> {#to_s} flow that would normally be
     # required to use ObjectInspector::Inspector.
     #
@@ -40,12 +32,7 @@ module ObjectInspector
           **kargs)
       @object = object
       @formatter_klass = formatter
-      @scope =
-        if ObjectInspector.use_string_inquirers?
-          scope.to_s.inquiry
-        else
-          scope.to_sym
-        end
+      @scope = Conversions.Scope(scope)
       @kargs = kargs
     end
 
@@ -56,7 +43,7 @@ module ObjectInspector
       formatter.call
     end
 
-    # Generate the inspect String for a wrapped object, if applicable.
+    # Generate the inspect String for the wrapped object, if present.
     #
     # @return [String] if {#object_is_a_wrapper}
     # @return [NilClass] if not {#object_is_a_wrapper}
@@ -110,7 +97,7 @@ module ObjectInspector
     end
 
     # @return [String] if `key` is found in {#kargs} or if {#object} responds to
-    #   `#{object_inspect_method_prefix}_#{key}` (e.g. `inspect_flags`)
+    #   `#{object_inspet_method_name}` (e.g. `inspect_flags`)
     # @return [NilClass] if not found in {#kargs} or {#object}
     def value(key:)
       return_value =
@@ -141,11 +128,13 @@ module ObjectInspector
     # Attempt to call `inspect_*` on {#object} based on the passed in `name`.
     #
     # @return [String] if {#object} responds to
-    #   `#{object_inspect_method_prefix}_#{name}` (e.g. `inspect_flags`)
+    #   `#{object_inspet_method_name}` (e.g. `inspect_flags`)
     # @return [NilClass] if not found on {#object}
-    def interrogate_object_inspect_method(name)
+    def interrogate_object_inspect_method(
+          name,
+          prefix: ObjectInspector.configuration.inspect_method_prefix)
       interrogate_object(
-        method_name: build_inspet_method_name(name),
+        method_name: object_inspet_method_name(name, prefix: prefix),
         kargs: object_method_keyword_arguments)
     end
 
@@ -159,12 +148,10 @@ module ObjectInspector
       interrogator.call
     end
 
-    def build_inspet_method_name(name)
-      "#{object_inspect_method_prefix}_#{name}"
-    end
-
-    def object_inspect_method_prefix
-      self.class.object_inspect_method_prefix
+    def object_inspet_method_name(
+          name,
+          prefix: ObjectInspector.configuration.inspect_method_prefix)
+      "#{prefix}_#{name}"
     end
 
     def object_method_keyword_arguments

data/lib/object_inspector/object_interrogator.rb

@@ -22,13 +22,21 @@ module ObjectInspector
     def call
       return unless object_responds_to_method_name?
 
+      if object.method(method_name).arity != 0
+        call_with_kargs
+      else
+        object.send(method_name)
+      end
+    end
+
+  private
+
+    def call_with_kargs
       object.send(method_name, **kargs)
     rescue ArgumentError
       object.send(method_name)
     end
 
-  private
-
     def object_responds_to_method_name?(include_private: true)
       object.respond_to?(method_name, include_private)
     end

data/lib/object_inspector/scope.rb

@@ -0,0 +1,82 @@
+module ObjectInspector
+  # ObjectInspector::Scope defines a predicate method that matches {#name} and
+  # responds with `true`. This is a prettier way to test for a given type of
+  # "scope" within objects.
+  #
+  # @see ActiveSupport::StringInquirer
+  #   http://api.rubyonrails.org/classes/ActiveSupport/StringInquirer.html
+  #
+  # @attr names [Array<#to_s>]
+  class Scope
+    attr_reader :names
+
+    def initialize(names = %w[self])
+      @names = Array(names).map { |name| String(name) }
+    end
+
+    # Join the passed-in flags with the passed in separator.
+    #
+    # @param items [Array<#to_s>]
+    # @param separator [#to_s] (ObjectInspector.configuration.flags_separator)
+    def join_flags(flags,
+                   separator: ObjectInspector.configuration.flags_separator)
+      Array(flags).join(separator)
+    end
+
+    # Join the passed-in items with the passed in separator.
+    #
+    # @param items [Array<#to_s>]
+    # @param separator [#to_s] (ObjectInspector.configuration.info_separator)
+    def join_info(items,
+                   separator: ObjectInspector.configuration.info_separator)
+      Array(items).join(separator)
+    end
+
+  private
+
+    def method_missing(method_name, *args, &block)
+      if method_name[-1] == "?"
+        scope_name = method_name[0..-2]
+        evaluate_match(scope_name, &block)
+      else
+        super
+      end
+    end
+
+    def evaluate_match(scope_name, &block)
+      is_a_match = match?(scope_name)
+
+      if block
+        evaluate_block_if(is_a_match, &block)
+      else
+        is_a_match
+      end
+    end
+
+    def evaluate_block_if(condition, &block)
+      if condition
+        block.call
+      else
+        ObjectInspector.configuration.out_of_scope_placeholder
+      end
+    end
+
+    def match?(scope_name)
+      any_names_match?(scope_name) ||
+        wild_card_scope?
+    end
+
+    def wild_card_scope?
+      @is_wild_card_scope ||=
+        any_names_match?(ObjectInspector.configuration.wild_card_scope)
+    end
+
+    def any_names_match?(other_name)
+      @names.any? { |name| name == other_name }
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name[-1] == "?" || super
+    end
+  end
+end

data/lib/object_inspector/version.rb

@@ -1,3 +1,3 @@
 module ObjectInspector
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/object_inspector.rb

@@ -1,19 +1,63 @@
 # ObjectInspector is the base namespace for all modules/classes related to the
 # object_inspector gem.
 module ObjectInspector
-  @@use_string_inquirers = nil
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+
+  class Configuration
+    attr_reader :wild_card_scope,
+                :out_of_scope_placeholder,
+                :flags_separator,
+                :info_separator,
+                :inspect_method_prefix
+
+    def initialize
+      @wild_card_scope = "all".freeze
+      @out_of_scope_placeholder = "*".freeze
+      @flags_separator = " / ".freeze
+      @info_separator = " | ".freeze
+      @inspect_method_prefix = "inspect".freeze
+    end
+
+    def wild_card_scope=(value)
+      @wild_card_scope = value.to_s.freeze
+    end
+
+    def out_of_scope_placeholder=(value)
+      @out_of_scope_placeholder = value.to_s.freeze
+    end
+
+    def flags_separator=(value)
+      @flags_separator = value.to_s.freeze
+    end
+
+    def info_separator=(value)
+      @info_separator = value.to_s.freeze
+    end
 
-  def self.use_string_inquirers?
-    if @@use_string_inquirers.nil?
-      @@use_string_inquirers = !!defined?(ActiveSupport::StringInquirer)
-    else
-      @@use_string_inquirers
+    def inspect_method_prefix=(value)
+      @inspect_method_prefix = value.to_s.freeze
     end
   end
 end
 
 require "object_inspector/version"
+require "object_inspector/conversions"
 require "object_inspector/inspector"
+require "object_inspector/scope"
 require "object_inspector/inspectors_helper"
 require "object_inspector/object_interrogator"
 require "object_inspector/formatters/base_formatter"

data/object_inspector.gemspec

@@ -33,11 +33,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.2"
   spec.add_development_dependency "simplecov", "~> 0.16"
   spec.add_development_dependency "byebug", "~> 10.0"
   spec.add_development_dependency "pry", "~> 0.11"
   spec.add_development_dependency "pry-byebug", "~> 3.6"
   spec.add_development_dependency "benchmark-ips", "~> 2.7"
-  spec.add_development_dependency "minitest-reporters", "~> 1.2"
-  # spec.add_development_dependency "object_identifier", "~> 0.1"  # Add when new version is released
+  spec.add_development_dependency "object_identifier", "~> 0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_inspector
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Paul Dobbins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-13 00:00:00.000000000 Z
+date: 2018-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -123,19 +137,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.7'
 - !ruby/object:Gem::Dependency
-  name: minitest-reporters
+  name: object_identifier
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.1'
 description: ObjectInspector takes Object#inspect to the next level. Specify any combination
   of identification attributes, flags, info, and/or a name along with an optional
   self-definable scope option to represent an object in the console, in logging, etc.
@@ -156,12 +170,14 @@ files:
 - bin/console
 - bin/setup
 - lib/object_inspector.rb
+- lib/object_inspector/conversions.rb
 - lib/object_inspector/formatters/base_formatter.rb
 - lib/object_inspector/formatters/combining_formatter.rb
 - lib/object_inspector/formatters/templating_formatter.rb
 - lib/object_inspector/inspector.rb
 - lib/object_inspector/inspectors_helper.rb
 - lib/object_inspector/object_interrogator.rb
+- lib/object_inspector/scope.rb
 - lib/object_inspector/version.rb
 - object_inspector.gemspec
 - scripts/benchmarking/formatters.rb