not-naughty 0.6.0

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,126 @@
+module NotNaughty
+
+  # == The superclass for Validations.
+  #
+  # See new for more information.
+  class Validation
+
+    BASEDIR = File.dirname __FILE__
+    # Loader pattern
+    PATTERN = File.join BASEDIR, %w[validations ** %s_validation.rb]
+
+    # Loads validations.
+    def self.load(*validations)
+      validations.each do |validation|
+        Dir.glob(PATTERN % validation).each { |path| require path }
+      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,41 @@
+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(opts, attributes) #:nodoc:
+      __message = opts[:message] || '#{"%s".humanize} could not be confirmed.'
+
+      if opts[:allow_blank] or opts[:allow_nil]
+        __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 o.send(:"#{a}_confirmation").eql? v
+        end
+      else
+        super opts, attributes do |o, a, v|
+          o.errors.add a, __message unless
+          o.send(:"#{a}_confirmation").eql? v
+        end
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validations/format_validation.rb

@@ -0,0 +1,55 @@
+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, 'abc'
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   FormatValidation.new({:with => /[A-Z]/}, :to_s).call obj, :to_s, 'abc'
+  #   obj.errors.on(:to_s) # => ["Format of to_s does not match."]
+  class FormatValidation < Validation
+
+    # Predefined matchers.
+    DEFINITIONS = {
+      :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(opts, attributes) #:nodoc:
+      format_matcher = if Symbol === opts[:with] then DEFINITIONS[opts[:with]]
+      elsif opts[:with].respond_to? :match then opts[:with]
+      end or raise ArgumentError, "#{ opts[:with].inspect } doesn't :match"
+
+      msg = opts[:message] || '%s does not match format.'
+
+      if opts[:allow_blank] or opts[:allow_nil]
+        pass = opts[:allow_blank] ? :blank? : :nil?
+
+        super opts, attributes do |obj, attr, val|
+          val.send pass or format_matcher.match val or
+          obj.errors.add attr, msg
+        end
+      else
+        super opts, attributes do |obj, attr, val|
+          format_matcher.match val or
+          obj.errors.add attr, msg
+        end
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validations/length_validation.rb

@@ -0,0 +1,95 @@
+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
+  class LengthValidation < Validation
+
+    def initialize(opts, attributes) #:nodoc:
+
+      block = build_block opts
+
+      if opts[:allow_blank]
+        super opts, attributes do |o, a, v|
+          block[o, a, v] unless v.blank?
+        end
+      else
+        super opts, attributes do |o, a, v|
+          block[o, a, v] unless v.nil?
+        end
+      end
+    end
+
+    protected
+    def build_block(opts) #:nodoc:
+      if __length = opts[:is]
+        __message = opts[:message] ||
+          "Length of %s is not equal to #{__length}."
+        proc do |o, a, v|
+          o.errors.add a, __message unless __length.eql? v.length
+        end
+      elsif opts[:within] or opts[:minimum] && opts[:maximum]
+        __range   = opts[:within]
+        __range ||= Range.new opts[:minimum], opts[:maximum]
+
+        __message = opts[:message] ||
+          "Length of %s is not within #{__range.first} and #{__range.last}."
+
+        proc do |o, a, v|
+          o.errors.add a, __message unless __range.include? v.length
+        end
+      elsif opts[:minimum]
+        __boundary  = opts[:minimum]
+        __message   = opts[:message] ||
+          "Length of %s is smaller than #{__boundary}."
+
+        proc do |o, a, v|
+          o.errors.add a, __message unless __boundary <= v.length
+        end
+      elsif opts[:maximum]
+        __boundary  = opts[:maximum]
+        __message   = opts[:message] ||
+          "Length of %s is greater than #{__boundary}."
+
+        proc do |o, a, v|
+          o.errors.add a, __message unless __boundary >= v.length
+        end
+      else
+        raise ArgumentError, 'no boundary given'
+      end
+    end
+
+  end
+end

data/lib/not_naughty/validations/numericality_validation.rb

@@ -0,0 +1,43 @@
+NotNaughty::Validation.load :format
+
+module NotNaughty
+
+  # == Validates numericality of obj's attribute via an regular expression.
+  #
+  # Unless the validation succeeds an error hash (:attribute => :message)
+  # is added to the obj's instance of Errors.
+  #
+  # <b>Options:</b>
+  # <tt>:only_integer</tt>:: validates with <tt>/^[+-]?\d+$/</tt> (false)
+  # <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 = '-12.2' #
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   NumericalityValidation.new({}, :to_s).call obj, :to_s, '-12.2'
+  #   obj.errors.on(:to_s).any? # => false
+  #
+  #   NumericalityValidation.new({:only_integer => true}, :to_s).
+  #     call obj, :to_s, '-12.2'
+  #
+  #   obj.errors.on(:to_s).any? # => true
+  class NumericalityValidation < FormatValidation
+
+    def initialize(opts, attributes) #:nodoc:
+      opts[:with] = if opts[:only_integer]
+        opts[:message] ||= '#{"%s".humanize} is not an integer.'
+        /^[+-]?\d+$/
+      else
+        opts[:message] ||= '#{"%s".humanize} is not a number.'
+        /^[+-]?\d*\.?\d+$/
+      end
+
+      super opts, attributes
+    end
+
+  end
+end

data/lib/not_naughty/validations/presence_validation.rb

@@ -0,0 +1,31 @@
+module NotNaughty
+
+  # == Validates presence of obj's attribute via the <tt>:blank?</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>Example:</b>
+  #
+  #   obj = '' # blank? => true
+  #   def obj.errors() @errors ||= NotNauthy::Errors.new end
+  #
+  #   PresenceValidation.new({}, :to_s).call obj, :to_s, ''
+  #   obj.errors.on(:to_s) # => ["To s is not present."]
+  class PresenceValidation < Validation
+
+    def initialize(opts, attributes) #:nodoc:
+      __message = opts[:message] || '#{"%s".humanize} is not present.'
+
+      super opts, attributes do |o, a, v|
+        o.errors.add a, __message if v.blank?
+      end
+    end
+
+  end
+end