arunthampi-friendly 0.5.1

data/lib/friendly.rb

@@ -0,0 +1,53 @@
+require 'friendly/associations'
+require 'friendly/attribute'
+require 'friendly/boolean'
+require 'friendly/cache'
+require 'friendly/cache/by_id'
+require 'friendly/data_store'
+require 'friendly/document'
+require 'friendly/document_table'
+require 'friendly/index'
+require 'friendly/indexer'
+require 'friendly/memcached'
+require 'friendly/query'
+require 'friendly/sequel_monkey_patches'
+require 'friendly/scope'
+require 'friendly/scope_proxy'
+require 'friendly/storage_factory'
+require 'friendly/storage_proxy'
+require 'friendly/translator'
+require 'friendly/uuid'
+
+require 'json/ext'
+require 'will_paginate/collection'
+
+module Friendly
+  class << self
+    attr_accessor :datastore, :db, :cache
+
+    def configure(config)
+      self.db        = Sequel.connect(config)
+      self.datastore = DataStore.new(db)
+    end
+
+    def batch
+      begin
+        datastore.start_batch
+        yield
+        datastore.flush_batch
+      ensure
+        datastore.reset_batch
+      end
+    end
+
+    def create_tables!
+      Document.create_tables!
+    end
+  end
+
+  class Error < RuntimeError; end
+  class RecordNotFound < Error; end
+  class MissingIndex < Error; end
+  class NoConverterExists < Friendly::Error; end
+  class NotSupported < Friendly::Error; end
+end

data/lib/friendly/associations.rb

@@ -0,0 +1,7 @@
+require 'friendly/associations/association'
+require 'friendly/associations/set'
+
+module Friendly
+  module Associations
+  end
+end

data/lib/friendly/associations/association.rb

@@ -0,0 +1,34 @@
+module Friendly
+  module Associations
+    class Association
+      attr_reader :owner_klass, :name
+
+      def initialize(owner_klass, name, options = {})
+        @owner_klass = owner_klass
+        @name        = name
+        @class_name  = options[:class_name]
+        @foreign_key = options[:foreign_key]
+      end
+
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      def foreign_key
+        @foreign_key ||= [owner_klass_name, :id].join("_").to_sym
+      end
+
+      def class_name
+        @class_name ||= name.to_s.classify
+      end
+
+      def owner_klass_name
+        owner_klass.name.to_s.underscore.singularize
+      end
+
+      def scope(document)
+        klass.scope(foreign_key => document.id)
+      end
+    end
+  end
+end

data/lib/friendly/associations/set.rb

@@ -0,0 +1,37 @@
+module Friendly
+  module Associations
+    class Set
+      attr_reader :klass, :association_klass, :associations
+
+      def initialize(klass, association_klass = Association)
+        @klass             = klass
+        @association_klass = association_klass
+        @associations      = {}
+      end
+
+      def add(name, options = {})
+        associations[name] = association_klass.new(klass, name, options)
+        add_association_accessor(name)
+      end
+
+      def get_scope(name, document)
+        get(name).scope(document)
+      end
+
+      def get(name)
+        associations[name]
+      end
+
+      protected
+        def add_association_accessor(name)
+          klass.class_eval do
+            eval <<-__END__
+            def #{name}
+              self.class.association_set.get_scope(:#{name}, self)
+            end
+            __END__
+          end
+        end
+    end
+  end
+end

data/lib/friendly/attribute.rb

@@ -0,0 +1,98 @@
+module Friendly
+  class Attribute
+    class << self
+      def register_type(type, sql_type, &block)
+        sql_types[type.name] = sql_type
+        converters[type]     = block
+      end
+
+      def deregister_type(type)
+        sql_types.delete(type.name)
+        converters.delete(type)
+      end
+        
+      def sql_type(type)
+        sql_types[type.name]
+      end
+
+      def sql_types
+        @sql_types ||= {}
+      end
+
+      def converters
+        @converters ||= {}
+      end
+
+      def custom_type?(klass)
+        !sql_type(klass).nil?
+      end
+    end
+
+    converters[Integer] = lambda { |s| s.to_i }
+    converters[String]  = lambda { |s| s.to_s }
+    
+    attr_reader :klass, :name, :type, :default_value
+
+    def initialize(klass, name, type, options = {})
+      @klass         = klass
+      @name          = name
+      @type          = type
+      @default_value = options[:default]
+      build_accessors
+    end
+
+    def typecast(value)
+      !type || value.is_a?(type) ? value : convert(value)
+    end
+
+    def convert(value)
+      assert_converter_exists(value)
+      converters[type].call(value)
+    end
+
+    def default
+      if !default_value.nil?
+        default_value
+      elsif type.respond_to?(:new)
+        type.new
+      else
+        nil
+      end
+    end
+
+    def assign_default_value(document)
+      document.send(:"#{name}=", default)
+    end
+      
+    protected
+      def build_accessors
+        n = name
+        klass.class_eval do
+          attr_reader n, :"#{n}_was"
+
+          eval <<-__END__
+            def #{n}=(value)
+              will_change(:#{n})
+              @#{n} = self.class.attributes[:#{n}].typecast(value)
+            end
+
+            def #{n}_changed?
+              attribute_changed?(:#{n})
+            end
+          __END__
+        end
+      end
+
+      def assert_converter_exists(value)
+        unless converters.has_key?(type)
+          msg = "Can't convert #{value} to #{type}. 
+                 Add a custom converter to Friendly::Attribute::CONVERTERS."
+          raise NoConverterExists, msg
+        end
+      end
+
+      def converters
+        self.class.converters
+      end
+  end
+end

data/lib/friendly/boolean.rb

@@ -0,0 +1,10 @@
+require 'friendly/attribute'
+
+module Friendly
+  # placeholder that represents a boolean
+  # since ruby has no boolean superclass
+  module Boolean
+  end
+end
+
+Friendly::Attribute.register_type(Friendly::Boolean, 'boolean') { |s| s }

data/lib/friendly/cache.rb

@@ -0,0 +1,24 @@
+require 'friendly/storage'
+
+module Friendly
+  class Cache < Storage
+    class << self
+      def cache_for(klass, fields, options)
+        unless fields == [:id]
+          raise NotSupported, "Caching is only possible by id at the moment."
+        end
+
+        ByID.new(klass, fields, options)
+      end
+    end
+
+    attr_reader :klass, :fields, :cache, :version
+
+    def initialize(klass, fields, options = {}, cache = Friendly.cache)
+      @klass   = klass
+      @fields  = fields
+      @cache   = cache
+      @version = options[:version] || 0
+    end
+  end
+end

data/lib/friendly/cache/by_id.rb

@@ -0,0 +1,33 @@
+module Friendly
+  class Cache
+    class ByID < Cache
+      def store(document)
+        cache.set(cache_key(document.id), document)
+      end
+      alias_method :create, :store
+      alias_method :update, :store
+
+      def destroy(document)
+        cache.delete(cache_key(document.id))
+      end
+
+      def first(query, &block)
+        cache.get(cache_key(query.conditions[:id]), &block)
+      end
+
+      def all(query, &block)
+        keys = query.conditions[:id].map { |k| cache_key(k) }
+        cache.multiget(keys, &block).values
+      end
+
+      def satisfies?(query)
+        query.conditions.keys == [:id]
+      end
+
+      protected
+        def cache_key(id)
+          [klass.name, version, id.to_guid].join("/")
+        end
+    end
+  end
+end

data/lib/friendly/data_store.rb

@@ -0,0 +1,73 @@
+module Friendly
+  class DataStore
+    attr_reader :database
+
+    def initialize(database)
+      @database = database
+    end
+
+    def insert(persistable, attributes)
+      batch? ? batch_insert(persistable, attributes) :
+        immediate_insert(persistable, attributes)
+    end
+
+    def all(persistable, query)
+      filtered = dataset(persistable)
+      filtered = filtered.where(query.conditions) unless query.conditions.empty?
+      if query.limit || query.offset
+        filtered = filtered.limit(query.limit, query.offset)
+      end
+      filtered = filtered.order(query.order) if query.order
+      filtered.map
+    end
+
+    def first(persistable, query)
+      dataset(persistable).first(query.conditions)
+    end
+
+    def update(persistable, id, attributes)
+      dataset(persistable).where(:id => id).update(attributes)
+    end
+
+    def delete(persistable, id)
+      dataset(persistable).where(:id => id).delete
+    end
+
+    def count(persistable, query)
+      dataset(persistable).where(query.conditions).count
+    end
+
+    def start_batch
+      Thread.current[:friendly_batch] = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def reset_batch
+      Thread.current[:friendly_batch] = nil
+    end
+
+    def flush_batch
+      batch = Thread.current[:friendly_batch]
+      batch.keys.each do |k|
+        database.from(k).multi_insert(batch[k], :commit_every => 1000)
+      end
+      reset_batch
+    end
+
+    protected
+      def dataset(persistable)
+        database.from(persistable.table_name)
+      end
+
+      def immediate_insert(persistable, attributes)
+        dataset(persistable).insert(attributes)
+      end
+
+      def batch_insert(persistable, attributes)
+        Thread.current[:friendly_batch][persistable.table_name] << attributes
+      end
+
+      def batch?
+        Thread.current[:friendly_batch]
+      end
+  end
+end

data/lib/friendly/document.rb

@@ -0,0 +1,70 @@
+require 'active_support/inflector'
+require 'friendly/document/associations'
+require 'friendly/document/attributes'
+require 'friendly/document/convenience'
+require 'friendly/document/scoping'
+require 'friendly/document/storage'
+
+module Friendly
+  module Document
+    class << self
+      attr_writer :documents
+
+      def included(klass)
+        documents << klass
+        klass.class_eval do
+          extend ClassMethods
+          attribute :id,         UUID
+          attribute :created_at, Time
+          attribute :updated_at, Time
+        end
+      end
+
+      def documents
+        @documents ||= []
+      end
+
+      def create_tables!
+        documents.each { |d| d.create_tables! }
+      end
+    end
+
+    module ClassMethods
+      attr_writer :table_name
+
+      def table_name
+        @table_name ||= name.pluralize.underscore
+      end
+    end
+
+    include Associations
+    include Convenience
+    include Scoping
+    include Storage
+    include Attributes
+
+    def table_name
+      self.class.table_name
+    end
+
+    def new_record?
+      new_record
+    end
+
+    def new_record
+      @new_record = true if @new_record.nil?
+      @new_record
+    end
+
+    def new_record=(value)
+      @new_record = value
+    end
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.is_a?(self.class) &&
+          !comparison_object.new_record? && 
+            comparison_object.id == id)
+    end
+  end
+end