tsuga 0.0.1

data/lib/tsuga/adapter/mongoid/record.rb

@@ -0,0 +1,16 @@
+require 'tsuga/model/record'
+require 'tsuga/adapter/mongoid/base'
+require 'mongoid'
+
+module Tsuga::Adapter::Mongoid
+  module Record
+    def self.included(by)
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Record
+      by.extend ScopeMethods
+    end
+
+    module ScopeMethods
+    end
+  end
+end

data/lib/tsuga/adapter/mongoid/test.rb

@@ -0,0 +1,77 @@
+require 'tsuga/adapter/mongoid/base'
+require 'tsuga/adapter/mongoid/cluster'
+require 'tsuga/adapter/mongoid/record'
+require 'mongoid'
+require 'ostruct'
+require 'forwardable'
+
+module Tsuga::Adapter::Mongoid
+  module Test
+    class << self
+      extend Forwardable
+      delegate [:records, :clusters] => :models
+
+      def models
+        @_models ||= _build_test_models
+      end
+
+
+      private 
+
+
+      def _build_test_models
+        ::Mongoid.load!("spec/support/mongoid.yml", :test)
+        _cluster_model.create_indexes
+        _record_model.create_indexes
+
+        # FIXME: hardly elegant but Mongoid insists on a named class.
+        self.const_set :Cluster, _cluster_model
+        self.const_set :Record,  _record_model
+
+        OpenStruct.new :clusters => _cluster_model, :records => _record_model
+      end
+
+
+      def _cluster_model
+        @_cluster_model ||= Class.new do
+          include Mongoid::Document
+
+          field :tilecode
+          field :depth
+          field :geohash
+          field :lat
+          field :lng
+          field :parent_id
+          field :children_type
+          field :children_ids
+          field :sum_lat
+          field :sum_lng
+          field :ssq_lat
+          field :ssq_lng
+          field :weight
+
+          store_in :collection => 'clusters'
+          index tilecode:1
+
+          include Tsuga::Adapter::Mongoid::Cluster
+        end
+      end
+
+
+      def _record_model
+        @_record_model ||= Class.new do
+          include Mongoid::Document
+
+          field :geohash
+          field :lat
+          field :lng
+
+          store_in :collection => 'records'
+          index geohash:1
+
+          include Tsuga::Adapter::Mongoid::Record
+        end
+      end
+    end
+  end
+end

data/lib/tsuga/adapter/sequel/base.rb

@@ -0,0 +1,57 @@
+require 'tsuga/errors'
+require 'tsuga/adapter'
+require 'sequel'
+require 'delegate'
+
+module Tsuga::Adapter::Sequel
+  module Base
+    def self.included(by)
+      by.dataset_module DatasetMethods
+    end
+
+    def id
+      @_id ||= super
+    end
+
+    def persist!
+      save
+    end
+
+    def new_record?
+      new?
+    end
+
+    module DatasetMethods
+      def mass_create(new_records)
+        multi_insert(new_records.map(&:to_hash))
+      end
+
+      def mass_update(records)
+        db.transaction do
+          records.each(&:save)
+        end
+      end
+
+      def find_by_id(id)
+        self[id]
+      end
+
+      def delete_all
+        where.delete
+      end
+
+      def collect_ids
+        map(:id)
+      end
+
+      def find_each
+        # TODO: pagination would be nice to have here, but seems not to
+        # work out-of-the-box with Sequel
+        # where.extension(:pagination).each_page(2000) do |page|
+        #   page.each { |r| yield r }
+        # end
+        all.each { |r| yield r }
+      end
+    end
+  end
+end

data/lib/tsuga/adapter/sequel/cluster.rb

@@ -0,0 +1,43 @@
+require 'tsuga/model/cluster'
+require 'tsuga/model/tile'
+require 'tsuga/adapter/sequel/base'
+require 'tsuga/adapter/shared/cluster'
+
+module Tsuga::Adapter::Sequel
+  module Cluster
+    def self.included(by)
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Cluster
+      by.send :include, Tsuga::Adapter::Shared::Cluster
+      by.dataset_module Scopes
+    end
+
+    def children_ids
+      @_children_ids ||= begin
+        stored = super
+        stored ? stored.split(',').map(&:to_i) : []
+      end
+    end
+
+    def children_ids=(value)
+      changed = (@_children_ids != value)
+      @_children_ids = value
+      super(@_children_ids.join(',')) if changed
+      @_children_ids
+    end
+
+    module Scopes
+      def at_depth(depth)
+        where(depth: depth)
+      end
+
+      def in_tile(*tiles)
+        depths = tiles.map(&:depth).uniq
+        if depths.length > 1
+          raise ArgumentError, 'all tile must be at same depth'
+        end
+        where(tilecode: tiles.map(&:prefix))
+      end
+    end
+  end
+end

data/lib/tsuga/adapter/sequel/record.rb

@@ -0,0 +1,15 @@
+require 'tsuga/model/record'
+require 'tsuga/adapter/sequel/base'
+
+module Tsuga::Adapter::Sequel
+  module Record
+    def self.included(by)
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Record
+      by.dataset_module Scopes
+    end
+
+    module Scopes
+    end
+  end
+end

data/lib/tsuga/adapter/sequel/test.rb

@@ -0,0 +1,73 @@
+require 'tsuga/adapter/sequel/base'
+require 'tsuga/adapter/sequel/cluster'
+require 'tsuga/adapter/sequel/record'
+require 'sequel'
+require 'sqlite3'
+require 'ostruct'
+require 'forwardable'
+
+module Tsuga::Adapter::Sequel
+  module Test
+    class << self
+      extend Forwardable
+      delegate [:records, :clusters] => :models
+
+      def models
+        @_models ||= _build_test_models
+      end
+
+      private
+
+      # Makes sure a connection exists
+      def _db
+        @_db ||= Sequel::DATABASES.first || Sequel.sqlite
+      end
+
+      def _prepare_tables
+        _db.drop_table?(:test_records)
+        _db.create_table(:test_records) do
+          primary_key :id
+          String      :geohash, size:32
+          Float       :lat
+          Float       :lng
+
+          index       :geohash
+        end
+
+        _db.drop_table?(:test_clusters)
+        _db.create_table(:test_clusters) do
+          primary_key :id
+          Integer     :depth
+          String      :geohash,  size:32
+          String      :tilecode, size:32
+          Float       :lat
+          Float       :lng
+          Integer     :parent_id
+          String      :children_type
+          String      :children_ids # FIXME
+          Double      :sum_lat
+          Double      :sum_lng
+          Double      :ssq_lat
+          Double      :ssq_lng
+          Integer     :weight
+
+          index       :tilecode
+        end
+      end
+
+      def _build_test_models
+        _prepare_tables
+
+        cluster_model = Class.new(Sequel::Model(:test_clusters)) do
+          include Tsuga::Adapter::Sequel::Cluster
+        end
+
+        record_model = Class.new(Sequel::Model(:test_records)) do
+          include Tsuga::Adapter::Sequel::Record
+        end
+
+        OpenStruct.new :clusters => cluster_model, :records => record_model
+      end
+    end
+  end
+end

data/lib/tsuga/adapter/shared.rb

@@ -0,0 +1,4 @@
+require 'tsuga/adapter'
+
+module Tsuga::Adapter::Shared
+end

data/lib/tsuga/adapter/shared/cluster.rb

@@ -0,0 +1,19 @@
+require 'tsuga/adapter/shared'
+
+# Shared functionnality between adapters
+module Tsuga::Adapter::Shared::Cluster
+  def children
+    return [] if children_ids.nil?
+    children_ids.map do |_id|
+      self.class.find_by_id(_id)
+    end
+  end
+
+  def leaves
+    if children_type != self.class.name || children_ids.nil? || children_ids.empty?
+      [self]
+    else
+      children.map(&:leaves).inject(:+)
+    end
+  end
+end

data/lib/tsuga/errors.rb

@@ -0,0 +1,3 @@
+module Tsuga
+  RecordNotFound = Class.new(RuntimeError)
+end

data/lib/tsuga/model/cluster.rb

@@ -0,0 +1,147 @@
+require 'tsuga'
+require 'tsuga/model/point'
+
+module Tsuga::Model
+  # Concretions (provided by adapters) have the following accessors:
+  # - :depth
+  # - :parent_id
+  # - :children_type (Record or Cluster)
+  # - :children_ids
+  # - :weight (count of Record in subtree)
+  # - :sum_lat, :sum_lng
+  # - :ssq_lat, :ssq_lng
+  # 
+  # Respond to class methods:
+  # - :in_tile(Tile) (scopish, response responds to :find_each)
+  # - :at_depth(depth)
+  # - :delete_all
+  # - :find(id)
+  # 
+  # Respond to the following instance methods:
+  # - :destroy
+  module Cluster
+    include Tsuga::Model::PointTrait
+    
+    def initialize
+      super
+      self.depth   ||= 1
+      # equator/greenwich
+      self.lat     ||= 0 
+      self.lng     ||= 0
+    end
+
+    # latitude deviation in cluster
+    def dlat
+      @_dlat ||= _safe_sqrt(ssq_lat/weight - (sum_lat/weight)**2)
+    end
+
+    # longitude deviation in cluster
+    def dlng
+      @_dlng ||= _safe_sqrt(ssq_lng/weight - (sum_lng/weight)**2)
+    end
+
+    # radius of cluster
+    def radius
+      @_radius ||= Math.sqrt(dlat ** 2 + dlng ** 2)
+    end
+
+    # density (weight per unit area)
+    def density
+      @_density ||= begin
+        # min. radius 1.4e-4 (about 15m at european latitudes)
+        # for 1-point clusters where density would otherwise be infinite
+        our_radius = [radius, 1.4e-4].max 
+        # Math.log(weight / (our_radius ** 2)) / Math.log(2)
+        weight / (our_radius ** 2)
+      end
+    end
+
+    def geohash=(value)
+      super(value)
+      _update_tilecode
+      geohash
+    end
+
+    def depth=(value)
+      super(value)
+      _update_tilecode
+      depth
+    end
+
+
+    def merge(other)
+      raise ArgumentError, 'not same depth'  unless depth == other.depth
+      raise ArgumentError, 'not same parent' unless parent_id == other.parent_id
+
+      self.weight  += other.weight
+      self.sum_lat += other.sum_lat
+      self.sum_lng += other.sum_lng
+      self.ssq_lat += other.ssq_lat
+      self.ssq_lng += other.ssq_lng
+      self.lat      = sum_lat/weight
+      self.lng      = sum_lng/weight
+      self.children_ids += other.children_ids
+
+      # dirty calculated values
+      @_dlng = @_dlat = @_radius = @_density = nil
+    end
+
+
+    module ClassMethods
+      # Cluster factory.
+      # +other+ is either a Cluster or a Record
+      # 
+      # FIXME: there's a potential for overflow here on large datasets on the sum-
+      # and sum-of-squares fields. it can be mitigated by using double-precision
+      # fields, or calculating sums only on the children (instead of the subtree)
+      def build_from(depth, other)
+        c = new()
+        c.depth = depth
+
+        c.lat           = other.lat
+        c.lng           = other.lng
+        c.children_ids  = [other.id]
+        c.children_type = other.class.name
+
+        case other
+        when Cluster
+          c.weight      = other.weight
+          c.sum_lng     = other.sum_lng
+          c.sum_lat     = other.sum_lat
+          c.ssq_lng     = other.ssq_lng
+          c.ssq_lat     = other.ssq_lat
+        else
+          c.weight      = 1
+          c.sum_lng     = other.lng
+          c.sum_lat     = other.lat
+          c.ssq_lng     = other.lng ** 2
+          c.ssq_lat     = other.lat ** 2
+        end
+
+        c.geohash # force geohash calculation
+        return c
+      end
+    end
+
+    def self.included(by)
+      by.extend(ClassMethods)
+    end
+  
+
+    private
+
+
+    def _safe_sqrt(value)
+      (value < 0) ? 0 : Math.sqrt(value)
+    end
+
+
+    def _update_tilecode
+      if geohash && depth
+        self.tilecode = prefix(depth)
+      else
+        self.tilecode = nil
+      end
+    end
+  end
+end