object_identifier 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0a0e09332282b492a3c9e83f9ab59a319a421c9ed3e83c2bfa87f6bfe20e6bd
-  data.tar.gz: 7b27cf091a8ecfd1c747fb75918f4b88aabd725dba3221489021aa2f5d24138a
+  metadata.gz: 77c88ad5dd6256732f3cb586a72a2a6eb4c0c36e9042af8be0176599ba16d2d2
+  data.tar.gz: 69874ab0c4790cc824e664394327132fac01c2ac4873b85b42c50792367ea1f9
 SHA512:
-  metadata.gz: 6b1150c07800795094a4f15e475ba180187c51e248f0a5cfb385030b9720c4b2e3000692974f89eecc211b223778159b3041b358957265ae7e2e55b2835f8e47
-  data.tar.gz: 75b8bc577271cfe6b8a58ec5ec8a7d65c1e308aee3dfef8481e65869ac4e749ff9725f7f0d4fa752b391638c0e4b0003cafd2cd91ff352514fa03301df7931e8
+  metadata.gz: 0f2a040a4fbf0becb441abe51af4d2dc1bd74b2f4b4f33a29ddbe0e68df38600c54c44e3d1b989d99e921d5a41b62d8ca4dac488ecfe6e7e123c299f91951af5
+  data.tar.gz: 57f3ed43f09b46f84d3982a36c4822b1ae86d659ed9f6ccbf928b939257e29ab2d0bd4891d702b43f37825b410baa90063945f59f0f08cde8ad061b52662dfc1

data/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+      # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ee2113536afb7f793eed4ce60e8d3b26db912da4 # v1.127.0
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+    - name: Run tests
+      run: bundle exec rake

data/.reek.yml

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

data/.rubocop.yml

@@ -24,6 +24,18 @@ Layout/FirstHashElementIndentation:
 Layout/FirstParameterIndentation:
   Enabled: false # Revisit if more settings become available.
 
+Layout/LineContinuationSpacing:
+  EnforcedStyle: no_space
+
+Layout/LineEndStringConcatenationIndentation:
+  EnforcedStyle: aligned
+
+Layout/LineLength:
+  Max: 80
+  Exclude:
+    - "object_identifier.gemspec"
+    - "scripts/benchmarking/**/*"
+
 Layout/MultilineMethodCallBraceLayout:
   EnforcedStyle: same_line
 
@@ -42,11 +54,15 @@ Lint/AmbiguousOperator:
 Lint/AmbiguousRegexpLiteral:
   Enabled: false # Conflicts with other rules.
 
+Lint/OrAssignmentToConstant:
+  Exclude:
+    - "scripts/**/*"
+
 Lint/Void:
   CheckForMethodsWithNoSideEffects: true
 
 Metrics/BlockLength:
-  ExcludedMethods:
+  AllowedMethods:
     - describe
     - context
     - ips # Benchmarking
@@ -55,11 +71,6 @@ Metrics/ClassLength:
   Exclude:
     - "test/**/*"
 
-Metrics/LineLength:
-  Max: 80
-  Exclude:
-    - "object_identifier.gemspec"
-
 Naming/MethodParameterName:
   AllowedNames:
     - a
@@ -71,6 +82,10 @@ Style/Alias:
 Style/BlockDelimiters:
   Enabled: false # Reconsider later.
 
+Style/ClassAndModuleChildren:
+  AutoCorrect: true
+  EnforcedStyle: compact
+
 Style/EmptyElse:
   # It"s helpful to show intent by including a comment in an else block.
   Enabled: false
@@ -88,6 +103,13 @@ Style/FormatString:
 Style/Lambda:
   EnforcedStyle: literal
 
+Style/LambdaCall:
+  Enabled: false # Allow ServiceObject.(*). Only use on classes, not instances.
+
+Style/OpenStructUse:
+  Exclude:
+    - "test/**/*"
+
 Style/RegexpLiteral:
   EnforcedStyle: mixed
 

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-### 0.4.1 - 2022-12-?
+### 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.
+- Add a benchmarking script for comparing performance of formatters. See the README for more.
+
+### 0.4.1 - 2022-12-30
 - Make compatible with Ruby 3.2 (and likely Ruby 3.0 and 3.1 as well).
 - Update development dependencies.
 

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    object_identifier (0.4.1)
+    object_identifier (0.6.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ansi (1.5.0)
     ast (2.4.2)
+    benchmark-ips (2.10.0)
     builder (3.2.4)
     byebug (11.1.3)
     coderay (1.1.3)
@@ -15,12 +16,13 @@ GEM
     json (2.6.3)
     kwalify (0.7.2)
     method_source (1.0.0)
-    minitest (5.16.3)
+    minitest (5.17.0)
     minitest-reporters (1.5.0)
       ansi
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    much-stub (0.1.10)
     parallel (1.22.1)
     parser (3.1.3.0)
       ast (~> 2.4.1)
@@ -38,14 +40,14 @@ GEM
       rainbow (>= 2.0, < 4.0)
     regexp_parser (2.6.1)
     rexml (3.2.5)
-    rubocop (1.41.1)
+    rubocop (1.42.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.2.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.23.0, < 2.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.24.1)
@@ -63,10 +65,12 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark-ips
   bundler
   byebug
   minitest
   minitest-reporters
+  much-stub
   object_identifier!
   pry
   pry-byebug

data/README.md

@@ -1,7 +1,6 @@
 # Object Identifier
 
 [![Gem Version](https://badge.fury.io/rb/object_identifier.svg)](https://badge.fury.io/rb/object_identifier)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/0b737a72d16ec755c1ff/test_coverage)](https://codeclimate.com/github/pdobb/object_identifier/test_coverage)
 [![Maintainability](https://api.codeclimate.com/v1/badges/0b737a72d16ec755c1ff/maintainability)](https://codeclimate.com/github/pdobb/object_identifier/maintainability)
 
 Object Identifier allows quick, easy, and uniform identification of an object by inspecting its class name and outputting any desirable attributes/methods. It is great for logging, sending descriptive notification messages, etc.
@@ -39,10 +38,27 @@ 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
+
+Global/default values for ObjectIdentifier can be configured via the ObjectIdentifier::Configuration object.
+
+_Note: In a Rails app, the following would go in e.g. `config/initializers/object_identifier.rb`_
+
+```ruby
+# Default values are shown.
+ObjectIdentifier.configure do |config|
+  config.formatter_class = ObjectIdentifier::StringFormatter
+  config.default_attributes = %i[id]
+end
+```
 
 
 ## Usage
@@ -152,6 +168,23 @@ OpenStruct.new(my_value: my_value_object).identify(:my_value)
 ObjectIdentifier works great with the [ObjectInspector](https://github.com/pdobb/object_inspector) gem.
 
 
+### Benchmarking Formatters
+
+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.
+
+```ruby
+custom_formatter_klasses = [MyCustomFormatter]
+
+play scripts/benchmarking/formatters.rb
+# ObjectIdentifier::StringFormatter
+#     58.478k (± 0.8%) i/s -    295.776k in   5.058178s
+# MyCustomFormatter
+#                          ...
+```
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

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.identify(self, *args, **kargs)
+    ObjectIdentifier.(self, *args, **kargs)
   end
 end

data/lib/object_identifier/formatters/string_formatter.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# ObjectIdentifier::StringFormatter builds a String to identify the
+# given object(s).
+class ObjectIdentifier::StringFormatter
+  NO_OBJECTS_INDICATOR = "[no objects]"
+
+  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 parameters [ObjectIdentifier::Parameters]
+  def initialize(objects, parameters = ObjectIdentifier.buid_parameters)
+    @objects = ObjectIdentifier::ArrayWrap.(objects)
+    @parameters = parameters
+  end
+
+  # Output the self-identifying string for the given object(s). Will either
+  # return a single object representation or a list of object
+  # representations, based on the number of objects we're identifying.
+  #
+  # @return [String] a string that identifies the object(s)
+  def call
+    if @objects.none?
+      NO_OBJECTS_INDICATOR
+    elsif @objects.one?
+      format_single_object
+    else # @objects.size > 1
+      format_multiple_objects
+    end
+  end
+
+  private
+
+  def format_single_object(object = @objects.first)
+    SingleObject.(object, @parameters)
+  end
+
+  def format_multiple_objects
+    Collection.(@objects, @parameters)
+  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
+
+    # @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 call
+      output_strings =
+        @objects.first(limit).map { |obj| format_single_object(obj) }
+      output_strings << "... (#{truncated_objects_count} more)" if truncated?
+      output_strings.join(", ")
+    end
+
+    private
+
+    def format_single_object(object = @objects.first)
+      SingleObject.(object, @parameters)
+    end
+
+    def limit
+      @parameters.limit { objects_count }
+    end
+
+    def truncated_objects_count
+      @truncated_objects_count ||= objects_count - limit
+    end
+
+    def objects_count
+      @objects_count ||= @objects.size
+    end
+
+    def truncated?
+      truncated_objects_count.positive?
+    end
+  end
+
+  # 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.4.1"
+  VERSION = "0.6.0"
 end

data/lib/object_identifier.rb

@@ -3,10 +3,146 @@
 # ObjectIdentifier is the base namespace for all modules/classes related to the
 # object_identifier gem.
 module ObjectIdentifier
+  # 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
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+
+  # ObjectIdentifier::Configuration stores the default configuration options for
+  # the ObjectIdentifier gem. Modification of attributes is possible at any
+  # time, and values will persist for the duration of the running process.
+  class Configuration
+    attr_reader :formatter_class,
+                :default_attributes
+
+    def initialize
+      @formatter_class = ObjectIdentifier::StringFormatter
+      @default_attributes = %i[id]
+    end
+
+    def formatter_class=(value)
+      unless value.is_a?(Class)
+        raise TypeError, "Formatter must be a Class constant"
+      end
+
+      @formatter_class = value
+    end
+
+    def default_attributes=(value)
+      @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"
 require "core_ext/symbol"

data/object_identifier.gemspec

@@ -7,9 +7,10 @@ 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" }
 
   spec.summary       = "ObjectIdentifier identifies an object by its class name and attributes."
   spec.description   = "Object Identifier allows quick, easy, and uniform identification of an object by inspecting its class name and outputting any desirable attributes/methods. It is great for logging, sending descriptive notification messages, etc."
@@ -32,10 +33,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "byebug"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "much-stub"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rake"

data/scripts/benchmarking/formatters.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Play from the pry console with:
+#   play scripts/benchmarking/formatters.rb
+
+require "benchmark/ips"
+
+custom_formatter_klasses ||= []
+
+formatter_klasses = [
+  ObjectIdentifier::StringFormatter,
+  *Array(custom_formatter_klasses)
+].freeze
+
+MyObject ||= Struct.new(:id, :name)
+
+objects = [
+  MyObject.new(id: 1, name: "NAME1"),
+  MyObject.new(id: 2, name: "NAME2"),
+  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], 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
+
+  x.compare!
+}
+puts "== Done"
+
+puts "== Individualized ======================================================="
+Benchmark.ips { |x|
+  # rubocop:disable Style/CombinableLoops
+  formatter_klasses.each do |formatter_klass|
+    x.report("#{formatter_klass} - Default Attributes") {
+      formatter_klass.new(objects[0]).call
+    }
+  end
+  formatter_klasses.each do |formatter_klass|
+    x.report("#{formatter_klass} - Custom Attributes") {
+      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], parameterize(klass: "CustomClass")).call
+    }
+  end
+  formatter_klasses.each do |formatter_klass|
+    x.report("#{formatter_klass} - Custom Attributes & Custom Class") {
+      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, 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, parameterize(%i[id name], klass: "CustomClass", limit: 2)).call
+    }
+  end
+  # rubocop:enable Style/CombinableLoops
+
+  x.compare!
+}
+puts "== Done"

metadata

@@ -1,16 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: object_identifier
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Paul DobbinSchmaltz
-- Evan Sherwood
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-30 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -67,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: much-stub
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -160,7 +187,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".reek.yml"
 - ".rubocop"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -176,13 +205,15 @@ files:
 - lib/core_ext/string.rb
 - lib/core_ext/symbol.rb
 - lib/object_identifier.rb
-- lib/object_identifier/identifier.rb
+- lib/object_identifier/formatters/string_formatter.rb
 - lib/object_identifier/version.rb
 - object_identifier.gemspec
+- scripts/benchmarking/formatters.rb
 homepage: https://github.com/pdobb/object_identifier
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/object_identifier/identifier.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module ObjectIdentifier
-  # ObjectIdentifier::Identifier manages construction of the inspect String.
-  class Identifier
-    NO_OBJECTS_INDICATOR = "[no objects]"
-
-    # Class method for constructing a self-identifying string for any given
-    # object or collection of objects.
-    #
-    # @overload self.identify(obj, *args)
-    #   @param obj [Object] the object to identify
-    #   @param args [*] (optional) a list of arguments to identify for this
-    #     object or for each object in this collection
-    # @overload self.identify(obj, *args, options)
-    #   @param obj [Object] the object to identify
-    #   @param args [*] (optional) (default :id) a list of arguments to identify
-    #     for this object
-    #   @param [Hash] options the options for building a customized
-    #     self-identifier
-    #   @option options [String, nil] :klass object class name override
-    #   @option options [Integer] :limit maximum number of objects to display
-    #     from a collection
-    #
-    # @return [String] a self-identifying string like `Class[id:1, name:'temp']`
-    #
-    # @example
-    #   ObjectIdentifier::Identifier.identify(
-    #     OpenStruct.new(a: 1, b: '2', c: :"3"), :a, :b, :c)
-    #   # => "OpenStruct[a:1, b:\"2\", c::\"3\"]"
-    #
-    #   ObjectIdentifier::Identifier.identify(1, :to_s)
-    #   # => "Integer[to_s:\"1\"]"
-    #   ObjectIdentifier::Identifier.identify(nil)
-    #   # => "[no objects]"
-    #
-    #   ObjectIdentifier::Identifier.identify(%w(1 2), :to_i, :to_f)
-    #   # => "String[to_i:1, to_f:1.0], String[to_i:2, to_f:2.0]"
-    #
-    #   ObjectIdentifier::Identifier.identify((1..10).to_a, :to_f, limit: 2)
-    #   # => "Integer[to_f:1.0], Integer[to_f:2.0], ... (8 more)"
-    def self.identify(*args, **kargs)
-      new(*args, **kargs).to_s
-    end
-
-    def initialize(objects, *args, limit: nil, klass: :not_given)
-      @objects = ArrayWrap.call(objects)
-      @attributes = args.empty? ? [:id] : args
-      @limit = (limit || @objects.size).to_i
-      @klass = klass
-    end
-
-    # Output the self-identifying string for an instance of
-    # ObjectIdentifier::Identifier. Will either return a single object
-    # representation or a list of object representations, based on the number of
-    # objects we're identifying.
-    #
-    # @return [String] a string representing the object or list of objects
-    def to_s
-      if many?
-        format_multiple_objects
-      else
-        format_single_object
-      end
-    end
-
-    private
-
-    def format_multiple_objects
-      objects =
-        @objects.first(@limit).map { |obj| format(obj) }
-
-      objects << "... (#{truncated_objects_count} more)" if truncated?
-
-      objects.join(", ")
-    end
-
-    def format_single_object
-      object = @objects.first if @objects.respond_to?(:first)
-
-      format(object)
-    end
-
-    def format(object)
-      return NO_OBJECTS_INDICATOR if blank?(object)
-
-      "#{class_name(object)}[#{format_attributes(evaluate_attributes(object))}]"
-    end
-
-    def format_attributes(attributes_hash)
-      return if attributes_hash.empty?
-
-      attributes_hash.
-        map(&format_attributes_map_block(attributes_hash)).
-        join(", ")
-    end
-
-    def format_attributes_map_block(attributes_hash)
-      if attributes_hash.one?
-        ->(_key, value) { value.inspect_lit }
-      else
-        ->(key, value) { "#{key}:#{value.inspect_lit}" }
-      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 class_name(object)
-      klass_given? ? @klass : object.class.name
-    end
-
-    def truncated_objects_count
-      objects_count - @limit
-    end
-
-    def objects_count
-      @objects_count ||= @objects.size
-    end
-
-    def klass_given?
-      @klass != :not_given
-    end
-
-    def blank?(object)
-      object.nil? || object == [] || object == {}
-    end
-
-    def many?
-      objects_count > 1
-    end
-
-    def truncated?
-      truncated_objects_count.positive?
-    end
-
-    # ObjectIdentifier::Identifier::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, utilize either `to_ary`
-    # or just actually wrapping the object in an Array.
-    class ArrayWrap
-      def self.call(object)
-        if object.nil?
-          []
-        elsif object.respond_to?(:to_ary)
-          object.to_ary || [object]
-        else
-          [object]
-        end
-      end
-    end
-  end
-end