equatable 0.2.0 → 0.3.0

data/README.md

@@ -1,5 +1,5 @@
 # Equatable
-[![Build Status](https://secure.travis-ci.org/peter-murach/equatable.png?branch=master)][travis] [![Code Climate](https://codeclimate.com/badge.png)][codeclimate]
+[![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
@@ -51,7 +51,9 @@ It is assumed that your objects are value objects and the only values that affec
 
 ```
 
-It is important that the attribute readers should allow for performing deterministic computations on class instances.
+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.
 
 ## Contributing
 

data/lib/equatable.rb

@@ -130,7 +130,7 @@ module Equatable
     #
     # @api public
     def eql?(other)
-      instance_of?(other.class) and compare?(__method__, other)
+      instance_of?(other.class) && compare?(__method__, other)
     end
 
     # Compare two objects for equality based on their value
@@ -143,8 +143,7 @@ module Equatable
     #
     # @api public
     def ==(other)
-      return false unless self.class <=> other.class
-      compare?(__method__, other)
+      kind_of?(other.class) && compare?(__method__, other)
     end
 
   end # Methods

data/lib/equatable/version.rb

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

data/spec/equatable/eql_spec.rb

@@ -2,205 +2,53 @@
 
 require 'spec_helper'
 
-describe Equatable do
+describe Equatable, '#eql?' do
   let(:name) { 'Value' }
+  let(:value) { 11 }
 
-  context 'without attributes' do
-    let(:klass) { ::Class.new }
+  let(:klass) {
+    ::Class.new do
+      include Equatable
 
-    subject { klass.new }
+      attr_reader :value
 
-    before {
-      klass.stub(:name).and_return 'Value'
-      klass.send :include, described_class
-    }
-
-    it { should respond_to :compare? }
-
-    it { should be_instance_of klass }
-
-    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 }
+      def initialize(value)
+        @value = value
       end
     end
+  }
 
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { (subject == other).should be_true }
-      end
+  let(:object) { klass.new(value) }
 
-      context 'when objects are different' do
-        let(:other) { stub('other') }
+  subject { object.eql?(other) }
 
-        it { (subject == other)}
-      end
-    end
+  context 'with the same object' do
+    let(:other) { object }
 
-    describe '#inspect' do
-      it { subject.inspect.should eql('#<Value>') }
-    end
+    it { should be_true }
 
-    describe '#hash' do
-      it { subject.hash.should eql([klass].hash) }
+    it 'is symmetric' do
+      should eql(other.eql?(object))
     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 }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
-      it 'is not equal to nil reference' do
-         subject.eql?(nil).should be_false
-      end
-
-      it 'is reflexive' do
-        subject.eql?(subject).should be_true
-      end
-
-      it 'is symmetric' do
-        (subject.eql?(other)).should eql( other.eql?(subject) )
-      end
+    it { should be_true }
 
-      it 'is transitive'
+    it 'is symmetric' do
+      should eql(other.eql?(object))
     end
   end
 
-  context '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
-    }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { ::Class.new(klass).new(value) }
 
-    subject { subclass.new(value) }
+    it { should be_false }
 
-    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
+    it 'is symmetric' do
+      should eql(other.eql?(object))
     end
   end
-
 end

data/spec/equatable/equal_spec.rb

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

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: equatable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-28 00:00:00.000000000 Z
+date: 2013-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2160246200 !ruby/object:Gem::Requirement
+  requirement: &2160139560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160246200
+  version_requirements: *2160139560
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2160245720 !ruby/object:Gem::Requirement
+  requirement: &2160138980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160245720
+  version_requirements: *2160138980
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2160245260 !ruby/object:Gem::Requirement
+  requirement: &2160138280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160245260
+  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.
@@ -65,6 +65,9 @@ files:
 - 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: []
@@ -92,5 +95,8 @@ 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: