sporkd-couchrest 0.30

data/lib/couchrest/more/extended_document.rb

@@ -0,0 +1,283 @@
+require 'mime/types'
+require File.join(File.dirname(__FILE__), "property")
+require File.join(File.dirname(__FILE__), '..', 'mixins', 'extended_document_mixins')
+require "enumerator"
+
+module CouchRest
+  
+  # Same as CouchRest::Document but with properties and validations
+  class ExtendedDocument < Document
+    include CouchRest::Callbacks
+    include CouchRest::Mixins::DocumentQueries    
+    include CouchRest::Mixins::Views
+    include CouchRest::Mixins::DesignDoc
+    include CouchRest::Mixins::ExtendedAttachments
+    include CouchRest::Mixins::ClassProxy
+    include CouchRest::Mixins::Collection
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+    
+    def self.inherited(subklass)
+      subklass.send(:include, CouchRest::Mixins::Properties)
+      subklass.class_eval <<-EOS, __FILE__, __LINE__
+        def self.inherited(subklass)
+          subklass.properties = self.properties.dup
+        end
+      EOS
+      subclasses << subklass
+    end
+    
+    # Accessors
+    attr_accessor :casted_by
+    
+    # Callbacks
+    define_callbacks :create, "result == :halt"
+    define_callbacks :save, "result == :halt"
+    define_callbacks :update, "result == :halt"
+    define_callbacks :destroy, "result == :halt"
+    
+    def initialize(passed_keys={})
+      apply_defaults # defined in CouchRest::Mixins::Properties
+      passed_keys.each do |k,v|
+        if self.respond_to?("#{k}=")
+          self.send("#{k}=", passed_keys.delete(k))
+        end
+      end if passed_keys
+      super
+      cast_keys      # defined in CouchRest::Mixins::Properties
+      unless self['_id'] && self['_rev']
+        self['couchrest-type'] = self.class.to_s
+      end
+    end
+    
+    # Defines an instance and save it directly to the database 
+    # 
+    # ==== Returns
+    #  returns the reloaded document
+    def self.create(options)
+      instance = new(options)
+      instance.create
+      instance
+    end
+    
+    # Defines an instance and save it directly to the database 
+    # 
+    # ==== Returns
+    #  returns the reloaded document or raises an exception
+    def self.create!(options)
+      instance = new(options)
+      instance.create!
+      instance
+    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 self.timestamps!
+      class_eval <<-EOS, __FILE__, __LINE__
+        property(:updated_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
+        property(:created_at, :read_only => true, :cast_as => 'Time', :auto_validation => false)
+        
+        set_callback :save, :before do |object|
+          object['updated_at'] = Time.now
+          object['created_at'] = object['updated_at'] if object.new?
+        end
+      EOS
+    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 self.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
+    
+    # Temp solution to make the view_by methods available
+    def self.method_missing(m, *args, &block)
+      if has_view?(m)
+        query = args.shift || {}
+        view(m, query, *args, &block)
+      else
+        super
+      end
+    end
+    
+    ### instance methods
+    
+    # Returns the Class properties
+    #
+    # ==== Returns
+    # Array:: the list of properties for the instance
+    def properties
+      self.class.properties
+    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.base_doc
+    end
+    
+    # Checks if we're the top document
+    def base_doc?
+      !@casted_by
+    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 attributes that cannot be updated, silently ignoring them
+      # which matches Rails behavior when, for instance, setting created_at.
+      # make a copy, we don't want to change arguments
+      attrs = hash.dup
+      %w[_id _rev created_at updated_at].each {|attr| attrs.delete(attr)}
+      attrs.each do |k, v|
+        raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
+      end      
+      attrs.each do |k, v|
+        self.send("#{k}=",v)
+      end
+    end
+    alias :attributes= :update_attributes_without_saving
+
+    # Takes a hash as argument, and applies the values by using writer methods
+    # for each key. Raises a NoMethodError if the corresponding methods are
+    # missing. In case of error, no attributes are changed.
+    def update_attributes(hash)
+      update_attributes_without_saving hash
+      save
+    end
+
+    # for compatibility with old-school frameworks
+    alias :new_record? :new?
+    
+    # Trigger the callbacks (before, after, around)
+    # and create the document
+    # It's important to have a create callback since you can't check if a document
+    # was new after you saved it
+    #
+    # When creating a document, both the create and the save callbacks will be triggered.
+    def create(bulk = false)
+      caught = catch(:halt)  do
+        _run_create_callbacks do
+            _run_save_callbacks do
+              create_without_callbacks(bulk)
+          end
+        end
+      end
+    end
+    
+    # unlike save, create returns the newly created document
+    def create_without_callbacks(bulk =false)
+      raise ArgumentError, "a document requires a database to be created to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      (result["ok"] == true) ? self : false
+    end
+    
+    # Creates the document in the db. Raises an exception
+    # if the document is not created properly.
+    def create!
+      raise "#{self.inspect} failed to save" unless self.create
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # only if the document isn't new
+    def update(bulk = false)
+      caught = catch(:halt)  do
+        if self.new?
+          save(bulk)
+        else
+          _run_update_callbacks do
+            _run_save_callbacks do
+              save_without_callbacks(bulk)
+            end
+          end
+        end
+      end
+    end
+    
+    # Trigger the callbacks (before, after, around)
+    # and save the document
+    def save(bulk = false)
+      caught = catch(:halt)  do
+        if self.new?
+          _run_save_callbacks do
+            save_without_callbacks(bulk)
+          end
+        else
+          update(bulk)
+        end
+      end
+    end
+    
+    # Overridden to set the unique ID.
+    # Returns a boolean value
+    def save_without_callbacks(bulk = false)
+      raise ArgumentError, "a document requires a database to be saved to (The document or the #{self.class} default database were not set)" unless database
+      set_unique_id if new? && self.respond_to?(:set_unique_id)
+      result = database.save_doc(self, bulk)
+      mark_as_saved if result["ok"] == true
+      result["ok"] == true
+    end
+    
+    # Saves the document to the db using save. Raises an exception
+    # if the document is not saved properly.
+    def save!
+      raise "#{self.inspect} failed to save" unless self.save
+    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>.
+    def destroy(bulk=false)
+      caught = catch(:halt)  do
+        _run_destroy_callbacks do
+          result = database.delete_doc(self, bulk)
+          if result['ok']
+            self.delete('_rev')
+            self.delete('_id')
+          end
+          result['ok']
+        end
+      end
+    end
+    
+    protected
+    
+    # Set document_saved flag on all casted models to true
+    def mark_as_saved
+      self.each do |key, prop|
+        if prop.is_a?(Array)
+          prop.each do |item|
+            if item.respond_to?(:document_saved)
+              item.send(:document_saved=, true)
+            end
+          end
+        elsif prop.respond_to?(:document_saved)
+          prop.send(:document_saved=, true)
+        end
+      end
+    end
+    
+  end
+end

data/lib/couchrest/more/property.rb

@@ -0,0 +1,59 @@
+module CouchRest
+  
+  # Basic attribute support for adding getter/setter + validation
+  class Property
+    attr_reader :name, :type, :read_only, :alias, :default, :casted, :init_method, :options
+    
+    # attribute to define
+    def initialize(name, type = nil, options = {})
+      @name = name.to_s
+      parse_type(type)
+      parse_options(options)
+      self
+    end
+    
+    
+    private
+    
+      def parse_type(type)
+        if type.nil?
+          @type = 'String'
+        elsif type.is_a?(Array) && type.empty?
+          @type = 'Array'
+        else
+          @type = type.is_a?(Array) ? [type.first.to_s] : type.to_s
+        end
+      end
+      
+      def parse_options(options)
+        return if options.empty?
+        @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?
+        @casted             = options[:casted] ? true : false
+        @init_method        = options[:send] ? options.delete(:send) : 'new'
+        @options            = options
+      end
+    
+  end
+end
+
+class CastedArray < Array
+  attr_accessor :casted_by
+  
+  def << obj
+    obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+    super(obj)
+  end
+  
+  def push(obj)
+    obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+    super(obj)
+  end
+  
+  def []= index, obj
+    obj.casted_by = self.casted_by if obj.respond_to?(:casted_by)
+    super(index, obj)
+  end
+end

data/lib/couchrest/support/blank.rb

@@ -0,0 +1,42 @@
+# blank? methods for several different class types
+class Object
+  # Returns true if the object is nil or empty (if applicable)
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end # class Object
+
+class Numeric
+  # Numerics can't be blank
+  def blank?
+    false
+  end
+end # class Numeric
+
+class NilClass
+  # Nils are always blank
+  def blank?
+    true
+  end
+end # class NilClass
+
+class TrueClass
+  # True is not blank.
+  def blank?
+    false
+  end
+end # class TrueClass
+
+class FalseClass
+  # False is always blank.
+  def blank?
+    true
+  end
+end # class FalseClass
+
+class String
+  # Strips out whitespace then tests if the string is empty.
+  def blank?
+    strip.empty?
+  end
+end # class String

data/lib/couchrest/support/class.rb

@@ -0,0 +1,190 @@
+# Copyright (c) 2006-2009 David Heinemeier Hansson
+#  
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#  
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#  
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Extracted From
+# http://github.com/rails/rails/commit/971e2438d98326c994ec6d3ef8e37b7e868ed6e2
+
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+#
+#  class Person
+#    cattr_accessor :hair_colors
+#  end
+#
+#  Person.hair_colors = [:brown, :black, :blonde, :red]
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+      EOS
+    end
+  end unless Class.respond_to?(:cattr_reader)
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end unless Class.respond_to?(:cattr_writer)
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end unless Class.respond_to?(:cattr_accessor)
+  
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def extlib_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end unless Class.respond_to?(:extlib_inheritable_reader)
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def extlib_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+
+      self.send("#{ivar}=", yield) if block_given?
+    end
+  end unless Class.respond_to?(:extlib_inheritable_writer)
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def extlib_inheritable_accessor(*syms, &block)
+    extlib_inheritable_reader(*syms)
+    extlib_inheritable_writer(*syms, &block)
+  end unless Class.respond_to?(:extlib_inheritable_accessor)
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end unless Array.new.respond_to?(:extract_options!)
+  
+  # Wraps the object in an Array unless it's an Array.  Converts the
+  # object to an Array using #to_ary if it implements that.
+  def self.wrap(object)
+    case object
+    when nil
+      []
+    when self
+      object
+    else
+      if object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
+    end
+  end unless Array.respond_to?(:wrap)
+end
+

data/lib/couchrest/support/rails.rb

@@ -0,0 +1,47 @@
+# 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
+
+CouchRest::Document.class_eval do
+  # Need this when passing doc to a resourceful route
+  alias_method :to_param, :id
+
+  # Hack so that CouchRest::Document, which descends from Hash,
+  # doesn't appear to Rails routing as a Hash of options
+  def is_a?(o)
+    return false if o == Hash
+    super
+  end
+  alias_method :kind_of?, :is_a?
+
+  # Gives extended doc a seamless logger
+  def logger
+    ActiveRecord::Base.logger
+  end
+end
+
+CouchRest::CastedModel.class_eval do
+  # The to_param method is needed for rails to generate resourceful routes.
+  # In your controller, remember that it's actually the id of the document.
+  def id
+    return nil if base_doc.nil?
+    base_doc.id
+  end
+  alias_method :to_param, :id
+end
+
+require Pathname.new(File.dirname(__FILE__)).join('..', 'validation', 'validation_errors')
+
+CouchRest::Validation::ValidationErrors.class_eval do
+  # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.
+  # This method is called by error_messages_for
+  def count
+    errors.values.inject(0) { |error_count, errors_for_attribute| error_count + errors_for_attribute.size }
+  end
+end