couchrest_model-radiant 1.0.0

data/lib/couchrest/model/property.rb

@@ -0,0 +1,97 @@
+# 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.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
+        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)) # Removed as there are no failing tests and caused mutex errors
+        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/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/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,175 @@
+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
+    # $8 = time zone direction
+    # $9 = tz difference
+    # utc time with wrong TZ info: 
+    time = mktime($1, RFC2822_MONTH_NAME[$2.to_i - 1], $3, $4, $5, $6)
+    if ($7)
+      tz_difference = ("#{$8 == '-' ? '+' : '-'}#{$9}".to_i * 3600)
+      time + tz_difference + zone_offset(time.zone) 
+    else
+      time
+    end
+  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.gsub(/,/, '.').gsub(/\.(?!\d*\Z)/, '').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
+          # After failures, resort to normal time parse
+          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.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require "couchrest/model/validations/casted_model"
+require "couchrest/model/validations/uniqueness"
+
+I18n.load_path << File.join(
+  File.dirname(__FILE__), "validations", "locale", "en.yml"
+)
+
+module CouchRest
+  module Model
+
+    # Validations may be applied to both Model::Base and Model::CastedModel
+    module Validations
+      extend ActiveSupport::Concern
+      included do
+        include ActiveModel::Validations
+      end
+      
+
+      module ClassMethods
+        
+        # Validates the associated casted model. This method should not be 
+        # used within your code as it is automatically included when a CastedModel
+        # is used inside the model.
+        #
+        def validates_casted_model(*args)
+          validates_with(CastedModelValidator, _merge_attributes(args))
+        end
+        
+        # Validates if the field is unique for this type of document. Automatically creates
+        # a view if one does not already exist and performs a search for all matching
+        # documents.
+        #
+        # Example:
+        #
+        #   class Person < CouchRest::Model::Base
+        #     property :title, String
+        # 
+        #     validates_uniqueness_of :title
+        #   end
+        #
+        # Asside from the standard options, you can specify the name of the view you'd like
+        # to use for the search inside the +:view+ option. The following example would search
+        # for the code in side the +all+ view, useful for when +unique_id+ is used and you'd
+        # like to check before receiving a RestClient Conflict error:
+        #
+        #   validates_uniqueness_of :code, :view => 'all'
+        #
+        # A +:proxy+ parameter is also accepted if you would 
+        # like to call a method on the document on which the view should be performed.
+        #
+        # For Example:
+        #
+        #   # Same as not including proxy:
+        #   validates_uniqueness_of :title, :proxy => 'class'
+        #
+        #   # Person#company.people provides a proxy object for people
+        #   validates_uniqueness_of :title, :proxy => 'company.people'
+        #
+        def validates_uniqueness_of(*args)
+          validates_with(UniquenessValidator, _merge_attributes(args))
+        end
+      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