equalizer 0.0.10 → 1.0.0

data/config/rubocop.yml

@@ -1,54 +0,0 @@
-Metrics/BlockNesting:
-  Max: 2
-
-Metrics/LineLength:
-  AllowURI: true
-  Enabled: false
-
-Metrics/MethodLength:
-  CountComments: false
-  Max: 15
-
-Metrics/ParameterLists:
-  Max: 4
-  CountKeywordArgs: true
-
-Style/AccessModifierIndentation:
-  EnforcedStyle: outdent
-
-Style/CollectionMethods:
-  PreferredMethods:
-    map:      'collect'
-    reduce:   'inject'
-    find:     'detect'
-    find_all: 'select'
-
-Style/Documentation:
-  Enabled: false
-
-Style/DotPosition:
-  EnforcedStyle: trailing
-
-Style/DoubleNegation:
-  Enabled: false
-
-Style/EachWithObject:
-  Enabled: false
-
-Style/Encoding:
-  Enabled: false
-
-Style/HashSyntax:
-  EnforcedStyle: hash_rockets
-
-Style/Lambda:
-  Enabled: false
-
-Style/RaiseArgs:
-  EnforcedStyle: compact
-
-Style/SpaceInsideHashLiteralBraces:
-  EnforcedStyle: no_space
-
-Style/TrailingComma:
-  EnforcedStyleForMultiline: 'comma'

data/equalizer.gemspec

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../lib/equalizer/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.name        = 'equalizer'
-  gem.version     = 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/dkubb/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 = '>= 1.8.7'
-
-  gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
-end

data/lib/equalizer/version.rb

@@ -1,6 +0,0 @@
-# encoding: utf-8
-
-class Equalizer < Module
-  # Gem version
-  VERSION = '0.0.10'.freeze
-end # class Equalizer

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-
-  SimpleCov.start do
-    command_name 'spec:unit'
-
-    add_filter 'config'
-    add_filter 'spec'
-    add_filter 'vendor'
-
-    minimum_coverage 100
-  end
-end
-
-require 'equalizer'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expect_with|
-    expect_with.syntax = :expect
-  end
-end

data/spec/support/config_alias.rb

@@ -1,5 +0,0 @@
-# encoding: utf-8
-
-require 'rbconfig'
-
-::Config = RbConfig unless defined?(::Config)

data/spec/unit/equalizer/included_spec.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 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
-    described_class::Methods.stub(: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 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.is_a?(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

@@ -1,65 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Equalizer::Methods, '#eql?' do
-  subject { object.eql?(other) }
-
-  let(:object) { described_class.new(true) }
-
-  let(:described_class) do
-    Class.new do
-      include 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

@@ -1,108 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 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 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 an equivalent object after coercion' do
-    let(:other) { Object.new }
-
-    before do
-      # declare a private #coerce method
-      described_class.class_eval do
-        def coerce(other)
-          [self.class.new(!!other), self]
-        end
-        private :coerce
-      end
-    end
-
-    it { should be(true) }
-
-    it 'is not symmetric' do
-      should_not 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

@@ -1,158 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Equalizer, '.new' do
-  let(:object) { described_class }
-  let(:name)   { 'User'          }
-  let(:klass)  { ::Class.new     }
-
-  context 'with no keys' do
-    subject { object.new }
-
-    before do
-      # specify the class #name method
-      klass.stub(:name).and_return(name)
-      klass.send(:include, subject)
-    end
-
-    let(:instance) { klass.new }
-
-    it { should be_instance_of(object) }
-
-    it { should be_frozen }
-
-    it 'defines #hash and #inspect methods dynamically' do
-      expect(subject.public_instance_methods(false).collect(&: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 { object.new(*keys) }
-
-    let(:keys)       { [: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, @lastname = firstname, lastname
-        end
-      end
-    end
-
-    before do
-      # specify the class #inspect method
-      klass.stub(:name).and_return(nil)
-      klass.stub(:inspect).and_return(name)
-      klass.send(:include, subject)
-    end
-
-    it { should be_instance_of(object) }
-
-    it { should be_frozen }
-
-    it 'defines #hash and #inspect methods dynamically' do
-      expect(subject.public_instance_methods(false).collect(&: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
-end