mongomatic 0.1.31 → 0.2.0

data/lib/mongomatic/validatable/validations/validates_numericality_of.rb

@@ -1,28 +0,0 @@
-module Mongomatic
-  module Validatable 
-    class ValidatesNumericalityOf < ValidationBase #:nodoc:
-      option :only_integer
-    
-      def valid?(instance)
-        value = value_for(instance)
-        return true if allow_nil && value.nil?
-        return true if allow_blank && value.blank?
-      
-        value = value.to_s
-        regex = self.only_integer ? /\A[+-]?\d+\Z/ : /^\d*\.{0,1}\d+$/
-        not (value =~ regex).nil?
-      end
-    
-      def message(instance)
-        super || "must be a number"
-      end
-    
-      private
-        def value_for(instance)
-          before_typecast_method = "#{self.attribute}_before_typecast"
-          value_method = instance.respond_to?(before_typecast_method.intern) ? before_typecast_method : self.attribute
-          instance.send(value_method)
-        end
-    end
-  end
-end

data/lib/mongomatic/validatable/validations/validates_presence_of.rb

@@ -1,18 +0,0 @@
-module Mongomatic
-  module Validatable 
-    class ValidatesPresenceOf < ValidationBase #:nodoc:
-      def valid?(instance)
-        value = instance[self.attribute.to_s]
-        return true if allow_nil && value.nil?
-        return true if allow_blank && value.blank?
-      
-        return false if instance[self.attribute.to_s].nil?
-        value.respond_to?(:strip) ? instance[self.attribute.to_s].strip.length != 0 : true
-      end
-    
-      def message(instance)
-        super || "can't be empty"
-      end
-    end
-  end
-end

data/lib/mongomatic/validatable/validations/validates_true_for.rb

@@ -1,15 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidatesTrueFor < ValidationBase #:nodoc:
-      required_option :logic
-  
-      def valid?(instance)
-        instance.instance_eval(&logic) == true
-      end
-    
-      def message(instance)
-        super || "is invalid"
-      end
-    end
-  end
-end

data/lib/mongomatic/validatable/validations/validation_base.rb

@@ -1,93 +0,0 @@
-module Mongomatic
-  module Validatable
-    class ValidationBase #:nodoc:
-      def self.required_option(*args)
-        option(*args)
-        requires(*args)
-      end
-    
-      def self.option(*args)
-        attr_accessor(*args)
-        understands(*args)
-      end
-    
-      def self.default(hash)
-        defaults.merge! hash
-      end
-    
-      def self.defaults
-        @defaults ||= {}
-      end
-    
-      def self.all_defaults
-        return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
-        defaults
-      end
-    
-      def self.after_validate(&block)
-        after_validations << block
-      end
-    
-      def self.after_validations
-        @after_validations ||= []
-      end
-    
-      def self.all_after_validations
-        return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
-        after_validations
-      end
-
-      include Understandable
-      include Requireable
-    
-      option :message, :if, :times, :level, :groups, :key, :after_validate, :allow_nil, :allow_blank
-      default :level => 1, :groups => []
-      attr_accessor :attribute
-    
-      def initialize(klass, attribute, options={})
-        must_understand options
-        requires options
-        self.class.all_understandings.each do |understanding|
-          options[understanding] = self.class.all_defaults[understanding] unless options.has_key? understanding
-          self.instance_variable_set("@#{understanding}", options[understanding])
-        end
-        self.attribute = attribute
-        self.groups = [self.groups] unless self.groups.is_a?(Array)
-        self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
-        raise_error_if_key_is_dup(klass)
-      end
-    
-      def raise_error_if_key_is_dup(klass)
-        message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
-        raise ArgumentError.new(message) if klass.validation_keys_include? self.key
-      end
-    
-      def should_validate?(instance)
-        result = validate_this_time?(instance)
-        case self.if
-          when Proc
-            result &&= instance.instance_eval(&self.if)
-          when Symbol, String
-            result &&= instance.instance_eval(self.if.to_s)
-        end
-        result
-      end
-    
-      def message(instance)
-        @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
-      end
-    
-      def validate_this_time?(instance)
-        return true if @times.nil?
-        self.times > instance.times_validated(self.key)
-      end
-    
-      def run_after_validate(result, instance, attribute)
-        self.class.all_after_validations.each do |block|
-          block.call result, instance, attribute
-        end
-        instance.instance_eval_with_params result, attribute, &self.after_validate unless self.after_validate.nil?
-      end
-    end
-  end
-end