object_identifier 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4553678db77484aa04ce8bf00e3238310bb253632fb8867cae4e948a35bfda6c
-  data.tar.gz: afae645239815d3a9a011b56892127eccbf0dbc9558fc59ed6d7c15349fdbbe7
+  metadata.gz: 77c88ad5dd6256732f3cb586a72a2a6eb4c0c36e9042af8be0176599ba16d2d2
+  data.tar.gz: 69874ab0c4790cc824e664394327132fac01c2ac4873b85b42c50792367ea1f9
 SHA512:
-  metadata.gz: 639af898d48d62cfdf69c325986fab12147ddad81219b0e60557a9e52288597d5dddd3f4473ac94df3bbfd5ade304bb55c3f1a49b9918f4c959941ba4899f773
-  data.tar.gz: 9f715f65e2afa4ac783db81cd8cab09b137b206dae15d4b05e757dc2d0c82e04848dbd2551e02b8a7c6127aed3b5cb5257c920e8d79f027cf42d1b61ae238679
+  metadata.gz: 0f2a040a4fbf0becb441abe51af4d2dc1bd74b2f4b4f33a29ddbe0e68df38600c54c44e3d1b989d99e921d5a41b62d8ca4dac488ecfe6e7e123c299f91951af5
+  data.tar.gz: 57f3ed43f09b46f84d3982a36c4822b1ae86d659ed9f6ccbf928b939257e29ab2d0bd4891d702b43f37825b410baa90063945f59f0f08cde8ad061b52662dfc1

data/.reek.yml

@@ -0,0 +1,11 @@
+directories:
+  "test":
+    IrresponsibleModule:
+      enabled: false
+    UtilityFunction:
+      enabled: false
+  "scripts":
+    IrresponsibleModule:
+      enabled: false
+    UtilityFunction:
+      enabled: false

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.6.0 - 2023-01-09
+- Internal refactoring for more Object-Oriented goodness.
+
+#### BREAKING
+- Refactor `ObjectIdentifier::Identifier` to just `ObjectIdentifier`. This has no effect on instance method usage (e.g. `<my_object>.identify(...)`). But if any manual invocations were made (e.g. `ObjectIdentifier::Identifier.call(...)`) then they will need to be updated to `ObjectIdentifier.call(...)` (or just `ObjectIdentifier.(...)`, per your own style guide).
+
 ### 0.5.0 - 2023-01-04
 - Add support for defining customer Formatters.
 - Add ObjectInspector::Configuration#formatter_class setting for overriding the default Formatter. See the README for more.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    object_identifier (0.5.0)
+    object_identifier (0.6.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -38,10 +38,12 @@ Or install it yourself as:
 ## Compatibility
 
 Tested MRI Ruby Versions:
-* 3.2.0
-* 2.4.9
-* 2.5.8
-* 2.6.6
+* 2.4 (not recently tested)
+* 2.5 (not recently tested)
+* 2.6 (not recently tested)
+* 2.7
+* 3.1
+* 3.2
 
 
 ## Configuration
@@ -168,7 +170,7 @@ ObjectIdentifier works great with the [ObjectInspector](https://github.com/pdobb
 
 ### Benchmarking Formatters
 
-Performance of Formatters can be tested by playing the [Formatters Benchmarking Scripts](https://github.com/pdobb/object_identifier/tree/master/scripts/benchmarking) in the pry console for this gem.
+Performance of Formatters can be tested by playing the [Formatters Benchmarking Scripts](https://github.com/pdobb/object_identifier/blob/master/scripts/benchmarking/formatters.rb) in the pry console for this gem.
 
 Custom Formatters may be similarly gauged for comparison by adding them to the `custom_formatter_klasses` array before playing the script.
 

data/lib/core_ext/object.rb

@@ -40,6 +40,6 @@ class Object
   #   (1..10).to_a.identify(:to_f, limit: 2)
   #   # => "Integer[to_f:1.0], Integer[to_f:2.0], ... (8 more)"
   def identify(*args, **kargs)
-    ObjectIdentifier::Identifier.(self, *args, **kargs)
+    ObjectIdentifier.(self, *args, **kargs)
   end
 end

data/lib/object_identifier/formatters/string_formatter.rb

@@ -4,29 +4,17 @@
 # given object(s).
 class ObjectIdentifier::StringFormatter
   NO_OBJECTS_INDICATOR = "[no objects]"
-  KLASS_NOT_GIVEN = "NOT_GIVEN"
 
-  def self.call(objects, *attributes, **kargs)
-    new(objects, *attributes, **kargs).call
+  def self.call(objects, parameters = ObjectIdentifier.buid_parameters)
+    new(objects, parameters).call
   end
 
   # @param objects [Object, [Object, ...]] the object(s) to be interrogated for
   #   String values to be added to the output String
-  # @param attributes [Array, *args] a list of method calls to interrogate the
-  #   given object(s) with
-  # @param limit [Integer, nil] a given limit on the number of objects to
-  #   interrogate
-  # @param klass [String, Symbol] a preferred type name for identifying the
-  #   given object(s) as
-  def initialize(
-        objects,
-        attributes = ObjectIdentifier::Identifier.default_attributes,
-        limit: nil,
-        klass: KLASS_NOT_GIVEN)
+  # @param parameters [ObjectIdentifier::Parameters]
+  def initialize(objects, parameters = ObjectIdentifier.buid_parameters)
     @objects = ObjectIdentifier::ArrayWrap.(objects)
-    @attributes = ObjectIdentifier::ArrayWrap.(attributes)
-    @limit = (limit || @objects.size).to_i
-    @klass = klass.to_s
+    @parameters = parameters
   end
 
   # Output the self-identifying string for the given object(s). Will either
@@ -35,69 +23,138 @@ class ObjectIdentifier::StringFormatter
   #
   # @return [String] a string that identifies the object(s)
   def call
-    return NO_OBJECTS_INDICATOR if @objects.empty?
-
-    output_strings = @objects.first(@limit).map { |obj| format(obj) }
-    output_strings << "... (#{truncated_objects_count} more)" if truncated?
-    output_strings.join(", ")
+    if @objects.none?
+      NO_OBJECTS_INDICATOR
+    elsif @objects.one?
+      format_single_object
+    else # @objects.size > 1
+      format_multiple_objects
+    end
   end
 
   private
 
-  def format(object)
-    return NO_OBJECTS_INDICATOR if blank?(object)
-
-    "#{class_name(object)}[#{format_attributes(evaluate_attributes(object))}]"
+  def format_single_object(object = @objects.first)
+    SingleObject.(object, @parameters)
   end
 
-  # Simple version of Rails' Object#blank? method.
-  def blank?(object)
-    object.nil? || object == [] || object == {}
+  def format_multiple_objects
+    Collection.(@objects, @parameters)
   end
 
-  def class_name(object)
-    klass_given? ? @klass : object.class.name
-  end
+  # ObjectIdentifier::StringFormatter::Collection formats a collection-specific
+  # identification String, which will also necessarily be composed of
+  # {ObjectIdentifier::StringFormatter::SingleObject} identification Strings.
+  class Collection
+    # @return [String] the self-identifying String for the passed in object.
+    def self.call(*args)
+      new(*args).call
+    end
 
-  def klass_given?
-    @klass != KLASS_NOT_GIVEN
-  end
+    # @param objects [Object, [Object, ...]] the object(s) to be interrogated
+    #   for String values to be added to the output String
+    # @param parameters [ObjectIdentifier::Parameters]
+    def initialize(objects, parameters)
+      @objects = objects
+      @parameters = parameters
+    end
 
-  def format_attributes(attributes_hash)
-    return if attributes_hash.empty?
+    def call
+      output_strings =
+        @objects.first(limit).map { |obj| format_single_object(obj) }
+      output_strings << "... (#{truncated_objects_count} more)" if truncated?
+      output_strings.join(", ")
+    end
 
-    attributes_formatter = determine_attributes_formatter(attributes_hash)
-    attributes_hash.map(&attributes_formatter).join(", ")
-  end
+    private
 
-  def determine_attributes_formatter(attributes_hash)
-    if attributes_hash.one?
-      ->(_key, value) { value.inspect_lit }
-    else
-      ->(key, value) { "#{key}:#{value.inspect_lit}" }
+    def format_single_object(object = @objects.first)
+      SingleObject.(object, @parameters)
     end
-  end
 
-  # @return [Hash]
-  def evaluate_attributes(object)
-    @attributes.each_with_object({}) { |key, acc|
-      if object.respond_to?(key, :include_private)
-        acc[key] = object.send(key)
-      elsif key.to_s.start_with?("@")
-        acc[key] = object.instance_variable_get(key)
-      end
-    }
-  end
+    def limit
+      @parameters.limit { objects_count }
+    end
 
-  def truncated_objects_count
-    @truncated_objects_count ||= objects_count - @limit
-  end
+    def truncated_objects_count
+      @truncated_objects_count ||= objects_count - limit
+    end
 
-  def objects_count
-    @objects_count ||= @objects.size
+    def objects_count
+      @objects_count ||= @objects.size
+    end
+
+    def truncated?
+      truncated_objects_count.positive?
+    end
   end
 
-  def truncated?
-    truncated_objects_count.positive?
+  # ObjectIdentifier::StringFormatter::SingleObject formats a
+  # single-object-specific identification String.
+  class SingleObject
+    # @return [String] the self-identifying String for the passed in object.
+    def self.call(*args)
+      new(*args).call
+    end
+
+    # @param object [Object] the object to be interrogated for String values to
+    #   be added to the output String
+    # @param parameters [ObjectIdentifier::Parameters]
+    def initialize(object, parameters)
+      @object = object
+      @parameters = parameters
+    end
+
+    # @return [String] the self-identifying String for {@object}.
+    def call
+      return NO_OBJECTS_INDICATOR if blank?
+
+      "#{class_name}[#{formatted_attributes}]"
+    end
+
+    private
+
+    # Simple version of Rails' Object#blank? method.
+    # :reek:NilCheck
+    def blank?
+      @object.nil? || @object == [] || @object == {}
+    end
+
+    def class_name
+      @parameters.klass { @object.class.name }
+    end
+
+    def formatted_attributes
+      return if attributes_hash.empty?
+
+      attributes_hash.map(&attributes_formatter).join(", ")
+    end
+
+    # :reek:DuplicateMethodCall
+    def attributes_formatter
+      @attributes_formatter ||=
+        if attributes_hash.one?
+          ->(_key, value) { value.inspect_lit }
+        else # attributes_hash.size > 1
+          ->(key, value) { "#{key}:#{value.inspect_lit}" }
+        end
+    end
+
+    # @return [Hash]
+    # :reek:ManualDispatch
+    def attributes_hash
+      @attributes_hash ||=
+        attributes.each_with_object({}) { |key, acc|
+          if @object.respond_to?(key, :include_private)
+            acc[key] = @object.__send__(key)
+          elsif key.to_s.start_with?("@")
+            acc[key] = @object.instance_variable_get(key)
+          end
+        }
+    end
+
+    def attributes
+      @parameters.attributes
+    end
   end
 end

data/lib/object_identifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ObjectIdentifier
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/object_identifier.rb

@@ -3,20 +3,41 @@
 # ObjectIdentifier is the base namespace for all modules/classes related to the
 # object_identifier gem.
 module ObjectIdentifier
-  # ObjectIdentifier::ArrayWrap mirrors the implementation of Rails'
-  # {Array.wrap} method. This allows us to get around objects that respond to
-  # `to_a` (such as Struct) and, instead, either utilize `to_ary` or just
-  # actually wrap the object in an Array ourselves.
-  class ArrayWrap
-    def self.call(object)
-      if object.nil?
-        []
-      elsif object.respond_to?(:to_ary)
-        object.to_ary || [object]
-      else
-        [object]
-      end
-    end
+  # ObjectIdentifier.call is the main entry point for use of this gem. In
+  # typical usage, however, this method will almost exclusively just be called
+  # by {Object#identify}, as defined in lib/core_ext/object.rb.
+  # :reek:LongParameterList
+  def self.call(
+        objects,
+        *attributes,
+        formatter_class: default_formatter_class,
+        **formatter_options)
+
+    parameters =
+      buid_parameters(
+        attributes: attributes,
+        formatter_options: formatter_options)
+
+    formatter_class.(objects, parameters)
+  end
+
+  # Factory method for building an {ObjectIdentifier::Parameters} object.
+  def self.buid_parameters(attributes: [], formatter_options: {})
+    attrs = ObjectIdentifier::ArrayWrap.(attributes)
+    attrs = default_attributes if attrs.empty?
+    attrs.flatten!
+
+    Parameters.new(
+      attributes: attrs,
+      formatter_options: formatter_options.to_h)
+  end
+
+  def self.default_formatter_class
+    configuration.formatter_class
+  end
+
+  def self.default_attributes
+    configuration.default_attributes
   end
 
   def self.configuration
@@ -55,10 +76,72 @@ module ObjectIdentifier
       @default_attributes = value.to_a.map!(&:to_sym)
     end
   end
+
+  # ObjectIdentifier::Parameters encapsulates the attributes list and
+  # formatter options that may be needed for custom formatting during object
+  # identification.
+  class Parameters
+    KLASS_NOT_GIVEN = "NOT_GIVEN"
+
+    attr_reader :attributes
+
+    # @param attributes [Array, *args] a list of method calls to interrogate the
+    #   given object(s) with
+    # @param formatter_options[:limit] [Integer, nil] (nil) a given limit on the
+    #   number of objects to interrogate
+    # @param formatter_options[:klass] [#to_s] a preferred type name for
+    #   identifying the given object(s) as
+    def initialize(
+          attributes: [],
+          formatter_options: {})
+      @attributes = attributes
+      @limit = formatter_options.fetch(:limit, nil)
+      @klass = formatter_options.fetch(:klass, KLASS_NOT_GIVEN)
+    end
+
+    # NOTE: Expects a block if a value wasn't supplied on initialization.
+    def limit
+      @limit || (yield if block_given?)
+    end
+
+    # NOTE: Expects a block if a value wasn't supplied on initialization.
+    def klass
+      if klass_given?
+        @klass.to_s
+      elsif block_given?
+        yield.to_s
+      else
+        nil
+      end
+    end
+
+    private
+
+    def klass_given?
+      @klass != KLASS_NOT_GIVEN
+    end
+  end
+
+  # ObjectIdentifier::ArrayWrap mirrors the implementation of Rails'
+  # {Array.wrap} method. This allows us to get around objects that respond to
+  # `to_a` (such as Struct) and, instead, either utilize `to_ary` or just
+  # actually wrap the object in an Array ourselves.
+  class ArrayWrap
+    # :reek:NilCheck
+    # :reek:ManualDispatch
+    def self.call(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
 end
 
 require "object_identifier/version"
-require "object_identifier/identifier"
 require "object_identifier/formatters/string_formatter"
 require "core_ext/object"
 require "core_ext/string"

data/object_identifier.gemspec

@@ -7,7 +7,7 @@ require "object_identifier/version"
 Gem::Specification.new do |spec|
   spec.name          = "object_identifier"
   spec.version       = ObjectIdentifier::VERSION
-  spec.authors       = ["Paul DobbinSchmaltz", "Evan Sherwood"]
+  spec.authors       = ["Paul DobbinSchmaltz"]
   spec.email         = ["p.dobbinschmaltz@icloud.com"]
   spec.required_ruby_version = ">= 2.4.0"
   spec.metadata      = { "rubygems_mfa_required" => "true" }

data/scripts/benchmarking/formatters.rb

@@ -20,16 +20,22 @@ objects = [
   MyObject.new(id: 3, name: "NAME3")
 ].freeze
 
+def parameterize(attributes = [], **formatter_options)
+  ObjectIdentifier.buid_parameters(
+    attributes: attributes,
+    formatter_options: formatter_options)
+end
+
 puts "== Averaged ============================================================="
 Benchmark.ips { |x|
   formatter_klasses.each do |formatter_klass|
     x.report(formatter_klass) {
       formatter_klass.new(objects[0]).call
-      formatter_klass.new(objects[0], %i[id name]).call
-      formatter_klass.new(objects[0], klass: "CustomClass").call
-      formatter_klass.new(objects[0], %i[id name], klass: "CustomClass").call
-      formatter_klass.new(objects, limit: 2).call
-      formatter_klass.new(objects, %i[id name], klass: "CustomClass", limit: 2).call
+      formatter_klass.new(objects[0], parameterize(%i[id name])).call
+      formatter_klass.new(objects[0], parameterize(klass: "CustomClass")).call
+      formatter_klass.new(objects[0], parameterize(%i[id name], klass: "CustomClass")).call
+      formatter_klass.new(objects, parameterize(limit: 2)).call
+      formatter_klass.new(objects, parameterize(%i[id name], klass: "CustomClass", limit: 2)).call
     }
   end
 
@@ -47,27 +53,27 @@ Benchmark.ips { |x|
   end
   formatter_klasses.each do |formatter_klass|
     x.report("#{formatter_klass} - Custom Attributes") {
-      formatter_klass.new(objects[0], %i[id name]).call
+      formatter_klass.new(objects[0], parameterize(%i[id name])).call
     }
   end
   formatter_klasses.each do |formatter_klass|
     x.report("#{formatter_klass} - Custom Class") {
-      formatter_klass.new(objects[0], klass: "CustomClass").call
+      formatter_klass.new(objects[0], parameterize(klass: "CustomClass")).call
     }
   end
   formatter_klasses.each do |formatter_klass|
     x.report("#{formatter_klass} - Custom Attributes & Custom Class") {
-      formatter_klass.new(objects[0], %i[id name], klass: "CustomClass").call
+      formatter_klass.new(objects[0], parameterize(%i[id name], klass: "CustomClass")).call
     }
   end
   formatter_klasses.each do |formatter_klass|
     x.report("#{formatter_klass} - Limit 2") {
-      formatter_klass.new(objects, limit: 2).call
+      formatter_klass.new(objects, parameterize(limit: 2)).call
     }
   end
   formatter_klasses.each do |formatter_klass|
     x.report("#{formatter_klass} - Custom Attributes & Custom Class & Limit 2") {
-      formatter_klass.new(objects, %i[id name], klass: "CustomClass", limit: 2).call
+      formatter_klass.new(objects, parameterize(%i[id name], klass: "CustomClass", limit: 2)).call
     }
   end
   # rubocop:enable Style/CombinableLoops

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_identifier
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Paul DobbinSchmaltz
-- Evan Sherwood
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-05 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -190,6 +189,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".gitignore"
+- ".reek.yml"
 - ".rubocop"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -206,7 +206,6 @@ files:
 - lib/core_ext/symbol.rb
 - lib/object_identifier.rb
 - lib/object_identifier/formatters/string_formatter.rb
-- lib/object_identifier/identifier.rb
 - lib/object_identifier/version.rb
 - object_identifier.gemspec
 - scripts/benchmarking/formatters.rb

data/lib/object_identifier/identifier.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# ObjectIdentifier::Identifier manages construction of identification outputs
-# using the passed in formatter_class.
-class ObjectIdentifier::Identifier
-  # NOTE: `kargs` may be specific to the Formatter being called.
-  def self.call(
-        objects,
-        *attributes,
-        formatter_class: default_formatter_class,
-        **formatter_options)
-    formatter_class.(objects, *attributes, **formatter_options)
-  end
-
-  def self.default_formatter_class
-    ObjectIdentifier.configuration.formatter_class
-  end
-
-  def self.default_attributes
-    ObjectIdentifier.configuration.default_attributes
-  end
-end