openlogic-couchrest_model 1.0.0

data/lib/couchrest/model/properties.rb

@@ -0,0 +1,228 @@
+# encoding: utf-8
+module CouchRest
+  module Model
+    module Properties
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute(:properties) unless self.respond_to?(:properties)
+        class_attribute(:properties_by_name) unless self.respond_to?(:properties_by_name)
+        self.properties ||= []
+        self.properties_by_name ||= {}
+        raise "You can only mixin Properties in a class responding to [] and []=, if you tried to mixin CastedModel, make sure your class inherits from Hash or responds to the proper methods" unless (method_defined?(:[]) && method_defined?(:[]=))
+      end
+
+      # Provide an attribute hash ready to be sent to CouchDB but with
+      # all the nil attributes removed.
+      def as_couch_json
+        super.delete_if{|k,v| v.nil?}
+      end
+
+      # Returns the Class properties with their values
+      #
+      # ==== Returns
+      # Array:: the list of properties with their values
+      def properties_with_values
+        props = {}
+        properties.each { |property| props[property.name] = read_attribute(property.name) }
+        props
+      end
+
+      # Read the casted value of an attribute defined with a property.
+      #
+      # ==== Returns
+      # Object:: the casted attibutes value.
+      def read_attribute(property)
+        self[find_property!(property).to_s]
+      end
+
+      # Store a casted value in the current instance of an attribute defined
+      # with a property and update dirty status
+      def write_attribute(property, value)
+        prop = find_property!(property)
+        value = prop.is_a?(String) ? value : prop.cast(self, value)
+        couchrest_attribute_will_change!(prop.name) if use_dirty? && self[prop.name] != value
+        self[prop.name] = value
+      end
+
+      # Takes a hash as argument, and applies the values by using writer methods
+      # for each key. It doesn't save the document at the end. Raises a NoMethodError if the corresponding methods are
+      # missing. In case of error, no attributes are changed.
+      def update_attributes_without_saving(hash)
+        # Remove any protected and update all the rest. Any attributes
+        # which do not have a property will simply be ignored.
+        attrs = remove_protected_attributes(hash)
+        directly_set_attributes(attrs)
+      end
+      alias :attributes= :update_attributes_without_saving
+
+      # 'attributes' needed for Dirty
+      alias :attributes :properties_with_values
+
+      def set_attributes(hash)
+        attrs = remove_protected_attributes(hash)
+        directly_set_attributes(attrs)
+      end
+
+      protected
+
+      def find_property(property)
+        property.is_a?(Property) ? property : self.class.properties_by_name[property.to_s]
+      end
+
+      # The following methods should be accessable by the Model::Base Class, but not by anything else!
+      def apply_all_property_defaults
+        return if self.respond_to?(:new?) && (new? == false)
+        # TODO: cache the default object
+        # Never mark default options as dirty!
+        dirty, self.disable_dirty = self.disable_dirty, true
+        self.class.properties.each do |property|
+          write_attribute(property, property.default_value)
+        end
+        self.disable_dirty = dirty
+      end
+
+      def prepare_all_attributes(attrs = {}, options = {})
+        self.disable_dirty = !!options[:directly_set_attributes]
+        apply_all_property_defaults
+        if options[:directly_set_attributes]
+          directly_set_read_only_attributes(attrs)
+          directly_set_attributes(attrs, true)
+        else
+          attrs = remove_protected_attributes(attrs)
+          directly_set_attributes(attrs)
+        end
+        self.disable_dirty = false
+        self
+      end
+
+      def find_property!(property)
+        prop = find_property(property)
+        raise ArgumentError, "Missing property definition for #{property.to_s}" if prop.nil?
+        prop
+      end
+
+      # Set all the attributes and return a hash with the attributes
+      # that have not been accepted.
+      def directly_set_attributes(hash, mass_assign = false)
+        return if hash.nil?
+        hash.reject do |key, value|
+          if self.respond_to?("#{key}=")
+            self.send("#{key}=", value)
+          elsif mass_assign || mass_assign_any_attribute
+            self[key] = value
+          end
+        end
+      end
+
+      def directly_set_read_only_attributes(hash)
+        property_list = self.properties.map{|p| p.name}
+        hash.each do |attribute_name, attribute_value|
+          next if self.respond_to?("#{attribute_name}=")
+          if property_list.include?(attribute_name)
+            write_attribute(attribute_name, hash.delete(attribute_name))
+          end
+        end
+      end
+
+
+
+      module ClassMethods
+
+        def property(name, *options, &block)
+          raise "Invalid property definition, '#{name}' already used for CouchRest Model type field" if name.to_s == model_type_key.to_s && CouchRest::Model::Base >= self
+          opts = { }
+          type = options.shift
+          if type.class != Hash
+            opts[:type] = type
+            opts.merge!(options.shift || {})
+          else
+            opts.update(type)
+          end
+          existing_property = self.properties.find{|p| p.name == name.to_s}
+          if existing_property.nil? || (existing_property.default != opts[:default])
+            define_property(name, opts, &block)
+          end
+        end
+
+        # Automatically set <tt>updated_at</tt> and <tt>created_at</tt> fields
+        # on the document whenever saving occurs.
+        # 
+        # These properties are casted as Time objects, so they should always
+        # be set to UTC.
+        def timestamps!
+          property(:updated_at, Time, :read_only => true, :protected => true, :auto_validation => false)
+          property(:created_at, Time, :read_only => true, :protected => true, :auto_validation => false)
+
+          set_callback :save, :before do |object|
+            write_attribute('updated_at', Time.now)
+            write_attribute('created_at', Time.now) if object.new?
+          end
+        end
+
+        protected
+
+          # This is not a thread safe operation, if you have to set new properties at runtime
+          # make sure a mutex is used.
+          def define_property(name, options={}, &block)
+            # check if this property is going to casted
+            type = options.delete(:type) || options.delete(:cast_as)
+            if block_given?
+              type = Class.new do
+                include Embeddable
+              end
+              if block.arity == 1 # Traditional, with options
+                type.class_eval { yield type }
+              else
+                type.instance_exec(&block)
+              end
+              type = [type] # inject as an array
+            end
+            property = Property.new(name, type, options)
+            create_property_getter(property)
+            create_property_setter(property) unless property.read_only == true
+            if property.type_class.respond_to?(:validates_casted_model)
+              validates_casted_model property.name
+            end
+            properties << property
+            properties_by_name[property.to_s] = property
+            property
+          end
+
+          # defines the getter for the property (and optional aliases)
+          def create_property_getter(property)
+            define_method(property.name) do
+              read_attribute(property.name)
+            end
+
+            if ['boolean', TrueClass.to_s.downcase].include?(property.type.to_s.downcase)
+              define_method("#{property.name}?") do
+                value = read_attribute(property.name)
+                !(value.nil? || value == false)
+              end
+            end
+
+            if property.alias
+              alias_method(property.alias, property.name.to_sym)
+            end
+          end
+
+          # defines the setter for the property (and optional aliases)
+          def create_property_setter(property)
+            name = property.name
+
+            define_method("#{name}=") do |value|
+              write_attribute(name, value)
+            end
+
+            if property.alias
+              alias_method "#{property.alias}=", "#{name}="
+            end
+          end
+
+      end # module ClassMethods
+
+    end
+  end
+end
+

data/lib/couchrest/model/property.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+module CouchRest::Model
+  class Property
+
+    include ::CouchRest::Model::Typecast
+
+    attr_reader :name, :type, :type_class, :read_only, :alias, :default, :casted, :init_method, :options
+
+    # Attribute to define.
+    # All Properties are assumed casted unless the type is nil.
+    def initialize(name, type = nil, options = {})
+      @name = name.to_s
+      @casted = true
+      parse_type(type)
+      parse_options(options)
+      self
+    end
+
+    def to_s
+      name
+    end
+
+    # Cast the provided value using the properties details.
+    def cast(parent, value)
+      return value unless casted
+      if type.is_a?(Array)
+        if value.nil?
+          value = []
+        elsif [Hash, HashWithIndifferentAccess].include?(value.class)
+          # Assume provided as a params hash where key is index
+          value = parameter_hash_to_array(value)
+        elsif !value.is_a?(Array)
+          raise "Expecting an array or keyed hash for property #{parent.class.name}##{self.name}"
+        end
+        arr = value.collect { |data| cast_value(parent, data) }
+        # allow casted_by calls to be passed up chain by wrapping in CastedArray
+        CastedArray.new(arr, self, parent)
+      elsif (type == Object || type == Hash) && (value.is_a?(Hash))
+        # allow casted_by calls to be passed up chain by wrapping in CastedHash
+        CastedHash[value, self, parent]
+      elsif !value.nil?
+        cast_value(parent, value)
+      end
+    end
+
+    # Cast an individual value
+    def cast_value(parent, value)
+      value = typecast_value(value, self)
+      associate_casted_value_to_parent(parent, value)
+    end
+
+    def default_value
+      return if default.nil?
+      if default.class == Proc
+        default.call
+      else
+        # TODO identify cause of mutex errors
+        Marshal.load(Marshal.dump(default))
+      end
+    end
+
+    # Initialize a new instance of a property's type ready to be
+    # used. If a proc is defined for the init method, it will be used instead of 
+    # a normal call to the class.
+    def build(*args)
+      raise StandardError, "Cannot build property without a class" if @type_class.nil?
+      if @init_method.is_a?(Proc)
+        @init_method.call(*args)
+      else
+        @type_class.send(@init_method, *args)
+      end
+    end
+
+    private
+
+      def parameter_hash_to_array(source)
+        value = [ ]
+        source.keys.each do |k|
+          value[k.to_i] = source[k]
+        end
+        value.compact
+      end
+
+      def associate_casted_value_to_parent(parent, value)
+        value.casted_by = parent if value.respond_to?(:casted_by)
+        value.casted_by_property = self if value.respond_to?(:casted_by_property)
+        value
+      end
+
+      def parse_type(type)
+        if type.nil?
+          @casted = false
+          @type = nil
+          @type_class = nil
+        else
+          base = type.is_a?(Array) ? type.first : type
+          base = Object if base.nil?
+          raise "Defining a property type as a #{type.class.name.humanize} is not supported in CouchRest Model!" if base.class != Class
+          @type_class = base
+          @type = type
+        end
+      end
+
+      def parse_options(options)
+        @validation_format  = options.delete(:format)     if options[:format]
+        @read_only          = options.delete(:read_only)  if options[:read_only]
+        @alias              = options.delete(:alias)      if options[:alias]
+        @default            = options.delete(:default)    unless options[:default].nil?
+        @init_method        = options[:init_method] ? options.delete(:init_method) : 'new'
+        @options            = options
+      end
+
+  end
+end

data/lib/couchrest/model/property_protection.rb

@@ -0,0 +1,71 @@
+module CouchRest
+  module Model
+    module PropertyProtection
+      extend ActiveSupport::Concern
+
+      # Property protection from mass assignment to CouchRest::Model properties
+      #
+      # Protected methods will be removed from
+      #  * new
+      #  * update_attributes
+      #  * upate_attributes_without_saving
+      #  * attributes=
+      #
+      # There are two modes of protection
+      #  1) Declare accessible poperties, and assume all unspecified properties are protected
+      #    property :name,  :accessible => true
+      #    property :admin                      # this will be automatically protected
+      #
+      #  2) Declare protected properties, and assume all unspecified properties are accessible
+      #    property :name                       # this will not be protected
+      #    property :admin, :protected => true
+      #
+      #  3) Mix and match, and assume all unspecified properties are protected.
+      #    property :name,  :accessible => true
+      #    property :admin, :protected  => true # ignored
+      #    property :phone                      # this will be automatically protected
+      #
+      #  Note: the timestamps! method protectes the created_at and updated_at properties
+
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def accessible_properties
+          props = properties.select { |prop| prop.options[:accessible] }
+          if props.empty?
+            props = properties.select { |prop| !prop.options[:protected] }
+          end
+          props
+        end
+
+        def protected_properties
+          accessibles = accessible_properties
+          properties.reject { |prop| accessibles.include?(prop) }
+        end
+      end
+
+      def accessible_properties
+        self.class.accessible_properties
+      end
+
+      def protected_properties
+        self.class.protected_properties
+      end
+
+      # Return a new copy of the attributes hash with protected attributes
+      # removed.
+      def remove_protected_attributes(attributes)
+        protected_names = protected_properties.map { |prop| prop.name }
+        return attributes if protected_names.empty? or attributes.nil?
+
+        attributes.reject do |property_name, property_value|
+          protected_names.include?(property_name.to_s)
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/proxyable.rb

@@ -0,0 +1,183 @@
+module CouchRest
+  module Model
+    # :nodoc: Because I like inventing words
+    module Proxyable
+      extend ActiveSupport::Concern
+
+      def proxy_database
+        raise StandardError, "Please set the #proxy_database_method" if self.class.proxy_database_method.nil?
+        @proxy_database ||= self.class.prepare_database(self.send(self.class.proxy_database_method))
+      end
+
+      module ClassMethods
+
+
+        # Define a collection that will use the base model for the database connection
+        # details.
+        def proxy_for(assoc_name, options = {})
+          db_method = options[:database_method] || "proxy_database"
+          options[:class_name] ||= assoc_name.to_s.singularize.camelize
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{assoc_name}
+              @#{assoc_name} ||= CouchRest::Model::Proxyable::ModelProxy.new(::#{options[:class_name]}, self, self.class.to_s.underscore, #{db_method})
+            end
+          EOS
+        end
+
+        # Tell this model which other model to use a base for the database
+        # connection to use.
+        def proxied_by(model_name, options = {})
+          raise "Model can only be proxied once or ##{model_name} already defined" if method_defined?(model_name) || !proxy_owner_method.nil?
+          self.proxy_owner_method = model_name
+          attr_accessor :model_proxy
+          attr_accessor model_name
+          overwrite_database_reader(model_name)
+        end
+
+        # Define an a class variable accessor ready to be inherited and unique
+        # for each Class using the base.
+        # Perhaps there is a shorter way of writing this.
+        def proxy_owner_method=(name); @proxy_owner_method = name; end
+        def proxy_owner_method; @proxy_owner_method; end
+
+        # Define the name of a method to call to determine the name of
+        # the database to use as a proxy.
+        def proxy_database_method(name = nil)
+          @proxy_database_method = name if name
+          @proxy_database_method
+        end
+
+        private
+
+        # Ensure that no attempt is made to autoload a database connection
+        # by overwriting it to provide a basic accessor.
+        def overwrite_database_reader(model_name)
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def self.database
+              raise StandardError, "#{self.to_s} database must be accessed via '#{model_name}' proxy"
+            end
+          EOS
+        end
+
+      end
+
+      class ModelProxy
+
+        attr_reader :model, :owner, :owner_name, :database
+
+        def initialize(model, owner, owner_name, database)
+          @model      = model
+          @owner      = owner
+          @owner_name = owner_name
+          @database   = database
+        end
+
+        # Base
+        def new(attrs = {}, options = {}, &block)
+          proxy_block_update(:new, attrs, options, &block)
+        end
+
+        def build_from_database(attrs = {}, options = {}, &block)
+          proxy_block_update(:build_from_database, attrs, options, &block)
+        end
+
+        def method_missing(m, *args, &block)
+          if has_view?(m)
+            if model.respond_to?(m)
+              return model.send(m, *args).proxy(self)
+            else
+              query = args.shift || {}
+              return view(m, query, *args, &block)
+            end
+          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)
+          proxy_update_all(@model.all({:database => @database}.merge(opts), &block))
+        end
+
+        def count(opts = {})
+          @model.count({:database => @database}.merge(opts))
+        end
+
+        def first(opts = {})
+          proxy_update(@model.first({:database => @database}.merge(opts)))
+        end
+
+        def last(opts = {})
+          proxy_update(@model.last({:database => @database}.merge(opts)))
+        end
+
+        def get(id)
+          proxy_update(@model.get(id, @database))
+        end
+        alias :find :get
+
+        # Views
+
+        def has_view?(view)
+          @model.has_view?(view)
+        end
+
+        def view_by(*args)
+          @model.view_by(*args)
+        end
+
+        def view(name, query={}, &block)
+          proxy_update_all(@model.view(name, {:database => @database}.merge(query), &block))
+        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
+          proxy_update(@model.first_from_view(name, *args))
+        end
+
+        # DesignDoc
+        def design_doc
+          @model.design_doc
+        end
+
+        def save_design_doc(db = nil)
+          @model.save_design_doc(db || @database)
+        end
+
+
+        protected
+
+        # Update the document's proxy details, specifically, the fields that
+        # link back to the original document.
+        def proxy_update(doc)
+          if doc && doc.is_a?(model)
+            doc.database = @database
+            doc.model_proxy = self
+            doc.send("#{owner_name}=", owner)
+          end
+          doc
+        end
+
+        def proxy_update_all(docs)
+          docs.each do |doc|
+            proxy_update(doc)
+          end
+        end
+
+        def proxy_block_update(method, *args, &block)
+          model.send(method, *args) do |doc|
+            proxy_update(doc)
+            yield doc if block_given?
+          end
+        end
+
+      end
+    end
+  end
+end