wayne-friendly 0.5.1

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

data/lib/friendly/document/associations.rb

@@ -0,0 +1,50 @@
+require 'friendly/associations'
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Associations
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :association_set
+
+        def association_set
+          @association_set ||= Friendly::Associations::Set.new(self)
+        end
+
+        # Add a has_many association.
+        #
+        # e.g.
+        #
+        #     class Post
+        #       attribute :user_id, Friendly::UUID
+        #       indexes   :user_id
+        #     end
+        #      
+        #     class User
+        #       has_many :posts
+        #     end
+        #     
+        #     @user = User.create
+        #     @post = @user.posts.create
+        #     @user.posts.all == [@post] # => true
+        #
+        # _Note: Make sure that the target model is indexed on the foreign key. If it isn't, querying the association will raise Friendly::MissingIndex._
+        #
+        # Friendly defaults the foreign key to class_name_id just like ActiveRecord.
+        # It also converts the name of the association to the name of the target class just like ActiveRecord does.
+        #
+        # The biggest difference in semantics between Friendly's has_many and active_record's is that Friendly's just returns a Friendly::Scope object. If you want all the associated objects, you have to call #all to get them. You can also use any other Friendly::Scope method.
+        #
+        # @param [Symbol] name The name of the association and plural name of the target class.
+        # @option options [String] :class_name The name of the target class of this association if it is different than the name would imply.
+        # @option options [Symbol] :foreign_key Override the foreign key.
+        # 
+        def has_many(name, options = {})
+          association_set.add(name, options)
+        end
+      end
+    end
+  end
+end

data/lib/friendly/document/attributes.rb

@@ -0,0 +1,114 @@
+require 'friendly/document/mixin'
+require 'set'
+
+module Friendly
+  module Document
+    module Attributes
+      extend Mixin
+
+      module ClassMethods
+        def attribute(name, type = nil, options = {})
+          attributes[name] = Attribute.new(self, name, type, options)
+        end
+
+        def attributes
+          @attributes ||= {}
+        end
+
+        def new_without_change_tracking(attributes)
+          doc = new(attributes)
+          doc.reset_changes
+          doc
+        end
+      end
+
+      def initialize(opts = {})
+        assign_default_values
+        self.attributes = opts
+      end
+
+      def attributes=(attrs)
+        assert_no_duplicate_keys(attrs)
+        attrs.each { |name, value| assign(name, value) }
+      end
+
+      def to_hash
+        Hash[*self.class.attributes.keys.map { |n| [n, send(n)] }.flatten]
+      end
+
+      def assign_default_values
+        self.class.attributes.values.each { |a| a.assign_default_value(self) }
+      end
+
+      def assign(name, value)
+        send(:"#{name}=", value)
+      end
+
+      # Notify the object that an attribute is about to change.
+      #
+      # @param [Symbol] attribute The name of the attribute about to change.
+      #
+      def will_change(attribute)
+        changed << attribute
+        instance_variable_set(:"@#{attribute}_was", send(attribute))
+      end
+
+      # Get the original value of an attribute that has changed.
+      #
+      # @param [Symbol] attribute The name of the attribute.
+      #
+      def attribute_was(attribute)
+        instance_variable_get(:"@#{attribute}_was")
+      end
+
+      # Has this attribute changed?
+      #
+      # @param [Symbol] attribute The name of the attribute.
+      #
+      def attribute_changed?(attribute)
+        changed.include?(attribute)
+      end
+
+      # Have any of the attributes that are being tracked changed since last reset?
+      #
+      def changed?
+        !changed.empty?
+      end
+
+      # Which attributes that are being tracked have changed since last reset?
+      #
+      def changed
+        @changed ||= Set.new
+      end
+
+      # Reset all the changes to this object.
+      #
+      def reset_changes
+        changed.each { |c| not_changed(c) }.clear
+      end
+
+      # Reset the changed-ness of one attribute.
+      #
+      def not_changed(attribute)
+        instance_variable_set(:"@#{attribute}_was", nil)
+        changed.delete(attribute)
+      end
+
+      # Override #save to reset changes afterwards
+      #
+      # @override
+      #
+      def save
+        super
+        reset_changes
+      end
+
+      protected
+        def assert_no_duplicate_keys(hash)
+          if hash.keys.map { |k| k.to_s }.uniq.length < hash.keys.length
+            raise ArgumentError, "Duplicate keys: #{hash.inspect}"
+          end
+        end
+    end
+  end
+end