arunthampi-friendly 0.5.1

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

data/lib/friendly/document/convenience.rb

@@ -0,0 +1,41 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Convenience
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :collection_klass
+        
+        def collection_klass
+          @collection_klass ||= WillPaginate::Collection
+        end
+
+        def find(id)
+          doc = first(:id => id)
+          raise RecordNotFound, "Couldn't find #{name}/#{id}" if doc.nil?
+          doc
+        end
+
+        def paginate(conditions)
+          query      = query(conditions)
+          count      = count(query)
+          collection = collection_klass.new(query.page, query.per_page, count)
+          collection.replace(all(query))
+        end
+
+        def create(attributes = {})
+          doc = new(attributes)
+          doc.save
+          doc
+        end
+      end
+
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+    end
+  end
+end

data/lib/friendly/document/mixin.rb

@@ -0,0 +1,15 @@
+module Friendly
+  module Document
+    module Mixin
+      # FIXME: I'm not in love with this. But, I also don't think it's the
+      # end of the world.
+      def included(klass)
+        if klass.const_defined?(:ClassMethods)
+          klass.const_get(:ClassMethods).send(:include, const_get(:ClassMethods))
+        else
+          klass.send(:extend, const_get(:ClassMethods))
+        end
+      end
+    end
+  end
+end

data/lib/friendly/document/scoping.rb

@@ -0,0 +1,66 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Scoping
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :scope_proxy
+        
+        def scope_proxy
+          @scope_proxy ||= ScopeProxy.new(self)
+        end
+
+        # Add a named scope to this Document.
+        #
+        # e.g.
+        #     
+        #     class Post
+        #       indexes     :created_at
+        #       named_scope :recent, :order! => :created_at.desc
+        #     end
+        #
+        # Then, you can access the recent posts with:
+        #
+        #     Post.recent.all
+        # ...or...
+        #     Post.recent.first
+        #
+        # Both #all and #first also take additional parameters:
+        #
+        #     Post.recent.all(:author_id => @author.id)
+        #
+        # Scopes are also chainable. See the README or Friendly::Scope docs for details.
+        #
+        # @param [Symbol] name the name of the scope.
+        # @param [Hash] parameters the query that this named scope will perform.
+        #
+        def named_scope(name, parameters)
+          scope_proxy.add_named(name, parameters)
+        end
+
+        # Returns boolean based on whether the Document has a scope by a particular name.
+        #
+        # @param [Symbol] name The name of the scope in question.
+        #
+        def has_named_scope?(name)
+          scope_proxy.has_named_scope?(name)
+        end
+
+        # Create an ad hoc scope on this Document.
+        #
+        # e.g.
+        #     
+        #     scope = Post.scope(:order! => :created_at)
+        #     scope.all # => [#<Post>, #<Post>]
+        #
+        # @param [Hash] parameters the query parameters to create the scope with.
+        #
+        def scope(parameters)
+          scope_proxy.ad_hoc(parameters)
+        end
+      end
+    end
+  end
+end

data/lib/friendly/document/storage.rb

@@ -0,0 +1,63 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Storage
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :storage_proxy, :query_klass
+        
+        def create_tables!
+          storage_proxy.create_tables!
+        end
+
+        def storage_proxy
+          @storage_proxy ||= StorageProxy.new(self)
+        end
+
+        def indexes(*args)
+          storage_proxy.add(args)
+        end
+
+        def caches_by(*fields)
+          options = fields.last.is_a?(Hash) ? fields.pop : {}
+          storage_proxy.cache(fields, options)
+        end
+
+        def first(query)
+          storage_proxy.first(query(query))
+        end
+
+        def all(query)
+          storage_proxy.all(query(query))
+        end
+
+        def count(conditions)
+          storage_proxy.count(query(conditions))
+        end
+
+        def query_klass
+          @query_klass ||= Query
+        end
+
+        protected
+          def query(conditions)
+            conditions.is_a?(Query) ? conditions : query_klass.new(conditions)
+          end
+      end
+      
+      def save
+        new_record? ? storage_proxy.create(self) : storage_proxy.update(self)
+      end
+
+      def destroy
+        storage_proxy.destroy(self)
+      end
+
+      def storage_proxy
+        self.class.storage_proxy
+      end
+    end
+  end
+end

data/lib/friendly/document_table.rb

@@ -0,0 +1,56 @@
+require 'friendly/table'
+
+module Friendly
+  class DocumentTable < Table
+    attr_reader :klass, :translator
+
+    def initialize(klass, datastore=Friendly.datastore, translator=Translator.new)
+      super(datastore)
+      @klass      = klass
+      @translator = translator
+    end
+
+    def table_name
+      klass.table_name
+    end
+
+    def satisfies?(query)
+      query.conditions.keys == [:id] && !query.order
+    end
+
+    def create(document)
+      record = translator.to_record(document)
+      datastore.insert(document, record)
+      update_document(document, record)
+    end
+
+    def update(document)
+      record = translator.to_record(document)
+      datastore.update(document, document.id, record)
+      update_document(document, record)
+    end
+
+    def destroy(document)
+      datastore.delete(document, document.id)
+    end
+
+    def first(query)
+      record = datastore.first(klass, query)
+      record && to_object(record)
+    end
+
+    def all(query)
+      datastore.all(klass, query).map { |r| to_object(r) }
+    end
+
+    protected
+      def update_document(document, record)
+        attrs = record.reject { |k,v| k == :attributes }.merge(:new_record => false)
+        document.attributes = attrs
+      end
+
+      def to_object(record)
+        translator.to_object(klass, record)
+      end
+  end
+end

data/lib/friendly/index.rb

@@ -0,0 +1,73 @@
+require 'friendly/table'
+
+module Friendly
+  class Index < Table
+    attr_reader :klass, :fields, :datastore
+
+    def initialize(klass, fields, datastore = Friendly.datastore)
+      @klass     = klass
+      @fields    = fields
+      @datastore = datastore
+    end
+
+    def table_name
+      ["index", klass.table_name, "on", fields.join("_and_")].join("_")
+    end
+
+    def satisfies?(query)
+      exact_match?(query) || valid_partial_match?(query)
+    end
+
+    def first(query)
+      row = datastore.first(self, query)
+      row && klass.first(:id => row[:id])
+    end
+
+    def all(query)
+      ids = datastore.all(self, query).map { |row| row[:id] }
+      klass.all(:id => ids, :preserve_order! => !query.order.nil?)
+    end
+
+    def count(query)
+      datastore.count(self, query)
+    end
+
+    def create(document)
+      datastore.insert(self, record(document))
+    end
+
+    def update(document)
+      datastore.update(self, document.id, record(document))
+    end
+
+    def destroy(document)
+      datastore.delete(self, document.id)
+    end
+
+    protected
+      def exact_match?(query)
+        query.conditions.keys.map { |f| f.to_s }.sort == 
+          fields.map { |f| f.to_s }.sort && 
+            valid_order?(query.order)
+      end
+
+      def valid_partial_match?(query)
+        condition_fields = query.conditions.keys
+        sorted = condition_fields.sort { |a,b| field_index(a) <=> field_index(b) }
+        sorted << query.order.expression if query.order
+        sorted.zip(fields).all? { |a,b| a == b }
+      end
+
+      def valid_order?(order)
+        order.nil? || order.expression == fields.last
+      end
+
+      def field_index(attr)
+        fields.index(attr) || 0
+      end
+
+      def record(document)
+        Hash[*(fields + [:id]).map { |f| [f, document.send(f)] }.flatten]
+      end
+  end
+end