samlown-couchrest 0.37.2 → 1.0.0

data/lib/couchrest/more/property.rb

@@ -1,50 +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 = [Object]
-        else
-          base_type = type.is_a?(Array) ? type.first : type
-          if base_type.is_a?(String)
-            if base_type.downcase == 'boolean'
-              base_type = TrueClass 
-            else
-              begin
-                base_type = ::CouchRest.constantize(base_type)
-              rescue  # leave base type as a string and convert in more/typecast
-              end
-            end
-          end
-          @type = type.is_a?(Array) ? [base_type] : base_type 
-        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[:init_method] ? options.delete(:init_method) : 'new'
-        @options            = options
-      end
-
-  end
-end

data/lib/couchrest/more/typecast.rb

@@ -1,175 +0,0 @@
-require 'time'
-require 'bigdecimal'
-require 'bigdecimal/util'
-require File.join(File.dirname(__FILE__), '..', 'more', 'property')
-
-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 More
-    module Typecast
-
-      def typecast_value(value, klass, init_method)
-        return nil if value.nil?
-        klass = ::CouchRest.constantize(klass) unless klass.is_a?(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
-          init_method.is_a?(Proc) ? init_method.call(value) : klass.send(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)
-          ::CouchRest.constantize(value.to_s)
-        rescue NameError
-          value
-        end
-
-    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/rails.rb

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

data/lib/couchrest/validation/auto_validate.rb

@@ -1,157 +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!
-      #   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_numericality_of
-      #       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_presence_of 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_of 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_numericality_of property.name, options_with_message(opts, property, :is_number)
-        elsif Float == property.type
-          opts[:precision] = property.precision
-          opts[:scale]     = property.scale
-          validates_numericality_of 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