boof-not-naughty 0.6.2

data/lib/not_naughty/error_handler.rb

@@ -0,0 +1,48 @@
+module Tree #:nodoc:
+  class TreeNode #:nodoc:
+
+    def closest(obj)
+      if @name == obj then self
+      elsif @name > obj
+        closest = self
+        @children.any? { |child| node = child.closest(obj) and closest = node }
+
+        closest
+      end
+    end
+
+  end
+end
+
+module NotNaughty
+  class ErrorHandler
+
+    def initialize(handler = Kernel)
+      @handles = Tree::TreeNode.new Exception, proc { |e| handler.raise e }
+    end
+
+    # Calls closest handle with exception.
+    def raise(exception)
+      handle = @handles.closest exception.class
+      handle.content.call exception
+    end
+
+    # Inserts handle into the ordered tree.
+    def handle(exception_class, &block)
+      closest_handle = @handles.closest exception_class
+
+      if closest_handle == exception_class then closest_handle.content = block
+      else
+        new_handle = Tree::TreeNode.new exception_class, block
+
+        closest_handle.children do |child|
+          exception_class > child.name and
+          new_handle << closest_handle.remove!(child)
+        end
+
+        closest_handle << new_handle
+      end
+    end
+
+  end
+end

data/lib/not_naughty/instance_methods.rb

@@ -0,0 +1,20 @@
+module NotNaughty
+  module InstanceMethods
+
+    # Returns instance of Errors.
+    def errors() @errors ||= ::NotNaughty::Violation.new end
+
+    # Returns true if all validations passed
+    def valid?
+      validate
+      errors.empty?
+    end
+
+    # Clears errors and validates.
+    def validate
+      errors.clear
+      self.class.validator.invoke self
+    end
+
+  end
+end

data/lib/not_naughty/validation.rb

@@ -0,0 +1,132 @@
+module NotNaughty
+
+  # == The superclass for Validations.
+  #
+  # See new for more information.
+  class Validation
+
+    # Returns array of paths which are scanned for validations by load.
+    def self.load_paths
+      @load_paths
+    end
+    @load_paths = [File.join(%W[#{ File.dirname __FILE__ } validations])]
+    PATTERN = File.join %w[%s ** %s_validation.rb]
+
+    # Loads validations from load_paths.
+    def self.load(*validations)
+      validations.each do |validation|
+        @load_paths.each do |load_path|
+          pattern = PATTERN % [load_path, validation]
+          Dir[pattern].each { |validation_path| require validation_path }
+        end
+      end
+    end
+
+    extend Observable
+    def self.inherited(descendant) #:nodoc:
+      changed and notify_observers(descendant)
+
+      descendant.
+      instance_variable_set :@observer_peers, @observer_peers.clone
+    end
+
+    # Builds validations.
+    #
+    # <b>Example:</b>
+    #   NotNaughty::Validation.new :temp, :if => :water? do |obj, attr, val|
+    #     obj.errors.add attr, 'too hot' unless val < 100
+    #   end
+    #
+    # <b>Like:</b>
+    #   class TempValidation < NotNaughty::Validation
+    #     def initialize(opts, attributes)
+    #       super opts, attributes method(:temp_validation)
+    #     end
+    #     def temp_validation(obj, attr, val)
+    #       obj.errors.add attr, 'too hot' unless val < 100
+    #     end
+    #   end
+    #
+    #   Validation.new TempValidation, :temp, :if => :water?
+    #
+    # The last one also notifies all Observers of Validation (see
+    # Builder#update). If Builder#update is called because <Name>Validation
+    # is inherited from Validation the ValidationBuilder gets the method
+    # validates_<name>_of and so does the classes that included the Builder.
+    def self.new(*params, &block)
+      attributes = if params.first.is_a? Class and params.first < self
+        klass = params.shift
+        klass.new(*params, &block)
+      else
+        options = params.extract_options!
+        instance = allocate
+        instance.send :initialize, options, params.map {|p|p.to_sym}, &block
+        instance
+      end
+    end
+
+    attr_reader :attributes
+
+    def initialize(opts, attributes, &block) #:nodoc:
+      build_conditions opts[:if], opts[:unless]
+      @attributes, @block, @opts = attributes, block, opts
+    end
+
+    def call_without_conditions(obj, attr, value) #:nodoc:
+      @block.call obj, attr, value
+    end
+    alias_method :call, :call_without_conditions
+
+    def call_with_conditions(obj, attr, value) #:nodoc:
+      if @conditions.all? { |c| c.evaluate obj }
+        call_without_conditions obj, attr, value
+      end
+    end
+
+    protected
+    def build_conditions(p, n) #:nodoc:
+      @conditions = []
+      [p].flatten.each {|c| @conditions << Condition.new(c) if c }
+      [n].flatten.each {|c| @conditions << Condition.new(c, false) if c }
+
+      (class << self; self; end).module_eval do
+        alias_method :call, :call_with_conditions
+      end unless @conditions.empty?
+    end
+
+    # Conditions for use in Validations are usually used with Validations.
+    class Condition
+
+      # An instance of Condition accepts Symbols, UnboundMethods or anything
+      # that responds to :call.
+      #
+      # The following examples are similiar to each other:
+      #
+      #   NotNaughty::Validation::Condition.new proc {|o| o.nil?}
+      #   NotNaughty::Validation::Condition.new :nil?
+      #   NotNaughty::Validation::Condition.new Object.instance_method(:nil?)
+      def self.new(condition, positive = true)
+        instance = allocate
+        instance.instance_variable_set :@condition, condition
+
+        block = case condition
+        when Symbol then positive ?
+          proc { |o| o.send @condition } :
+          proc { |o| not o.send @condition }
+        when UnboundMethod then positive ?
+          proc { |o| @condition.bind(o).call } :
+          proc { |o| not @condition.bind(o).call }
+        else positive ?
+          proc { |o| @condition.call o } :
+          proc { |o| not @condition.call o }
+        end
+
+        (class << instance; self; end).
+        module_eval { define_method(:evaluate, &block) }
+
+        instance
+      end
+
+    end
+  end
+end

data/lib/not_naughty/validations/acceptance_validation.rb

@@ -0,0 +1,46 @@
+module NotNaughty
+
+  # == Validates acceptance of obj's attribute against a fixed value via <tt>:eql?</tt> call.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:accept</tt>::  object to check against (via :eql?)
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   invalid = 'abc'
+  #   valid = '1'
+  #   def invalid.errors() @errors ||= NotNauthy::Errors.new end
+  #   def valid.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   AcceptanceValidation.new({}, :to_s).call invalid, :to_s, 'abc'
+  #   invalid.errors.on(:to_s).any? # => true
+  #
+  #   AcceptanceValidation.new({}, :to_s).call valid, :to_s, '1'
+  #   valid.errors.on(:to_s).any? # => false
+  class AcceptanceValidation < Validation
+
+    def initialize(opts, attributes) #:nodoc:
+      __message, __accept =
+        opts[:message] || '#{"%s".humanize} not accepted.',
+        opts[:accept] || '1'
+
+      if opts[:allow_blank] or opts.fetch(:allow_nil, true)
+        __allow = if opts[:allow_blank] then :blank? else :nil? end
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless v.send __allow or __accept.eql? v
+        end
+      else
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless __accept.eql? v
+        end
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validations/confirmation_validation.rb

@@ -0,0 +1,49 @@
+module NotNaughty
+
+  # == Validates confirmaton of obj's attribute via <tt>:eql?</tt> call against the _appropiate_ confirmation attribute.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = 'abc'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #   def obj.to_s_confirmation() '123 end
+  #
+  #   ConfirmationValidation.new({}, :to_s).call obj, :to_s, 'abc'
+  #   obj.errors.on(:to_s).any? # => true
+  class ConfirmationValidation < Validation
+
+    def initialize(valid, attributes) #:nodoc:
+      valid[:message] ||= '%s could not be confirmed.'
+
+      if valid[:allow_blank] || valid[:allow_nil]
+        valid[:allow] = valid[:allow_blank] ? :blank? : :nil?
+        super valid, attributes, &confirmation_block_with_exception(valid)
+      else
+        super valid, attributes, &confirmation_block(valid)
+      end
+    end
+
+    protected
+    def confirmation_block_with_exception(valid)
+      proc do |obj, attr, value|
+        value.send valid[:allow] or
+        obj.send(:"#{ attr }_confirmation") == value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+    def confirmation_block(valid)
+      proc do |obj, attr, value|
+        obj.send(:"#{ attr }_confirmation") == value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+  end
+end

data/lib/not_naughty/validations/format_validation.rb

@@ -0,0 +1,71 @@
+module NotNaughty
+
+  # == Validates format of obj's attribute via the <tt>:match</tt> method.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:with</tt>::    object that checks via a <tt>:match</tt> call
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Example:</b>
+  #
+  #   obj = 'abc'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   FormatValidation.new({:with => /[a-z]/}, :to_s).call obj, :to_s, obj
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   FormatValidation.new({:with => /[A-Z]/}, :to_s).call obj, :to_s, obj
+  #   obj.errors.on(:to_s) # => ["Format of to_s does not match."]
+  #
+  # <b>Use predefined format expressions:</b>
+  #
+  #   obj = 'Valid Address <foo@bar.baz>'
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   FormatValidation.new({:with => :email}, :to_s).call obj, :to_s, obj
+  #   obj.errors.on(:to_s).any? # => false
+  class FormatValidation < Validation
+
+    # Predefined matchers.
+    PREDEFINED = {
+      :email => /[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/,
+      :ip => /(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/
+    }
+
+    def initialize(valid, attributes) #:nodoc:
+      valid[:with] = PREDEFINED.fetch valid[:with] if valid[:with].is_a? Symbol
+      valid[:with].respond_to? :match or
+      raise ArgumentError, "#{ valid[:with].inspect } doesn't :match"
+
+      valid[:message] ||= '%s does not match format.'
+
+      if valid[:allow_blank] || valid[:allow_nil]
+        valid[:allow] = valid[:allow_blank] ? :blank? : :nil?
+        super valid, attributes, &matching_block_with_exception(valid)
+      else
+        super valid, attributes, &matching_block(valid)
+      end
+    end
+
+    protected
+    def matching_block_with_exception(valid)
+      proc do |obj, attr, value|
+        value.send valid[:allow] or
+        valid[:with].match value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+    def matching_block(valid)
+      proc do |obj, attr, value|
+        valid[:with].match value or
+        obj.errors.add attr, valid[:message]
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validations/length_validation.rb

@@ -0,0 +1,91 @@
+module NotNaughty
+
+  # == Validates length of obj's attribute via the <tt>:length</tt> method.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:message</tt>:: see NotNaughty::Errors for details
+  # <tt>:if</tt>::      see NotNaughty::Validation::Condition for details
+  # <tt>:unless</tt>::  see NotNaughty::Validation::Condition for details
+  #
+  # <b>Boundaries (by precendence):</b>
+  # <tt>:is</tt>::      valid length
+  # <tt>:within</tt>::  valid range of length
+  # <tt>:minimum</tt>:: maximum length
+  # <tt>:maximum</tt>:: minimum length
+  #
+  # If both, <tt>:minimum</tt> and <tt>:maximum</tt> are provided they're
+  # converted to :within.  Each boundary type has its own default message:
+  # precise:: "Length of %s is not equal to #{__length}."
+  # range:: "Length of %s is not within #{__range.first} and #{__range.last}."
+  # lower:: "Length of %s is smaller than #{__boundary}."
+  # upper:: "Length of %s is greater than #{__boundary}."
+  #
+  # <b>Example:</b>
+  #
+  #   obj = %w[a sentence with five words] #
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   LengthValidation.new({:minimum => 4}, :to_a).
+  #     call obj, :to_a, %w[a sentence with five words]
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   LengthValidation.new({:within => 1..4}, :to_a).
+  #     call obj, :to_a, %w[a sentence with five words]
+  #   obj.errors.on(:to_s).any? # => true
+  #
+  # I'm sorry for using eval here...
+  class LengthValidation < Validation
+
+TEMPLATE = <<-BLOCK
+proc do |obj, attr, value|
+  value.%s or %s value.length or
+  obj.errors.add attr, %s
+end
+BLOCK
+
+    def initialize(valid, attributes) #:nodoc:
+      super valid, attributes, &build_block(valid)
+    end
+
+    protected
+    def build_block(valid) #:nodoc:
+      if valid[:is] then is_block valid
+      elsif valid[:within] or valid[:minimum] && valid[:maximum] then within_block valid
+      elsif valid[:minimum] then minimum_block valid
+      elsif valid[:maximum] then maximum_block valid
+      else
+        raise ArgumentError, 'no boundary given'
+      end
+    end
+
+    def is_block(valid)
+      valid[:message] ||= "Length of %s is not equal to #{ valid[:is] }."
+
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:is].inspect } ==", valid[:message].inspect ]
+    end
+    def within_block(valid)
+      valid[:within] ||= Range.new valid[:minimum], valid[:maximum]
+      valid[:message] ||= "Length of %s is not within #{ valid[:within].min } and #{ valid[:within].max }."
+
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "(#{ valid[:within].inspect }).include?", valid[:message].inspect ]
+    end
+    def minimum_block(valid)
+      valid[:message] ||= "Length of %s is less than #{ valid[:minimum] }."
+
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:minimum].inspect } <=", valid[:message].inspect ]
+    end
+    def maximum_block(valid)
+      valid[:message] ||= "Length of %s is greater than #{ valid[:maximum] }."
+
+      eval TEMPLATE % [ valid[:allow_blank] ? :blank? : :nil?,
+        "#{ valid[:maximum].inspect } >=", valid[:message].inspect ]
+    end
+
+  end
+end