equalizer 0.0.10 → 1.0.0

data/Rakefile

@@ -1,34 +1,54 @@
-# encoding: utf-8
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-
-task :test    => :spec
-task :default => :spec
-
-begin
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new do |task|
-    task.options = %w(--config config/rubocop.yml)
-  end
-rescue LoadError
-  desc 'Run RuboCop'
-  task :rubocop do
-    $stderr.puts 'RuboCop is disabled'
-  end
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+# Override release task to only tag and push to git
+# The GitHub Action (push.yml) handles the actual gem push
+Rake::Task["release"].clear
+desc "Create tag v#{Equalizer::VERSION} and push to GitHub"
+task "release", [:remote] => ["build", "release:guard_clean"] do |_, args|
+  Rake::Task["release:source_control_push"].invoke(args[:remote])
+end
+require "rake/testtask"
+require "standard/rake"
+require "rubocop/rake_task"
+require "yard"
+require "yardstick/rake/verify"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = true
+end
+
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = %w[--display-cop-names]
 end
 
-require 'yardstick/rake/measurement'
-Yardstick::Rake::Measurement.new do |measurement|
-  measurement.output = 'measurement/report.txt'
+YARD::Rake::YardocTask.new(:yard) do |t|
+  t.files = ["lib/**/*.rb"]
+  t.options = ["--no-private", "--markup", "markdown"]
 end
 
-require 'yardstick/rake/verify'
-Yardstick::Rake::Verify.new do |verify|
+Yardstick::Rake::Verify.new(:yardstick) do |verify|
   verify.threshold = 100
+  verify.require_exact_threshold = false
 end
 
-task :ci => [:spec, :rubocop, :verify_measurements]
+desc "Run Steep type checker"
+task :steep do
+  sh "steep check"
+end
+
+desc "Run mutation testing"
+task :mutant do
+  ENV["MUTANT"] = "true"
+  sh "bundle exec mutant run"
+end
+
+desc "Run all quality checks"
+task quality: %i[rubocop steep yardstick]
+
+desc "Run all checks (tests, quality, mutation)"
+task default: %i[test quality mutant]

data/Steepfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+  check "lib"
+
+  configure_code_diagnostics(D::Ruby.strict)
+end

data/lib/equalizer.rb

@@ -1,119 +1,182 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-# Define equality, equivalence and inspection methods
-class Equalizer < Module
-  # Initialize an Equalizer with the given keys
-  #
-  # Will use the keys with which it is initialized to define #cmp?,
-  # #hash, and #inspect
-  #
-  # @param [Array<Symbol>] keys
-  #
-  # @return [undefined]
-  #
-  # @api private
-  def initialize(*keys)
-    @keys = keys
-    define_methods
-    freeze
-  end
-
-private
+# Equalizer provides equality, equivalence, hashing, pattern matching, and
+# inspection methods for Ruby objects based on specified attributes.
+#
+# @example Basic usage
+#   class GeoLocation
+#     include Equalizer.new(:latitude, :longitude)
+#
+#     attr_reader :latitude, :longitude, :name
+#
+#     def initialize(latitude, longitude, name = nil)
+#       @latitude = latitude
+#       @longitude = longitude
+#       @name = name
+#     end
+#   end
+#
+#   loc1 = GeoLocation.new(1.0, 2.0, "Home")
+#   loc2 = GeoLocation.new(1.0, 2.0, "Work")
+#   loc1 == loc2  # => true (name is not part of equality)
+#
+# @example Pattern matching
+#   case location
+#   in GeoLocation(latitude:, longitude:) then "#{latitude}, #{longitude}"
+#   in [lat, lon]                         then "coords: #{lat}, #{lon}"
+#   end
+#
+# @api public
+module Equalizer
+  # The current version of the Equalizer gem
+  VERSION = "1.0.0"
 
-  # Hook called when module is included
+  # Creates a module providing equality methods based on the given attributes
   #
-  # @param [Module] descendant
-  #   the module or class including Equalizer
+  # @example Basic usage
+  #   class Point
+  #     include Equalizer.new(:x, :y)
+  #     attr_reader :x, :y
+  #   end
   #
-  # @return [self]
+  # @param keys [Array<Symbol>] attribute names to use for equality
+  # @param inspect [Boolean] whether to override #inspect and #pretty_print
+  # @return [Module] a module to include in your class
+  # @raise [ArgumentError] if keys is empty or contains non-Symbols
   #
-  # @api private
-  def included(descendant)
-    super
-    descendant.module_eval { include Methods }
+  # @api public
+  def self.new(*keys, inspect: true)
+    validate_keys!(keys)
+    build_module(keys.freeze, inspect:)
   end
 
-  # Define the equalizer methods based on #keys
+  # Validates that keys are non-empty and all Symbols
   #
-  # @return [undefined]
+  # @param keys [Array<Object>] the keys to validate
+  # @return [void]
+  # @raise [ArgumentError] if keys is empty or contains non-Symbols
   #
   # @api private
-  def define_methods
-    define_cmp_method
-    define_hash_method
-    define_inspect_method
+  def self.validate_keys!(keys)
+    raise ArgumentError, "at least one attribute is required" if keys.empty?
+
+    invalid_types = keys.grep_v(Symbol).map(&:class).uniq
+    return if invalid_types.empty?
+
+    raise ArgumentError,
+      "attribute must be a Symbol, got #{invalid_types.join(", ")}"
   end
+  private_class_method :validate_keys!
 
-  # Define an #cmp? method based on the instance's values identified by #keys
-  #
-  # @return [undefined]
+  # Instance methods mixed into classes that include an Equalizer module
   #
   # @api private
-  def define_cmp_method
-    keys = @keys
-    define_method(:cmp?) do |comparator, other|
-      keys.all? { |key| send(key).send(comparator, other.send(key)) }
+  module InstanceMethods
+    # Equality comparison allowing subclasses
+    #
+    # @param other [Object] object to compare
+    # @return [Boolean] true if other is_a? same class with equal attributes
+    def ==(other)
+      other.is_a?(self.class) &&
+        cmp?(:==, other)
     end
-    private :cmp?
-  end
 
-  # Define a #hash method based on the instance's values identified by #keys
-  #
-  # @return [undefined]
-  #
-  # @api private
-  def define_hash_method
-    keys = @keys
-    define_method(:hash) do | |
-      keys.collect(&method(:send)).push(self.class).hash
+    # Strict equality requiring exact class match
+    #
+    # @param other [Object] object to compare
+    # @return [Boolean] true if other is exact same class with eql? attributes
+    def eql?(other)
+      other.instance_of?(self.class) &&
+        cmp?(:eql?, other)
     end
-  end
 
-  # Define an inspect method that reports the values of the instance's keys
-  #
-  # @return [undefined]
-  #
-  # @api private
-  def define_inspect_method
-    keys = @keys
-    define_method(:inspect) do | |
-      klass = self.class
-      name  = klass.name || klass.inspect
-      "#<#{name}#{keys.collect { |key| " #{key}=#{send(key).inspect}" }.join}>"
+    # Hash code based on class and attribute values
+    #
+    # @return [Integer] hash code
+    def hash
+      [self.class, *deconstruct].hash
     end
-  end
 
-  # The comparison methods
-  module Methods
-    # Compare the object with other object for equality
+    # Array deconstruction for pattern matching
     #
-    # @example
-    #   object.eql?(other)  # => true or false
+    # @return [Array] attribute values in order
+    def deconstruct
+      equalizer_keys.map { |key| public_send(key) }
+    end
+
+    # Hash deconstruction for pattern matching
     #
-    # @param [Object] other
-    #   the other object to compare with
+    # @param requested [Array<Symbol>, nil] keys to include, or nil for all
+    # @return [Hash{Symbol => Object}] requested attribute key-value pairs
+    def deconstruct_keys(requested)
+      subset = requested.nil? ? equalizer_keys : equalizer_keys & requested
+      subset.to_h { |key| [key, public_send(key)] }
+    end
+
+    private
+
+    # Compare all attributes using the given comparator
     #
-    # @return [Boolean]
+    # @param comparator [Symbol] method to use for comparison
+    # @param other [Object] object to compare against
+    # @return [Boolean] true if all attributes match
     #
-    # @api public
-    def eql?(other)
-      instance_of?(other.class) && cmp?(__method__, other)
+    # @api private
+    def cmp?(comparator, other)
+      equalizer_keys.all? do |key|
+        public_send(key)
+          .public_send(comparator, other.public_send(key))
+      end
     end
+  end
 
-    # Compare the object with other object for equivalency
-    #
-    # @example
-    #   object == other  # => true or false
+  # Instance methods for inspect and pretty print output
+  #
+  # @api private
+  module InspectMethods
+    # String representation showing only equalizer attributes
     #
-    # @param [Object] other
-    #   the other object to compare with
+    # @return [String] inspect output
+    def inspect
+      attrs = equalizer_keys
+        .map { |key| "@#{key}=#{public_send(key).inspect}" }
+        .join(", ")
+      Object.instance_method(:to_s).bind_call(self).sub(/>\z/, " #{attrs}>")
+    end
+
+    # Pretty print output using PP's object formatting
     #
-    # @return [Boolean]
+    # @param q [PP] pretty printer
+    # @return [void]
+    def pretty_print(q)
+      q.pp_object(self)
+    end
+
+    # Instance variables to display in pretty print output
     #
-    # @api public
-    def ==(other)
-      other = coerce(other).first if respond_to?(:coerce, true)
-      other.is_a?(self.class) && cmp?(__method__, other)
+    # @return [Array<Symbol>] instance variable names
+    def pretty_print_instance_variables
+      equalizer_keys.map { |key| :"@#{key}" }
+    end
+  end
+
+  # Builds the module with equality methods for the given keys
+  #
+  # @param keys [Array<Symbol>] attribute names (frozen)
+  # @param inspect [Boolean] whether to include inspect methods
+  # @return [Module] the configured module
+  #
+  # @api private
+  def self.build_module(keys, inspect:)
+    Module.new do
+      include InstanceMethods
+      include InspectMethods if inspect
+
+      set_temporary_name("Equalizer(#{keys.join(", ")})")
+
+      define_method(:equalizer_keys) { keys }
+      private :equalizer_keys
     end
-  end # module Methods
-end # class Equalizer
+  end
+  private_class_method :build_module
+end

data/sig/equalizer.rbs

@@ -0,0 +1,64 @@
+# Type signatures for the Equalizer gem
+#
+# Equalizer provides equality, equivalence, hashing, and inspection methods
+# for Ruby objects based on specified attributes.
+
+module Equalizer
+  # The current version of the Equalizer gem.
+  VERSION: String
+
+  # Define equality methods for the given attributes.
+  #
+  # Creates a module that, when included, adds equality methods
+  # based on the specified attributes.
+  def self.new: (*Symbol keys, ?inspect: bool) -> Module
+
+  # Private method to validate keys
+  def self.validate_keys!: (Array[untyped] keys) -> void
+
+  # Private method to build the module
+  def self.build_module: (Array[Symbol] keys, inspect: bool) -> Module
+
+  # Instance methods mixed into classes that include an Equalizer module.
+  # Assumes equalizer_keys is provided by the dynamic module.
+  module InstanceMethods : _Equalizer
+    private
+
+    # Compare all attributes using the given comparator.
+    def cmp?: (Symbol comparator, untyped other) -> bool
+  end
+
+  # Inspect and pretty print methods, optionally included.
+  module InspectMethods : _Equalizer
+    # Custom inspect output showing equalizer attributes.
+    def inspect: () -> String
+
+    # Pretty print output using PP's object formatting.
+    def pretty_print: (untyped q) -> void
+
+    # Returns instance variable names for PP (pretty print).
+    def pretty_print_instance_variables: () -> Array[Symbol]
+  end
+end
+
+# Interface for classes that include an Equalizer module
+interface _Equalizer
+  # Returns the attribute keys used for equality comparison (private).
+  def equalizer_keys: () -> Array[Symbol]
+
+  # Equivalence check - allows subclass instances.
+  def ==: (untyped other) -> bool
+
+  # Strict equality check - requires exact same class.
+  def eql?: (untyped other) -> bool
+
+  # Generate a hash code based on class and attribute values.
+  def hash: () -> Integer
+
+  # Array deconstruction for pattern matching.
+  def deconstruct: () -> Array[untyped]
+
+  # Hash deconstruction for pattern matching.
+  def deconstruct_keys: (Array[Symbol]? requested) -> Hash[Symbol, untyped]
+end
+

metadata

@@ -1,94 +1,69 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: equalizer
-version: !ruby/object:Gem::Version 
-  version: 0.0.10
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Dan Kubb
 - Markus Schirp
-autorequire: 
+- Piotr Solnica
+- Erik Berlin
 bindir: bin
 cert_chain: []
-
-date: 2015-03-20 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  type: :development
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.3"
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.5
-  requirement: *id001
-  prerelease: false
-  name: bundler
-description: Module to define equality, equivalence and inspection methods
-email: 
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Equalizer provides a simple way to define equality
+  (==), equivalence (eql?), and hashing (hash) methods
+  for Ruby objects based on specified attributes. Includes
+  pattern matching support and clean inspect output.
+email:
 - dan.kubb@gmail.com
 - mbj@schirp-dso.com
+- piotr.solnica@gmail.com
+- sferik@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.md
-- CONTRIBUTING.md
-files: 
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .ruby-gemset
-- .travis.yml
-- .yardstick.yml
+extra_rdoc_files: []
+files:
+- ".mutant.yml"
+- ".rubocop.yml"
+- ".yardopts"
+- ".yardstick.yml"
+- CHANGELOG.md
 - CONTRIBUTING.md
-- Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- config/rubocop.yml
-- equalizer.gemspec
+- Steepfile
 - lib/equalizer.rb
-- lib/equalizer/version.rb
-- spec/spec_helper.rb
-- spec/support/config_alias.rb
-- spec/unit/equalizer/included_spec.rb
-- spec/unit/equalizer/methods/eql_predicate_spec.rb
-- spec/unit/equalizer/methods/equality_operator_spec.rb
-- spec/unit/equalizer/universal_spec.rb
+- sig/equalizer.rbs
 homepage: https://github.com/dkubb/equalizer
-licenses: 
+licenses:
 - MIT
-metadata: {}
-
-post_install_message: 
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/dkubb/equalizer/issues
+  changelog_uri: https://github.com/dkubb/equalizer/blob/master/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/equalizer/
+  homepage_uri: https://github.com/dkubb/equalizer
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/dkubb/equalizer
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 4.0.8
 specification_version: 4
-summary: Module to define equality, equivalence and inspection methods
-test_files: 
-- spec/unit/equalizer/included_spec.rb
-- spec/unit/equalizer/methods/eql_predicate_spec.rb
-- spec/unit/equalizer/methods/equality_operator_spec.rb
-- spec/unit/equalizer/universal_spec.rb
-has_rdoc: 
+summary: Define equality, equivalence, and hashing methods for Ruby objects
+test_files: []

data/.gitignore

@@ -1,39 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## Rubinius
-*.rbc
-.rbx
-
-## PROJECT::GENERAL
-*.gem
-coverage
-profiling
-turbulence
-rdoc
-pkg
-tmp
-doc
-log
-.yardoc
-measurements
-
-## BUNDLER
-.bundle
-Gemfile.lock
-bin
-bundle
-
-## PROJECT::SPECIFIC

data/.rspec

@@ -1,6 +0,0 @@
---backtrace
---color
---format progress
---order random
---profile
---warnings

data/.ruby-gemset

@@ -1 +0,0 @@
-equalizer

data/.travis.yml

@@ -1,31 +0,0 @@
-before_install: gem update bundler
-cache: bundler
-sudo: false
-env:
-  global:
-    - JRUBY_OPTS="$JRUBY_OPTS --debug" # for simplecov
-language: ruby
-script: "bundle exec rake ci"
-rvm:
-  - 1.8.7
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-  - jruby-18mode
-  - jruby-19mode
-  - jruby-head
-  - rbx-2
-  - ree
-  - ruby-head
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-  fast_finish: true
-notifications:
-  irc:
-    channels:
-      - irc.freenode.org#rom-rb
-    on_success: never
-    on_failure: change

data/Gemfile

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-source 'https://rubygems.org'
-
-gem 'rake'
-
-group :test do
-  gem 'backports'
-  gem 'coveralls'
-  gem 'json',                    :platforms => [:ruby_19]
-  gem 'mime-types',  '~> 1.25',  :platforms => [:jruby, :ruby_18]
-  gem 'rest-client', '~> 1.6.0', :platforms => [:jruby, :ruby_18]
-  gem 'rspec',       '~> 3.0'
-  gem 'rubocop',     '>= 0.25',  :platforms => [:ruby_19, :ruby_20, :ruby_21, :ruby_22]
-  gem 'simplecov',   '>= 0.9'
-  gem 'yardstick'
-end
-
-gemspec