dao 3.3.0 → 4.2.1

data/lib/dao/validations.rb

@@ -1,178 +1,69 @@
 module Dao
-  class Validations < ::Map
-  # supporting classes
-  #
-    class Callback < ::Proc
-      attr :options
+  module Validations
+    class Error < Dao::Error; end
 
-      def initialize(options = {}, &block)
-        @options = Dao.map_for(options || {})
-        super(&block)
-      end
+    Dao.load('validations/validator.rb')
+    Dao.load('validations/callback.rb')
+    Dao.load('validations/common.rb')
 
-      def block
-        self
+    ClassMethods = proc do
+      def validator
+        @validator ||= Validator.new(self)
       end
 
-      class Chain
-        def initialize
-          @chain = []
-        end
-
-        def add(callback)
-          @chain.push(callback)
-        end
-
-        def each(&block)
-          @chain.each(&block)
-        end
+      def validator=(validator)
+        @validator = validator
       end
-    end
 
-  # class methods
-  #
-    class << Validations
-      def for(*args, &block)
-        new(*args, &block)
+      %w(
+        validations
+        validates
+      ).each do |method|
+        module_eval <<-__, __FILE__, __LINE__
+          def self.#{ method }(*args, &block)
+            validator.#{ method }(*args, &block)
+          end
+        __
       end
     end
 
-  # instance methods
-  #
-    attr_accessor :map
-    attr_accessor :errors
-    attr_accessor :status
-    attr_accessor :ran
-
-    def initialize(*args, &block)
-      @map = args.first.is_a?(Map) ? args.shift : Map.new
-      options = Map.options_for!(args)
-
-      @errors = options[:errors] || Errors.new
-      @status = options[:status] || Status.default
-
-      @map.extend(InstanceExec) unless @map.respond_to?(:instance_exec)
-      @ran = false
-      super
-    end
-    alias_method('ran?', 'ran')
-
-    def errors
-      @map.errors
-    end
-
-    def run
-      previous_errors = []
-      new_errors = []
-
-      errors.each_message do |keys, message|
-        previous_errors.push([keys, message])
+    InstanceMethods = proc do
+      def validator
+        @validator ||= Validator.new(self)
       end
-      errors.clear!
-
-      depth_first_each do |keys, chain|
-        chain.each do |callback|
-          next unless callback and callback.respond_to?(:to_proc)
-
-          number_of_errors = errors.size
-          value = @map.get(keys)
-          returned =
-            catch(:valid) do
-              args = [value, map].slice(0, callback.arity)
-              @map.instance_exec(*args, &callback)
-            end
-
-          case returned
-            when Hash
-              map = Dao.map(returned)
-              valid = map[:valid]
-              message = map[:message]
-
-            when TrueClass, FalseClass
-              valid = returned
-              message = nil
-
-            else
-              any_errors_added = errors.size > number_of_errors
-              valid = !any_errors_added
-              message = nil
-          end
 
-          message ||= callback.options[:message]
-          message ||= (value.to_s.strip.empty? ? 'is blank' : 'is invalid')
-
-          unless valid
-            new_errors.push([keys, message])
-          else
-            new_errors.push([keys, Cleared])
-          end
-        end
+      def validator=(validator)
+        @validator = validator
       end
 
-      previous_errors.each do |keys, message|
-        errors.add(keys, message) unless new_errors.assoc(keys)
-      end
-
-      new_errors.each do |keys, value|
-        next if value == Cleared
-        message = value
-        errors.add(keys, message)
+      %w(
+        validations
+        validates
+        validated?
+        validated!
+        validate
+        validate!
+        run_validations!
+        valid!
+        forcing_validity?
+        valid?
+        errors
+        status
+      ).each do |method|
+        module_eval <<-__, __FILE__, __LINE__
+          def #{ method }(*args, &block)
+            validator.#{ method }(*args, &block)
+          end
+        __
       end
-
-      @ran = true
-      return self
-    end
-    Cleared = 'Cleared'.freeze unless defined?(Cleared)
-
-    def run!
-      errors.clear!
-      run
-    end
-
-    def each(&block)
-      depth_first_each(&block)
     end
 
-    def size
-      size = 0
-      depth_first_each{ size += 1 }
-      size
-    end
-    alias_method('count', 'size')
-    alias_method('length', 'size')
-
-    def add(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
-      block = args.pop if args.last.respond_to?(:call)
-      block ||= NotBlank
-      callback = Callback.new(options, &block)
-      set(args => Callback::Chain.new) unless has?(args)
-      get(args).add(callback)
-      callback
-    end
-    NotBlank = lambda{|value| !value.to_s.strip.empty?} unless defined?(NotBlank)
-  end
-
-  Dao.load('validations/base.rb')
-  Dao.load('validations/common.rb')
-
-  module Validations::Mixin
-    def self.included(other)
-      other.module_eval do
-        include Validations::Base
-        include Validations::Common 
-      end
+    def Validations.included(other)
+      other.send(:instance_eval, &ClassMethods)
+      other.send(:class_eval, &InstanceMethods)
+      other.send(:include, Common)
+      other.send(:extend, Common)
       super
     end
-
-    def self.list
-      @list ||= (
-        c = Class.new
-        a = c.instance_methods
-        c.class_eval{ include Validations::Mixin }
-        b = c.instance_methods
-        b - a
-      )
-    end
   end
 end

data/lib/dao/validations/callback.rb

@@ -0,0 +1,30 @@
+module Dao
+  module Validations
+    class Callback < ::Proc
+      attr :options
+
+      def initialize(options = {}, &block)
+        @options = Map.for(options || {})
+        super(&block)
+      end
+
+      def block
+        self
+      end
+
+      class Chain
+        def initialize
+          @chain = []
+        end
+
+        def add(callback)
+          @chain.push(callback)
+        end
+
+        def each(&block)
+          @chain.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/dao/validations/common.rb

@@ -1,457 +1,459 @@
 module Dao
-  module Validations::Common
-    def validates_length_of(*args)
-      options = Dao.options_for!(args)
+  module Validations
+    module Common
+      def validates_length_of(*args)
+        options = Map.options_for!(args)
 
-      message = options[:message]
+        message = options[:message]
 
-      if options[:in].is_a?(Range)
-        options[:minimum] = options[:in].begin
-        options[:maximum] = options[:in].end
-      end
-      minimum = options[:minimum] || 1
-      maximum = options[:maximum]
+        if options[:in].is_a?(Range)
+          options[:minimum] = options[:in].begin
+          options[:maximum] = options[:in].end
+        end
+        minimum = options[:minimum] || 1
+        maximum = options[:maximum]
 
-      too_short = options[:too_short] || message || 'is too short'
-      too_long = options[:too_long] || message || 'is too long'
+        too_short = options[:too_short] || message || 'is too short'
+        too_long = options[:too_long] || message || 'is too long'
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      minimum = Float(minimum)
-      maximum = Float(maximum) if maximum
+        minimum = Float(minimum)
+        maximum = Float(maximum) if maximum
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-          if value.nil? and allow_nil
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            if value.nil? and allow_nil
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          value = value.to_s.strip
+            value = value.to_s.strip
 
-          if value.empty? and allow_blank
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            if value.empty? and allow_blank
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.size < minimum
-            m[:message] = too_short
-            m[:valid] = false
-            throw(:valid, m)
-          end
+            if value.size < minimum
+              m[:message] = too_short
+              m[:valid] = false
+              throw(:validation, m)
+            end
+
+            if(maximum and(value.size > maximum))
+              m[:message] = too_long
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          if(maximum and(value.size > maximum))
-            m[:message] = too_long
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
+        validates(*args, &block)
+      end
 
-      validates(*args, &block)
-    end
+      def validates_word_count_of(*args)
+        options = Map.options_for!(args)
 
-    def validates_word_count_of(*args)
-      options = Dao.options_for!(args)
+        message = options[:message]
 
-      message = options[:message]
+        if options[:in].is_a?(Range)
+          options[:minimum] = options[:in].begin
+          options[:maximum] = options[:in].end
+        end
+        minimum = options[:minimum] || 1
+        maximum = options[:maximum]
 
-      if options[:in].is_a?(Range)
-        options[:minimum] = options[:in].begin
-        options[:maximum] = options[:in].end
-      end
-      minimum = options[:minimum] || 1
-      maximum = options[:maximum]
+        too_short = options[:too_short] || message || 'is too short'
+        too_long = options[:too_long] || message || 'is too long'
 
-      too_short = options[:too_short] || message || 'is too short'
-      too_long = options[:too_long] || message || 'is too long'
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        minimum = Float(minimum)
+        maximum = Float(maximum) if maximum
 
-      minimum = Float(minimum)
-      maximum = Float(maximum) if maximum
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+            if value.nil? and allow_nil
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.nil? and allow_nil
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            value = value.to_s.strip
 
-          value = value.to_s.strip
+            if value.empty? and allow_blank
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.empty? and allow_blank
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            words = value.split(/\s+/)
 
-          words = value.split(/\s+/)
+            if words.size < minimum
+              m[:message] = too_short
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          if words.size < minimum
-            m[:message] = too_short
-            m[:valid] = false
-            throw(:valid, m)
-          end
+            if(maximum and(words.size > maximum))
+              m[:message] = too_long
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          if(maximum and(words.size > maximum))
-            m[:message] = too_long
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
+        validates(*args, &block)
+      end
 
-      validates(*args, &block)
-    end
+      def validates_as_email(*args)
+        options = Map.options_for!(args)
 
-    def validates_as_email(*args)
-      options = Dao.options_for!(args)
+        message = options[:message] || "doesn't look like an email (username@domain.com)"
 
-      message = options[:message] || "doesn't look like an email (username@domain.com)"
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+            if value.nil? and allow_nil
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.nil? and allow_nil
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            value = value.to_s.strip
 
-          value = value.to_s.strip
+            if value.empty? and allow_blank
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.empty? and allow_blank
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            parts = value.split(/@/)
 
-          parts = value.split(/@/)
+            unless parts.size == 2
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          unless parts.size == 2
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
+        args.push(:message => message)
+        validates(*args, &block)
+      end
 
-      args.push(:message => message)
-      validates(*args, &block)
-    end
+      def validates_as_url(*args)
+        options = Map.options_for!(args)
 
-    def validates_as_url(*args)
-      options = Dao.options_for!(args)
+        message = options[:message] || "doesn't look like a url (http://domain.com)"
 
-      message = options[:message] || "doesn't look like a url (http://domain.com)"
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+            if value.nil? and allow_nil
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.nil? and allow_nil
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            value = value.to_s.strip
 
-          value = value.to_s.strip
+            if value.empty? and allow_blank
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.empty? and allow_blank
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            parts = value.split(%r|://|)
 
-          parts = value.split(%r|://|)
+            unless parts.size >= 2
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          unless parts.size >= 2
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
+        args.push(:message => message)
+        validates(*args, &block)
+      end
 
-      args.push(:message => message)
-      validates(*args, &block)
-    end
+      def validates_as_phone(*args)
+        options = Map.options_for!(args)
 
-    def validates_as_phone(*args)
-      options = Dao.options_for!(args)
+        message = options[:message] || "doesn't look like a phone number (012.345.6789)"
 
-      message = options[:message] || "doesn't look like a phone number (012.345.6789)"
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+            if value.nil? and allow_nil
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.nil? and allow_nil
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            value = value.to_s.strip
 
-          value = value.to_s.strip
+            if value.empty? and allow_blank
+              m[:valid] = true
+              throw(:validation, m)
+            end
 
-          if value.empty? and allow_blank
-            m[:valid] = true
-            throw(:valid, m)
-          end
+            parts = value.scan(/\d+/)
 
-          parts = value.scan(/\d+/)
+            unless parts.size >= 1
+              m[:valid] = false
+              throw(:validation, m)
+            end
 
-          unless parts.size >= 1
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
-
-      args.push(:message => message)
-      validates(*args, &block)
-    end
+        args.push(:message => message)
+        validates(*args, &block)
+      end
 
-    def validates_presence_of(*args)
-      options = Dao.options_for!(args)
+      def validates_presence_of(*args)
+        options = Map.options_for!(args)
 
-      message = options[:message] || 'is blank or missing'
+        message = options[:message] || 'is blank or missing'
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-          if value.nil?
-            unless allow_nil
-              m[:message] = message
-              m[:valid] = false
-              throw(:valid, m)
+            if value.nil?
+              unless allow_nil
+                m[:message] = message
+                m[:valid] = false
+                throw(:validation, m)
+              end
             end
-          end
 
-          value = value.to_s.strip
+            value = value.to_s.strip
 
-          if value.empty?
-            unless allow_blank
-              m[:message] = message
-              m[:valid] = false
-              throw(:valid, m)
+            if value.empty?
+              unless allow_blank
+                m[:message] = message
+                m[:valid] = false
+                throw(:validation, m)
+              end
             end
-          end
 
-          m
-        end
-
-      validates(*args, &block)
-    end
+            m
+          end
 
-    def validates_any_of(*args)
-      options = Dao.options_for!(args)
-      list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
+        validates(*args, &block)
+      end
 
-      list.each do |args|
-        candidates = list.dup
-        candidates.delete(args)
+      def validates_any_of(*args)
+        options = Map.options_for!(args)
+        list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
 
-        message = options[:message] || "(or #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
-        allow_nil = options[:allow_nil]
-        allow_blank = options[:allow_blank]
+        list.each do |args|
+          candidates = list.dup
+          candidates.delete(args)
 
-        result = self.result
+          message = options[:message] || "(or #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
+          allow_nil = options[:allow_nil]
+          allow_blank = options[:allow_blank]
 
-        block =
-          lambda do |value|
-            m = Dao.map(:valid => true)
-            values = list.map{|key| result.get(key)}
-            valid = false
-            values.each do |val|
-              if val
-                valid = true
-                break
-              end
+          result = self.result
 
-              if val.nil?
-                if allow_nil
+          block =
+            lambda do |value|
+              m = Map(:valid => true)
+              values = list.map{|key| result.get(key)}
+              valid = false
+              values.each do |val|
+                if val
                   valid = true
                   break
                 end
-              end
 
-              val = val.to_s.strip
+                if val.nil?
+                  if allow_nil
+                    valid = true
+                    break
+                  end
+                end
 
-              if val.empty?
-                if allow_blank
-                  valid = true
-                  break
+                val = val.to_s.strip
+
+                if val.empty?
+                  if allow_blank
+                    valid = true
+                    break
+                  end
                 end
               end
-            end
 
-            unless valid
-              if value.nil?
-                unless allow_nil
-                  m[:message] = message
-                  m[:valid] = false
-                  throw(:valid, m)
+              unless valid
+                if value.nil?
+                  unless allow_nil
+                    m[:message] = message
+                    m[:valid] = false
+                    throw(:validation, m)
+                  end
                 end
-              end
 
-              value = value.to_s.strip
+                value = value.to_s.strip
 
-              if value.empty?
-                unless allow_blank
-                  m[:message] = message
-                  m[:valid] = false
-                  throw(:valid, m)
+                if value.empty?
+                  unless allow_blank
+                    m[:message] = message
+                    m[:valid] = false
+                    throw(:validation, m)
+                  end
                 end
               end
-            end
 
-            m
-          end
-        validates(*args, &block)
+              m
+            end
+          validates(*args, &block)
+        end
       end
-    end
 
-    def validates_all_of(*args)
-      options = Dao.options_for!(args)
-      list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
+      def validates_all_of(*args)
+        options = Map.options_for!(args)
+        list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
 
-      list.each do |args|
-        candidates = list.dup
-        candidates.delete(args)
-
-        message = options[:message] || "(and #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
-        allow_nil = options[:allow_nil]
-        allow_blank = options[:allow_blank]
+        list.each do |args|
+          candidates = list.dup
+          candidates.delete(args)
 
-        result = self.result
+          message = options[:message] || "(and #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
+          allow_nil = options[:allow_nil]
+          allow_blank = options[:allow_blank]
 
-        block =
-          lambda do |value|
-            m = Dao.map(:valid => true)
+          result = self.result
 
-            values = list.map{|key| result.get(key)}
-            valid = true
-            values.each do |val|
-              if val
-                break
-              end
+          block =
+            lambda do |value|
+              m = Map(:valid => true)
 
-              if val.nil?
-                unless allow_nil
-                  valid = false
+              values = list.map{|key| result.get(key)}
+              valid = true
+              values.each do |val|
+                if val
                   break
                 end
-              end
 
-              val = val.to_s.strip
+                if val.nil?
+                  unless allow_nil
+                    valid = false
+                    break
+                  end
+                end
 
-              if val.empty?
-                unless allow_blank
-                  valid = false
-                  break
+                val = val.to_s.strip
+
+                if val.empty?
+                  unless allow_blank
+                    valid = false
+                    break
+                  end
                 end
               end
-            end
 
-            unless valid
-              if value.nil?
-                unless allow_nil
-                  m[:message] = message
-                  m[:valid] = false
-                  throw(:valid, m)
+              unless valid
+                if value.nil?
+                  unless allow_nil
+                    m[:message] = message
+                    m[:valid] = false
+                    throw(:validation, m)
+                  end
                 end
-              end
 
-              value = value.to_s.strip
+                value = value.to_s.strip
 
-              if value.empty?
-                unless allow_blank
-                  m[:message] = message
-                  m[:valid] = false
-                  throw(:valid, m)
+                if value.empty?
+                  unless allow_blank
+                    m[:message] = message
+                    m[:valid] = false
+                    throw(:validation, m)
+                  end
                 end
               end
-            end
 
-            m
-          end
-        validates(*args, &block)
+              m
+            end
+          validates(*args, &block)
+        end
       end
-    end
 
-    def validates_confirmation_of(*args)
-      options = Dao.options_for!(args)
+      def validates_confirmation_of(*args)
+        options = Map.options_for!(args)
 
 
-      confirmation_key = args.map{|k| k.to_s}
-      last = confirmation_key.pop
-      last = "#{ last }_confirmation" unless last =~ /_confirmation$/
-      confirmation_key.push(last)
+        confirmation_key = args.map{|k| k.to_s}
+        last = confirmation_key.pop
+        last = "#{ last }_confirmation" unless last =~ /_confirmation$/
+        confirmation_key.push(last)
 
-      key = args.map{|k| k.to_s}
-      last = key.pop
-      last.sub!(/_confirmation$/, '')
-      key.push(last)
+        key = args.map{|k| k.to_s}
+        last = key.pop
+        last.sub!(/_confirmation$/, '')
+        key.push(last)
 
-      message = options[:message] || "does not match #{ key.join('.') }"
+        message = options[:message] || "does not match #{ key.join('.') }"
 
-      allow_nil = options[:allow_nil]
-      allow_blank = options[:allow_blank]
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
 
-      block =
-        lambda do |value|
-          m = Dao.map(:valid => true)
+        block =
+          lambda do |value|
+            m = Map(:valid => true)
 
-          if value.nil?
-            unless allow_nil
-              m[:message] = message
-              m[:valid] = false
-              throw(:valid, m)
+            if value.nil?
+              unless allow_nil
+                m[:message] = message
+                m[:valid] = false
+                throw(:validation, m)
+              end
             end
-          end
 
-          value = value.to_s.strip
+            value = value.to_s.strip
 
-          if value.empty?
-            unless allow_blank
+            if value.empty?
+              unless allow_blank
+                m[:message] = message
+                m[:valid] = false
+                throw(:validation, m)
+              end
+            end
+
+            target = get(key).to_s.strip
+            confirmed = target == value
+
+            unless confirmed
               m[:message] = message
               m[:valid] = false
-              throw(:valid, m)
+              throw(:validation, m)
             end
-          end
 
-          target = get(key).to_s.strip
-          confirmed = target == value
-
-          unless confirmed
-            m[:message] = message
-            m[:valid] = false
-            throw(:valid, m)
+            m
           end
 
-          m
-        end
-
-      validates(confirmation_key, &block)
+        validates(confirmation_key, &block)
+      end
     end
   end