dry-equalizer 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 68e7a5819b71d2ffd60f4424d3b06e92710404a1a83b5fb1770f36530fee537e
+  data.tar.gz: fbaa5d489d993948159108249b42eaec44a144163ea73285cff6c88c0cec1dd0
+SHA512:
+  metadata.gz: 7951e751feca649d17457d9d95f18af296bac9a583ed5d3644edb9e926afcdd2187af0effec08723a580b3acadd9fbac3467bda3c90ef5863c417c14b1d9e22b
+  data.tar.gz: e09afaa53dcb1d775a634d453f3e3d9b015834a3d07e2ae3cfb2bedcb0cf9b37825da42e3cf8224f926c81eafd195d6b981700a2586c9e609bc9d37da331cf1f

data/.gitignore

@@ -0,0 +1,39 @@
+## 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

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

data/.travis.yml

@@ -0,0 +1,24 @@
+language: ruby
+cache: bundler
+bundler_args: --without benchmarks tools
+after_success:
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
+rvm:
+  - 2.2.10
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.1
+  - jruby-9.2.6.0
+env:
+  global:
+    - COVERAGE=true
+    - JRUBY_OPTS='--dev -J-Xmx1024M'
+notifications:
+  email: false
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/19098b4253a72c9796db
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

data/.yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+# v0.2.2 2019-03-08
+
+### Added
+
+* Generation of `#to_s` and `#inspect` can be disabled with `inspect: false` (flash-gordon)
+  ```ruby
+  class User
+    include Dry::Equalizer(:id, :name, :age, inspect: false)
+  end
+  ```
+
+[Compare v0.2.1...v0.2.2](https://github.com/dry-rb/dry-equalizer/compare/v0.2.1...v0.2.2)
+
+# v0.2.1 2018-04-26
+
+### Fixed
+
+* Including equalizer module with same keys multiple times won't cause duped keys in `inspect` output (radar)
+
+[Compare v0.2.0...v0.2.1](https://github.com/dry-rb/dry-equalizer/compare/v0.2.0...v0.2.1)
+
+# v0.2.0 2015-11-13
+
+Really make it work with MRI 2.0 again (it's Friday 13th OK?!)
+
+# v0.1.1 2015-11-13
+
+Make it work with MRI 2.0 again
+
+# v0.1.0 2015-11-11
+
+## Added
+
+- `Dry::Equalizer()` method accepting a list of keys (solnic)
+
+## Changed
+
+- `eql?` no longer tries to coerce `other` with `coerce` method (solnic)

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Issue Guidelines
+
+## Reporting bugs
+
+If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
+
+## Reporting feature requests
+
+Report a feature request **only after discussing it first on [discuss.dry-rb.org](https://discuss.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
+
+## Reporting questions, support requests, ideas, concerns etc.
+
+**PLEASE DON'T** - use [discuss.dry-rb.org](http://discuss.dry-rb.org) instead.
+
+# Pull Request Guidelines
+
+A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
+
+Other requirements:
+
+1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
+2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
+3) Add API documentation if it's a new feature
+4) Update API documentation if it changes an existing feature
+5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
+
+# Asking for help
+
+If these guidelines aren't helpful, and you're stuck, please post a message on [discuss.dry-rb.org](https://discuss.dry-rb.org).

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'bundler'
+  gem 'rake'
+  gem 'rspec', '~> 3.5'
+end
+
+group :test do
+  platform :mri do
+    gem "codeclimate-test-reporter", require: false
+    gem 'simplecov', require: false
+  end
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009-2013 Dan Kubb
+Copyright (c) 2012 Markus Schirp (packaging)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# dry-equalizer <a href="https://gitter.im/dry-rb/chat" target="_blank">![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)</a>
+
+Module to define equality, equivalence and inspection methods
+
+[![Gem Version](http://img.shields.io/gem/v/dry-equalizer.svg)][gem]
+[![Build Status](http://img.shields.io/travis/dry-rb/dry-equalizer.svg)][travis]
+[![Maintainability](https://api.codeclimate.com/v1/badges/5a9a139af1d4a80a28c4/maintainability)](https://codeclimate.com/github/dry-rb/dry-equalizer/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/5a9a139af1d4a80a28c4/test_coverage)](https://codeclimate.com/github/dry-rb/dry-equalizer/test_coverage)
+
+[gem]: https://rubygems.org/gems/dry-equalizer
+[travis]: https://travis-ci.org/dry-rb/dry-equalizer
+[codeclimate]: https://codeclimate.com/github/dry-rb/dry-equalizer
+
+Examples
+--------
+
+``` ruby
+class GeoLocation
+  include Dry::Equalizer(:latitude, :longitude)
+
+  attr_reader :latitude, :longitude
+
+  def initialize(latitude, longitude)
+    @latitude, @longitude = latitude, longitude
+  end
+end
+
+point_a = GeoLocation.new(1, 2)
+point_b = GeoLocation.new(1, 2)
+point_c = GeoLocation.new(2, 2)
+
+point_a.inspect    # => "#<GeoLocation latitude=1 longitude=2>"
+
+point_a == point_b           # => true
+point_a.hash == point_b.hash # => true
+point_a.eql?(point_b)        # => true
+point_a.equal?(point_b)      # => false
+
+point_a == point_c           # => false
+point_a.hash == point_c.hash # => false
+point_a.eql?(point_c)        # => false
+point_a.equal?(point_c)      # => false
+```
+
+Supported Ruby Versions
+-----------------------
+
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* MRI 2.2+
+* JRuby 9.x
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions or
+implementations, however support will only be provided for the implementations
+listed above.
+
+If you would like this library to support another Ruby version or
+implementation, you may volunteer to be a maintainer. Being a maintainer
+entails making sure all tests run and pass on that implementation. When
+something breaks on your implementation, you will be responsible for providing
+patches in a timely fashion. If critical issues for a particular implementation
+exist at the time of a major release, support for that Ruby version may be
+dropped.
+
+Credits
+-------
+
+This is a fork of the original [equalizer](https://github.com/dkubb/equalizer).
+
+* Dan Kubb ([dkubb](https://github.com/dkubb))
+* Piotr Solnica ([solnic](https://github.com/solnic))
+* Markus Schirp ([mbj](https://github.com/mbj))
+* Erik Michaels-Ober ([sferik](https://github.com/sferik))
+
+Contributing
+-------------
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+Copyright
+---------
+
+Copyright &copy; 2009-2013 Dan Kubb. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: [:spec]

data/dry-equalizer.gemspec

@@ -0,0 +1,19 @@
+require File.expand_path('../lib/dry/equalizer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'dry-equalizer'
+  gem.version     = Dry::Equalizer::VERSION.dup
+  gem.authors     = ['Dan Kubb', 'Markus Schirp']
+  gem.email       = %w[dan.kubb@gmail.com mbj@schirp-dso.com]
+  gem.description = 'Module to define equality, equivalence and inspection methods'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/dryrb/dry-equalizer'
+  gem.licenses    = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- spec/{unit,integration}`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.md CONTRIBUTING.md]
+
+  gem.required_ruby_version = '>= 2.0.0'
+end

data/lib/dry-equalizer.rb

@@ -0,0 +1 @@
+require 'dry/equalizer'

data/lib/dry/equalizer.rb

@@ -0,0 +1,127 @@
+module Dry
+  # Build an equalizer module for the inclusion in other class
+  #
+  # @api public
+  def self.Equalizer(*keys, **options)
+    Dry::Equalizer.new(*keys, **options)
+  end
+
+  # 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, inspect: true)
+      @keys = keys.uniq
+      define_methods(inspect: inspect)
+      freeze
+    end
+
+    private
+
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module or class including Equalizer
+    #
+    # @return [self]
+    #
+    # @api private
+    def included(descendant)
+      super
+      descendant.send(:include, Methods)
+    end
+
+    # Define the equalizer methods based on #keys
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_methods(inspect: true)
+      define_cmp_method
+      define_hash_method
+      define_inspect_method if inspect
+    end
+
+    # Define an #cmp? method based on the instance's values identified by #keys
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_cmp_method
+      keys = @keys
+      define_method(:cmp?) do |comparator, other|
+        keys.all? do |key|
+          __send__(key).public_send(comparator, other.__send__(key))
+        end
+      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.map(&method(:send)).push(self.class).hash
+      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.map { |key| " #{key}=#{__send__(key).inspect}" }.join}>"
+      end
+    end
+
+    # The comparison methods
+    module Methods
+      # Compare the object with other object for equality
+      #
+      # @example
+      #   object.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) && cmp?(__method__, other)
+      end
+
+      # Compare the object with other object for equivalency
+      #
+      # @example
+      #   object == other  # => true or false
+      #
+      # @param [Object] other
+      #   the other object to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        other.is_a?(self.class) && cmp?(__method__, other)
+      end
+    end # module Methods
+  end # class Equalizer
+end

data/lib/dry/equalizer/version.rb

@@ -0,0 +1,6 @@
+module Dry
+  class Equalizer < Module
+    # Gem version
+    VERSION = '0.2.2'.freeze
+  end # class Equalizer
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
+  require 'yaml'
+  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
+  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
+
+  if RUBY_VERSION == latest_mri
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/spec/'
+    end
+  end
+end
+
+require 'dry-equalizer'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
+
+  config.warnings = true
+end

data/spec/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/unit/equalizer/included_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe Dry::Equalizer, '#included' do
+  subject { descendant.instance_exec(object) { |mod| include mod } }
+
+  let(:object)     { described_class.new        }
+  let(:descendant) { Class.new                  }
+  let(:superclass) { described_class.superclass }
+
+  before do
+    # Prevent Module.included from being called through inheritance
+    allow(described_class::Methods).to receive(:included)
+  end
+
+  around do |example|
+    # Restore included method after each example
+    superclass.class_eval do
+      alias_method :original_included, :included
+      example.call
+      undef_method :included
+      alias_method :included, :original_included
+    end
+  end
+
+  it 'delegates to the superclass #included method' do
+    # This is the most succinct approach I could think of to test whether the
+    # superclass#included method is called. All of the built-in rspec helpers
+    # did not seem to work for this.
+    included = false
+
+    superclass.class_eval do
+      define_method(:included) do |_|
+        # Only set the flag when an Dry::Equalizer instance is included.
+        # Otherwise, other module includes (which get triggered internally
+        # in RSpec when `change` is used for the first time, since it uses
+        # autoloading for its matchers) will wrongly set this flag.
+        included = true if self.kind_of?(Dry::Equalizer)
+      end
+    end
+
+    expect { subject }.to change { included }.from(false).to(true)
+  end
+
+  it 'includes methods into the descendant' do
+    subject
+    expect(descendant.included_modules).to include(described_class::Methods)
+  end
+end

data/spec/unit/equalizer/methods/eql_predicate_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe Dry::Equalizer::Methods, '#eql?' do
+  subject { object.eql?(other) }
+
+  let(:object) { described_class.new(true) }
+
+  let(:described_class) do
+    Class.new do
+      include Dry::Equalizer::Methods
+
+      attr_reader :boolean
+
+      def initialize(boolean)
+        @boolean = boolean
+      end
+
+      def cmp?(comparator, other)
+        boolean.send(comparator, other.boolean)
+      end
+    end
+  end
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(true) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+
+  context 'with a different object' do
+    let(:other) { described_class.new(false) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

data/spec/unit/equalizer/methods/equality_operator_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe Dry::Equalizer::Methods, '#==' do
+  subject { object == other }
+
+  let(:object)          { described_class.new(true) }
+  let(:described_class) { Class.new(super_class)    }
+
+  let(:super_class) do
+    Class.new do
+      include Dry::Equalizer::Methods
+
+      attr_reader :boolean
+
+      def initialize(boolean)
+        @boolean = boolean
+      end
+
+      def cmp?(comparator, other)
+        boolean.send(comparator, other.boolean)
+      end
+    end
+  end
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with a subclass instance having equivalent obervable state' do
+    let(:other) { Class.new(described_class).new(true) }
+
+    it { should be(true) }
+
+    it 'is not symmetric' do
+      # the subclass instance should maintain substitutability with the object
+      # (in the LSP sense) the reverse is not true.
+      should_not eql(other == object)
+    end
+  end
+
+  context 'with a superclass instance having equivalent observable state' do
+    let(:other) { super_class.new(true) }
+
+    it { should be(false) }
+
+    it 'is not symmetric' do
+      should_not eql(other == object)
+    end
+  end
+
+  context 'with an object of another class' do
+    let(:other) { Class.new.new }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with a different object' do
+    let(:other) { described_class.new(false) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+end

data/spec/unit/equalizer/universal_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+RSpec.describe Dry::Equalizer do
+  let(:name)   { 'User'          }
+  let(:klass)  { ::Class.new     }
+
+  context 'with no keys' do
+    subject { Dry::Equalizer() }
+
+    before do
+      # specify the class #name method
+      allow(klass).to receive(:name).and_return(name)
+      klass.include(subject)
+    end
+
+    let(:instance) { klass.new }
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+
+    it 'defines #hash and #inspect methods dynamically' do
+      expect(subject.public_instance_methods(false).map(&:to_s).sort)
+        .to eql(%w[hash inspect])
+    end
+
+    describe '#eql?' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { expect(instance.eql?(other)).to be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { double('other') }
+
+        it { expect(instance.eql?(other)).to be(false) }
+      end
+    end
+
+    describe '#==' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { expect(instance == other).to be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { double('other') }
+
+        it { expect(instance == other).to be(false) }
+      end
+    end
+
+    describe '#hash' do
+      it 'has the expected arity' do
+        expect(klass.instance_method(:hash).arity).to be(0)
+      end
+
+      it { expect(instance.hash).to eql([klass].hash) }
+    end
+
+    describe '#inspect' do
+      it 'has the expected arity' do
+        expect(klass.instance_method(:inspect).arity).to be(0)
+      end
+
+      it { expect(instance.inspect).to eql('#<User>') }
+    end
+  end
+
+  context 'with keys' do
+    subject { Dry::Equalizer(*keys) }
+
+    let(:keys)       { %i[firstname lastname].freeze  }
+    let(:firstname)  { 'John'                         }
+    let(:lastname)   { 'Doe'                          }
+    let(:instance)   { klass.new(firstname, lastname) }
+
+    let(:klass) do
+      ::Class.new do
+        attr_reader :firstname, :lastname
+        private :firstname, :lastname
+
+        def initialize(firstname, lastname)
+          @firstname = firstname
+          @lastname = lastname
+        end
+      end
+    end
+
+    before do
+      # specify the class #inspect method
+      allow(klass).to receive_messages(name: nil, inspect: name)
+      klass.include(subject)
+    end
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+
+    it 'defines #hash and #inspect methods dynamically' do
+      expect(subject.public_instance_methods(false).map(&:to_s).sort)
+        .to eql(%w[hash inspect])
+    end
+
+    describe '#eql?' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { expect(instance.eql?(other)).to be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { double('other') }
+
+        it { expect(instance.eql?(other)).to be(false) }
+      end
+    end
+
+    describe '#==' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { expect(instance == other).to be(true) }
+      end
+
+      context 'when the objects are different type' do
+        let(:other) { klass.new('Foo', 'Bar') }
+
+        it { expect(instance == other).to be(false) }
+      end
+
+      context 'when the objects are from different type' do
+        let(:other) { double('other') }
+
+        it { expect(instance == other).to be(false) }
+      end
+    end
+
+    describe '#hash' do
+      it 'returns the expected hash' do
+        expect(instance.hash)
+          .to eql([firstname, lastname, klass].hash)
+      end
+    end
+
+    describe '#inspect' do
+      it 'returns the expected string' do
+        expect(instance.inspect)
+          .to eql('#<User firstname="John" lastname="Doe">')
+      end
+    end
+  end
+
+  context 'with duplicate keys' do
+    subject { Dry::Equalizer(*keys) }
+
+    let(:keys)       { %i[firstname firstname lastname].freeze  }
+    let(:firstname)  { 'John'                                   }
+    let(:lastname)   { 'Doe'                                    }
+    let(:instance)   { klass.new(firstname, lastname)           }
+
+    let(:klass) do
+      ::Class.new do
+        attr_reader :firstname, :lastname
+        private :firstname, :lastname
+
+        def initialize(firstname, lastname)
+          @firstname = firstname
+          @lastname = lastname
+        end
+      end
+    end
+
+    before do
+      # specify the class #inspect method
+      allow(klass).to receive_messages(name: nil, inspect: name)
+      klass.include(subject)
+    end
+
+    it { should be_instance_of(described_class) }
+
+    it { should be_frozen }
+
+    describe '#inspect' do
+      it 'returns the expected string' do
+        expect(instance.inspect)
+          .to eql('#<User firstname="John" lastname="Doe">')
+      end
+    end
+  end
+
+  context 'with options' do
+    context 'w/o inspect' do
+      subject { Dry::Equalizer(*keys, inspect: false) }
+
+      let(:keys)       { %i[firstname lastname].freeze  }
+      let(:firstname)  { 'John'                         }
+      let(:lastname)   { 'Doe'                          }
+      let(:instance)   { klass.new(firstname, lastname) }
+
+      let(:klass) do
+        ::Struct.new(:firstname, :lastname)
+      end
+
+      before { klass.include(subject) }
+
+      describe '#inspect' do
+        it 'returns the default string' do
+          expect(instance.inspect).to eql('#<struct firstname="John", lastname="Doe">')
+          expect(instance.to_s).to eql('#<struct firstname="John", lastname="Doe">')
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: dry-equalizer
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Dan Kubb
+- Markus Schirp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-09 00:00:00.000000000 Z
+dependencies: []
+description: Module to define equality, equivalence and inspection methods
+email:
+- dan.kubb@gmail.com
+- mbj@schirp-dso.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- CONTRIBUTING.md
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardstick.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dry-equalizer.gemspec
+- lib/dry-equalizer.rb
+- lib/dry/equalizer.rb
+- lib/dry/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
+homepage: https://github.com/dryrb/dry-equalizer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+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