tsuga 0.0.1

data/spec/adapter/memory/base_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+require 'tsuga/adapter/memory/base'
+
+describe Tsuga::Adapter::Memory::Base do
+  let(:stuff_class) do
+    Class.new.class_eval do
+      include Tsuga::Adapter::Memory::Base
+      attr_accessor :foo
+      self
+    end
+  end
+
+  let(:stuff) { stuff_class.new }
+
+  describe '#persist!' do
+    it 'returns the record' do
+      stuff.persist!.object_id.should == stuff.object_id
+    end
+
+    it 'makes objects retrievable' do
+      stuff.persist!
+      expect { stuff_class.find_by_id(stuff.id) }.not_to raise_error
+    end
+
+    it 'persists only current state' do
+      stuff.foo = 1
+      stuff.persist!
+      stuff.foo = 2
+
+      stuff_class.find_by_id(stuff.id).foo.should == 1
+    end
+  end
+
+  describe '#destroy' do
+    it 'removes records' do
+      id = stuff.persist!.id
+      stuff.destroy
+      expect { stuff_class.find_by_id(id) }.to raise_error
+    end
+
+    it 'clears record id' do
+      stuff.persist!.destroy.id.should be_nil
+    end
+  end
+
+  describe '.find' do
+    it 'retrives record by ID' do
+      stuff.persist!
+      stuff_class.find_by_id(stuff.id).id.should == stuff.id
+    end
+
+    it 'fails if not persisted' do
+      stuff = stuff_class.new
+      expect { stuff_class.find_by_id(stuff.id) }.to raise_error(Tsuga::RecordNotFound)
+    end
+
+    it 'fails if ID is unknown' do
+      expect { stuff_class.find_by_id(123) }.to raise_error(Tsuga::RecordNotFound)
+    end
+  end
+
+  describe '.find_each' do
+    it 'yields nothing is no records present' do
+      expect { |b| stuff_class.find_each(&b) }.not_to yield_control
+    end
+
+    it 'yields each persisted record' do
+      id0 = stuff_class.new.persist!.id
+      id1 = stuff_class.new.id
+      id2 = stuff_class.new.persist!.id
+      expect { |b| stuff_class.find_each(&b) }.to yield_control.twice
+    end
+
+    it 'allows writes while iterating' do
+      stuff_class.new.persist!
+      expect {
+        stuff_class.find_each { |r| stuff_class.new.persist! }
+      }.not_to raise_error
+    end
+  end
+
+  describe '.delete_all' do
+    it 'forgets persisted records' do
+      stuff.persist!
+      stuff_class.delete_all
+      expect { stuff_class.find_by_id(stuff.id) }.to raise_error
+    end
+  end
+
+  describe '.collect_ids' do
+    it 'returns a set' do
+      stuff_class.collect_ids.should be_a_kind_of(Set)
+    end
+
+    it 'returns all ids' do
+      stuff_class.new.persist!
+      stuff_class.new.persist!
+      stuff_class.collect_ids.to_a.should =~ [1,2]
+    end
+  end
+
+  describe '.scoped' do
+    it 'returns a scope' do
+      stuff_class.scoped.should be_a_kind_of(described_class::Scope)
+    end
+  end
+
+  describe described_class::Scope do
+    subject { stuff_class.scoped(lambda { |record| record.id % 2 == 0 }) }
+
+    before do
+      stuff1 = stuff_class.new.persist! # id 1
+      stuff2 = stuff_class.new.persist! # id 2
+    end
+
+    describe '#find' do
+      it 'finds selected items' do
+        expect { subject.find_by_id(2) }.not_to raise_error
+      end
+
+      it 'filters out unscoped items' do
+        expect { subject.find_by_id(1) }.to raise_error
+      end
+    end
+
+    describe '#delete_all' do
+      it 'deletes selected items' do
+        subject.delete_all
+        expect { stuff_class.find_by_id(2) }.to raise_error
+      end
+
+      it 'leaves filtered items' do
+        subject.delete_all
+        expect { stuff_class.find_by_id(1) }.not_to raise_error
+      end
+    end
+
+    describe '#find_each' do
+      it 'yields selected items' do
+        expect { |b| subject.find_each(&b) }.to yield_control.once
+      end
+    end
+
+    describe '#collect_ids' do
+      it 'returns selected ids' do
+        subject.collect_ids.to_a.should == [2]
+      end
+    end
+  end
+
+  describe 'defining named scopes' do
+    before do
+      stuff_class.class_eval do
+        def self.id_multiple_of(n)
+          scoped(lambda { |r| r.id % n == 0 })
+        end
+      end
+
+      10.times { stuff_class.new.persist! }
+    end
+
+    it 'works' do
+      expect { |b|
+        stuff_class.id_multiple_of(3).find_each(&b)
+      }.to yield_control.exactly(3).times
+    end
+
+    it 'is chainable' do
+      expect { |b|
+        stuff_class.id_multiple_of(3).id_multiple_of(2).find_each(&b)
+      }.to yield_control.exactly(1).times
+    end
+  end
+end

data/spec/adapter/memory/cluster_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'tsuga/adapter/memory/cluster'
+
+describe Tsuga::Adapter::Memory::Cluster do
+  let(:concretion_class) do
+    Class.new.class_eval do
+      include Tsuga::Adapter::Memory::Cluster
+      self
+    end
+  end
+
+  let(:concretion) { concretion_class.new }
+
+  describe '#persist!' do
+    it 'returns the record' do
+      concretion.persist!.object_id.should == concretion.object_id
+    end
+
+    it 'makes objects retrievable' do
+      concretion.persist!
+      expect { concretion_class.find_by_id(concretion.id) }.not_to raise_error
+    end
+  end
+
+  describe '#destroy' do
+    it 'removes records' do
+      id = concretion.persist!.id
+      concretion.destroy
+      expect { concretion_class.find_by_id(id) }.to raise_error
+    end
+  end
+
+  describe '.find' do
+    it 'retrives record by ID' do
+      concretion.persist!
+      concretion_class.find_by_id(concretion.id).id.should == concretion.id
+    end
+  end
+end

data/spec/adapter/shared/cluster_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'tsuga/adapter/shared/cluster'
+require 'tsuga/adapter/memory/cluster'
+
+describe Tsuga::Adapter::Shared::Cluster do
+  let(:concretion_class) do
+    Class.new.class_eval do
+      include Tsuga::Adapter::Memory::Cluster
+      self
+    end
+  end
+
+  let(:concretion) { concretion_class.new }
+
+  describe '#children' do
+    let(:records) { (1..5).map { concretion_class.new.persist! } }
+
+    it 'retrieves child records' do
+      concretion.children_type = concretion.class.name
+      concretion.children_ids  = records.map(&:id)
+      concretion.children.map(&:id).should == records.map(&:id)
+    end
+
+    it 'works with no children' do
+      concretion.children_type = concretion.class.name
+      concretion.children_ids  = []
+      concretion.children.should == []
+    end
+  end
+
+  describe '#leaves' do
+    # setup: r1 -> r2 -> r3 ; r4 isolated
+    before do
+      @r1 = concretion_class.new.persist!
+      @r2 = concretion_class.new.persist!
+      @r3 = concretion_class.new.persist!
+      @r4 = concretion_class.new.persist!
+
+      @r2.children_type = concretion_class.name
+      @r2.children_ids  = [@r1.id]
+      @r2.persist!
+
+      @r3.children_type = concretion_class.name
+      @r3.children_ids  = [@r2.id]
+      @r3.persist!
+    end
+
+    it 'follows branches' do
+      @r3.leaves.map(&:id).should == [@r1.id]
+    end
+
+    it 'works with no children' do
+      @r4.leaves.map(&:id).should == [@r4.id]
+    end
+  end
+end

data/spec/integration/active_record_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'tsuga/adapter/active_record/test'
+require 'integration/shared'
+
+describe 'integration' do
+  describe 'active_record adapter' do
+    let(:adapter) { Tsuga::Adapter::ActiveRecord::Test.clusters }
+    it_should_behave_like 'an adapter suitable for clustering'
+  end
+end

data/spec/integration/memory_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'tsuga/adapter/memory/test'
+require 'integration/shared'
+
+describe 'integration' do
+  describe 'memory adapter' do
+    let(:adapter)   { Tsuga::Adapter::Memory::Test.clusters }
+    it_should_behave_like 'an adapter suitable for clustering'
+  end
+end

data/spec/integration/mongoid_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'tsuga/adapter/mongoid/test'
+require 'integration/shared'
+
+describe 'integration' do
+  describe 'mongoid adapter' do
+    let(:adapter) { Tsuga::Adapter::Mongoid::Test.clusters }
+    it_should_behave_like 'an adapter suitable for clustering'
+  end
+end

data/spec/integration/sequel_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'tsuga/adapter/sequel/test'
+require 'integration/shared'
+
+describe 'integration' do
+  describe 'sequel adapter' do
+    let(:adapter)   { Tsuga::Adapter::Sequel::Test.clusters }
+    it_should_behave_like 'an adapter suitable for clustering'
+  end
+end

data/spec/integration/shared.rb

@@ -0,0 +1,50 @@
+require 'tsuga/service/clusterer'
+require 'tsuga/model/point'
+
+shared_examples_for 'an adapter suitable for clustering' do
+  let(:clusterer) { Tsuga::Service::Clusterer.new(source: records, adapter: adapter) }
+  let(:records) { ArrayWithFindEach.new }
+
+  def make_record(lat, lng)
+    records << OpenStruct.new(lat:lat, lng:lng)
+  end
+
+  before { adapter.delete_all }
+
+  context 'with random records' do
+    let(:count) { 10 }
+    before do
+      count.times { make_record(rand, rand) }
+      clusterer.run
+    end
+
+    let :toplevel_cluster do
+      id = adapter.at_depth(3).collect_ids.first
+      adapter.find_by_id(id)
+    end
+
+    let :barycenter do
+      sum_lat = 0
+      sum_lng = 0
+      records.each { |r| sum_lat += r.lat ; sum_lng += r.lng }
+      Tsuga::Model::Point.new(lat: sum_lat/count, lng: sum_lng/count)
+    end
+
+    it 'toplevel cluster has correct weight' do
+      toplevel_cluster.weight.should == count
+    end
+
+    it 'toplevel cluster is centered' do
+      toplevel_cluster.lat
+      (toplevel_cluster & barycenter).should < 1e-6 # 10 micro degrees ~ 1 meter at equator
+    end
+
+    it 'all depths have same total weight' do
+      3.upto(19) do |depth|
+        total_weight = 0
+        adapter.at_depth(depth).find_each { |c| total_weight += c.weight }
+        total_weight.should == 10
+      end
+    end
+  end
+end

data/spec/model/point_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'tsuga/model/point'
+
+describe Tsuga::Model::Point do
+  describe '#distance_to' do
+    let(:p00) { described_class.new(lat:0, lng:0) }
+    let(:p01) { described_class.new(lat:0, lng:1) }
+    let(:p11) { described_class.new(lat:1, lng:1) }
+
+    it 'is zero for the same point' do
+      p00.distance_to(p00).should be_within(1e-6).of(0)
+    end
+
+    it 'is 1 for points 1 degree apart' do
+      p00.distance_to(p01).should be_within(1e-6).of(1)
+    end
+
+    it 'uses euclidian distance' do
+      p00.distance_to(p11).should be_within(1e-6).of(Math.sqrt(2))
+    end
+  end
+
+  describe '#lat=, #lng=' do
+    let(:result) { subject.geohash }
+
+    it 'converts latitude and longitude to a geohash' do
+      subject.lat =  -90
+      subject.lng = -180
+      result.should == '00000000000000000000000000000000'
+    end
+
+    it 'is ok for the highest hash' do
+      subject.lat = 90 - 1e-8
+      subject.lng = 180 - 1e-8
+      result.should == '33333333333333333333333333333333'
+    end
+
+    it 'is ok or equator/greenwhich' do
+      subject.lat = 0
+      subject.lng = 0
+      result.should == '30000000000000000000000000000000'
+    end
+
+    it 'fails when lat/lng missing' do
+      subject.lat = nil
+      subject.lng = 0
+      result.should be_nil
+    end
+
+    it 'fails when lat out of bounds' do
+      expect { subject.lat = 90 }.to raise_error(ArgumentError)
+    end
+
+    it 'fails when lng out of bounds' do
+      expect { subject.lng = 180 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#lat #lng' do
+    it 'computes coordinates from hash' do
+      subject.geohash = '22222222222222222222222222222222'
+      subject.lat.should be_within(1e-6).of(-90)
+      subject.lng.should be_within(1e-6).of(180)
+    end
+
+    it 'is ok or equator/greenwhich' do
+      subject.geohash = '30000000000000000000000000000000'
+      subject.lat.should be_within(1e-6).of(0)
+      subject.lng.should be_within(1e-6).of(0)
+    end
+  end
+
+  describe '#prefix' do
+    it 'returns a prefix of the geohash' do
+      subject.geohash = '12332100000000000000000000000000'
+      subject.prefix(6).should == '123321'
+    end
+  end
+
+  describe '(comparison)' do
+    it 'preserves lat-order' do
+      described_class.new(lat:45, lng:2).geohash.should <
+      described_class.new(lat:46, lng:2).geohash
+    end
+
+    it 'preserves lng-order' do
+      described_class.new(lat:45, lng:2).geohash.should <
+      described_class.new(lat:45, lng:3).geohash
+    end
+
+    it 'preserves order around greenwich' do
+      described_class.new(lat:45, lng:-1).geohash.should <
+      described_class.new(lat:45, lng: 1).geohash
+    end
+
+    it 'preserves order around equator' do
+      described_class.new(lat:-1, lng:2).geohash.should <
+      described_class.new(lat: 1, lng:2).geohash
+    end
+  end
+end
+