object_inspector 0.10.0 → 1.1.0

data/lib/object_inspector/formatters/base_formatter.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-# ObjectInspector::BaseFormatter is an abstract base class that interfaces
-# with {ObjectInspector::Inspector} objects to combine the supplied
-# {#identification}, {#flags}, {#info}, and {#name} strings into a friendly
-# "inspect" String.
+# An abstract base class that interfaces with {ObjectInspector::Inspector}
+# objects to combine the supplied {#identification}, {#flags}, {#issues},
+# {#info}, and {#name} Strings into a friendly "inspect" String.
 class ObjectInspector::BaseFormatter
   attr_reader :inspector
 
@@ -21,49 +20,49 @@ class ObjectInspector::BaseFormatter
 
   # Delegates to {Inspector#wrapped_object_inspection_result}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def wrapped_object_inspection_result
     @wrapped_object_inspection_result ||=
-      @inspector.wrapped_object_inspection_result
+      inspector.wrapped_object_inspection_result
   end
 
   # Delegates to {Inspector#identification}.
   #
-  # @return [String] if given
+  # @return [String] If given.
   def identification
-    @identification ||= @inspector.identification
+    @identification ||= inspector.identification
   end
 
   # Delegates to {Inspector#flags}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def flags
-    @flags ||= @inspector.flags
+    @flags ||= inspector.flags
   end
 
   # Delegates to {Inspector#issues}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def issues
-    @issues ||= @inspector.issues
+    @issues ||= inspector.issues
   end
 
   # Delegates to {Inspector#info}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def info
-    @info ||= @inspector.info
+    @info ||= inspector.info
   end
 
   # Delegates to {Inspector#name}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def name
-    @name ||= @inspector.name
+    @name ||= inspector.name
   end
 end

data/lib/object_inspector/formatters/combining_formatter.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-# ObjectInspector::CombiningFormatter implements
-# {ObjectInspector::BaseFormatter} to return the standard/default inspect
-# output format by combining Strings.
+# Specializes on {ObjectInspector::BaseFormatter} to build inspect output by
+# combining Strings (as opposed to {ObjectInspector::TemplatingFormatter}).
 #
 # @attr (see BaseFormatter)
 class ObjectInspector::CombiningFormatter < ObjectInspector::BaseFormatter
@@ -20,8 +19,8 @@ class ObjectInspector::CombiningFormatter < ObjectInspector::BaseFormatter
   private
 
   def build_wrapped_object_string
-    "#{build_string} "\
-      "#{ObjectInspector.configuration.presented_object_separator} "\
+    "#{build_string}"\
+      "#{ObjectInspector.configuration.presented_object_separator}"\
       "#{wrapped_object_inspection_result}"
   end
 

data/lib/object_inspector/formatters/templating_formatter.rb

@@ -4,9 +4,8 @@
 # :reek:TooManyMethods
 # rubocop:disable Metrics/ClassLength
 
-# ObjectInspector::TemplatingFormatter specializes on
-# {ObjectInspector::BaseFormatter} to return the standard/default inspect
-# output format via String templates.
+# Specializes on {ObjectInspector::BaseFormatter} to build the default inspect
+# output format using String templates.
 #
 # @attr (see BaseFormatter)
 class ObjectInspector::TemplatingFormatter < ObjectInspector::BaseFormatter
@@ -47,13 +46,12 @@ class ObjectInspector::TemplatingFormatter < ObjectInspector::BaseFormatter
   private
 
   def build_wrapped_object_string
-    "#{build_string} "\
-      "#{ObjectInspector.configuration.presented_object_separator} "\
+    "#{build_string}"\
+      "#{ObjectInspector.configuration.presented_object_separator}"\
       "#{wrapped_object_inspection_result}"
   end
 
-  # rubocop:disable Metrics/MethodLength
-  def build_string
+  def build_string # rubocop:disable Metrics/MethodLength
     if flags
       build_string_with_flags_and_maybe_issues_and_info_and_name
     elsif issues
@@ -66,7 +64,6 @@ class ObjectInspector::TemplatingFormatter < ObjectInspector::BaseFormatter
       build_base_string
     end
   end
-  # rubocop:enable Metrics/MethodLength
 
   def build_string_with_flags_and_maybe_issues_and_info_and_name
     if issues

data/lib/object_inspector/inspect_behaviors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# ObjectInspector::InspectBehaviors can be included into any object to override
+# the default `#inspect` method for that object to instead call
+# {ObjectInspector::Inspector.inspect}.
+module ObjectInspector::InspectBehaviors
+  # Calls {ObjectInspector::Inspector.inspect} on `self`, passing through any
+  # keyword arguments.
+  #
+  # @return [String]
+  def inspect(**)
+    return super() if ObjectInspector.configuration.disabled?
+
+    ObjectInspector::Inspector.inspect(self, **)
+  end
+
+  # Like {#inspect} but:
+  # - Ignores the enabled/disabled state of ObjectInspector
+  # - Forces scope to `:all`
+  #
+  # This (the bang (!) version) is considered the "more dangerous" version of
+  # {#inspect} since the `:all` scope may result in additional queries or extra
+  # processing--depending on how the inspect hooks are setup.
+  #
+  # @return [String]
+  def inspect!(**)
+    ObjectInspector::Inspector.inspect(self, **, scope: :all)
+  end
+
+  private
+
+  # :reek:UtilityFunction
+
+  # Allow ActiveRecord::Core#pretty_print to produce the standard Pretty-printed
+  # output (vs just straight #inspect String) when ObjectInspector is disabled.
+  def custom_inspect_method_defined?
+    ObjectInspector.configuration.enabled?
+  end
+end

data/lib/object_inspector/inspector.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 
-# ObjectInspector::Inspector organizes inspection of the associated {#object}
-# via the passed in options and via an {ObjectInspector::BaseFormatter}
-# instance.
-#
 # :reek:TooManyMethods
+
+# Organizes inspection of the associated {#object} via the passed in options and
+# via an {ObjectInspector::BaseFormatter} instance.
+#
+# @example
+#   ObjectInspector::Inspector.inspect(
+#     self,
+#     identification: self.class.name,
+#     flags: "FLAG1",
+#     issues: "ISSUE1",
+#     info: "INFO",
+#     name: "NAME",
+#   )
+#   # => "<Object(FLAG1) !!ISSUE1!! INFO :: NAME>"
 class ObjectInspector::Inspector
   attr_reader :object
 
@@ -12,9 +22,9 @@ class ObjectInspector::Inspector
   # required to use ObjectInspector::Inspector.
   #
   # @return [String]
-  def self.inspect(...)
-    new(...).to_s
-  end
+  def self.inspect(...) = new(...).to_s
+
+  # :reek:DuplicateMethodCall
 
   # @param object [Object] the object being inspected
   # @param scope [Symbol] Object inspection type. For example:
@@ -22,18 +32,17 @@ class ObjectInspector::Inspector
   #   <custom>        -- Anything else that makes sense for {#object} to key
   #                      on
   # @param formatter [ObjectInspector::BaseFormatter]
-  #   (ObjectInspector.configuration.formatter) the formatter object type
-  #   to use for formatting the inspect String
-  # @param kwargs [Hash] options to be sent to {#object} via the
-  #   {ObjectInspector::ObjectInterrogator} when calling the `inspect_*`
-  #   methods
-  #
-  # :reek:DuplicateMethodCall (ObjectInspecto.configuration)
+  #   (ObjectInspector.configuration.formatter_class) The formatter object type
+  #   to use for formatting the inspect String.
+  # @param kwargs [Hash] Options to be sent to {#object} via
+  #   {ObjectInspector::InterrogateObject} when calling the `inspect_*`
+  #   methods.
   def initialize(
-        object,
-        scope: ObjectInspector.configuration.default_scope,
-        formatter: ObjectInspector.configuration.formatter_class,
-        **kwargs)
+    object,
+    scope: ObjectInspector.configuration.default_scope,
+    formatter: ObjectInspector.configuration.formatter_class,
+    **kwargs
+  )
     @object = object
     @scope = ObjectInspector::Conversions.Scope(scope)
     @formatter_class = formatter
@@ -50,8 +59,8 @@ class ObjectInspector::Inspector
   # Generate the inspect String for the wrapped object, if `self` is a wrapper
   # object.
   #
-  # @return [String] if {#object_is_a_wrapper?}
-  # @return [NilClass] if not {#object_is_a_wrapper?}
+  # @return [String] If {#object_is_a_wrapper?}.
+  # @return [nil] If not {#object_is_a_wrapper?}.
   def wrapped_object_inspection_result
     return unless object_is_a_wrapper?
 
@@ -59,7 +68,8 @@ class ObjectInspector::Inspector
       extract_wrapped_object,
       scope: @scope,
       formatter: @formatter_class,
-      kwargs: @kwargs)
+      kwargs: @kwargs,
+    )
   end
 
   # Core object identification details, such as the {#object} class name and
@@ -67,62 +77,68 @@ class ObjectInspector::Inspector
   #
   # @return [String]
   def identification
-    (value(key: :identification) || @object.class).to_s
+    (value(key: :identification) || object.class).to_s
   end
 
   # Boolean flags/states applicable to {#object}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def flags
     value(key: :flags)
   end
 
   # Issues/Warnings applicable to {#object}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def issues
     value(key: :issues)
   end
 
   # Informational details applicable to {#object}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def info
     value(key: :info)
   end
 
   # A human-friendly identifier for {#object}.
   #
-  # @return [String] if given
-  # @return [NilClass] if not given
+  # @return [String] If given.
+  # @return [nil] If not given.
   def name
     key = :name
 
     if @kwargs.key?(key)
-      value(key: key)
+      value(key:)
     else
       interrogate_object_inspect_method(key) ||
         interrogate_object(
-          method_name: :display_name, kwargs: object_method_keyword_arguments)
+          method_name: :display_name,
+          kwargs: object_method_keyword_arguments,
+        )
     end
   end
 
   private
 
+  attr_reader :scope,
+              :formatter_class,
+              :kwargs
+
   def formatter
-    @formatter_class.new(self)
+    formatter_class.new(self)
   end
 
-  # @return [String] if `key` is found in {#kwargs} or if {#object} responds to
-  #   `#{object_inspection_method_name}` (e.g. `inspect_flags`)
-  # @return [NilClass] if not found in {#kwargs} or {#object}
+  # @return [String] If `key` is found in {#kwargs} or if {#object} responds to
+  #   `#{object_inspection_method_name}` (e.g. `inspect_flags`).
+  # @return [nil] If not found in {#kwargs} or {#object}.
   def value(key:)
     return_value =
-      if @kwargs.key?(key)
-        evaluate_passed_in_value(@kwargs[key])
+      if kwargs.key?(key)
+        evaluate_passed_in_value(kwargs[key])
       else
         interrogate_object_inspect_method(key)
       end
@@ -133,10 +149,10 @@ class ObjectInspector::Inspector
   # Call `value` on {#object} if it responds to it and the result is not nil,
   # else just return `value`.
   #
-  # @return [#to_s] if {#object} responds to `value` and if the call result
-  #   isn't nil
-  # @return [#nil] if {#object} doesn't respond to `value` or if the call
-  #   result is nil
+  # @return [#to_s] If {#object} responds to `value` and if the call result
+  #   isn't nil.
+  # @return [nil] If {#object} doesn't respond to `value` or if the call result
+  #   is nil.
   def evaluate_passed_in_value(value)
     if value.is_a?(Symbol)
       interrogate_object(method_name: value) || value
@@ -147,47 +163,44 @@ class ObjectInspector::Inspector
 
   # Attempt to call `inspect_*` on {#object} based on the passed in `name`.
   #
-  # @return [String] if {#object} responds to
-  #   `#{object_inspection_method_name}` (e.g. `inspect_flags`)
-  # @return [NilClass] if not found on {#object}
+  # @return [String] If {#object} responds to
+  #   `#{object_inspection_method_name}` (e.g. `inspect_flags`).
+  # @return [nil] If not found on {#object}.
   def interrogate_object_inspect_method(
-        name,
-        prefix: ObjectInspector.configuration.inspect_method_prefix)
+    name,
+    prefix: ObjectInspector.configuration.inspect_method_prefix
+  )
     interrogate_object(
-      method_name: object_inspection_method_name(name, prefix: prefix),
-      kwargs: object_method_keyword_arguments)
+      method_name: object_inspection_method_name(name, prefix:),
+      kwargs: object_method_keyword_arguments,
+    )
   end
 
   def interrogate_object(method_name:, kwargs: {})
-    interrogator =
-      ObjectInspector::ObjectInterrogator.new(
-        object: @object,
-        method_name: method_name,
-        kwargs: kwargs)
-
-    interrogator.call
+    ObjectInspector::InterrogateObject.(object, method_name:, kwargs:)
   end
 
   # :reek:UtilityFunction
+
   def object_inspection_method_name(
-        name,
-        prefix: ObjectInspector.configuration.inspect_method_prefix)
+    name,
+    prefix: ObjectInspector.configuration.inspect_method_prefix
+  )
     "#{prefix}_#{name}"
   end
 
   def object_method_keyword_arguments
-    {
-      scope: @scope,
-    }
+    { scope: }
   end
 
   def extract_wrapped_object
-    @object.to_model
+    object.to_model
   end
 
   # :reek:ManualDispatch
+
   def object_is_a_wrapper?
-    @object.respond_to?(:to_model) &&
-      @object.to_model != @object
+    object.respond_to?(:to_model) &&
+      object.to_model != object
   end
 end

data/lib/object_inspector/{object_interrogator.rb → interrogate_object.rb}

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
-# ObjectInspector::ObjectInterrogator collaborates with {#object} to return
-# Object#{#method_name} if {#object} responds to the method.
+# Collaborates with {#object} to return {#object}#{#method_name} if {#object}
+# responds to {#method_name}.
 #
-# If Object#{#method_name} accepts the supplied `kwargs` then they are passed
+# If {#object}#{#method_name} accepts the supplied `kwargs` then they are passed
 # in as well. If not, then any supplied `kwargs` will be ignored.
-class ObjectInspector::ObjectInterrogator
+class ObjectInspector::InterrogateObject
+  # @return (see #call)
+  def self.call(...) = new(...).call
+
   attr_reader :object,
               :method_name,
               :kwargs
 
-  def initialize(object:, method_name:, kwargs: {})
+  def initialize(object, method_name:, kwargs: {})
     @object = object
     @method_name = method_name
     @kwargs = kwargs
   end
 
-  # @return [String, ...] whatever type Object#{#method_name} returns
+  # @return [Object, nil] The result of calling {#method_name} on {#object},
+  #   or `nil` if {#object} does not respond to {#method_name}.
   #
-  # @raise [ArgumentError] if Object#{#method_name} has an unexpected method
-  #   signature
+  # @raise [ArgumentError] If {#object}#{#method_name} has an unexpected method
+  #   signature.
   def call
     return unless object_responds_to_method_name?
 
@@ -40,6 +44,7 @@ class ObjectInspector::ObjectInterrogator
 
   # :reek:ManualDispatch
   # :reek:BooleanParameter
+
   def object_responds_to_method_name?(include_private: true)
     object.respond_to?(method_name, include_private)
   end

data/lib/object_inspector/scope.rb

@@ -2,9 +2,8 @@
 
 # :reek:TooManyMethods
 
-# ObjectInspector::Scope defines a predicate method that matches {#names} and
-# responds with `true`. This is a prettier way to test for a given type of
-# "scope" within objects.
+# Defines a predicate method that matches {#names} and responds with `true`.
+# This is a prettier way to test for a given type of "scope" within objects.
 #
 # It is possible to pass in multiple scope names to match on.
 #
@@ -13,6 +12,19 @@
 # Passing a block to a scope predicate falls back to the out-of-scope
 # placeholder (`*` by default) if the scope does not match.
 #
+# @example
+#   ObjectInspector::Scope.new
+#   # => <ObjectInspector::Scope :: ["self"]>
+#
+#   ObjectInspector::Scope.new(:my_custom_scope)
+#   # => <ObjectInspector::Scope :: ["my_custom_scope"]>
+#
+#   ObjectInspector::Scope.new(%w[verbose complex])
+#   # => <ObjectInspector::Scope :: ["complex", "verbose"]>
+#
+#   ObjectInspector::Scope.new(:verbose, :self)
+#   # => <ObjectInspector::Scope :: ["self", "verbose"]>
+#
 # @see ActiveSupport::StringInquirer
 #   http://api.rubyonrails.org/classes/ActiveSupport/StringInquirer.html
 #
@@ -20,16 +32,21 @@
 class ObjectInspector::Scope
   attr_reader :names
 
-  def initialize(names = %w[self])
-    @names = Array(names).map { |name| String(name) }
+  # :reek:FeatureEnvy
+
+  def initialize(*names)
+    names = names.empty? ? %w[self] : names.flatten
+    @names = names.map! { |name| String(name) }.sort!
   end
 
   # Join the passed in name parts with the passed in separator.
   #
   # @param parts [Array<#to_s>]
-  # @param separator [#to_s] (ObjectInspector.configuration.flags_separator)
+  # @param separator [#to_s] (ObjectInspector.configuration.name_separator)
   def join_name(
-        parts, separator: ObjectInspector.configuration.name_separator)
+    parts,
+    separator: ObjectInspector.configuration.name_separator
+  )
     _join(parts, separator)
   end
 
@@ -38,7 +55,9 @@ class ObjectInspector::Scope
   # @param flags [Array<#to_s>]
   # @param separator [#to_s] (ObjectInspector.configuration.flags_separator)
   def join_flags(
-        flags, separator: ObjectInspector.configuration.flags_separator)
+    flags,
+    separator: ObjectInspector.configuration.flags_separator
+  )
     _join(flags, separator)
   end
 
@@ -47,7 +66,9 @@ class ObjectInspector::Scope
   # @param issues [Array<#to_s>]
   # @param separator [#to_s] (ObjectInspector.configuration.issues_separator)
   def join_issues(
-        issues, separator: ObjectInspector.configuration.issues_separator)
+    issues,
+    separator: ObjectInspector.configuration.issues_separator
+  )
     _join(issues, separator)
   end
 
@@ -56,19 +77,21 @@ class ObjectInspector::Scope
   # @param items [Array<#to_s>]
   # @param separator [#to_s] (ObjectInspector.configuration.info_separator)
   def join_info(
-        items, separator: ObjectInspector.configuration.info_separator)
+    items,
+    separator: ObjectInspector.configuration.info_separator
+  )
     _join(items, separator)
   end
 
   # Compare self with the passed in object.
   #
-  # @return [TrueClass] if self and `other` resolve to the same set of objects
-  # @return [FalseClass] if self and `other` resolve to a different set of
-  #   objects
+  # @return [TrueClass] If self and `other` resolve to the same set of objects.
+  # @return [FalseClass] If self and `other` resolve to a different set of
+  #   objects.
   def ==(other)
-    @names.sort == Array(other).map(&:to_s).sort!
+    names == Array(other).map(&:to_s).sort!
   end
-  alias_method :eql?, :==
+  alias eql? ==
 
   # @return [String] the contents of {#names}, joined by `, `.
   def to_s(separator: ", ")
@@ -80,6 +103,11 @@ class ObjectInspector::Scope
     names
   end
 
+  # @return [String] A pretty representation of the scope and its {#names}.
+  def inspect
+    "<#{self.class.name} :: #{names.inspect}>"
+  end
+
   private
 
   def method_missing(method_name, *args, &)
@@ -131,10 +159,11 @@ class ObjectInspector::Scope
   end
 
   def any_names_match?(other_name)
-    @names.any?(other_name)
+    names.any?(other_name)
   end
 
   # :reek:BooleanParameter
+
   def respond_to_missing?(method_name, include_private = false)
     method_name[-1] == "?" || super
   end

data/lib/object_inspector/version.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+# :reek:IrresponsibleModule
+
 module ObjectInspector
   # The current ObjectInspector gem version.
-  VERSION = "0.10.0"
+  VERSION = "1.1.0"
+  public_constant :VERSION
 end