samflores-couchrest 0.2.1 → 0.12.3

data/lib/couchrest/more/extended_document.rb

@@ -1,217 +0,0 @@
-begin
-  # still required for Time parsing and pluralization in the validation
-  require 'extlib'
-rescue 
-  puts "CouchRest::ExtendedDocument still requires extlib (not for much longer). This is left out of the gemspec on purpose."
-  raise
-end
-
-require 'mime/types'
-require File.join(File.dirname(__FILE__), "property")
-require File.join(File.dirname(__FILE__), '..', 'mixins', 'extended_document_mixins')
-
-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
-    
-    def self.inherited(subklass)
-      subklass.send(:include, CouchRest::Mixins::Properties)
-    end
-    
-    # Accessors
-    attr_accessor :casted_by
-    
-    # Callbacks
-    define_callbacks :create
-    define_callbacks :save
-    define_callbacks :update
-    define_callbacks :destroy
-    
-    def initialize(passed_keys={})
-      apply_defaults # defined in CouchRest::Mixins::Properties
-      super
-      cast_keys      # defined in CouchRest::Mixins::Properties
-      unless self['_id'] && self['_rev']
-        self['couchrest-type'] = self.class.to_s
-      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 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)
-        
-        save_callback :before do |object|
-          object['updated_at'] = Time.now
-          object['created_at'] = object['updated_at'] if object.new_document?
-        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)
-      if has_view?(m)
-        query = args.shift || {}
-        view(m, query, *args)
-      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
-    
-    # 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)
-      hash.each do |k, v|
-        raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
-      end      
-      hash.each do |k, v|
-        self.send("#{k}=",v)
-      end
-    end
-
-    # 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_document?
-    
-    # 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_document? && 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_document?
-          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_document?
-          _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_document? && self.respond_to?(:set_unique_id)
-      result = database.save_doc(self, bulk)
-      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['_rev'] = nil
-            self['_id'] = nil
-          end
-          result['ok']
-        end
-      end
-    end
-    
-  end
-end

data/lib/couchrest/more/property.rb

@@ -1,40 +0,0 @@
-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)    if options[:default]
-        @casted             = options[:casted] ? true : false
-        @init_method        = options[:send] ? options.delete(:send) : 'new'
-        @options            = options
-      end
-    
-  end
-end

data/lib/couchrest/support/blank.rb

@@ -1,42 +0,0 @@
-# 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

@@ -1,191 +0,0 @@
-# Copyright (c) 2004-2008 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.
- 
-# Allows attributes to be shared within an inheritance hierarchy, but where
-# each descendant gets a copy of their parents' attributes, instead of just a
-# pointer to the same. This means that the child can add elements to, for
-# example, an array without those additions being shared with either their
-# parent, siblings, or children, which is unlike the regular class-level
-# attributes that are shared across the entire hierarchy.
-module CouchRest
-  module ClassExtension
-    def self.included(base)
-      if CouchRest::ClassExtension::InstanceMethods.instance_methods.all? {|m| base.respond_to?(m)}
-        # do nothing
-      elsif CouchRest::ClassExtension::InstanceMethods.instance_methods.any? {|m| base.respond_to?(m)}
-        raise RuntimeError, "Conflicting extentions to Class, work it out"
-      else
-        base.send(:include, CouchRest::ClassExtension::InstanceMethods)
-      end
-    end
-    
-    module InstanceMethods
-      # Defines class-level and instance-level attribute reader.
-      #
-      # @param *syms<Array> Array of attributes to define reader for.
-      # @return <Array[#to_s]> List of attributes that were made into cattr_readers
-      #
-      # @api public
-      #
-      # @todo Is this inconsistent in that it does not allow you to prevent
-      # an instance_reader via :instance_reader => false
-      def cattr_reader(*syms)
-        syms.flatten.each do |sym|
-          next if sym.is_a?(Hash)
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-    unless defined? @@#{sym}
-    @@#{sym} = nil
-    end
- 
-    def self.#{sym}
-    @@#{sym}
-    end
- 
-    def #{sym}
-    @@#{sym}
-    end
-    RUBY
-        end
-      end
- 
-      # Defines class-level (and optionally instance-level) attribute writer.
-      #
-      # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
-      # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
-      # @return <Array[#to_s]> List of attributes that were made into cattr_writers
-      #
-      # @api public
-      def cattr_writer(*syms)
-        options = syms.last.is_a?(Hash) ? syms.pop : {}
-        syms.flatten.each do |sym|
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-    unless defined? @@#{sym}
-    @@#{sym} = nil
-    end
- 
-    def self.#{sym}=(obj)
-    @@#{sym} = obj
-    end
-    RUBY
- 
-          unless options[:instance_writer] == false
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-    def #{sym}=(obj)
-    @@#{sym} = obj
-    end
-    RUBY
-          end
-        end
-      end
- 
-      # Defines class-level (and optionally instance-level) attribute accessor.
-      #
-      # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
-      # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
-      # @return <Array[#to_s]> List of attributes that were made into accessors
-      #
-      # @api public
-      def cattr_accessor(*syms)
-        cattr_reader(*syms)
-        cattr_writer(*syms)
-      end
- 
-      # 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 class_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.is_a?(Symbol) ? 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
- 
-      # 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 class_inheritable_writer(*ivars)
-        instance_writer = ivars.pop[:instance_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
-        end
-      end
- 
-      # 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 class_inheritable_accessor(*syms)
-        class_inheritable_reader(*syms)
-        class_inheritable_writer(*syms)
-      end
-    end
-  end
-end
-
-Class.send(:include, CouchRest::ClassExtension)

data/lib/couchrest/validation/auto_validate.rb

@@ -1,163 +0,0 @@
-# Ported from dm-migrations
-require File.join(File.dirname(__FILE__), '..', 'support', 'class')
-
-module CouchRest
-  
-  class Property
-    # flag letting us know if we already checked the autovalidation settings
-    attr_accessor :autovalidation_check
-    @autovalidation_check = false
-  end
-
-  module Validation
-    module AutoValidate      
-      
-      # # Force the auto validation for the class properties
-      # # This feature is still not fully ported over,
-      # # test are lacking, so please use with caution
-      # def auto_validate!
-      #   require 'ruby-debug'
-      #   debugger
-      #   auto_validation = true
-      # end
-      
-      # adds message for validator
-      def options_with_message(base_options, property, validator_name)
-        options = base_options.clone
-        opts = property.options
-        options[:message] = if opts[:messages]
-          if opts[:messages].is_a?(Hash) and msg = opts[:messages][validator_name]
-            msg
-          else
-            nil
-          end
-        elsif opts[:message]
-          opts[:message]
-        else
-          nil
-        end
-        options
-      end
-
-      
-      ##
-      # Auto-generate validations for a given property. This will only occur
-      # if the option :auto_validation is either true or left undefined.
-      #
-      # @details [Triggers]
-      #   Triggers that generate validator creation
-      #
-      #   :nullable => false
-      #       Setting the option :nullable to false causes a
-      #       validates_presence_of validator to be automatically created on
-      #       the property
-      #
-      #   :size => 20 or :length => 20
-      #       Setting the option :size or :length causes a validates_length_of
-      #       validator to be automatically created on the property. If the
-      #       value is a Integer the validation will set :maximum => value if
-      #       the value is a Range the validation will set :within => value
-      #
-      #   :format => :predefined / lambda / Proc
-      #       Setting the :format option causes a validates_format_of
-      #       validator to be automatically created on the property
-      #
-      #   :set => ["foo", "bar", "baz"]
-      #       Setting the :set option causes a validates_within
-      #       validator to be automatically created on the property
-      #
-      #   Integer type
-      #       Using a Integer type causes a validates_is_number
-      #       validator to be created for the property.  integer_only
-      #       is set to true
-      #
-      #   Float type
-      #       Using a Integer type causes a validates_is_number
-      #       validator to be created for the property.  integer_only
-      #       is set to false, and precision/scale match the property
-      #
-      #
-      #   Messages
-      #
-      #   :messages => {..}
-      #       Setting :messages hash replaces standard error messages
-      #       with custom ones. For instance:
-      #       :messages => {:presence => "Field is required",
-      #                     :format => "Field has invalid format"}
-      #       Hash keys are: :presence, :format, :length, :is_unique,
-      #                      :is_number, :is_primitive
-      #
-      #   :message => "Some message"
-      #       It is just shortcut if only one validation option is set
-      #
-      def auto_generate_validations(property)
-        return unless ((property.autovalidation_check != true) && self.auto_validation)
-        return if (property.options && (property.options.has_key?(:auto_validation) && !property.options[:auto_validation]) || property.read_only)
-        # value is set by the storage system
-        opts = {}
-        opts[:context] = property.options[:validates] if property.options.has_key?(:validates)
-
-        # presence
-        if opts[:allow_nil] == false
-          # validates_present property.name, opts
-          validates_present property.name, options_with_message(opts, property, :presence)
-        end
-
-        # length
-        if property.type == "String"
-          # XXX: maybe length should always return a Range, with the min defaulting to 1
-          # 52 being the max set 
-          len = property.options.fetch(:length, property.options.fetch(:size, 52))
-          if len.is_a?(Range)
-            opts[:within] = len
-          else
-            opts[:maximum] = len
-          end
-          # validates_length property.name, opts
-          validates_length property.name, options_with_message(opts, property, :length)
-        end
-
-        # format
-        if property.options.has_key?(:format)
-          opts[:with] = property.options[:format]
-          # validates_format property.name, opts
-          validates_format property.name, options_with_message(opts, property, :format)
-        end
-
-        # uniqueness validator
-        if property.options.has_key?(:unique)
-          value = property.options[:unique]
-          if value.is_a?(Array) || value.is_a?(Symbol)
-            # validates_is_unique property.name, :scope => Array(value)
-            validates_is_unique property.name, options_with_message({:scope => Array(value)}, property, :is_unique)
-          elsif value.is_a?(TrueClass)
-            # validates_is_unique property.name
-            validates_is_unique property.name, options_with_message({}, property, :is_unique)
-          end
-        end
-
-        # within validator
-        if property.options.has_key?(:set)
-          validates_within property.name, options_with_message({:set => property.options[:set]}, property, :within)
-        end
-
-        # numeric validator
-        if "Integer" == property.type
-          opts[:integer_only] = true
-          # validates_is_number property.name, opts
-          validates_is_number property.name, options_with_message(opts, property, :is_number)
-        elsif Float == property.type
-          opts[:precision] = property.precision
-          opts[:scale]     = property.scale
-          # validates_is_number property.name, opts
-          validates_is_number property.name, options_with_message(opts, property, :is_number)
-        end
-        
-        # marked the property has checked
-        property.autovalidation_check = true
-        
-      end
-
-    end # module AutoValidate
-  end # module Validation
-end # module CouchRest