not_naughty 0.3

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

data/lib/not_naughty/validator.rb

@@ -0,0 +1,119 @@
+module NotNaughty
+
+  # == Superclass for all Adapters.
+  #
+  # See new and get_state for more information.
+  class Validator
+    
+    attr_reader :states
+    
+    # By default it comes with the :default State unless other states are
+    # provided.
+    #
+    # <b>Example:</b>
+    #   NotNaughty::Validator.new
+    #     # has the :default state
+    #   NotNaughty::Validator.new :create, :update
+    #     # has the :create and :update states
+    #
+    # <em>Adapters should overwrite this method.</em>
+    def initialize(*states)
+      states << :default if states.empty?
+      
+      @states         = states.inject({}) {|m, s| m.update s => State.new(s)}
+      @initial_state  = @states[states.first]
+    end
+    
+    def clone #:nodoc:
+      states = [@initial_state.name] | @states.keys
+      
+      clone = self.class.new(*states)
+      @states.each do |n, s|
+        s.validations.each { |a, v| clone.states[n].validations[a] = v.clone }
+      end
+      clone.instance_eval { @initial_state = @states[states.first] }
+      
+      clone
+    end
+    
+    # Returns the state for the given object. By default it does return the
+    # initial state.
+    #
+    # <em>Adapters that provide multiple states should eventually overwrite
+    # this method</em>.
+    def get_state(obj = nil) @initial_state end
+    
+    # Adds a validation to all/specified states.
+    #
+    # <b>Example:</b>
+    #   add_validation(:firstname, :lastname, :on => :default) {|o, a, v|}
+    #     # adds validation to :default state
+    #   add_validation(:firstname, :lastname) {|o, a, v|}
+    #     # adds validation to all states
+    #   add_validation(:first, :last, :on => [:create, :update]) {|o, a, v|}
+    #     # adds validation to :create and :update states
+    def add_validation(*p, &b)
+      options = (p.last.is_a? Hash) ? p.last : {}
+      
+      if states = options.delete(:on)
+        @states.values_at(*states).each do |state|
+          state.add_validation(*p, &b) unless state.nil?
+        end
+      else
+        @states.each { |name, state| state.add_validation(*p, &b) }
+      end
+    end
+    
+    # Returns true if given object has validations in its current state. If
+    # no object was given it returns true if any state has validations. It
+    # otherwise returns false.
+    def has_validations?(obj = nil)
+      if obj.nil? then @states.any? { |name, state| state.has_validations? }
+      else get_state(obj).has_validations? end
+    end
+    
+    # Runs all validations on object for the object's state.
+    def invoke(obj)
+      get_state(obj).validations.each do |attr, validations|
+        val = obj.send! attr
+        validations.each { |validation| validation.call obj, attr, val }
+      end
+    end
+    
+    # == Container for attribute specific validations
+    #
+    # See Validator for details.
+    class State
+      
+      attr_reader :validations, :name
+      
+      # Initializes the state with given name.
+      def initialize(name = :default)
+        @name, @validations = name, Hash.new {|h, k| h[k] = []}
+      end
+      
+      # Adds the validation that results from <tt>params</tt> and
+      # <tt>block</tt> to validated attributes (see Validation#new for
+      # details).
+      def add_validation(*params, &block)
+        validation = Validation.new(*params, &block)
+        
+        validation.attributes.each do |attribute|
+          @validations[attribute] << validation if attribute.is_a? Symbol
+        end
+      end
+      
+      # Returns validations for given attribute.
+      def [](attribute)
+        @validations[attribute]
+      end
+      
+      # Returns true if a attributes has validations assigned, false
+      # otherwise.
+      def has_validations?
+        @validations.any? { |attribute, validations| validations.any? }
+      end
+      
+    end
+  end
+end

data/lib/not_naughty.rb

@@ -0,0 +1,85 @@
+require 'delegate'
+require 'observer'
+
+require 'rubygems'
+require 'assistance'
+
+module Kernel#:nodoc:all
+  methods.include? 'send!' or
+  alias_method :send!, :send
+end
+
+$:.unshift File.dirname(__FILE__)
+
+module NotNaughty
+  require 'not_naughty/validator'
+
+  require 'not_naughty/builder'
+  require 'not_naughty/validation'
+  Validation.add_observer Builder
+  
+  require 'not_naughty/errors'
+  require 'not_naughty/instance_methods'
+  
+  # Extended classes get NotNaughty::Builder and NotNaughty::InstanceMethods.
+  def self.extended(base)
+    base.instance_eval do
+      include InstanceMethods
+      extend Builder
+    end
+  end
+  
+  # call-seq:
+  # validator(validator_klass = NotNaughty::Validator, *states = [:default])
+  #
+  # Returns instance of Validator. This is either the validator's clone of
+  # superclass, an instance of the the given descendant of or the
+  # <tt>NotNaughty:Validator</tt> himself.
+  #
+  # <b>Examples:</b>
+  #   validator # => Instance of NotNaughty::Validator with :default state
+  #   validator :create, :update # ~ - but with :create and :update states
+  #   validator AnotherValidator # Instance of AnotherValidator
+  #
+  # The above examples work as long validator is not already called. To reset
+  # an already assigned validator set <tt>@validator</tt> to nil.
+  def validator(*states)
+    @validator ||= if superclass.respond_to? :validator
+      superclass.validator.clone
+
+    else
+      validator_klass =
+        if states[0].is_a? Class and states[0] <= NotNaughty::Validator
+          states.shift
+        else
+          NotNaughty::Validator
+        end
+      
+      validator_klass.new(*states)
+    end
+  end
+  
+  # Prepends a call for validation before then given method. If, on call, the
+  # validation passes the method is called. Otherwise it raises an
+  # NotNaughty::ValidationException or returns false.
+  #
+  # <b>Example:</b>
+  #   validated_before :save # raise ValidationException unless valid?
+  #   validated_before :save, :without => :exception # => false unless valid?
+  def validated_before(method, *args)
+    __method = :"#{method}_without_validations"
+    alias_method __method, method
+    
+    without = args.extract_options![:without]
+    if [*without].include? :exception
+      define_method method do |*params|
+        if valid? then send! __method else false end
+      end
+    else
+      define_method method do |*params|
+        if valid? then send! __method else raise errors.to_exception end
+      end
+    end
+  end
+  
+end

data/lib/sequel_not_naughty.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/not_naughty'
+require 'sequel'
+
+module Sequel #:nodoc:
+  module Plugins #:nodoc:
+    # == Adapter for Sequel ...
+    #
+    # ... is a Sequel::Plugin.
+    #
+    # ---
+    #
+    # <b>To make it overall available:</b>
+    #
+    #   class Sequel::Model
+    #     is :not_naughty
+    #   end
+    #
+    # <b>To turn off before_validate and after_validate hooks:</b>
+    #
+    #   class User < Sequel::Model
+    #     is :not_naughty, :without => :hooks
+    #   end
+    #
+    # <b>To turn off raised Exceptions if validation before save fails:</b>
+    #
+    #   class User < Sequel::Model
+    #     # save on invalid users will return false
+    #     is :not_naughty, :without => :exceptions
+    #   end
+    #
+    # <b>To combine those:</b>
+    #
+    #   class User < Sequel::Model
+    #     is :not_naughty, :without => [:exceptions, :hooks]
+    #   end
+    #
+    class NotNaughty < NotNaughty::Validator
+      
+      # Applies plugin to a Sequel::Model.
+      def self.apply(receiver, *args)
+        receiver.extend ::NotNaughty
+        receiver.validator self, :create, :update
+        
+        ::NotNaughty::Validation.load(
+          :acceptance, :confirmation, :format,
+          :length, :numericality, :presence
+        )
+        
+        receiver.extend ClassMethods
+        receiver.instance_eval { alias_method :save, :save! }
+        receiver.validated_before :save, *args
+        
+        without = args.extract_options![:without]
+        receiver.send! :include, Hooks unless [*without].include? :hooks
+      end
+      
+      # Returns state for given instance.
+      def get_state(instance)
+        if instance.new? then @states[:create] else @states[:update] end
+      end
+      
+      # Adds validation hooks to Sequel::Model.
+      module Hooks
+        def self.included(base)
+          base.instance_eval do
+            def_hook_method :before_validate
+            def_hook_method :after_validate
+            alias_method :validate_without_hooks, :validate
+            alias_method :validate, :validate_with_hooks
+          end
+        end
+        
+        def before_validate() end
+        def after_validate() end
+        
+        def validate_with_hooks
+          before_validate
+          validate_without_hooks
+          after_validate
+        end
+      end
+      
+      # Ensures Sequel::Model API compatibility.
+      module ClassMethods
+        
+        # Returns the validations hash for the class.
+        def validations
+          validator.states.
+          inject({}) do |validations, state_with_name|
+            validations.merge(state_with_name[1].validations) {|k,o,n| o|n}
+          end
+        end
+        # Returns true if validations are defined.
+        def has_validations?()
+          validator.has_validations?
+        end
+        # Validates the given instance.
+        def validate(instance)
+          validator.invoke instance
+        end
+        
+      end
+      
+    end
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,69 @@
+require "#{ File.dirname(__FILE__) }/spec_helper.rb"
+
+describe subject::Builder do
+  
+  before(:each) do
+    @validatable = Class.new(Object) do
+      def self.validator=(validator) @validator = validator end
+      def self.validator() @validator end
+      def initialize(state) @state = state end
+      def validation_state() state end
+    end
+    @validatable.validator = mock 'Validator'
+    @validatable.extend(subject::Builder)
+  end
+  
+  it "should have a delegator class" do
+    subject::Builder.constants.
+      should include('ValidationDelegator')
+    subject::Builder.const_get('ValidationDelegator').
+      should < SimpleDelegator
+  end
+  it "should provide the :validates builder method" do
+    @validatable.should respond_to(:validates)
+  end
+  it "should add validation for :name via :validates" do
+    @validatable.validator.should_receive(:add_validation).
+      with(NotNaughty::PresenceValidation, :name, {}).twice
+    @validatable.validates { presence_of :name }
+    @validatable.validates(:name) { presence }
+  end
+  it "should add validation for :name on update via :validates" do
+    @validatable.validator.should_receive(:add_validation).
+      with(NotNaughty::PresenceValidation, :name, {:on => :update}).twice
+    @validatable.validates { presence_of :name, :on => :update }
+    @validatable.validates(:on => :update) { presence_of :name }
+  end
+  it "should add validation for :firstname and :lastname via :validates" do
+    @validatable.validator.should_receive(:add_validation).
+      with(NotNaughty::PresenceValidation, :firstname, :lastname, {}).twice
+    @validatable.validates { presence_of :firstname, :lastname }
+    @validatable.validates(:firstname, :lastname) { presence :name }
+  end
+  it "should register validation" do
+    validation = Class.new(subject::Validation) do
+      def self.name() 'TestValidation' end
+      def initialize(opts, &block) end
+      def call(obj, attr, value) end
+    end
+
+    @validatable.should respond_to(:validates_test_of)
+  end
+  it "should provide the :validates_each builder method" do
+    @validatable.should respond_to(:validates_each)
+  end
+  it "should build the Validations with :validates_each" do
+    @validatable.validator = mock 'Validator'
+    @validatable.validator.
+      should_receive(:add_validation).
+      with(:a, :b)
+    @validatable.validates_each(:a, :b) {|o, a, v|}
+    
+    pending 'expect a block'
+  end
+  it "should raise a NoMethodError is builder method does not exist" do
+    lambda { @validatable.validates() { bunch_of :holy_crap } }.
+    should raise_error(NoMethodError)
+  end
+  
+end

data/spec/errors_spec.rb

@@ -0,0 +1,61 @@
+require "#{ File.dirname(__FILE__) }/spec_helper.rb"
+
+describe subject::Errors do
+  
+  before(:each) { @errors = subject::Errors.new }
+  
+  it "should add errors in a hash" do
+    @errors.add :attribute, 'Message'
+
+    @errors.instance_variable_get(:@errors)[:attribute].
+    should include('Message')
+  end
+  it "should return full messages" do
+    @errors.add :attribute, 'Message #{"%s".capitalize}'
+
+    @errors.full_messages.
+    should == ['Message Attribute']
+  end
+  it "should return an #{subject::ValidationException} with errors" do
+    exception = @errors.to_exception
+    exception.should be_an_instance_of(subject::ValidationException)
+    exception.errors.should == @errors
+  end
+  it "should have methods delegated" do
+    probe = mock 'Probe'
+    methods = [:empty?, :clear, :[], :each, :to_yaml]
+    
+    methods.each { |m| probe.should_receive m }
+    @errors.instance_variable_set :@errors, probe
+    
+    methods.each { |m| @errors.send! m }
+  end
+  it "should return evaluated errors messages" do
+    @errors.add :attribute, 'Message #{"%s".capitalize}'
+    @errors.on(:attribute).should == ['Message Attribute']
+  end
+  
+end
+
+describe subject::ValidationException do
+  
+  it "should return an exception with errors" do
+    probe = mock 'probe'
+    probe.should_receive(:any?).and_return(true)
+    exception = subject::ValidationException.new probe
+
+    lambda { raise exception }.should_not raise_error(TypeError)
+    exception.errors.should == probe
+  end
+  it "should have methods delegated" do
+    methods = [:on, :full_messages, :each]
+
+    probe = mock 'Probe'
+    probe.should_receive(:any?).and_return(true)
+    exception = subject::ValidationException.new probe
+
+    methods.each { |m| probe.should_receive m }
+    methods.each { |m| exception.send! m }
+  end
+  
+end

data/spec/not_naughty_spec.rb

@@ -0,0 +1,80 @@
+require "#{ File.dirname(__FILE__) }/spec_helper.rb"
+
+module subject::Builder
+  def self.extended(base) end
+end
+module subject::InstanceMethods
+  def self.included(base) end
+end
+
+describe subject do
+  
+  it "should load necessary files" do
+    subject::should be_const_defined(:Validation)
+    subject::should be_const_defined(:Validator)
+    subject::should be_const_defined(:Builder)
+    subject::should be_const_defined(:InstanceMethods)
+    subject::should be_const_defined(:Errors)
+  end
+  it "should define a validator" do
+    validated = Class.new(Object).extend subject
+    validated.should respond_to(:validator)
+    validated.validator.should be_an_instance_of(subject::Validator)
+    
+    validator = Class.new(subject::Validator)
+    validated = Class.new(Object).extend subject
+    validated.validator validator, :create, :update
+    validated.validator.should be_an_instance_of(validator)
+    validated.validator.states.keys.should include(:create, :update)
+  end
+  it "should extend the receiver if validator is defined" do
+    validated = Class.new(Object)
+    
+    subject::Builder.should_receive(:extended).with(validated)
+    subject::InstanceMethods.should_receive(:included).with(validated)
+    
+    validated.extend subject
+  end
+  it "should deep-clone the validator if inherited" do
+    super_validated = Class.new(Object).extend subject
+    super_validated.validator.add_validation(:name) {|o, a, v|}
+    validated = Class.new(super_validated)
+    
+    validated.validator.should_not == super_validated.validator
+    validated.validator.should have_validations
+    validated.validator.add_validation(:name) {|o, a, v|}
+    
+    super_validated.validator.get_state.validations[:name].length.
+    should < validated.validator.get_state.validations[:name].length
+  end
+  it "should prepend a validation before any method" do
+    validated = Class.new(Object).extend subject
+    
+    validated.validated_before :clone
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(true)
+    instance.should_receive(:clone_without_validations)
+    instance.clone
+  end
+  it "should raise an exception if invalid and method called" do
+    validated = Class.new(Object).extend subject
+    
+    validated.validated_before :clone
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(false)
+    lambda { instance.clone }.should raise_error(subject::ValidationException)
+  end
+  it "should return false if invalid and method called" do
+    validated = Class.new(Object).extend subject
+    
+    validated.validated_before :clone, :without => :exception
+    instance = validated.new
+    instance.should_receive(:valid?).once.and_return(false)
+    instance.clone.should == false
+  end
+  it "should add Builder to Validation observers" do
+    subject::Validation.instance_variable_get(:@observer_peers).
+    should include(subject::Builder)
+  end
+  
+end

data/spec/rcov.opts

@@ -0,0 +1,4 @@
+--exclude
+gems
+--exclude
+spec