tsuga 0.0.1

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

@@ -0,0 +1,52 @@
+require 'tsuga/model/cluster'
+require 'tsuga/model/tile'
+require 'tsuga/adapter/active_record/base'
+require 'tsuga/adapter/shared/cluster'
+
+module Tsuga::Adapter::ActiveRecord
+  module Cluster
+    def self.included(by)
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Cluster
+      by.send :include, Tsuga::Adapter::Shared::Cluster
+      by.extend Scopes
+
+      by.class_eval do
+        belongs_to :parent, class_name: by.name
+      end
+    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
+
+      # FIXME: this also is redundant with the mongoid adapter implementation
+      def in_tile(*tiles)
+        depths = tiles.map(&:depth).uniq
+        raise ArgumentError, 'all tile must be at same depth' if depths.length > 1
+        where(tilecode: tiles.map(&:prefix))
+      end
+
+      def in_viewport(sw:nil, ne:nil, depth:nil)
+        tiles = Tsuga::Model::Tile.enclosing_viewport(point_sw: sw, point_ne: ne, depth: depth)
+        in_tile(*tiles)
+      end
+    end
+  end
+end
+

data/lib/tsuga/adapter/active_record/migration.rb

@@ -0,0 +1,50 @@
+require 'tsuga/adapter'
+require 'active_record'
+
+module Tsuga::Adapter::ActiveRecord
+  module Migration
+    def self.included(by)
+      by.extend(ClassMethods)
+    end
+
+    def up
+      create_table _clusters_table_name do |t|
+        t.string  :tilecode,       limit:32
+        t.integer :depth,          limit:1
+        t.string  :geohash,        limit:32
+        t.float   :lat
+        t.float   :lng
+        t.integer :weight
+        t.integer :parent_id
+        t.string  :children_type
+        t.text    :children_ids
+        t.float   :sum_lat,        limit:53
+        t.float   :sum_lng,        limit:53
+        t.float   :ssq_lat,        limit:53
+        t.float   :ssq_lng,        limit:53
+      end
+
+      add_index _clusters_table_name, :tilecode, using: :hash
+    end
+
+    def down
+      drop_table _clusters_table_name
+    end
+
+    private
+
+    def _clusters_table_name
+      self.class.clusters_table_name
+    end
+
+    module ClassMethods
+      def clusters_table_name=(custom_name)
+        @clusters_table_name = custom_name
+      end
+
+      def clusters_table_name
+        @clusters_table_name ||= :clusters
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,73 @@
+require 'tsuga/adapter/active_record/base'
+require 'tsuga/adapter/active_record/cluster'
+require 'tsuga/adapter/active_record/record'
+require 'tsuga/adapter/active_record/migration'
+require 'active_record'
+require 'sqlite3'
+require 'ostruct'
+require 'forwardable'
+require 'yaml'
+
+module Tsuga::Adapter::ActiveRecord
+  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 ||= begin
+          unless ActiveRecord::Base.connected?
+            ActiveRecord::Base.establish_connection(adapter:'sqlite3', database:':memory:')
+          end
+          ActiveRecord::Base.connection
+        end
+      end
+
+      def _prepare_tables
+        _db.drop_table(:test_records) if _db.table_exists?(:test_records)
+        _db.create_table(:test_records) do |t|
+          t.string   :geohash, limit:32
+          t.float    :lat
+          t.float    :lng
+        end
+        _db.add_index :test_records, :geohash
+
+        _db.drop_table(:test_clusters) if _db.table_exists?(:test_clusters)
+        Migration.new.tap { |m| m.verbose = false ; m.up }
+      end
+
+      def _build_test_models
+        _prepare_tables
+
+        cluster_model = Class.new(ActiveRecord::Base) do
+          self.table_name = 'test_clusters'
+          include Tsuga::Adapter::ActiveRecord::Cluster
+
+          def run_callbacks(*args)
+            yield if block_given?
+          end
+        end
+
+        record_model = Class.new(ActiveRecord::Base) do
+          self.table_name = 'test_records'
+          include Tsuga::Adapter::ActiveRecord::Record
+        end
+
+        OpenStruct.new :clusters => cluster_model, :records => record_model
+      end
+
+      class Migration < ActiveRecord::Migration
+        include Tsuga::Adapter::ActiveRecord::Migration
+        self.clusters_table_name = :test_clusters
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'set'
+require 'tsuga/errors'
+require 'tsuga/adapter'
+
+module Tsuga::Adapter::Memory
+  # A memory-backed activerecord pattern implementation.
+  # Makes my test fly like crazy.
+  module Base
+
+    def self.included(by)
+      by.send :attr_reader, :id
+      by.extend ClassMethods
+    end
+
+
+    def initialize(*args)
+      @new_record = false
+      super(*args)
+    end
+
+
+    def new_record?
+      @new_record
+    end
+
+    def persist!
+      @id ||= self.class.generate_id
+      @new_record = false
+      self.class._records[id] = self.clone
+      self
+    end
+
+    def destroy
+      self.class._records.delete(id)
+      @id = nil
+      self
+    end
+
+
+    module ClassMethods
+      def mass_create(records)
+        records.each(&:persist!)
+      end
+
+      def mass_update(records)
+        records.each(&:persist!)
+      end
+
+      # FIXME: not thread safe. not sure we care, either.
+      def generate_id
+        @_last_id ||= 0
+        @_last_id += 1
+      end
+
+      def find_by_id(id)
+        _records.fetch(id) { raise Tsuga::RecordNotFound }.clone
+      end
+
+      def scoped(*filters)
+        Scope.new(self, filters)
+      end
+
+      def delete_all
+        _records.replace Hash.new
+      end
+
+      def find_each
+        _records.dup.each_value { |r| yield r.clone }
+      end
+
+      def collect_ids
+        Set.new(_records.keys)
+      end
+
+      def _records
+        @_records ||= {}
+      end
+    end # ClassMethods
+
+
+    class Scope
+      attr_reader :_filters
+      attr_reader :_origin
+
+      def initialize(origin, filters)
+        @_origin  = origin
+        @_filters = filters
+      end
+
+      def scoped(*filters)
+        Scope.new(_origin, _filters + filters)
+      end
+
+      def find_by_id(id)
+        _origin.find_by_id(id).tap do |record|
+          raise Tsuga::RecordNotFound unless _matches?(record)
+        end
+      end
+
+      def delete_all
+        _origin._records.each_pair do |id,record|
+          next unless _matches?(record)
+          _origin._records.delete(id)
+        end
+      end
+
+      def find_each
+        _origin._records.dup.each_value do |record| 
+          next unless _matches?(record)
+          yield record.clone
+        end
+      end
+
+      def collect_ids
+        Set.new.tap do |result|
+          _origin._records.each_value do |record| 
+            next unless _matches?(record)
+            result << record.id
+          end
+        end
+      end
+
+      def to_a
+        Array.new.tap do |ary|
+          find_each { |record| ary << record }
+        end
+      end
+
+      def method_missing(method, *args)
+        result = _origin.send(method, *args)
+        result = scoped(*(result._filters)) if result.kind_of?(Scope)
+      end
+
+      def respond_to?(method, include_private=false)
+        super || _origin.respond_to?(method, include_private)
+      end
+
+      private 
+
+      def _matches?(record)
+        _filters.all? { |f| f.call(record) }
+      end
+    end # Scope
+
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'tsuga/model/cluster'
+require 'tsuga/adapter/memory/base'
+require 'tsuga/adapter/shared/cluster'
+
+module Tsuga::Adapter::Memory
+  module Cluster
+    module Fields
+      attr_accessor :geohash, :lat, :lng, :depth, :parent_id
+      attr_accessor :children_type, :children_ids
+      attr_accessor :sum_lat, :sum_lng, :ssq_lat, :ssq_lng, :weight
+      attr_accessor :tilecode
+    end
+
+    def self.included(by)
+      by.send :include, Fields
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Cluster
+      by.send :include, Tsuga::Adapter::Shared::Cluster
+      by.extend ClassMethods
+    end
+
+    module ClassMethods
+      def at_depth(depth)
+        scoped(lambda { |r| r.depth == depth })
+      end
+
+      def in_tile(*tiles)
+        scoped(lambda { |r| tiles.any? { |t| (t.depth == r.depth) && t.contains?(r) } })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'tsuga/adapter/memory/base'
+require 'tsuga/adapter/memory/cluster'
+require 'ostruct'
+
+module Tsuga::Adapter::Memory
+  module Test
+    class << self
+      def clusters
+        models.clusters
+      end
+
+      def models
+        @_models ||= _build_test_models
+      end
+
+
+      private 
+
+      def _build_test_models
+
+        OpenStruct.new :clusters => Class.new {
+          include Tsuga::Adapter::Memory::Cluster 
+        }, :records => Array
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'tsuga/errors'
+require 'tsuga/adapter'
+require 'scanf'
+
+module Tsuga::Adapter::Mongoid
+  module Base
+    def self.included(by)
+      by.extend ScopeMethods
+    end
+
+    def persist!
+      save!
+    end
+
+    def id
+      @_id ||= super
+    end
+
+    module ScopeMethods
+      def mass_create(new_records)
+        collection.insert(new_records.map(&:attributes))
+      end
+
+      def mass_update(records)
+        records.map(&:persist!)
+      end
+
+      def find_by_id(id)
+        find(id)
+      end
+
+      def collect_ids
+        pluck(:id)
+      end
+
+      def find_each(&block)
+        each(&block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'tsuga/model/tile'
+require 'tsuga/model/cluster'
+require 'tsuga/adapter/mongoid/base'
+require 'tsuga/adapter/shared/cluster'
+require 'mongoid'
+
+module Tsuga::Adapter::Mongoid
+  module Cluster
+    def self.included(by)
+      by.send :include, Base
+      by.send :include, Tsuga::Model::Cluster
+      by.send :include, Tsuga::Adapter::Shared::Cluster
+      by.extend ScopeMethods
+    end
+
+    module ScopeMethods
+      def at_depth(depth)
+        where(:depth => depth)
+      end
+
+      def in_tile(*tiles)
+        # where(:geohash.gte => sw, :geohash.lte => ne)
+        depths = tiles.map(&:depth).uniq
+        raise ArgumentError, 'all tiles must be at same depth' if depths.length > 1
+        where(:tilecode.in => tiles.map(&:prefix))
+      end
+    end
+  end
+end