ranked-model-rails2 0.4.0

data/spec/duck-model/lots_of_ducks_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Duck do
+
+  before {
+    200.times do |i|
+      Duck.create \
+        :name => "Duck #{i}"
+    end
+  }
+
+  describe "setting and fetching by position" do
+
+    describe '137' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, 137
+      }
+
+      subject { Duck.ranker(:row).with(Duck.new).current_at_position(137).instance }
+
+      its(:id) { should == @last.id }
+
+    end
+
+    describe '2' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, 2
+      }
+
+      subject { Duck.ranker(:row).with(Duck.new).current_at_position(2).instance }
+
+      its(:id) { should == @last.id }
+
+    end
+
+    describe 'last' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, :last
+      }
+
+      subject { Duck.rank(:row).last }
+
+      its(:id) { should == @last.id }
+
+    end
+
+    describe 'first' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, :first
+      }
+
+      subject { Duck.rank(:row).first }
+
+      its(:id) { should == @last.id }
+
+    end
+
+  end
+
+  describe "a rearrangement" do
+
+    describe "with max value" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.offset(1).first
+        @ordered = Duck.rank(:row).where(%Q{"id" NOT IN (#{@first.id}, #{@second.id})}).collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MAX_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MAX_RANK_VALUE
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == (@ordered[0..-2] + [@ordered[-1], @first.id, @second.id]) }
+
+      }
+
+    end
+
+    describe "with max value and with_same pond" do
+
+      before {
+        Duck.order("id ASC").limit(50).each_with_index do |d, index|
+          d.update_attributes :age => index % 10, :pond => "Pond #{index / 10}"
+        end
+        @duck_11 = Duck.offset(10).first
+        @duck_12 = Duck.offset(11).first
+        @ordered = Duck.where(:pond => 'Pond 1').rank(:age).where(%Q{"id" NOT IN (#{@duck_11.id}, #{@duck_12.id})}).collect {|d| d.id }
+        @duck_11.update_attribute :age, RankedModel::MAX_RANK_VALUE
+        @duck_12.update_attribute :age, RankedModel::MAX_RANK_VALUE
+      }
+
+      context {
+        subject { Duck.where(:pond => 'Pond 1').rank(:age).collect {|d| d.id } }
+
+        it { should == (@ordered[0..-2] + [@ordered[-1], @duck_11.id, @duck_12.id]) }
+      }
+
+      context {
+        subject { Duck.first.age }
+        it { should == 0}
+      }
+
+    end
+
+    describe "with min value" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.offset(1).first
+        @ordered = Duck.rank(:row).where(%Q{"id" NOT IN (#{@first.id}, #{@second.id})}).collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MIN_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MIN_RANK_VALUE
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == ([@second.id, @first.id] + @ordered) }
+
+      }
+
+    end
+
+    describe "with no more gaps" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.where(:row => RankedModel::MAX_RANK_VALUE).first || Duck.offset(1).first
+        @third = Duck.offset(2).first
+        @fourth = Duck.offset(4).first
+        @lower = Duck.rank(:row).
+          where(%Q{"id" NOT IN (#{@first.id}, #{@second.id}, #{@third.id}, #{@fourth.id})}).
+          where(%Q{"row" < ?}, RankedModel::MAX_RANK_VALUE / 2).
+          collect {|d| d.id }
+        @upper = Duck.rank(:row).
+          where(%Q{"id" NOT IN (#{@first.id}, #{@second.id}, #{@third.id}, #{@fourth.id})}).
+          where(%Q{"row" >= ?}, RankedModel::MAX_RANK_VALUE / 2).
+          collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MIN_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MAX_RANK_VALUE
+        @third.update_attribute :row, (RankedModel::MAX_RANK_VALUE / 2)
+        @fourth.update_attribute :row, @third.row
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == ([@first.id] + @lower + [@fourth.id, @third.id] + @upper + [@second.id]) }
+
+      }
+
+    end
+
+  end
+
+end

data/spec/duck-model/wrong_ducks_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe WrongScopeDuck do
+
+  it "should raise an error because of an unknown scope" do
+
+    expect {
+      WrongScopeDuck.create(:name => 'Quocky', :pond => 'Shin')
+    }.to raise_error(RankedModel::InvalidScope, 'No scope called "non_existant_scope" found in model')
+
+  end
+
+end
+
+describe WrongFieldDuck do
+
+  it "should raise an error because of an unknown field" do
+
+    expect {
+      WrongFieldDuck.create(:name => 'Quicky', :pond => 'Shin')
+    }.to raise_error(RankedModel::InvalidField, 'No field called "non_existant_field" found in model')
+
+  end
+
+end
+
+describe ReallyWrongFieldDuck do
+
+  it "should raise an error because of a specific unknown field" do
+
+    expect {
+      ReallyWrongFieldDuck.create(:name => 'Quicky', :pond => 'Shin')
+    }.to raise_error(RankedModel::InvalidField, 'No field called "non_existant_field" found in model')
+  end
+
+end

data/spec/ego-model/ego_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Ego do
+
+  before {
+    @egos = {
+      :bob   => Ego.create(:name => 'Bob'),
+      :nick  => Ego.create(:name => 'Nick'),
+      :sally => Ego.create(:name => 'Sally')
+    }
+    @egos.each { |name, ego|
+      ego.reload
+      ego.update_attribute :size_position, 0
+      ego.save!
+    }
+    @egos.each {|name, ego| ego.reload }
+  }
+
+  describe "sorting on size alternative primary key" do
+
+    before {
+      @egos[:nick].update_attribute :size_position, 0
+      @egos[:sally].update_attribute :size_position, 2
+    }
+
+    subject { Ego.rank(:size).to_a }
+
+    its(:size) { should == 3 }
+
+    its(:first) { should == @egos[:nick] }
+
+    its(:last) { should == @egos[:sally] }
+
+  end
+
+end

data/spec/player-model/records_already_exist_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Player do
+
+  before {
+    @players = {}
+    @players[:dave] = Player.create!(:name => "Dave", :city => "Detroit")
+    @players[:bob] = Player.create!(:name => "Bob", :city => "Portland")
+    @players[:nigel] = Player.create!(:name => "Nigel", :city => "New York")
+    Player.class_eval do
+      include RankedModel
+      ranks :score
+    end
+
+  }
+
+  describe "setting the position of a record that already exists" do
+    it "sets the rank without error" do
+      expect{@players[:bob].update_attributes! :score_position => 1}.to_not raise_error
+    end
+  end
+end

data/spec/ranked-model/ranker_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe RankedModel::Ranker, 'initialized' do
+
+  subject {
+    RankedModel::Ranker.new \
+      :overview,
+      :column     => :a_sorting_column,
+      :scope      => :a_scope,
+      :with_same  => :a_column,
+      :class_name => 'SomeClass',
+      :unless     => :a_method
+  }
+
+  its(:name) { should == :overview }
+  its(:column) { should == :a_sorting_column }
+  its(:scope) { should == :a_scope }
+  its(:with_same) { should == :a_column }
+  its(:class_name) { should == 'SomeClass' }
+  its(:unless) { should == :a_method }
+end
+
+describe RankedModel::Ranker, 'unless as Symbol' do
+  let(:receiver) { mock('model') }
+
+  subject {
+    RankedModel::Ranker.new(:overview, :unless => :a_method).with(receiver)
+  }
+
+  context 'returns true' do
+    before { receiver.expects(:a_method).once.returns(true) }
+
+    its(:handle_ranking) { should == nil }
+  end
+
+  context 'returns false' do
+    before { receiver.expects(:a_method).once.returns(false) }
+
+    it {
+      subject.expects(:update_index_from_position).once
+      subject.expects(:assure_unique_position).once
+
+      subject.handle_ranking
+    }
+  end
+end
+
+describe RankedModel::Ranker, 'unless as Proc' do
+  context 'returns true' do
+    subject { RankedModel::Ranker.new(:overview, :unless => Proc.new { true }).with(Class.new) }
+    its(:handle_ranking) { should == nil }
+  end
+
+  context 'returns false' do
+    subject { RankedModel::Ranker.new(:overview, :unless => Proc.new { false }).with(Class.new) }
+
+    it {
+      subject.expects(:update_index_from_position).once
+      subject.expects(:assure_unique_position).once
+
+      subject.handle_ranking
+    }
+  end
+end

data/spec/ranked-model/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe RankedModel do
+
+  it { should define_constant(:VERSION) }
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'ranked-model'
+
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each {|f| require f}
+
+# After the DB connection is setup
+require 'database_cleaner'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+end
+
+RSpec::Matchers.define :define_constant do |expected|
+  match { |actual| actual.const_defined?(expected) }
+end

data/spec/sti-model/element_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Element do
+
+  before {
+    @elements = {
+      :chromium  => TransitionMetal.create( :symbol => 'Cr' ),
+      :manganese => TransitionMetal.create( :symbol => 'Mn' ),
+      :argon     => NobleGas.create( :symbol => 'Ar' ),
+      :helium    => NobleGas.create( :symbol => 'He' ),
+      :xenon     => NobleGas.create( :symbol => 'Xe' )
+    }
+    @elements.each { |name, element|
+      element.reload
+      element.update_attribute :combination_order_position, 0
+    }
+    @elements.each {|name, element| element.reload }
+  }
+
+  describe "rebalancing on an STI class should not affect the other class" do
+
+    before {
+      @elements[:helium].update_attribute :combination_order_position, :first
+      @elements[:xenon].update_attribute :combination_order_position, :first
+      @elements[:argon].update_attribute :combination_order_position, :last
+
+      TransitionMetal.ranker(:combination_order).with(@elements[:chromium]).instance_eval { rebalance_ranks }
+    }
+
+    subject { NobleGas.rank(:combination_order) }
+
+    its(:size) { should == 3 }
+
+    its(:first) { should == @elements[:xenon] }
+
+    its(:last) { should == @elements[:argon] }
+
+  end
+
+  describe "setting positions on STI classes" do
+
+    before {
+      @elements[:helium].update_attribute :combination_order_position, :first
+      @elements[:xenon].update_attribute :combination_order_position, :first
+      @elements[:argon].update_attribute :combination_order_position, :first
+
+      @elements[:chromium].update_attribute :combination_order_position, 1
+      @elements[:manganese].update_attribute :combination_order_position, 1
+      @elements[:manganese].update_attribute :combination_order_position, 0
+      @elements[:chromium].update_attribute :combination_order_position, 0
+      @elements[:manganese].update_attribute :combination_order_position, 0
+      @elements[:chromium].update_attribute :combination_order_position, 0
+    }
+
+    describe "NobleGas" do
+
+      subject { NobleGas.rank(:combination_order) }
+
+      its(:size) { should == 3 }
+
+      its(:first) { should == @elements[:argon] }
+
+      its(:last) { should == @elements[:helium] }
+
+    end
+
+    describe "TransitionMetal" do
+
+      subject { TransitionMetal.rank(:combination_order) }
+
+      its(:size) { should == 2 }
+
+      its(:first) { should == @elements[:chromium] }
+
+      its(:last) { should == @elements[:manganese] }
+
+    end
+
+  end
+
+  describe "setting positions on STI classes" do
+
+    before {
+      @elements[:helium].update_attribute :combination_order_position, :first
+      @elements[:xenon].update_attribute :combination_order_position, :first
+      @elements[:argon].update_attribute :combination_order_position, :first
+
+      @elements[:chromium].update_attribute :combination_order_position, 1
+      @elements[:manganese].update_attribute :combination_order_position, 1
+      @elements[:manganese].update_attribute :combination_order_position, 0
+      @elements[:chromium].update_attribute :combination_order_position, 0
+      @elements[:manganese].update_attribute :combination_order_position, 0
+      @elements[:chromium].update_attribute :combination_order_position, 0
+    }
+
+    describe "NobleGas" do
+
+      subject { NobleGas.rank(:combination_order) }
+
+      its(:size) { should == 3 }
+
+      its(:first) { should == @elements[:argon] }
+
+      its(:last) { should == @elements[:helium] }
+
+    end
+
+    describe "TransitionMetal" do
+
+      subject { TransitionMetal.rank(:combination_order) }
+
+      its(:size) { should == 2 }
+
+      its(:first) { should == @elements[:chromium] }
+
+      its(:last) { should == @elements[:manganese] }
+
+    end
+
+  end
+
+end