mongomatic 0.0.2 → 0.0.3

data/lib/mongomatic/base.rb

@@ -1,7 +1,7 @@
 module Mongomatic
   class Base
     include Mongomatic::Modifiers
-    include Validatable
+    include Mongomatic::Validatable
     
     class << self
       def settings

data/lib/mongomatic/validatable/child_validation.rb

@@ -0,0 +1,17 @@
+module Mongomatic
+  module Validatable
+    class ChildValidation #:nodoc:
+      attr_accessor :attribute, :map, :should_validate_proc
+    
+      def initialize(attribute, map, should_validate_proc)
+        @attribute = attribute
+        @map = map
+        @should_validate_proc = should_validate_proc
+      end
+    
+      def should_validate?(instance)
+        instance.instance_eval &should_validate_proc
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/errors.rb

@@ -0,0 +1,108 @@
+module Mongomatic
+  module Validatable
+    class Errors
+      extend Forwardable
+      include Enumerable
+
+      def_delegators :errors, :clear, :each, :each_pair, :empty?, :length, :size
+
+      # Returns true if the specified +attribute+ has errors associated with it.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.invalid?(:name)      # => true
+      #   company.errors.invalid?(:address)   # => false
+      def invalid?(attribute)
+        !@errors[attribute.to_sym].nil?
+      end
+
+      # Adds an error to the base object instead of any particular attribute. This is used
+      # to report errors that don't tie to any specific attribute, but rather to the object
+      # as a whole. These error messages don't get prepended with any field name when iterating
+      # with +each_full+, so they should be complete sentences.
+      def add_to_base(msg)
+        add(:base, msg)
+      end
+
+      # Returns errors assigned to the base object through +add_to_base+ according to the normal rules of <tt>on(attribute)</tt>.
+      def on_base
+        on(:base)
+      end    
+
+      # call-seq: on(attribute)
+      #
+      # * Returns nil, if no errors are associated with the specified +attribute+.
+      # * Returns the error message, if one error is associated with the specified +attribute+.
+      # * Returns an array of error messages, if more than one error is associated with the specified +attribute+.
+      def on(attribute)
+        return nil if errors[attribute.to_sym].nil?
+        errors[attribute.to_sym].size == 1 ? errors[attribute.to_sym].first : errors[attribute.to_sym]
+      end
+
+      # Rails 3 API for errors, always return array.
+      def [](attribute)
+        errors[attribute.to_sym] || []
+      end
+
+      def add(attribute, message) #:nodoc:
+        errors[attribute.to_sym] = [] if errors[attribute.to_sym].nil?
+        errors[attribute.to_sym] << message
+      end
+
+      def merge!(errors) #:nodoc:
+        errors.each_pair{|k, v| add(k,v)}
+        self
+      end
+
+      # call-seq: replace(attribute)
+      #
+      # * Replaces the errors value for the given +attribute+
+      def replace(attribute, value)
+        errors[attribute.to_sym] = value
+      end
+
+      # call-seq: raw(attribute)
+      #
+      # * Returns an array of error messages associated with the specified +attribute+.
+      def raw(attribute)
+        errors[attribute.to_sym]
+      end
+
+      def errors #:nodoc:
+        @errors ||= {}
+      end
+
+      def count #:nodoc:
+        errors.values.flatten.size
+      end
+
+      # call-seq: full_messages -> an_array_of_messages
+      #
+      # Returns an array containing the full list of error messages.
+      def full_messages
+        full_messages = []
+
+        errors.each_key do |attribute|
+          errors[attribute].each do |msg|
+            next if msg.nil?
+
+            if attribute.to_s == "base"
+              full_messages << msg
+            else
+              full_messages << humanize(attribute.to_s) + " " + msg
+            end
+          end
+        end
+        full_messages
+      end
+
+      def humanize(lower_case_and_underscored_word) #:nodoc:
+        lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/included_validation.rb

@@ -0,0 +1,11 @@
+module Mongomatic
+  module Validatable
+    class IncludedValidation #:nodoc:
+      attr_accessor :attribute
+    
+      def initialize(attribute)
+        @attribute = attribute
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/macros.rb

@@ -0,0 +1,316 @@
+module Mongomatic
+  module Validatable
+    module Macros
+      # call-seq: validates_each(*args)
+      # 
+      # Validates that the logic evaluates to true
+      # 
+      #   class Address
+      #     include Validatable
+      #     validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") if ZipCodeService.allows(zip_code) }
+      #   end
+      #
+      # The logic option is required.
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * level - The level at which the validation should occur
+      #     * logic - A block that executes to perform the validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      def validates_each(*args)
+        add_validations(args, ValidatesEach)
+      end
+    
+      # call-seq: validates_format_of(*args)
+      # 
+      # Validates whether the value of the specified attribute is of the 
+      # correct form by matching it against the regular expression provided.
+      # 
+      #   class Person
+      #     include Validatable    
+      #     validates_format_of :first_name, :with => /[ A-Za-z]/
+      #   end
+      # 
+      # A regular expression must be provided or else an exception will be raised.
+      # 
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * with - The regular expression used to validate the format
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_format_of(*args)
+        add_validations(args, ValidatesFormatOf)
+      end
+    
+      # call-seq: validates_length_of(*args)
+      # 
+      # Validates that the specified attribute matches the length restrictions supplied.
+      # 
+      #   class Person
+      #     include Validatable
+      #     validates_length_of :first_name, :maximum=>30
+      #     validates_length_of :last_name, :minimum=>30
+      #   end
+      # 
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * minimum - The minimum size of the attribute
+      #     * maximum - The maximum size of the attribute
+      #     * is - The size the attribute must be
+      #     * within - A range that the size of the attribute must fall within
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_length_of(*args)
+        add_validations(args, ValidatesLengthOf)
+      end
+
+      # call-seq: validates_numericality_of(*args)
+      # 
+      # Validates that the specified attribute is numeric.
+      # 
+      #   class Person
+      #     include Validatable
+      #     validates_numericality_of :age
+      #   end
+      # 
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      #     * only_integer - Whether the attribute must be an integer (default is false)
+      def validates_numericality_of(*args)
+        add_validations(args, ValidatesNumericalityOf)
+      end
+
+      # call-seq: validates_acceptance_of(*args)
+      #
+      # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
+      # 
+      #   class Person
+      #     include Validatable
+      #     validates_acceptance_of :terms_of_service
+      #     validates_acceptance_of :eula, :message => "must be abided"
+      #   end
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_acceptance_of(*args)
+        add_validations(args, ValidatesAcceptanceOf)
+      end
+
+      # call-seq: validates_confirmation_of(*args)
+      #
+      # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
+      # 
+      #   Class:
+      #     class PersonPresenter
+      #       include Validatable
+      #       validates_confirmation_of :user_name, :password
+      #       validates_confirmation_of :email_address, :message => "should match confirmation"
+      #     end
+      # 
+      #   View:
+      #     <%= password_field "person", "password" %>
+      #     <%= password_field "person", "password_confirmation" %>
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * case_sensitive - Whether or not to apply case-sensitivity on the comparison.  Defaults to true.
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_confirmation_of(*args)
+        add_validations(args, ValidatesConfirmationOf)
+      end
+  
+      # call-seq: validates_presence_of(*args)
+      # 
+      # Validates that the specified attributes are not nil or an empty string
+      # 
+      #   class Person
+      #     include Validatable
+      #     validates_presence_of :first_name
+      #   end
+      #
+      # The first_name attribute must be in the object and it cannot be nil or empty.
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_presence_of(*args)
+        add_validations(args, ValidatesPresenceOf)
+      end
+    
+      # call-seq: validates_true_for(*args)
+      # 
+      # Validates that the logic evaluates to true
+      # 
+      #   class Person
+      #     include Validatable
+      #     validates_true_for :first_name, :logic => lambda { first_name == 'Jamie' }
+      #   end
+      #
+      # The logic option is required.
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      #     * logic - A block that executes to perform the validation
+      def validates_true_for(*args)
+        add_validations(args, ValidatesTrueFor)
+      end
+    
+      def validates_exclusion_of(*args)
+        add_validations(args, ValidatesExclusionOf)
+      end
+
+      def validates_inclusion_of(*args)
+        add_validations(args, ValidatesInclusionOf)
+      end
+
+      # call-seq: validates_associated(*args)
+      #
+      # Checks the validity of an associated object or objects and adds a single
+      # error if validation fails.
+      #
+      #   class Person
+      #     include Validatable
+      #     attr_accessor :addresses
+      #     validates_associated :addresses
+      #   end
+      #
+      # Configuration options:
+      #
+      #     * after_validate - A block that executes following the run of a validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      #     * level - The level at which the validation should occur
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      def validates_associated(*args)
+        add_validations(args, ValidatesAssociated)
+      end
+
+      # call-seq: include_validations_from(attribute)
+      # 
+      # Includes all the validations that are defined on the attribute.
+      #   class Person
+      #     include Validatable
+      #     validates_presence_of :name
+      #   end
+      # 
+      #   class PersonPresenter
+      #     include Validatable
+      #     include_validataions_from :person
+      #     attr_accessor :person
+      #     def name
+      #       person.name
+      #     end
+      #
+      #     def initialize(person)
+      #       @person = person
+      #     end
+      #   end
+      #   
+      #   presenter = PersonPresenter.new(Person.new)
+      #   presenter.valid? #=> false
+      #   presenter.errors.on(:name) #=> "can't be blank"
+      #
+      # The name attribute whose validations should be added.
+      def include_validations_from(attribute_to_validate, options = {})
+        validations_to_include << IncludedValidation.new(attribute_to_validate)
+      end
+
+      # call-seq: include_errors_from(attribute_to_validate, options = {})
+      # 
+      # Validates the specified attributes.
+      #   class Person
+      #     include Validatable
+      #     validates_presence_of :name
+      #     attr_accessor :name
+      #   end
+      # 
+      #   class PersonPresenter
+      #     include Validatable
+      #     include_errors_from :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
+      #     attr_accessor :person
+      #     
+      #     def initialize(person)
+      #       @person = person
+      #     end
+      #   end
+      #   
+      #   presenter = PersonPresenter.new(Person.new)
+      #   presenter.valid? #=> false
+      #   presenter.errors.on(:namen) #=> "can't be blank"
+      #
+      # The person attribute will be validated.  
+      # If person is invalid the errors will be added to the PersonPresenter errors collection.
+      #
+      # Configuration options:
+      # 
+      #     * map - A hash that maps attributes of the child to attributes of the parent.
+      #     * if - A block that when executed must return true of the validation will not occur.
+      def include_errors_from(attribute_to_validate, options = {})
+        children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+      end
+    
+      def include_validations_for(attribute_to_validate, options = {}) #:nodoc:
+        puts "include_validations_for is deprecated; use include_errors_from instead"
+        children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+      end
+    
+      # call-seq: before_validation(&block)
+      # 
+      # Is called before valid? or valid_for_*?
+      # 
+      #   class Person
+      #     include Validatable
+      #     before_validation do
+      #       self.name = "default name"
+      #     end
+      # 
+      #     attr_accessor :name
+      #   end
+      # 
+      def before_validation(&block)
+        before_validations << block
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/requireable.rb

@@ -0,0 +1,28 @@
+module Mongomatic
+  module Validatable
+    module Requireable #:nodoc:
+      module ClassMethods #:nodoc:
+        def requires(*args)
+          required_options.concat args        
+        end
+      
+        def required_options
+          @required_options ||= []
+        end
+      end
+    
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+    
+      def requires(options)
+        required_options = self.class.required_options.inject([]) do |errors, attribute|
+          errors << attribute.to_s unless options.has_key?(attribute)
+          errors
+        end
+        raise ArgumentError.new("#{self.class} requires options: #{required_options.join(', ')}") if required_options.any?
+        true
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/understandable.rb

@@ -0,0 +1,33 @@
+module Mongomatic
+  module Validatable
+    module Understandable #:nodoc:
+      module ClassMethods #:nodoc:
+        def understands(*args)
+          understandings.concat args
+        end
+
+        def understandings
+          @understandings ||= []
+        end
+
+        def all_understandings
+          return understandings + self.superclass.all_understandings if self.superclass.respond_to? :all_understandings
+          understandings
+        end
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      def must_understand(hash)
+        invalid_options = hash.inject([]) do |errors, (key, value)|
+          errors << key.to_s unless self.class.all_understandings.include?(key)
+          errors
+        end
+        raise ArgumentError.new("invalid options: #{invalid_options.join(', ')}") if invalid_options.any?
+        true
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/validatable_class_methods.rb

@@ -0,0 +1,89 @@
+module Mongomatic
+  module Validatable
+    module ClassMethods #:nodoc:
+    
+      def validate_children(instance, group)
+        self.children_to_validate.each do |child_validation|
+          next unless child_validation.should_validate?(instance)
+          child_or_children = instance.send child_validation.attribute
+          [child_or_children].flatten.each do |child|
+            if (child.respond_to?(:valid_for_group?))
+              child.valid_for_group?(group)
+            else
+              child.valid?
+            end
+            child.errors.each do |attribute, messages|
+              if messages.is_a?(String)
+                add_error(instance, child_validation.map[attribute.to_sym] || attribute, messages)
+              else
+                messages.each do |message|
+                  add_error(instance, child_validation.map[attribute.to_sym] || attribute, message)
+                end
+              end
+            end
+          end
+        end
+      end
+    
+      def all_before_validations
+        if self.superclass.respond_to? :all_before_validations
+          return before_validations + self.superclass.all_before_validations 
+        end
+        before_validations
+      end
+    
+      def before_validations
+        @before_validations ||= []
+      end
+
+      def all_validations
+        if self.respond_to?(:superclass) && self.superclass.respond_to?(:all_validations)
+          return validations + self.superclass.all_validations 
+        end
+        validations
+      end
+
+      def validations
+        @validations ||= []
+      end
+    
+      def add_error(instance, attribute, msg)
+        instance.errors.add(attribute, msg)
+      end
+    
+      def validation_keys_include?(key)
+        validations.map { |validation| validation.key }.include?(key)
+      end
+    
+      def validations_to_include
+        @validations_to_include ||= []
+      end
+    
+      protected
+    
+      def add_validations(args, klass)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args.each do |attribute|
+          new_validation = klass.new self, attribute, options
+          self.validations << new_validation
+          self.create_valid_method_for_groups new_validation.groups
+        end
+      end
+    
+      def create_valid_method_for_groups(groups)
+        groups.each do |group|
+          self.class_eval do
+            define_method "valid_for_#{group}?".to_sym do
+              valid_for_group?(group)
+            end
+          end
+        end
+      end
+    
+      def children_to_validate
+        @children_to_validate ||= []
+      end
+    
+    end
+  end
+end