rankle 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93e91d72d1ae47471f1be951fdf49bea1b5de6c0
-  data.tar.gz: e6cee95ce83201559b16638e08eefb73b1cf89ba
+  metadata.gz: d2a00ba713d656ff500838729e9ea39ed91d71c5
+  data.tar.gz: 1b07a9638a677ca8265d6a146674d222d80b0470
 SHA512:
-  metadata.gz: 196913721f0a56bd267fc1f1b17c13e8e4a3dde6251fb22c3a6ffecc4896bb510a9d24ecceb73712d53f50e5a26ed52b699a1fb988a392949a0813020da59f00
-  data.tar.gz: e3919e144ebd2a1d86f4a42a0105c7bd946567e6caef4061e7d2bd75fb29266c50ed0b4fc3065ee10bb1d6766a380a3300578cdf41893fb58609f54f1c41b79d
+  metadata.gz: a48c2ed7910ffc5d4e0c8d23fcfec501e220c82ea7db87f8d88a30dbb500251b4e67dc8c2743d0380182fb75b47a4bbb204cb7440803925f375f9ecdbf0ba26a
+  data.tar.gz: 1bb2cee9412e484908a9e94d4095ecda288223b868b487259bdfa0c2d40b1cb8d2d0a4c50258d949d2ba1bc295003e987c98856134698a116e011724cf8dbc79

data/.gitignore

@@ -37,3 +37,4 @@ Gemfile.lock
 
 # The db directory is used by the test suite to verify the rankle install generator
 /db
+/bin

data/Rakefile

@@ -3,7 +3,12 @@ require 'yard'
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::TestTask.new :bench do |t|
+  t.test_files = FileList['test/**/*_benchmark.rb']
   t.verbose = true
 end
 
@@ -11,4 +16,4 @@ YARD::Rake::YardocTask.new do |t|
   t.files = ['lib/rankle.rb']
 end
 
-task :default => [:test, :yard]
+task :default => [:test, :bench, :yard]

data/lib/rankle/ranker.rb

@@ -1,9 +1,36 @@
 module Rankle
   class Ranker
+    MIN_INDEX = -2147483648
+    MAX_INDEX =  2147483647
+
     attr_accessor :strategy
 
     def initialize strategy
       @strategy = strategy
     end
+
+    def self.insert target_position, existing_elements
+      if existing_elements.count > MAX_INDEX - MIN_INDEX
+        raise IndexError
+      elsif existing_elements.empty?
+        return 0, []
+      elsif target_position <= 0
+        return (MIN_INDEX + existing_elements.first) / 2, existing_elements
+      elsif target_position >= existing_elements.count
+        return (MAX_INDEX + existing_elements.last) / 2, existing_elements
+      elsif existing_elements[target_position] - existing_elements[target_position - 1] > 1
+        return (existing_elements[target_position] + existing_elements[target_position - 1]) / 2, existing_elements
+      else
+        existing_elements = balance existing_elements
+        insert target_position, existing_elements
+      end
+    end
+
+    def self.balance indices, options = {}
+      min_index = options[:min_index] || MIN_INDEX
+      max_index = options[:max_index] || MAX_INDEX
+      offset = (max_index - min_index) / (indices.count + 1)
+      indices.count.times.map { |index| min_index + (offset * (index + 1)) + index }
+    end
   end
-end
+end

data/lib/rankle/version.rb

@@ -1,3 +1,3 @@
 module Rankle
-  VERSION = '0.0.0'
+  VERSION = '0.0.1'
 end

data/lib/rankle.rb

@@ -38,7 +38,7 @@ module Rankle
       RankleIndex.set_default_position self
     end
 
-    # Assigns an explicit position to the record
+    # Assigns an explicit position to the record using the default ranker
     #
     # @param format [Integer] the new position
     # @return [Integer or Exception] the new position or an exception if the position could not be set
@@ -60,7 +60,7 @@ ActiveRecord::Base.extend Rankle::ClassMethods
 ActiveRecord::Base.send :include, Rankle::InstanceMethods
 
 class ActiveRecord::Base
-  def self.inherited(child)
+  def self.inherited child
     super
     unless child == ActiveRecord::SchemaMigration || child == RankleIndex
       child.send :after_create, :set_default_position

data/lib/rankle_index.rb

@@ -19,28 +19,27 @@ class RankleIndex < ActiveRecord::Base
   end
 
   def self.rank instance, name, position
-    rankle_index = RankleIndex.where(indexable_name: name.to_s, indexable_id: instance.id, indexable_type: instance.class).first_or_create!
-    rankle_index_length = if name == :default
-                            RankleIndex.where(indexable_name: name.to_s, indexable_type: instance.class).count
+    existing_indices = if name == :default
+                            RankleIndex.where indexable_name: name.to_s, indexable_type: instance.class
                           else
-                            RankleIndex.where(indexable_name: name.to_s).count
+                            RankleIndex.where indexable_name: name.to_s
                           end
+    position = existing_indices.length - 1 if position > existing_indices.length
     position = 0 if position < 0
-    position = rankle_index_length - 1 if position >= rankle_index_length
-    rankle_index.update_attribute(:indexable_position, rankle_index_length - 1) unless rankle_index.indexable_position
-    swap_distance  = -1
-    swap_distance *= -1 if rankle_index.indexable_position < position
-    until rankle_index.indexable_position == position
-      if name == :default
-        swap(rankle_index, RankleIndex.where(indexable_name: name.to_s, indexable_type: instance.class, indexable_position: rankle_index.indexable_position + swap_distance).first)
-      else
-        swap(rankle_index, RankleIndex.where(indexable_name: name.to_s, indexable_position: rankle_index.indexable_position + swap_distance).first)
-      end
+    index = RankleIndex.where(indexable_name: name.to_s, indexable_id: instance.id, indexable_type: instance.class).first_or_initialize
+    existing_positions = existing_indices.pluck(:indexable_position).compact
+    existing_positions -= [index.indexable_position] unless index.new_record?
+    indexable_position, existing_positions = Rankle::Ranker.insert(position, existing_positions)
+    existing_positions.each_with_index do |position, index|
+      existing_indices[index].update_attribute(:indexable_position, position) unless existing_indices[index].indexable_position = position
     end
+    index.indexable_position = indexable_position
+    index.save!
   end
 
   def self.position instance, name
-    where(indexable_name: name.to_s, indexable_id: instance.id, indexable_type: instance.class).first_or_create!.indexable_position
+    indexable_position = where(indexable_name: name.to_s, indexable_id: instance.id, indexable_type: instance.class).first_or_create!.indexable_position
+    where(indexable_name: name.to_s).where('indexable_position < ?', indexable_position).count
   end
 
   def self.ranked name

data/test/default_behavior_test.rb

@@ -19,4 +19,4 @@ class TestDefaultBehavior < Minitest::Test
 
     assert_equal ['apple', 'orange'], Fruit.ranked.map(&:name)
   end
-end
+end

data/test/performance/rank_benchmark.rb

@@ -0,0 +1,38 @@
+require_relative '../support/test_helper'
+require 'minitest/benchmark'
+
+class BenchmarkRank < Minitest::Benchmark
+  def self.bench_range
+    Minitest::Benchmark.bench_exp 16, 256, 2
+  end
+
+  def trials
+    1
+  end
+
+  def bench_insert_has_linear_performance
+    assert_performance_linear 0.99 do |n|
+      trials.times do
+        DatabaseCleaner.clean
+        n.times { |name| Fruit.create! name: name }
+      end
+    end
+
+    DatabaseCleaner.clean
+  end
+
+  def bench_reverse_insert_has_power_performance
+    Fruit.send :ranks, ->(a, b) { a.name.to_i > b.name.to_i }
+
+    assert_performance_power 0.99 do |n|
+      trials.times do
+        DatabaseCleaner.clean
+        n.times { |name| Fruit.create! name: name }
+      end
+    end
+
+    # FIXME: This unfortunate hack reaches into the internals of RankleIndex to reset the test state
+    RankleIndex.instance_variable_set(:@rankers, {})
+    DatabaseCleaner.clean
+  end
+end

data/test/spec/ranker_test.rb

@@ -0,0 +1,115 @@
+require_relative '../support/test_helper'
+
+describe Rankle::Ranker do
+  describe '.insert into' do
+    describe 'empty array' do
+      describe 'at position 0' do
+        it{ assert_equal [0, []], Rankle::Ranker.insert(0, []) }
+      end
+
+      describe 'at position -100' do
+        it{ assert_equal [0, []], Rankle::Ranker.insert(-100, []) }
+      end
+
+      describe 'at position 100' do
+        it{ assert_equal [0, []], Rankle::Ranker.insert(100, []) }
+      end
+    end
+
+    describe 'singleton array' do
+      describe 'at position 0' do
+        it{ assert_equal [-1073741824, [0]], Rankle::Ranker.insert(0, [0]) }
+      end
+
+      describe 'at position 1' do
+        it{ assert_equal [1073741823, [0]], Rankle::Ranker.insert(1, [0]) }
+      end
+
+      describe 'at position -100' do
+        it{ assert_equal [-1073741824, [0]], Rankle::Ranker.insert(-100, [0]) }
+      end
+
+      describe 'at position 100' do
+        it{ assert_equal [1073741823, [0]], Rankle::Ranker.insert(100, [0]) }
+      end
+    end
+
+    describe 'between non-adjacent elements' do
+      it{ assert_equal [0, [-1, 1]], Rankle::Ranker.insert(1, [-1, 1]) }
+      it{ assert_equal [0, [-1, 2]], Rankle::Ranker.insert(1, [-1, 2]) }
+    end
+
+    describe 'saturated' do
+      before do
+        @min_index = Rankle::Ranker::MIN_INDEX
+        @max_index = Rankle::Ranker::MAX_INDEX
+        Rankle::Ranker.send :remove_const, :MIN_INDEX
+        Rankle::Ranker.send :remove_const, :MAX_INDEX
+        Rankle::Ranker::MIN_INDEX = -2
+        Rankle::Ranker::MAX_INDEX = 2
+      end
+
+      it{ assert_raises(IndexError) { Rankle::Ranker.insert(0, [-2, -1, 0, 1, 2]) } }
+
+      after do
+        Rankle::Ranker.send :remove_const, :MIN_INDEX
+        Rankle::Ranker.send :remove_const, :MAX_INDEX
+        Rankle::Ranker::MIN_INDEX = @min_index
+        Rankle::Ranker::MAX_INDEX = @max_index
+      end
+    end
+
+    describe 'collision' do
+      it{ assert_equal [0, [-715827883, 715827883]], Rankle::Ranker.insert(1, [-1, 0]) }
+      it{ assert_equal [0, [-715827883, 715827883]], Rankle::Ranker.insert(1, [ 0, 1]) }
+    end
+
+    describe 'cascading collision' do
+      it{ assert_equal [-858993459, [-1288490189, -429496729, 429496731, 1288490191]], Rankle::Ranker.insert(1, [-2, -1, 0, 1]) }
+      it{ assert_equal [-858993459, [-1288490189, -429496729, 429496731, 1288490191]], Rankle::Ranker.insert(1, [-1,  0, 1, 2]) }
+    end
+
+    describe 'half-saturated' do
+      before do
+        @min_index = Rankle::Ranker::MIN_INDEX
+        @max_index = Rankle::Ranker::MAX_INDEX
+        Rankle::Ranker.send :remove_const, :MIN_INDEX
+        Rankle::Ranker.send :remove_const, :MAX_INDEX
+        Rankle::Ranker::MIN_INDEX = -2
+        Rankle::Ranker::MAX_INDEX = 2
+      end
+
+      it{ assert_equal [-1, [-2, 0, 2]], Rankle::Ranker.insert(1, [-2, 0, 2]) }
+      it{ assert_equal [1, [-2, 0, 2]], Rankle::Ranker.insert(2, [-2, 0, 2]) }
+
+      after do
+        Rankle::Ranker.send :remove_const, :MIN_INDEX
+        Rankle::Ranker.send :remove_const, :MAX_INDEX
+        Rankle::Ranker::MIN_INDEX = @min_index
+        Rankle::Ranker::MAX_INDEX = @max_index
+      end
+    end
+  end
+
+  describe '.balance' do
+    describe 'with default range' do
+      before do
+        @indices = {
+          [-1073741824] => [-1],
+          [1073741823]  => [-1],
+          [-1, 1]       => [-715827883, 715827883]
+        }
+      end
+
+      it do
+        @indices.each do |indices, expected|
+          assert_equal expected, Rankle::Ranker.balance(indices)
+        end
+      end
+    end
+
+    describe 'with custom range' do
+      it{ assert_equal [3, 7], Rankle::Ranker.balance([0, 1], min_index: 0, max_index: 10) }
+    end
+  end
+end

data/test/spec/rankle_index_test.rb

@@ -0,0 +1,23 @@
+require_relative '../support/test_helper'
+
+describe RankleIndex do
+  describe 'position' do
+    describe 'when 1 record' do
+      describe 'when indexable_position is 0' do
+        it 'returns 0' do
+          apple = Fruit.create! name: 'apple'
+          RankleIndex.first.update_attribute :indexable_position, 0
+          assert_equal 0, apple.position
+        end
+      end
+
+      describe 'when indexable_position is 11' do
+        it 'returns 0' do
+          apple = Fruit.create! name: 'apple'
+          RankleIndex.first.update_attribute :indexable_position, 11
+          assert_equal 0, apple.position
+        end
+      end
+    end
+  end
+end

data/test/support/models.rb

@@ -1,5 +1,3 @@
-#require_relative '../../lib/rankle_index'
-
 class Fruit < ActiveRecord::Base
   has_many :rankle_indices, as: :indexable
 end

data/test/support/test_helper.rb

@@ -13,25 +13,23 @@ ActiveRecord::Base.establish_connection(
 rake = Rake.application
 rake.init
 rake.load_rakefile
-Dir.entries(File.dirname(__FILE__) + '/../../db/migrate').each do |filename|
-  File.delete(File.dirname(__FILE__) + '/../../db/migrate/' + filename) rescue nil
+
+[File.dirname(__FILE__) + '/../../db/migrate',
+ 'rankle.sqlite3'].each do |path|
+  FileUtils::rm_rf(path) if File.exist?(path)
 end
+
 Rails::Generators.invoke 'rankle:install'
-require File.dirname(__FILE__) + '/../../db/migrate/' + Dir.entries(File.dirname(__FILE__) + '/../../db/migrate')[0]
-File.delete 'rankle.sqlite3'
+require File.dirname(__FILE__) + '/../../db/migrate/' + Dir.entries(File.dirname(__FILE__) + '/../../db/migrate').sort.last
 CreateRankleIndices.new.migrate :up
 
 load File.dirname(__FILE__) + '/schema.rb'
 load File.dirname(__FILE__) + '/models.rb'
 
-DatabaseCleaner.strategy = :truncation
+DatabaseCleaner.strategy = :deletion
 
 class Minitest::Test
   def setup
-    DatabaseCleaner.start
-  end
-
-  def teardown
     DatabaseCleaner.clean
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rankle
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Wil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-01 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -145,8 +145,11 @@ files:
 - test/default_behavior_test.rb
 - test/multiple_resources_test.rb
 - test/named_ranking_test.rb
+- test/performance/rank_benchmark.rb
 - test/scoped_ranking_test.rb
 - test/simple_usage_test.rb
+- test/spec/ranker_test.rb
+- test/spec/rankle_index_test.rb
 - test/support/models.rb
 - test/support/schema.rb
 - test/support/test_helper.rb
@@ -178,8 +181,11 @@ test_files:
 - test/default_behavior_test.rb
 - test/multiple_resources_test.rb
 - test/named_ranking_test.rb
+- test/performance/rank_benchmark.rb
 - test/scoped_ranking_test.rb
 - test/simple_usage_test.rb
+- test/spec/ranker_test.rb
+- test/spec/rankle_index_test.rb
 - test/support/models.rb
 - test/support/schema.rb
 - test/support/test_helper.rb