openlogic-couchrest_model 1.0.0

data/lib/couchrest/model/base.rb

@@ -0,0 +1,129 @@
+module CouchRest
+  module Model
+    class Base < CouchRest::Document
+
+      extend ActiveModel::Naming
+
+      include CouchRest::Model::Configuration
+      include CouchRest::Model::Connection
+      include CouchRest::Model::Persistence
+      include CouchRest::Model::DocumentQueries
+      include CouchRest::Model::Views
+      include CouchRest::Model::DesignDoc
+      include CouchRest::Model::ExtendedAttachments
+      include CouchRest::Model::ClassProxy
+      include CouchRest::Model::Proxyable
+      include CouchRest::Model::Collection
+      include CouchRest::Model::PropertyProtection
+      include CouchRest::Model::Associations
+      include CouchRest::Model::Validations
+      include CouchRest::Model::Callbacks
+      include CouchRest::Model::Designs
+      include CouchRest::Model::CastedBy
+      include CouchRest::Model::Dirty
+      include CouchRest::Model::Callbacks
+
+      def self.subclasses
+        @subclasses ||= []
+      end
+
+      def self.inherited(subklass)
+        super
+        subklass.send(:include, CouchRest::Model::Properties)
+
+        subklass.class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def self.inherited(subklass)
+            super
+            subklass.properties = self.properties.dup
+            # This is nasty:
+            subklass._validators = self._validators.dup
+          end
+        EOS
+        subclasses << subklass
+      end
+
+      # Instantiate a new CouchRest::Model::Base by preparing all properties
+      # using the provided document hash.
+      #
+      # Options supported:
+      #
+      # * :directly_set_attributes, true when data comes directly from database
+      # * :database, provide an alternative database
+      #
+      # If a block is provided the new model will be passed into the
+      # block so that it can be populated.
+      def initialize(attributes = {}, options = {})
+        super()
+        prepare_all_attributes(attributes, options)
+        # set the instance's database, if provided
+        self.database = options[:database] unless options[:database].nil?
+        unless self['_id'] && self['_rev']
+          self[self.model_type_key] = self.class.to_s
+        end
+
+        yield self if block_given?
+
+        after_initialize if respond_to?(:after_initialize)
+        run_callbacks(:initialize) { self }
+      end
+
+
+      # Temp solution to make the view_by methods available
+      def self.method_missing(m, *args, &block)
+        if has_view?(m)
+          query = args.shift || {}
+          return view(m, query, *args, &block)
+        elsif m.to_s =~ /^find_(by_.+)/
+          view_name = $1
+          if has_view?(view_name)
+            return first_from_view(view_name, *args)
+          end
+        end
+        super
+      end
+
+      # compatbility for 1.8, it does not use respond_to_missing?
+      # thing is, when using it like this only, doing method(:find_by_view)
+      # will throw an error
+      def self.respond_to?(m, include_private = false)
+        super || respond_to_missing?(m, include_private)
+      end
+
+      # ruby 1.9 feature
+      # this allows ruby to know that the method is defined using
+      # method_missing, and as such, method(:find_by_view) will actually
+      # give a Method back, and not throw an error like in 1.8!
+      def self.respond_to_missing?(m, include_private = false)
+        has_view?(m) || has_view?(m.to_s[/^find_(by_.+)/, 1])
+      end
+
+      def to_key
+        new? ? nil : [id]
+      end
+
+      alias :to_param :id
+      alias :new_record? :new?
+      alias :new_document? :new?
+
+      # Compare this model with another by confirming to see 
+      # if the IDs and their databases match!
+      #
+      # Camparison of the database is required in case the 
+      # model has been proxied or loaded elsewhere.
+      #
+      # A Basic CouchRest document will only ever compare using 
+      # a Hash comparison on the attributes.
+      def == other
+        return false unless other.is_a?(Base)
+        if id.nil? && other.id.nil?
+          # no ids? assume comparing nested and revert to hash comparison
+          to_hash == other.to_hash
+        else
+          database == other.database && id == other.id
+        end
+      end
+      alias :eql? :==
+
+    end
+  end
+end

data/lib/couchrest/model/callbacks.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module CouchRest #:nodoc:
+  module Model #:nodoc:
+
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      CALLBACKS = [
+        :before_validation, :after_validation,
+        :after_initialize,
+        :before_create, :around_create, :after_create,
+        :before_destroy, :around_destroy, :after_destroy,
+        :before_save, :around_save, :after_save,
+        :before_update, :around_update, :after_update,
+      ]
+
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations::Callbacks
+
+        define_model_callbacks :initialize, :only => :after
+        define_model_callbacks :create, :destroy, :save, :update
+      end
+    end
+
+  end
+end

data/lib/couchrest/model/casted_array.rb

@@ -0,0 +1,83 @@
+#
+# Wrapper around Array so that the casted_by attribute is set in all
+# elements of the array.
+#
+
+module CouchRest::Model
+  class CastedArray < Array
+    include CouchRest::Model::CastedBy
+    include CouchRest::Model::Dirty
+    attr_accessor :casted_by_property
+
+    def initialize(array, property, parent = nil)
+      self.casted_by_property = property
+      self.casted_by = parent unless parent.nil?
+      super(array)
+    end
+
+    # Adding new entries
+
+    def << obj
+      super(instantiate_and_cast(obj))
+    end
+
+    def push(obj)
+      super(instantiate_and_cast(obj))
+    end
+
+    def unshift(obj)
+      super(instantiate_and_cast(obj))
+    end
+
+    def []= index, obj
+      value = instantiate_and_cast(obj, false)
+      couchrest_parent_will_change! if use_dirty? && value != self[index]
+      super(index, value)
+    end
+
+    def pop
+      couchrest_parent_will_change! if use_dirty? && self.length > 0
+      super
+    end
+
+    def shift
+      couchrest_parent_will_change! if use_dirty? && self.length > 0
+      super
+    end
+
+    def clear
+      couchrest_parent_will_change! if use_dirty? && self.length > 0
+      super
+    end
+
+    def delete(obj)
+      couchrest_parent_will_change! if use_dirty? && self.length > 0
+      super(obj)
+    end
+
+    def delete_at(index)
+      couchrest_parent_will_change! if use_dirty? && self.length > 0
+      super(index)
+    end
+
+    def build(*args)
+      obj = casted_by_property.build(*args)
+      self.push(obj)
+      obj
+    end
+
+    protected
+
+    def instantiate_and_cast(obj, change = true)
+      property = casted_by_property
+      couchrest_parent_will_change! if change && use_dirty?
+      if casted_by && property && obj.class != property.type_class
+        property.cast_value(casted_by, obj)
+      else
+        obj.casted_by = casted_by if obj.respond_to?(:casted_by)
+        obj.casted_by_property = casted_by_property if obj.respond_to?(:casted_by_property)
+        obj
+      end
+    end
+  end
+end

data/lib/couchrest/model/casted_by.rb

@@ -0,0 +1,33 @@
+
+module CouchRest::Model
+  module CastedBy
+    extend ActiveSupport::Concern
+    included do
+      self.send(:attr_accessor, :casted_by)
+      self.send(:attr_accessor, :casted_by_property)
+    end
+
+    # Gets a reference to the actual document in the DB
+    # Calls up to the next document if there is one,
+    # Otherwise we're at the top and we return self
+    def base_doc
+      return self if base_doc?
+      casted_by ? casted_by.base_doc : nil
+    end
+
+    # Checks if we're the top document
+    def base_doc?
+      !casted_by
+    end
+
+    # Provide the property this casted model instance has been
+    # used by. If it has not been set, search through the 
+    # casted_by objects properties to try and find it.
+    #def casted_by_property
+    #  return nil unless casted_by
+    #  attrs = casted_by.attributes
+    #  @casted_by_property ||= casted_by.properties.detect{ |k| attrs[k.to_s] === self }
+    #end
+
+  end
+end

data/lib/couchrest/model/casted_hash.rb

@@ -0,0 +1,84 @@
+#
+# Wrapper around Hash so that the casted_by attribute is set.
+
+module CouchRest::Model
+  class CastedHash < Hash
+    include CouchRest::Model::CastedBy
+    include CouchRest::Model::Dirty
+    attr_accessor :casted_by_property
+
+    def self.[](hash, property, parent = nil)
+      obj = super(hash)
+      obj.casted_by_property = property
+      obj.casted_by = parent unless parent.nil?
+      obj
+    end
+
+    # needed for dirty
+    def attributes
+      self
+    end
+
+    def []= key, obj
+      couchrest_attribute_will_change!(key) if use_dirty? && obj != self[key]
+      super(key, obj)
+    end
+
+    def delete(key)
+      couchrest_attribute_will_change!(key) if use_dirty? && include?(key)
+      super(key)
+    end
+
+    def merge!(other_hash)
+      if use_dirty? && other_hash && other_hash.kind_of?(Hash)
+        other_hash.keys.each do |key|
+          if self[key] != other_hash[key] || !include?(key)
+            couchrest_attribute_will_change!(key)
+          end
+        end
+      end
+      super(other_hash)
+    end
+
+    def replace(other_hash)
+      if use_dirty? && other_hash && other_hash.kind_of?(Hash)
+        # new keys and changed keys
+        other_hash.keys.each do |key|
+          if self[key] != other_hash[key] || !include?(key) 
+            couchrest_attribute_will_change!(key) 
+          end
+        end
+        # old keys
+        old_keys = self.keys.reject { |key| other_hash.include?(key) }
+        old_keys.each { |key| couchrest_attribute_will_change!(key) }
+      end
+
+      super(other_hash)
+    end
+
+    def clear
+      self.keys.each { |key| couchrest_attribute_will_change!(key) } if use_dirty?
+      super
+    end
+
+    def delete_if
+      if use_dirty? && block_given?
+        self.keys.each do |key|
+          couchrest_attribute_will_change!(key) if yield key, self[key]
+        end
+      end
+      super
+    end
+
+    # ruby 1.9 
+    def keep_if
+      if use_dirty? && block_given?
+        self.keys.each do |key|
+          couchrest_attribute_will_change!(key) if !yield key, self[key]
+        end
+      end
+      super
+    end
+
+  end
+end

data/lib/couchrest/model/class_proxy.rb

@@ -0,0 +1,135 @@
+module CouchRest
+  module Model
+    module ClassProxy
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        # Return a proxy object which represents a model class on a
+        # chosen database instance. This allows you to DRY operations
+        # where a database is chosen dynamically.
+        #  
+        # ==== Example:
+        #  
+        #   db = CouchRest::Database.new(...)
+        #   articles = Article.on(db)
+        #
+        #   articles.all { ... }
+        #   articles.by_title { ... }
+        #
+        #   u = articles.get("someid")
+        #
+        #   u = articles.new(:title => "I like plankton")
+        #   u.save    # saved on the correct database
+
+        def on(database)
+          Proxy.new(self, database)
+        end
+      end
+
+      class Proxy #:nodoc:
+        def initialize(klass, database)
+          @klass = klass
+          @database = database
+        end
+        
+        # Base
+        
+        def new(*args)
+          doc = @klass.new(*args)
+          doc.database = @database
+          doc
+        end
+        
+        def method_missing(m, *args, &block)
+          if has_view?(m)
+            query = args.shift || {}
+            return view(m, query, *args, &block)
+          elsif m.to_s =~ /^find_(by_.+)/
+            view_name = $1
+            if has_view?(view_name)
+              return first_from_view(view_name, *args) 
+            end
+          end
+          super
+        end
+        
+        # DocumentQueries
+        
+        def all(opts = {}, &block)
+          docs = @klass.all({:database => @database}.merge(opts), &block)
+          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
+          docs
+        end
+        
+        def count(opts = {}, &block)
+          @klass.all({:database => @database, :raw => true, :limit => 0}.merge(opts), &block)['total_rows']
+        end
+        
+        def first(opts = {})
+          doc = @klass.first({:database => @database}.merge(opts))
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        
+        def last(opts = {})
+          doc = @klass.last({:database => @database}.merge(opts))
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        
+        def get(id)
+          doc = @klass.get(id, @database)
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        alias :find :get
+
+        def get!(id)
+          doc = @klass.get!(id, @database)
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+        alias :find! :get!
+
+        # Views
+        
+        def has_view?(view)
+          @klass.has_view?(view)
+        end
+        
+        def view(name, query={}, &block)
+          docs = @klass.view(name, {:database => @database}.merge(query), &block)
+          docs.each { |doc| doc.database = @database if doc.respond_to?(:database) } if docs
+          docs
+        end
+        
+        def first_from_view(name, *args)
+          # add to first hash available, or add to end
+          (args.last.is_a?(Hash) ? args.last : (args << {}).last)[:database] = @database
+          doc = @klass.first_from_view(name, *args)
+          doc.database = @database if doc && doc.respond_to?(:database)
+          doc
+        end
+       
+        # DesignDoc
+        
+        def design_doc
+          @klass.design_doc
+        end
+        
+        def refresh_design_doc
+          @klass.refresh_design_doc(@database)
+        end
+        
+        def save_design_doc
+          @klass.save_design_doc(@database)
+        end
+
+      end
+    end
+  end
+end