equalizer 0.0.1

data/lib/equalizer/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+class Equalizer < Module
+  VERSION = '0.0.1'.freeze
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/hash_method_behavior.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples_for 'a hash method' do
+  it_should_behave_like 'an idempotent method'
+
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    instance_eval(&specification)
+  end
+
+  it 'memoizes the hash code' do
+    subject.should eql(object.memoized(:hash))
+  end
+end

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'equalizer'
+require 'spec'
+require 'spec/autorun'
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+end

data/spec/support/config_alias.rb

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

data/spec/unit/equalizer/class_method/new_spec.rb

@@ -0,0 +1,134 @@
+# 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
+      subject.public_instance_methods(false).map(&:to_s).should =~ %w[ hash inspect ]
+    end
+
+    describe '#eql?' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { instance.eql?(other).should be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { stub('other') }
+
+        it { instance.eql?(other).should be(false) }
+      end
+    end
+
+    describe '#==' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { (instance == other).should be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { stub('other') }
+
+        it { (instance == other).should be(false) }
+      end
+    end
+
+    describe '#hash' do
+      it { instance.hash.should eql(klass.hash) }
+    end
+
+    describe '#inspect' do
+      it { instance.inspect.should eql('#<User>') }
+    end
+  end
+
+  context 'with keys' do
+    subject { object.new(*keys) }
+
+    let(:keys)       { [ :first_name ].freeze }
+    let(:first_name) { 'John'                 }
+    let(:instance)   { klass.new(first_name)  }
+
+    let(:klass) do
+      ::Class.new do
+        attr_reader :first_name
+
+        def initialize(first_name)
+          @first_name = first_name
+        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
+      subject.public_instance_methods(false).map(&:to_s).should =~ %w[ hash inspect ]
+    end
+
+    describe '#eql?' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { instance.eql?(other).should be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { stub('other') }
+
+        it { instance.eql?(other).should be(false) }
+      end
+    end
+
+    describe '#==' do
+      context 'when the objects are similar' do
+        let(:other) { instance.dup }
+
+        it { (instance == other).should be(true) }
+      end
+
+      context 'when the objects are different' do
+        let(:other) { stub('other') }
+
+        it { (instance == other).should be(false) }
+      end
+    end
+
+    describe '#hash' do
+      it { instance.hash.should eql(klass.hash ^ first_name.hash) }
+    end
+
+    describe '#inspect' do
+      it { instance.inspect.should eql('#<User first_name="John">') }
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Equalizer::Methods, '#eql?' do
+  subject { object.eql?(other) }
+
+  let(:object) { described_class.new }
+
+  let(:described_class) do
+    Class.new do
+      include Equalizer::Methods
+
+      def cmp?(comparator, other)
+        !!(comparator and other)
+      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 }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Equalizer::Methods, '#==' do
+  subject { object == 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 == 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(described_class).new(true) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should 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)
+        end
+        private :coerce
+      end
+    end
+
+    it { should be(true) }
+
+    it 'is not symmetric' do
+      should_not eql(other == object)
+    end
+  end
+end

data/tasks/metrics/ci.rake

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+desc 'Run metrics with Heckle'
+task :ci => %w[ ci:metrics metrics:heckle ]
+
+namespace :ci do
+  desc 'Run metrics (except heckle) and spec'
+  task :metrics => %w[ spec metrics:verify_measurements metrics:flog metrics:flay metrics:reek metrics:roodi metrics:all ]
+end

data/tasks/metrics/flay.rake

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+begin
+  require 'flay'
+  require 'yaml'
+
+  config      = YAML.load_file(File.expand_path('../../../config/flay.yml', __FILE__)).freeze
+  threshold   = config.fetch('threshold').to_i
+  total_score = config.fetch('total_score').to_f
+  files       = Flay.expand_dirs_to_files(config.fetch('path', 'lib')).sort
+
+  namespace :metrics do
+    # original code by Marty Andrews:
+    # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+    desc 'Analyze for code duplication'
+    task :flay do
+      # run flay once without a threshold to ensure the max mass matches the threshold
+      flay = Flay.new(:fuzzy => false, :verbose => false, :mass => 0)
+      flay.process(*files)
+
+      max = (flay.masses.map { |hash, mass| mass.to_f / flay.hashes[hash].size }.max) || 0
+      unless max >= threshold
+        raise "Adjust flay threshold down to #{max}"
+      end
+
+      total = flay.masses.reduce(0.0) { |total, (hash, mass)| total + (mass.to_f / flay.hashes[hash].size) }
+      unless total == total_score
+        raise "Flay total is now #{total}, but expected #{total_score}"
+      end
+
+      # run flay a second time with the threshold set
+      flay = Flay.new(:fuzzy => false, :verbose => false, :mass => threshold.succ)
+      flay.process(*files)
+
+      if flay.masses.any?
+        flay.report
+        raise "#{flay.masses.size} chunks of code have a duplicate mass > #{threshold}"
+      end
+    end
+  end
+rescue LoadError
+  task :flay do
+    $stderr.puts 'Flay is not available. In order to run flay, you must: gem install flay'
+  end
+end

data/tasks/metrics/flog.rake

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+begin
+  require 'flog'
+  require 'yaml'
+
+  class Float
+    def round_to(n)
+      (self * 10**n).round.to_f * 10**-n
+    end
+  end
+
+  config    = YAML.load_file(File.expand_path('../../../config/flog.yml', __FILE__)).freeze
+  threshold = config.fetch('threshold').to_f.round_to(1)
+
+  namespace :metrics do
+    # original code by Marty Andrews:
+    # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
+    desc 'Analyze for code complexity'
+    task :flog do
+      flog = Flog.new
+      flog.flog Array(config.fetch('path', 'lib'))
+
+      totals = flog.totals.select  { |name, score| name[-5, 5] != '#none' }.
+                           map     { |name, score| [ name, score.round_to(1) ] }.
+                           sort_by { |name, score| score }
+
+      if totals.any?
+        max = totals.last[1]
+        unless max >= threshold
+          raise "Adjust flog score down to #{max}"
+        end
+      end
+
+      bad_methods = totals.select { |name, score| score > threshold }
+      if bad_methods.any?
+        bad_methods.reverse_each do |name, score|
+          puts '%8.1f: %s' % [ score, name ]
+        end
+
+        raise "#{bad_methods.size} methods have a flog complexity > #{threshold}"
+      end
+    end
+  end
+rescue LoadError
+  task :flog do
+    $stderr.puts 'Flog is not available. In order to run flog, you must: gem install flog'
+  end
+end