couchrest_model_thought 1.0.0.beta8

data/lib/couchrest/model/extended_attachments.rb

@@ -0,0 +1,73 @@
+module CouchRest
+  module Model
+    module ExtendedAttachments
+
+      # Add a file attachment to the current document. Expects
+      # :file and :name to be included in the arguments.
+      def create_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return if has_attachment?(args[:name])
+        self['_attachments'] ||= {}
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # reads the data from an attachment
+      def read_attachment(attachment_name)
+        database.fetch_attachment(self, attachment_name)
+      end
+
+      # modifies a file attachment on the current doc
+      def update_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return unless has_attachment?(args[:name])
+        delete_attachment(args[:name])
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # deletes a file attachment from the current doc
+      def delete_attachment(attachment_name)
+        return unless self['_attachments']
+        self['_attachments'].delete attachment_name
+      end
+
+      # returns true if attachment_name exists
+      def has_attachment?(attachment_name)
+        !!(self['_attachments'] && self['_attachments'][attachment_name] && !self['_attachments'][attachment_name].empty?)
+      end
+
+      # returns URL to fetch the attachment from
+      def attachment_url(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.root}/#{self.id}/#{attachment_name}"
+      end
+      
+      # returns URI to fetch the attachment from
+      def attachment_uri(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.uri}/#{self.id}/#{attachment_name}"
+      end
+      
+      private
+      
+        def get_mime_type(path)
+          return nil if path.nil?
+          type = ::MIME::Types.type_for(path)
+          type.empty? ? nil : type.first.content_type
+        end
+
+        def set_attachment_attr(args)
+          content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file].path)
+          content_type ||= (get_mime_type(args[:name]) || 'text/plain')
+          self['_attachments'][args[:name]] = {
+            'content_type' => content_type,
+            'data'         => args[:file].read
+          }
+        end
+      
+    end # module ExtendedAttachments
+  end
+end

data/lib/couchrest/model/persistence.rb

@@ -0,0 +1,141 @@
+module CouchRest
+  module Model
+    module Persistence
+      extend ActiveSupport::Concern
+
+      # Create the document. Validation is enabled by default and will return 
+      # false if the document is not valid. If all goes well, the document will
+      # be returned.
+      def create(options = {})
+        return false unless perform_validations(options)
+        _run_create_callbacks do
+          _run_save_callbacks do
+            set_unique_id if new? && self.respond_to?(:set_unique_id)
+            result = database.save_doc(self)
+            (result["ok"] == true) ? self : false
+          end
+        end
+      end
+     
+      # Creates the document in the db. Raises an exception
+      # if the document is not created properly.
+      def create!
+        self.class.fail_validate!(self) unless self.create
+      end
+      
+      # Trigger the callbacks (before, after, around)
+      # only if the document isn't new
+      def update(options = {})
+        raise "Calling #{self.class.name}#update on document that has not been created!" if self.new?
+        return false unless perform_validations(options)
+        _run_update_callbacks do
+          _run_save_callbacks do
+            result = database.save_doc(self)
+            result["ok"] == true
+          end
+        end
+      end
+      
+      # Trigger the callbacks (before, after, around) and save the document
+      def save(options = {})
+        self.new? ? create(options) : update(options)
+      end
+      
+      # Saves the document to the db using save. Raises an exception
+      # if the document is not saved properly.
+      def save!
+        self.class.fail_validate!(self) unless self.save
+        true
+      end
+
+      # Deletes the document from the database. Runs the :destroy callbacks.
+      # Removes the <tt>_id</tt> and <tt>_rev</tt> fields, preparing the
+      # document to be saved to a new <tt>_id</tt> if required.
+      def destroy
+        _run_destroy_callbacks do
+          result = database.delete_doc(self)
+          if result['ok']
+            self.delete('_rev')
+            self.delete('_id')
+          end
+          result['ok']
+        end
+      end
+
+    protected
+
+      def perform_validations(options = {})
+        perform_validation = case options
+        when Hash
+          options[:validate] != false
+        else
+          options
+        end
+        perform_validation ? valid? : true
+      end
+
+
+      module ClassMethods
+
+        # Creates a new instance, bypassing attribute protection
+        #
+        #
+        # ==== Returns
+        #  a document instance
+        def create_from_database(doc = {})
+          base = (doc['couchrest-type'].blank? || doc['couchrest-type'] == self.to_s) ? self : doc['couchrest-type'].constantize
+          base.new(doc, :directly_set_attributes => true)      
+        end
+
+        # Defines an instance and save it directly to the database 
+        # 
+        # ==== Returns
+        #  returns the reloaded document
+        def create(attributes = {})
+          instance = new(attributes)
+          instance.create
+          instance
+        end
+        
+        # Defines an instance and save it directly to the database 
+        # 
+        # ==== Returns
+        #  returns the reloaded document or raises an exception
+        def create!(attributes = {})
+          instance = new(attributes)
+          instance.create!
+          instance
+        end
+
+        # Name a method that will be called before the document is first saved,
+        # which returns a string to be used for the document's <tt>_id</tt>.
+        #
+        # Because CouchDB enforces a constraint that each id must be unique,
+        # this can be used to enforce eg: uniq usernames. Note that this id
+        # must be globally unique across all document types which share a
+        # database, so if you'd like to scope uniqueness to this class, you
+        # should use the class name as part of the unique id.
+        def unique_id method = nil, &block
+          if method
+            define_method :set_unique_id do
+              self['_id'] ||= self.send(method)
+            end
+          elsif block
+            define_method :set_unique_id do
+              uniqid = block.call(self)
+              raise ArgumentError, "unique_id block must not return nil" if uniqid.nil?
+              self['_id'] ||= uniqid
+            end
+          end
+        end
+
+        # Raise an error if validation failed.
+        def fail_validate!(document)
+          raise Errors::Validations.new(document)
+        end
+      end
+      
+
+    end
+  end
+end

data/lib/couchrest/model/properties.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+module CouchRest
+  module Model
+    module Properties
+      
+      class IncludeError < StandardError; end
+      
+      def self.included(base)
+        base.class_eval <<-EOS, __FILE__, __LINE__ + 1
+            extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
+            self.properties ||= []
+        EOS
+        base.extend(ClassMethods)
+        raise CouchRest::Mixins::Properties::IncludeError, "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 (base.new.respond_to?(:[]) && base.new.respond_to?(:[]=))
+      end
+
+      # Returns the Class properties
+      #
+      # ==== Returns
+      # Array:: the list of properties for model's class
+      def properties
+        self.class.properties
+      end
+
+      def read_attribute(property)
+        self[property.to_s]
+      end
+
+      def write_attribute(property, value)
+        prop = property.is_a?(Property) ? property : self.class.properties.detect {|p| p.to_s == property.to_s}
+        raise "Missing property definition for #{property.to_s}" unless prop
+        self[prop.to_s] = prop.cast(self, value)
+      end
+
+      def apply_all_property_defaults
+        return if self.respond_to?(:new?) && (new? == false)
+        # TODO: cache the default object
+        self.class.properties.each do |property|
+          write_attribute(property, property.default_value)
+        end
+      end
+     
+      module ClassMethods
+        
+        def property(name, *options, &block)
+          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. CouchRest uses a pretty
+        # decent time format by default. See Time#to_json
+        def timestamps!
+          class_eval <<-EOS, __FILE__, __LINE__
+            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
+          EOS
+        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(Hash) do
+                include CastedModel
+              end
+              type.class_eval { yield type }
+              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
+            property
+          end
+          
+          # defines the getter for the property (and optional aliases)
+          def create_property_getter(property)
+            # meth = property.name
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{property.name}
+                read_attribute('#{property.name}')
+              end
+            EOS
+
+            if ['boolean', TrueClass.to_s.downcase].include?(property.type.to_s.downcase)
+              class_eval <<-EOS, __FILE__, __LINE__
+                def #{property.name}?
+                  value = read_attribute('#{property.name}')
+                  !(value.nil? || value == false)
+                end
+              EOS
+            end
+
+            if property.alias
+              class_eval <<-EOS, __FILE__, __LINE__ + 1
+                alias #{property.alias.to_sym} #{property.name.to_sym}
+              EOS
+            end
+          end
+
+          # defines the setter for the property (and optional aliases)
+          def create_property_setter(property)
+            property_name = property.name
+            class_eval <<-EOS
+              def #{property_name}=(value)
+                write_attribute('#{property_name}', value)
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS
+                alias #{property.alias.to_sym}= #{property_name.to_sym}=
+              EOS
+            end
+          end
+          
+      end # module ClassMethods
+      
+    end
+  end
+end

data/lib/couchrest/model/property.rb

@@ -0,0 +1,96 @@
+# 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 Hash where key is index!
+          data = value
+          value = [ ]
+          data.keys.sort.each do |k|
+            value << data[k]
+          end
+        elsif value.class != 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
+        value = type_class != String ? CastedArray.new(arr, self) : arr
+        value.casted_by = parent if value.respond_to?(:casted_by)
+      elsif !value.nil?
+        value = cast_value(parent, value)
+      end
+      value
+    end
+
+    # Cast an individual value, not an array
+    def cast_value(parent, value)
+      raise "An array inside an array cannot be casted, use CastedModel" if value.is_a?(Array)
+      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
+        Marshal.load(Marshal.dump(default))
+      end
+    end
+
+    private
+
+    def associate_casted_value_to_parent(parent, value)
+      value.casted_by = parent if value.respond_to?(:casted_by)
+      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/support/couchrest.rb

@@ -0,0 +1,19 @@
+
+module CouchRest
+
+  class Database
+
+    alias :delete_orig! :delete!
+    def delete!
+      clear_model_fresh_cache
+      delete_orig!
+    end
+
+    # If the database is deleted, ensure that the design docs will be refreshed.
+    def clear_model_fresh_cache
+      ::CouchRest::Model::Base.subclasses.each{|klass| klass.req_design_doc_refresh if klass.respond_to?(:req_design_doc_refresh)}
+    end
+
+  end
+
+end

data/lib/couchrest/model/support/hash.rb

@@ -0,0 +1,9 @@
+# This file contains various hacks for Rails compatibility.
+class Hash
+  # Hack so that CouchRest::Document, which descends from Hash,
+  # doesn't appear to Rails routing as a Hash of options
+  def self.===(other)
+    return false if self == Hash && other.is_a?(CouchRest::Document)
+    super
+  end
+end

data/lib/couchrest/model/typecast.rb

@@ -0,0 +1,170 @@
+class Time                       
+  # returns a local time value much faster than Time.parse
+  def self.mktime_with_offset(string)
+    string =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})[T|\s](\d{2}):(\d{2}):(\d{2})([\+|\s|\-])*(\d{2}):?(\d{2})/
+    # $1 = year
+    # $2 = month
+    # $3 = day
+    # $4 = hours
+    # $5 = minutes
+    # $6 = seconds
+    # $7 = time zone direction
+    # $8 = tz difference
+    # utc time with wrong TZ info: 
+    time = mktime($1, RFC2822_MONTH_NAME[$2.to_i - 1], $3, $4, $5, $6, $7)
+    tz_difference = ("#{$7 == '-' ? '+' : '-'}#{$8}".to_i * 3600)
+    time + tz_difference + zone_offset(time.zone) 
+  end 
+end
+
+module CouchRest
+  module Model
+    module Typecast
+
+      def typecast_value(value, property) # klass, init_method)
+        return nil if value.nil?
+        klass = property.type_class
+        if value.instance_of?(klass) || klass == Object
+          value
+        elsif [String, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class].include?(klass)
+          send('typecast_to_'+klass.to_s.downcase, value)
+        else
+          # Allow the init_method to be defined as a Proc for advanced conversion
+          property.init_method.is_a?(Proc) ? property.init_method.call(value) : klass.send(property.init_method, value)
+        end
+      end
+
+      protected
+
+        # Typecast a value to an Integer
+        def typecast_to_integer(value)
+          typecast_to_numeric(value, :to_i)
+        end
+
+        # Typecast a value to a String
+        def typecast_to_string(value)
+          value.to_s
+        end
+
+        # Typecast a value to a true or false
+        def typecast_to_trueclass(value)
+          if value.kind_of?(Integer)
+            return true  if value == 1
+            return false if value == 0
+          elsif value.respond_to?(:to_s)
+            return true  if %w[ true  1 t ].include?(value.to_s.downcase)
+            return false if %w[ false 0 f ].include?(value.to_s.downcase)
+          end
+          value
+        end
+
+        # Typecast a value to a BigDecimal
+        def typecast_to_bigdecimal(value)
+          if value.kind_of?(Integer)
+            value.to_s.to_d
+          else
+            typecast_to_numeric(value, :to_d)
+          end
+        end
+
+        # Typecast a value to a Float
+        def typecast_to_float(value)
+          typecast_to_numeric(value, :to_f)
+        end
+
+        # Match numeric string
+        def typecast_to_numeric(value, method)
+          if value.respond_to?(:to_str)
+            if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+              $1.send(method)
+            else
+              value
+            end
+          elsif value.respond_to?(method)
+            value.send(method)
+          else
+            value
+          end
+        end
+
+        # Typecasts an arbitrary value to a DateTime.
+        # Handles both Hashes and DateTime instances.
+        # This is slow!! Use Time instead.
+        def typecast_to_datetime(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_datetime(value)
+          else
+            DateTime.parse(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Date
+        # Handles both Hashes and Date instances.
+        def typecast_to_date(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_date(value)
+          elsif value.is_a?(Time) # sometimes people think date is time!
+            value.to_date
+          elsif value.to_s =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})/
+            # Faster than parsing the date
+            Date.new($1.to_i, $2.to_i, $3.to_i)
+          else
+            Date.parse(value)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Time
+        # Handles both Hashes and Time instances.
+        def typecast_to_time(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_time(value)
+          else
+            Time.mktime_with_offset(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        rescue TypeError
+          value
+        end
+
+        # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_datetime(value)
+          DateTime.new(*extract_time(value))
+        end
+
+        # Creates a Date instance from a Hash with keys :year, :month, :day
+        def typecast_hash_to_date(value)
+          Date.new(*extract_time(value)[0, 3])
+        end
+
+        # Creates a Time instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_time(value)
+          Time.local(*extract_time(value))
+        end
+
+        # Extracts the given args from the hash. If a value does not exist, it
+        # uses the value of Time.now.
+        def extract_time(value)
+          now  = Time.now
+          [:year, :month, :day, :hour, :min, :sec].map do |segment|
+            typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
+          end
+        end
+
+        # Typecast a value to a Class
+        def typecast_to_class(value)
+          value.to_s.constantize
+        rescue NameError
+          value
+        end
+
+    end
+  end
+end
+

data/lib/couchrest/model/validations/casted_model.rb

@@ -0,0 +1,14 @@
+module CouchRest
+  module Model
+    module Validations
+      class CastedModelValidator < ActiveModel::EachValidator
+        
+        def validate_each(document, attribute, value)
+          values = value.is_a?(Array) ? value : [value]
+          return if values.collect {|doc| doc.nil? || doc.valid? }.all?
+          document.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+        end
+      end
+    end
+  end
+end

data/lib/couchrest/model/validations/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  errors:
+    messages:
+      taken: "is already taken"
+