object_inspector 0.6.2 → 0.7.0

data/lib/object_inspector/inspector.rb

@@ -1,188 +1,192 @@
 # frozen_string_literal: true
 
-module ObjectInspector
-  # ObjectInspector::Inspector organizes inspection of the associated {@object}
-  # via the passed in options and via a {ObjectInspector::BaseFormatter}
-  # instance.
-  class Inspector
-    attr_reader :object
-
-    # Shortcuts the instantiation -> {#to_s} flow that would normally be
-    # required to use ObjectInspector::Inspector.
-    #
-    # @return [String]
-    def self.inspect(object, **kargs)
-      new(object, **kargs).to_s
-    end
+# ObjectInspector::Inspector organizes inspection of the associated {#object}
+# via the passed in options and via an {ObjectInspector::BaseFormatter}
+# instance.
+#
+# :reek:TooManyMethods
+class ObjectInspector::Inspector
+  attr_reader :object
+
+  # Shortcuts the instantiation -> {#to_s} flow that would normally be
+  # required to use ObjectInspector::Inspector.
+  #
+  # @return [String]
+  def self.inspect(...)
+    new(...).to_s
+  end
 
-    # @param object [Object] the object being inspected
-    # @param scope [Symbol] Object inspection type. For example:
-    #   :self (default) -- Means: Only interrogate self. Don't visit neighbors.
-    #   <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 kargs [Hash] options to be sent to {@object} via the
-    #   {ObjectInspector::ObjectInterrogator} when calling the `inspect_*`
-    #   methods
-    def initialize(
-          object,
-          scope: ObjectInspector.configuration.default_scope,
-          formatter: ObjectInspector.configuration.formatter_class,
-          **kargs)
-      @object = object
-      @scope = Conversions.Scope(scope)
-      @formatter_klass = formatter
-      @kargs = kargs
-    end
+  # @param object [Object] the object being inspected
+  # @param scope [Symbol] Object inspection type. For example:
+  #   :self (default) -- Means: Only interrogate self. Don't visit neighbors.
+  #   <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)
+  def initialize(
+        object,
+        scope: ObjectInspector.configuration.default_scope,
+        formatter: ObjectInspector.configuration.formatter_class,
+        **kwargs)
+    @object = object
+    @scope = ObjectInspector::Conversions.Scope(scope)
+    @formatter_klass = formatter
+    @kwargs = kwargs
+  end
 
-    # Generate the formatted inspect String.
-    #
-    # @return [String]
-    def to_s
-      formatter.call
-    end
+  # Generate the formatted inspect String.
+  #
+  # @return [String]
+  def to_s
+    formatter.call
+  end
 
-    # 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}
-    def wrapped_object_inspection_result
-      return unless object_is_a_wrapper?
-
-      self.class.inspect(
-        extract_wrapped_object,
-        scope: @scope,
-        formatter: @formatter_klass,
-        kargs: @kargs)
-    end
+  # 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?}
+  def wrapped_object_inspection_result
+    return unless object_is_a_wrapper?
+
+    self.class.inspect(
+      extract_wrapped_object,
+      scope: @scope,
+      formatter: @formatter_klass,
+      kwargs: @kwargs)
+  end
 
-    # Core object identification details, such as the {@object} class name and
-    # any core-level attributes.
-    #
-    # @return [String]
-    def identification
-      (value(key: :identification) || @object.class).to_s
-    end
+  # Core object identification details, such as the {#object} class name and
+  # any core-level attributes.
+  #
+  # @return [String]
+  def identification
+    (value(key: :identification) || @object.class).to_s
+  end
 
-    # Boolean flags/states applicable to {@object}.
-    #
-    # @return [String] if given
-    # @return [NilClass] if not given
-    def flags
-      value(key: :flags)
-    end
+  # Boolean flags/states applicable to {#object}.
+  #
+  # @return [String] if given
+  # @return [NilClass] if not given
+  def flags
+    value(key: :flags)
+  end
 
-    # Issues/Warnings applicable to {@object}.
-    #
-    # @return [String] if given
-    # @return [NilClass] if not given
-    def issues
-      value(key: :issues)
-    end
+  # Issues/Warnings applicable to {#object}.
+  #
+  # @return [String] if given
+  # @return [NilClass] if not given
+  def issues
+    value(key: :issues)
+  end
 
-    # Informational details applicable to {@object}.
-    #
-    # @return [String] if given
-    # @return [NilClass] if not given
-    def info
-      value(key: :info)
-    end
+  # Informational details applicable to {#object}.
+  #
+  # @return [String] if given
+  # @return [NilClass] if not given
+  def info
+    value(key: :info)
+  end
 
-    # A human-friendly identifier for {@object}.
-    #
-    # @return [String] if given
-    # @return [NilClass] if not given
-    def name
-      key = :name
+  # A human-friendly identifier for {#object}.
+  #
+  # @return [String] if given
+  # @return [NilClass] if not given
+  def name
+    key = :name
 
-      if @kargs.key?(key)
-        value(key: key)
-      else
-        interrogate_object_inspect_method(key) ||
-          interrogate_object(method_name: :display_name,
-                             kargs: object_method_keyword_arguments)
-      end
+    if @kwargs.key?(key)
+      value(key: key)
+    else
+      interrogate_object_inspect_method(key) ||
+        interrogate_object(
+          method_name: :display_name, kwargs: object_method_keyword_arguments)
     end
+  end
 
-    private
-
-    def formatter
-      @formatter_klass.new(self)
-    end
+  private
 
-    # @return [String] if `key` is found in {#kargs} or if {@object} responds to
-    #   `#{object_inspet_method_name}` (e.g. `inspect_flags`)
-    # @return [NilClass] if not found in {#kargs} or {@object}
-    def value(key:)
-      return_value =
-        if @kargs.key?(key)
-          evaluate_passed_in_value(@kargs[key])
-        else
-          interrogate_object_inspect_method(key)
-        end
-
-      return_value&.to_s
-    end
+  def formatter
+    @formatter_klass.new(self)
+  end
 
-    # 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
-    def evaluate_passed_in_value(value)
-      if value.is_a?(Symbol)
-        interrogate_object(method_name: value) || value
+  # @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}
+  def value(key:)
+    return_value =
+      if @kwargs.key?(key)
+        evaluate_passed_in_value(@kwargs[key])
       else
-        value
+        interrogate_object_inspect_method(key)
       end
-    end
 
-    # Attempt to call `inspect_*` on {@object} based on the passed in `name`.
-    #
-    # @return [String] if {@object} responds to
-    #   `#{object_inspet_method_name}` (e.g. `inspect_flags`)
-    # @return [NilClass] if not found on {@object}
-    def interrogate_object_inspect_method(
-          name,
-          prefix: ObjectInspector.configuration.inspect_method_prefix)
-      interrogate_object(
-        method_name: object_inspet_method_name(name, prefix: prefix),
-        kargs: object_method_keyword_arguments)
+    return_value&.to_s
+  end
+
+  # 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
+  def evaluate_passed_in_value(value)
+    if value.is_a?(Symbol)
+      interrogate_object(method_name: value) || value
+    else
+      value
     end
+  end
 
-    def interrogate_object(method_name:, kargs: {})
-      interrogator =
-        ObjectInterrogator.new(
-          object: @object,
-          method_name: method_name,
-          kargs: kargs)
+  # 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}
+  def interrogate_object_inspect_method(
+        name,
+        prefix: ObjectInspector.configuration.inspect_method_prefix)
+    interrogate_object(
+      method_name: object_inspection_method_name(name, prefix: prefix),
+      kwargs: object_method_keyword_arguments)
+  end
 
-      interrogator.call
-    end
+  def interrogate_object(method_name:, kwargs: {})
+    interrogator =
+      ObjectInspector::ObjectInterrogator.new(
+        object: @object,
+        method_name: method_name,
+        kwargs: kwargs)
 
-    def object_inspet_method_name(
-          name,
-          prefix: ObjectInspector.configuration.inspect_method_prefix)
-      "#{prefix}_#{name}"
-    end
+    interrogator.call
+  end
 
-    def object_method_keyword_arguments
-      {
-        scope: @scope
-      }
-    end
+  # :reek:UtilityFunction
+  def object_inspection_method_name(
+        name,
+        prefix: ObjectInspector.configuration.inspect_method_prefix)
+    "#{prefix}_#{name}"
+  end
 
-    def extract_wrapped_object
-      @object.to_model
-    end
+  def object_method_keyword_arguments
+    {
+      scope: @scope,
+    }
+  end
 
-    def object_is_a_wrapper?
-      @object.respond_to?(:to_model) &&
-        @object.to_model != @object
-    end
+  def extract_wrapped_object
+    @object.to_model
+  end
+
+  # :reek:ManualDispatch
+  def object_is_a_wrapper?
+    @object.respond_to?(:to_model) &&
+      @object.to_model != @object
   end
 end

data/lib/object_inspector/inspectors_helper.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-module ObjectInspector
-  # ObjectInspector::InspectorsHelper can be included into any object to
-  # simplify the process of instantiating an ObjectInspector::Inspector and
-  # generating the inspection output.
-  module InspectorsHelper
-    # Calls {ObjectInspector::Inspector.inspect} on the passed in `object`,
-    # passing it the passed in `kargs` (keyword arguments).
-    #
-    # @return [String]
-    def inspect(object = self, **kargs)
-      Inspector.inspect(object, **kargs)
-    end
+# ObjectInspector::InspectorsHelper can be included into any object to
+# simplify the process of instantiating an ObjectInspector::Inspector and
+# generating the inspection output.
+module ObjectInspector::InspectorsHelper
+  # Calls {ObjectInspector::Inspector.inspect} on the passed in `object`,
+  # passing it the passed in `kwargs` (keyword arguments).
+  #
+  # @return [String]
+  def inspect(object = self, **kwargs)
+    ObjectInspector::Inspector.inspect(object, **kwargs)
   end
 end

data/lib/object_inspector/object_interrogator.rb

@@ -1,44 +1,46 @@
 # frozen_string_literal: true
 
-module ObjectInspector
-  # ObjectInspector::ObjectInterrogator collaborates with {@object} to return
-  # Object#{@method_name} if {@object} responds to the method.
-  #
-  # If Object#{@method_name} accepts the supplied {@kargs} then they are passed
-  # in as well. If not, then any supplied {@kargs} will be ignored.
-  class ObjectInterrogator
-    attr_reader :object
+# ObjectInspector::ObjectInterrogator collaborates with {#object} to return
+# Object#{#method_name} if {#object} responds to the method.
+#
+# 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
+  attr_reader :object,
+              :method_name,
+              :kwargs
 
-    def initialize(object:, method_name:, kargs: {})
-      @object = object
-      @method_name = method_name
-      @kargs = kargs
-    end
+  def initialize(object:, method_name:, kwargs: {})
+    @object = object
+    @method_name = method_name
+    @kwargs = kwargs
+  end
 
-    # @return [String, ...] whatever type Object#{#method} returns
-    #
-    # @raise [ArgumentError] if Object#{#method} has an unexpected method
-    #   signature
-    def call
-      return unless object_responds_to_method_name?
+  # @return [String, ...] whatever type Object#{#method_name} returns
+  #
+  # @raise [ArgumentError] if Object#{#method_name} has an unexpected method
+  #   signature
+  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
+    if object.method(method_name).arity.zero?
+      object.__send__(method_name)
+    else
+      call_with_kwargs
     end
+  end
 
-    private
+  private
 
-    def call_with_kargs
-      @object.__send__(@method_name, **@kargs)
-    rescue ArgumentError
-      @object.__send__(@method_name)
-    end
+  def call_with_kwargs
+    object.__send__(method_name, **kwargs)
+  rescue ArgumentError
+    object.__send__(method_name)
+  end
 
-    def object_responds_to_method_name?(include_private: true)
-      @object.respond_to?(@method_name, include_private)
-    end
+  # :reek:ManualDispatch
+  # :reek:BooleanParameter
+  def object_responds_to_method_name?(include_private: true)
+    object.respond_to?(method_name, include_private)
   end
 end