equatable 0.3.0 → 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 260460daef33f12a7c0995243cf628bbd2eb81f9e42f0bf00a7b0d226e91eadf
+  data.tar.gz: f38cd2a3d53cabb2f9fdbaa8c4e446be59aecc08b6121385acf4de2d5c72d116
+SHA512:
+  metadata.gz: 4b7074a4d0d50f379e5831530ea473745b9a22257d0583d67d974830998f9e85d5418cedb37990ff6e5a1607556626343746025e2e3c937a93e7217b0a662daa
+  data.tar.gz: 9e980c6ee681d0e359200803502f0a17c6be5a655a863cf6fd9de5fea17b2419f71a7eb5b6ccea6c4bcd729327f1d3653bd8f98c60b2a0c0aa39ba3776f03381

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change log
+
+## [v0.7.0] - 2021-04-05
+
+### Changed
+* Change gemspec to remove test and rake files to reduce gem size
+* Change to remove bundler as a dev dependency and relax rspec upper constraint
+* Change to require Ruby 2.0 or higher
+
+## [v0.6.1] - 2019-06-26
+
+### Added
+* Add license key to gemspec
+
+## [v0.6.0] - 2019-06-16
+
+### Added
+* Add dev dependencies to gemspec
+
+### Changed
+* Change to limit Ruby >= 1.8.7
+* Change gemspec to load files directly instead of git
+
+## [v0.1.0] - 2012-12-09
+
+* Initial implementation and release
+
+[v0.7.0]: https://github.com/piotrmurach/equatable/compare/v0.6.1...v0.7.0
+[v0.6.1]: https://github.com/piotrmurach/equatable/compare/v0.6.0...v0.6.1
+[v0.6.0]: https://github.com/piotrmurach/equatable/compare/v0.5.0...v0.6.0
+[v0.5.0]: https://github.com/piotrmurach/equatable/compare/v0.4.0...v0.5.0
+[v0.4.0]: https://github.com/piotrmurach/equatable/compare/v0.3.0...v0.4.0
+[v0.3.0]: https://github.com/piotrmurach/equatable/compare/v0.2.0...v0.3.0
+[v0.2.0]: https://github.com/piotrmurach/equatable/compare/v0.1.0...v0.2.0
+[v0.1.0]: https://github.com/piotrmurach/equatable/compare/v0.1.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Piotr Murach
+Copyright (c) 2012 Piotr Murach (piotrmurach.com)
 
 MIT License
 
@@ -19,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,18 +1,28 @@
 # Equatable
-[![Gem Version](https://badge.fury.io/rb/equatable.png)](http://badge.fury.io/rb/equatable) [![Build Status](https://secure.travis-ci.org/peter-murach/equatable.png?branch=master)][travis] [![Code Climate](https://codeclimate.com/badge.png)][codeclimate]
 
-[travis]: http://travis-ci.org/peter-murach/equatable
-[codeclimate]: https://codeclimate.com/github/peter-murach/equatable
+[![Gem Version](https://badge.fury.io/rb/equatable.svg)][gem]
+[![Actions CI](https://github.com/piotrmurach/equatable/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
+[![Build status](https://ci.appveyor.com/api/projects/status/lsb02nm0g4c6guiu?svg=true)][appveyor]
+[![Code Climate](https://codeclimate.com/github/piotrmurach/equatable/badges/gpa.svg)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/equatable/badge.svg)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/equatable.svg?branch=master)][inchpages]
 
-Allows ruby objects to implement equality comparison and inspection methods.
+[gem]: http://badge.fury.io/rb/equatable
+[gh_actions_ci]: https://github.com/piotrmurach/equatable/actions?query=workflow%3ACI
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/equatable
+[codeclimate]: https://codeclimate.com/github/piotrmurach/equatable
+[coverage]: https://coveralls.io/github/piotrmurach/equatable
+[inchpages]: http://inch-ci.org/github/piotrmurach/equatable
 
-By including this module, a class indicates that its instances have explicit general contracts for `hash`, `==` and `eql?` methods. Specifically `eql?` contract requires that it implements an equivalence relation. By default each instance of the class is equal only to itself. This is a right behaviour when you have distinct objects. Howerver, it is the responsibility of any class to clearly define their equality. Failure to do so may prevent instances to behave as expected when for instance `Array#uniq` is invoked or when they are used as `Hash` keys.
+> Provide equality comparison methods for objects based on their attributes.
+
+By including this module, a class indicates that its instances have explicit general contracts for `==`, `eql?` and `hash` methods. Specifically the `eql?` contract requires that it implements an equivalence relation. By default, each instance of a class is equal only to itself. This is the right behaviour when you have distinct objects. However, it is the responsibility of any class to clearly define its equality. Failure to do so may prevent instances from behaving as expected when tested for uniqueness in Array#uniq or when used as Hash keys.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'equatable'
+    gem "equatable"
 
 And then execute:
 
@@ -27,33 +37,63 @@ Or install it yourself as:
 It is assumed that your objects are value objects and the only values that affect equality comparison are the ones specified by your attribute readers. Each attribute reader should be a significant field in determining objects values.
 
 ```ruby
-  class Value
-    include Equatable
+class Point
+  include Equatable
 
-    attr_reader :value
+  attr_reader :x, :y
 
-    def initialize(value)
-      @value = value
-    end
+  def initialize(x, y)
+    @x, @y = x, y
   end
+end
 
-  val1 = Value.new(11)
-  val2 = Value.new(11)
-  val3 = Value.new(13)
+point_1 = Point.new(1, 1)
+point_2 = Point.new(1, 1)
+point_3 = Point.new(1, 2)
 
-  val1 == val2            # => true
-  val1.hash == val2.hash  # => true
-  val1 eql? val2          # => true
+point_1 == point_2            # => true
+point_1.hash == point_2.hash  # => true
+point_1.eql?(point_2)         # => true
+point_1.equal?(point_2)       # => false
 
-  val1 == val3            # => false
-  val1.hash == val3.hash  # => false
-  val1 eql? val3          # => false
+point_1 == point_3            # => false
+point_1.hash == point_3.hash  # => false
+point_1.eql?(point_3)         # => false
+point_1.equal?(point_3)       # => false
 
+point_1.inspect  # => "#<Point x=1 y=1>"
 ```
 
+## Attributes
+
 It is important that the attribute readers should allow for performing deterministic computations on class instances. Therefore you should avoid specifying attributes that depend on unreliable resources like IP address that require network access.
 
-Note that adding a extra attr reader to a subclass will violate the equivalence contract.
+## Subtypes
+
+**Equatable** ensures that any important property of a type holds for its subtypes. However, please note that adding an extra attribute reader to a subclass will violate the equivalence contract, namely, the superclass will be equal to the subclass but reverse won't be true. For example:
+
+```ruby
+class ColorPoint < Point
+  attr_reader :color
+
+  def initialize(x, y, color)
+    super(x, y)
+    @color = color
+  end
+end
+
+point = Point.new(1, 1)
+color_point = ColorPoint.new(1, 1, :red)
+
+point == color_point            # => true
+color_point == point            # => false
+
+point.hash == color_point.hash  # => false
+point.eql?(color_point)         # => false
+point.equal?(color_point)       # => false
+```
+
+The `ColorPoint` class demonstrates that extending a class with extra value property does not preserve the `equals` contract.
 
 ## Contributing
 
@@ -63,6 +103,10 @@ Note that adding a extra attr reader to a subclass will violate the equivalence
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
+## Code of Conduct
+
+Everyone interacting in the Equatable project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/equatable/blob/master/CODE_OF_CONDUCT.md).
+
 ## Copyright
 
-Copyright (c) 2012-2013 Piotr Murach. See LICENSE for further details.
+Copyright (c) 2012 Piotr Murach. See LICENSE for further details.

data/lib/equatable.rb

@@ -1,10 +1,9 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require "equatable/version"
 
 # Make it easy to define equality and hash methods.
 module Equatable
-
   # Hook into module inclusion.
   #
   # @param [Module] base
@@ -17,11 +16,9 @@ module Equatable
     super
     base.extend(self)
     base.class_eval do
-      define_comparison_attrs
       include Methods
       define_methods
     end
-    self
   end
 
   # Holds all attributes used for comparison.
@@ -42,7 +39,7 @@ module Equatable
   # @api public
   def attr_reader(*args)
     super
-    @comparison_attrs.concat(args)
+    comparison_attrs.concat(args)
   end
 
   # Copy the comparison_attrs into the subclass.
@@ -57,24 +54,25 @@ module Equatable
 
   private
 
-  # Define class instance #comparison_attrs as an empty array.
+  # Define all methods needed for ensuring object's equality.
   #
   # @return [undefined]
   #
   # @api private
-  def define_comparison_attrs
-    instance_variable_set('@comparison_attrs', [])
+  def define_methods
+    define_comparison_attrs
+    define_compare
+    define_hash
+    define_inspect
   end
 
-  # Define all methods needed for ensuring object's equality.
+  # Define class instance #comparison_attrs as an empty array.
   #
   # @return [undefined]
   #
   # @api private
-  def define_methods
-    define_compare
-    define_hash
-    define_inspect
+  def define_comparison_attrs
+    instance_variable_set("@comparison_attrs", [])
   end
 
   # Define a #compare? method to check if the receiver is the same
@@ -86,8 +84,10 @@ module Equatable
   def define_compare
     define_method(:compare?) do |comparator, other|
       klass = self.class
-      attrs = klass.comparison_attrs || []
-      attrs.all? { |attr| send(attr).send(comparator, other.send(attr)) }
+      attrs = klass.comparison_attrs
+      attrs.all? do |attr|
+        other.respond_to?(attr) && send(attr).send(comparator, other.send(attr))
+      end
     end
   end
 
@@ -98,8 +98,8 @@ module Equatable
   def define_hash
     define_method(:hash) do
       klass = self.class
-      attrs = klass.comparison_attrs || []
-      ([klass] + attrs.map { |attr| send(attr)}).hash
+      attrs = klass.comparison_attrs
+      ([klass] + attrs.map { |attr| send(attr) }).hash
     end
   end
 
@@ -112,14 +112,14 @@ module Equatable
   def define_inspect
     define_method(:inspect) do
       klass = self.class
-      name = klass.name || klass.inspect
-      attrs = klass.comparison_attrs || []
+      name  = klass.name || klass.inspect
+      attrs = klass.comparison_attrs
       "#<#{name}#{attrs.map { |attr| " #{attr}=#{send(attr).inspect}" }.join}>"
     end
   end
 
+  # The equality methods
   module Methods
-
     # Compare two objects for equality based on their value
     # and being an instance of the given class.
     #
@@ -143,8 +143,7 @@ module Equatable
     #
     # @api public
     def ==(other)
-      kind_of?(other.class) && compare?(__method__, other)
+      other.is_a?(self.class) && compare?(__method__, other)
     end
-
   end # Methods
 end # Equatable

data/lib/equatable/version.rb

@@ -1,5 +1,5 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
 module Equatable
-  VERSION = "0.3.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,102 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: equatable
 version: !ruby/object:Gem::Version
-  version: 0.3.0
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-03 00:00:00.000000000 Z
+date: 2021-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &2160139560 !ruby/object:Gem::Requirement
-    none: false
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160139560
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2160138980 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2160138980
 - !ruby/object:Gem::Dependency
-  name: yard
-  requirement: &2160138280 !ruby/object:Gem::Requirement
-    none: false
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *2160138280
-description: Allows ruby objects to implement equality comparison and inspection methods.
-  By including this module, a class indicates that its instances have explicit general
-  contracts for `hash`, `==` and `eql?` methods.
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Provide equality comparison methods for objects based on their attributes
+  by generating implementations for the ==, eql?, hash and inspect methods.
 email:
-- ''
+- piotr@piotrmurach.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENSE.txt
 files:
-- .gitignore
-- .rspec
-- .rvmrc
-- .travis.yml
-- Gemfile
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- equatable.gemspec
 - lib/equatable.rb
 - lib/equatable/version.rb
-- spec/equatable/eql_spec.rb
-- spec/equatable/equal_spec.rb
-- spec/equatable/include_spec.rb
-- spec/equatable/subclass_spec.rb
-- spec/spec_helper.rb
-homepage: http://github.com/peter-murach/equatable
-licenses: []
+homepage: https://github.com/piotrmurach/equatable
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/piotrmurach/equatable/issues
+  changelog_uri: https://github.com/piotrmurach/equatable/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/github/piotrmurach/equatable
+  homepage_uri: https://github.com/piotrmurach/equatable
+  source_code_uri: https://github.com/piotrmurach/equatable
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 3.1.2
 signing_key: 
-specification_version: 3
-summary: Allows ruby objects to implement equality comparison and inspection methods.
-test_files:
-- spec/equatable/eql_spec.rb
-- spec/equatable/equal_spec.rb
-- spec/equatable/include_spec.rb
-- spec/equatable/subclass_spec.rb
-- spec/spec_helper.rb
-has_rdoc: 
+specification_version: 4
+summary: Provide equality comparison methods for objects based on their attributes.
+test_files: []

data/.gitignore

@@ -1,18 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.sw*

data/.rspec

@@ -1,2 +0,0 @@
---color
--f s

data/.rvmrc

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-
-environment_id="ruby-1.9.3-p0@equatable"
-
-#
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-#
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-
-  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
-  then
-    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
-  fi
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  if ! rvm --create  "$environment_id"
-  then
-    echo "Failed to create RVM environment '${environment_id}'."
-    return 1
-  fi
-fi
-
-if [[ $- == *i* ]] # check for interactive shells
-then
-    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
-else 
-	echo "Using: $GEM_HOME" # don't use colors in interactive shells
-fi

data/.travis.yml

@@ -1,20 +0,0 @@
-language: ruby
-before_install:
-  - gem install bundler
-rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - ruby-head
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
-  - ree
-  - jruby-head
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-    - rvm: jruby-19mode
-    - rvm: rbx-19mode

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Rakefile

@@ -1,12 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.unshift File.expand_path('../lib', __FILE__)
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-FileList['tasks/**/*.rake'].each { |task| import task }
-
-task :default => [:spec]

data/equatable.gemspec

@@ -1,23 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'equatable/version'
-
-Gem::Specification.new do |gem|
-  gem.name          = "equatable"
-  gem.version       = Equatable::VERSION
-  gem.authors       = ["Piotr Murach"]
-  gem.email         = [""]
-  gem.description   = %q{Allows ruby objects to implement equality comparison and inspection methods. By including this module, a class indicates that its instances have explicit general contracts for `hash`, `==` and `eql?` methods.}
-  gem.summary       = %q{Allows ruby objects to implement equality comparison and inspection methods.}
-  gem.homepage      = "http://github.com/peter-murach/equatable"
-
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'yard'
-end

data/spec/equatable/eql_spec.rb

@@ -1,54 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Equatable, '#eql?' do
-  let(:name) { 'Value' }
-  let(:value) { 11 }
-
-  let(:klass) {
-    ::Class.new do
-      include Equatable
-
-      attr_reader :value
-
-      def initialize(value)
-        @value = value
-      end
-    end
-  }
-
-  let(:object) { klass.new(value) }
-
-  subject { object.eql?(other) }
-
-  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(klass).new(value) }
-
-    it { should be_false }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-end

data/spec/equatable/equal_spec.rb

@@ -1,76 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Equatable, '#==' do
-  let(:name) { 'Value' }
-  let(:value) { 11 }
-
-  let(:super_klass) {
-    ::Class.new do
-      include Equatable
-
-      attr_reader :value
-
-      def initialize(value)
-        @value = value
-      end
-    end
-  }
-
-  let(:klass) { Class.new(super_klass) }
-
-  let(:object) { klass.new(value) }
-
-  subject { object == other }
-
-  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 an equivalent object of a subclass' do
-    let(:other) { ::Class.new(klass).new(value) }
-
-    it { should be_false }
-
-    it 'is not symmetric' do
-      should_not eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object of a superclass' do
-    let(:other) { super_klass.new(value) }
-
-    it { should be_true }
-
-    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
-end

data/spec/equatable/include_spec.rb

@@ -1,170 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Equatable, '#include' do
-  let(:name) { 'Value' }
-  let(:object) { described_class }
-
-  context 'without attributes' do
-    let(:klass) { ::Class.new }
-
-    subject { klass.new }
-
-    before {
-      klass.stub(:name).and_return name
-      klass.send(:include, object)
-    }
-
-    it { should respond_to :compare? }
-
-    it { should be_instance_of klass }
-
-    describe '#inspect' do
-      it { subject.inspect.should eql('#<Value>') }
-    end
-
-    describe '#hash' do
-      it { subject.hash.should eql([klass].hash) }
-    end
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { subject.eql?(other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { subject.eql?(other).should be_false }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { (subject == other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { (subject == other)}
-      end
-    end
-
-    context 'equivalence relation' do
-      let(:other) { subject.dup }
-      let(:another) { other.dup }
-
-      it 'is not equal to nil reference' do
-         expect(subject.eql?(nil)).to be_false
-      end
-
-      it 'is reflexive' do
-        expect(subject.eql?(subject)).to be_true
-      end
-
-      it 'is symmetric' do
-        expect(subject.eql?(other)).to eql( other.eql?(subject) )
-      end
-
-      it 'is transitive' do
-        expect(subject.eql?(other) && other.eql?(another)).to eql(subject.eql?(another))
-      end
-    end
-  end
-
-  context 'with attributes' do
-    let(:value) { 11 }
-    let(:klass) {
-      ::Class.new do
-        include Equatable
-
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-    }
-
-    before {
-      klass.stub(:name).and_return name
-    }
-
-    subject { klass.new(value) }
-
-    it 'dynamically defines #hash method' do
-      klass.method_defined?(:hash).should be_true
-    end
-
-    it 'dynamically defines #inspect method' do
-      klass.method_defined?(:inspect).should be_true
-    end
-
-    it { should respond_to :compare? }
-
-    it { should respond_to :eql? }
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { subject.eql?(other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { subject.eql?(other).should be_false }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { (subject == other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { (subject == other).should be_false }
-      end
-    end
-
-    describe '#inspect' do
-      it { subject.inspect.should eql('#<Value value=11>') }
-    end
-
-    describe '#hash' do
-      it { subject.hash.should eql( ([klass] + [value]).hash) }
-    end
-
-    context 'equivalence relation' do
-      let(:other) { subject.dup }
-      let(:another) { other.dup }
-
-      it 'is not equal to nil reference' do
-         expect(subject.eql?(nil)).to be_false
-      end
-
-      it 'is reflexive' do
-        expect(subject.eql?(subject)).to be_true
-      end
-
-      it 'is symmetric' do
-        expect(subject.eql?(other)).to eql( other.eql?(subject) )
-      end
-
-      it 'is transitive' do
-        expect(subject.eql?(other) && other.eql?(another)).to eql(subject.eql?(another))
-      end
-    end
-  end
-end

data/spec/equatable/subclass_spec.rb

@@ -1,66 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Equatable, 'subclass' do
-  let(:name) { 'Value' }
-
-  context 'when subclass' do
-    let(:value) { 11 }
-    let(:klass) {
-      ::Class.new do
-        include Equatable
-
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-    }
-    let(:subclass) { ::Class.new(klass) }
-
-    before {
-      klass.stub(:name).and_return name
-    }
-
-    subject { subclass.new(value) }
-
-    it { subclass.superclass.should == klass }
-
-    it { should respond_to :value }
-
-    describe '#inspect' do
-      it { subject.inspect.should eql('#<Value value=11>') }
-    end
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { subject.eql?(other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { subject.eql?(other).should be_false }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { (subject == other).should be_true }
-      end
-
-      context 'when objects are different' do
-        let(:other) { stub('other') }
-
-        it { (subject == other)}
-      end
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'rspec'
-require 'equatable'
-
-RSpec.configure do |config|
-  config.order = :rand
-end