assistance 0.1.1 → 0.1.2

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 0.1.2 (2008-01-21)
+
+* Imported Validation from Sequel.
+
 === 0.1.1 (2008-01-18)
 
 * Added Array#extract_options! method.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "assistance"
-VERS = "0.1.1"
+VERS = "0.1.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/lib/assistance.rb

@@ -6,4 +6,5 @@ dir = File.join(File.dirname(__FILE__), "assistance")
   inflector
   blank
   extract_options
+  validation
 ].each {|f| require(File.join(dir, f))}

data/lib/assistance/validation.rb

@@ -0,0 +1,239 @@
+# The Validations module provides validation capabilities as a mixin. When
+# included into a class, it enhances the class with class and instance
+# methods for defining validations and validating class instances.
+# 
+# The Validation emulates the validation capabilities of ActiveRecord, and
+# provides methods for validating acceptance, confirmation, presence, format, 
+# length and numericality of attributes.
+#
+# To use validations, you need to include the Validation module in your
+# class:
+#
+#   class MyClass
+#     include Validation
+#     validates_length_of :password, :minimum => 6
+#   end
+module Validation
+  # Includes the Validation class methods into the including class.
+  def self.included(c)
+    c.extend ClassMethods
+  end
+  
+  # Returns the validation errors associated with the object.
+  def errors
+    @errors ||= Errors.new
+  end
+
+  # Validates the object.
+  def validate
+    errors.clear
+    self.class.validate(self)
+  end
+
+  # Validates the object and returns true if no errors are reported.
+  def valid?
+    validate
+    errors.empty?
+  end
+
+  # Validation::Errors represents validation errors.
+  class Errors
+    # Initializes a new instance of validation errors.
+    def initialize
+      @errors = Hash.new {|h, k| h[k] = []}
+    end
+    
+    # Returns true if no errors are stored.
+    def empty?
+      @errors.empty?
+    end
+    
+    # Clears all errors.
+    def clear
+      @errors.clear
+    end
+    
+    # Returns the errors for the given attribute.
+    def on(att)
+      @errors[att]
+    end
+    alias_method :[], :on
+    
+    # Adds an error for the given attribute.
+    def add(att, msg)
+      @errors[att] << msg
+    end
+    
+    # Returns an array of fully-formatted error messages.
+    def full_messages
+      @errors.inject([]) do |m, kv| att, errors = *kv
+        errors.each {|e| m << "#{att} #{e}"}
+        m
+      end
+    end
+  end
+  
+  # The Generator class is used to generate validation definitions using 
+  # the validates {} idiom.
+  class Generator
+    # Initializes a new generator.
+    def initialize(receiver ,&block)
+      @receiver = receiver
+      instance_eval(&block)
+    end
+
+    # Delegates method calls to the receiver by calling receiver.validates_xxx.
+    def method_missing(m, *args)
+      @receiver.send(:"validates_#{m}", *args)
+    end
+  end
+  
+  # Validation class methods.
+  module ClassMethods
+    # Defines validations by converting a longhand block into a series of 
+    # shorthand definitions. For example:
+    #
+    #   class MyClass
+    #     include Validation
+    #     validates do
+    #       length_of :name, :minimum => 6
+    #       length_of :password, :minimum => 8
+    #     end
+    #   end
+    #
+    # is equivalent to:
+    #   class MyClass
+    #     include Validation
+    #     validates_length_of :name, :minimum => 6
+    #     validates_length_of :password, :minimum => 8
+    #   end
+    def validates(&block)
+      Generator.new(self, &block)
+    end
+
+    # Returns the validations hash for the class.
+    def validations
+      @validations ||= Hash.new {|h, k| h[k] = []}
+    end
+    
+    # Returns true if validations are defined.
+    def has_validations?
+      !validations.empty?
+    end
+
+    # Validates the given instance.
+    def validate(o)
+      validations.each do |att, procs|
+        v = o.send(att)
+        procs.each {|p| p[o, att, v]}
+      end
+    end
+    
+    # Adds a validation for each of the given attributes using the supplied
+    # block. The block must accept three arguments: instance, attribute and 
+    # value, e.g.:
+    #
+    #   validates_each :name, :password do |object, attribute, value|
+    #     object.errors[attribute] << 'is not nice' unless value.nice?
+    #   end
+    def validates_each(*atts, &block)
+      atts.each {|a| validations[a] << block}
+    end
+
+    # Validates acceptance of an attribute.
+    def validates_acceptance_of(*atts)
+      opts = {
+        :message => 'is not accepted',
+        :allow_nil => true,
+        :accept => '1'
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v == opts[:accept]
+      end
+    end
+
+    # Validates confirmation of an attribute.
+    def validates_confirmation_of(*atts)
+      opts = {
+        :message => 'is not confirmed',
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        c = o.send(:"#{a}_confirmation")
+        o.errors[a] << opts[:message] unless v == c
+      end
+    end
+
+    # Validates the format of an attribute.
+    def validates_format_of(*atts)
+      opts = {
+        :message => 'is invalid',
+      }.merge!(atts.extract_options!)
+      
+      unless opts[:with].is_a?(Regexp)
+        raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
+      end
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
+      end
+    end
+
+    # Validates the length of an attribute.
+    def validates_length_of(*atts)
+      opts = {
+        :too_long     => 'is too long',
+        :too_short    => 'is too short',
+        :wrong_length => 'is the wrong length'
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        if m = opts[:maximum]
+          o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
+        end
+        if m = opts[:minimum]
+          o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
+        end
+        if i = opts[:is]
+          o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
+        end
+        if w = opts[:within]
+          o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+        end
+      end
+    end
+
+    NUMBER_RE = /^\d*\.{0,1}\d+$/
+    INTEGER_RE = /\A[+-]?\d+\Z/
+
+    # Validates whether an attribute is a number.
+    def validates_numericality_of(*atts)
+      opts = {
+        :message => 'is not a number',
+      }.merge!(atts.extract_options!)
+      
+      re = opts[:only_integer] ? INTEGER_RE : NUMBER_RE
+      
+      validates_each(*atts) do |o, a, v|
+        next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+        o.errors[a] << opts[:message] unless v.to_s =~ re
+      end
+    end
+
+    # Validates the presence of an attribute.
+    def validates_presence_of(*atts)
+      opts = {
+        :message => 'is not present',
+      }.merge!(atts.extract_options!)
+      
+      validates_each(*atts) do |o, a, v|
+        o.errors[a] << opts[:message] unless v && !v.blank?
+      end
+    end
+  end
+end

data/spec/validation_spec.rb

@@ -0,0 +1,291 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Validation::Errors" do
+  setup do
+    @errors = Validation::Errors.new
+    class Validation::Errors
+      attr_accessor :errors
+    end
+  end
+  
+  specify "should be clearable using #clear" do
+    @errors.errors = {1 => 2, 3 => 4}
+    @errors.clear
+    @errors.errors.should == {}
+  end
+  
+  specify "should be empty if no errors are added" do
+    @errors.should be_empty
+    @errors[:blah] << "blah"
+    @errors.should_not be_empty
+  end
+  
+  specify "should return errors for a specific attribute using #on or #[]" do
+    @errors[:blah].should == []
+    @errors.on(:blah).should == []
+
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    @errors.on(:blah).should == ['blah']
+
+    @errors[:bleu].should == []
+    @errors.on(:bleu).should == []
+  end
+  
+  specify "should accept errors using #[] << or #add" do
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    
+    @errors.add :blah, 'zzzz'
+    @errors[:blah].should == ['blah', 'zzzz']
+  end
+  
+  specify "should return full messages using #full_messages" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
+  end
+end
+
+describe Validation do
+  setup do
+    @c = Class.new do
+      include Validation
+      
+      def self.validates_coolness_of(attr)
+        validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
+      end
+    end
+    
+    @d = Class.new do
+      attr_accessor :errors
+      def initialize; @errors = Validation::Errors.new; end
+    end
+  end
+  
+  specify "should respond to validates, validations, has_validations?" do
+    @c.should respond_to(:validations)
+    @c.should respond_to(:has_validations?)
+  end
+  
+  specify "should acccept validation definitions using validates_each" do
+    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
+    
+    @c.validations[:xx].size.should == 1
+    @c.validations[:yy].size.should == 1
+    
+    o = @d.new
+    @c.validations[:xx].first.call(o, :aa, 40)
+    @c.validations[:yy].first.call(o, :bb, 60)
+    
+    o.errors.full_messages.should == ['aa too low']
+  end
+
+  specify "should return true/false for has_validations?" do
+    @c.has_validations?.should == false
+    @c.validates_each(:xx) {1}
+    @c.has_validations?.should == true
+  end
+  
+  specify "should provide a validates method that takes block with validation definitions" do
+    @c.validates do
+      coolness_of :blah
+    end
+    @c.validations[:blah].should_not be_empty
+
+    o = @d.new
+    @c.validations[:blah].first.call(o, :ttt, 40)
+    o.errors.full_messages.should == ['ttt is not cool']
+    o.errors.clear
+    @c.validations[:blah].first.call(o, :ttt, :cool)
+    o.errors.should be_empty
+  end
+end
+
+describe "A Validation instance" do
+  setup do
+    @c = Class.new do
+      attr_accessor :score
+      
+      include Validation
+      
+      validates_each :score do |o, a, v|
+        o.errors[a] << 'too low' if v < 87
+      end
+    end
+    
+    @o = @c.new
+  end
+  
+  specify "should supply a #valid? method that returns true if validations pass" do
+    @o.score = 50
+    @o.should_not be_valid
+    @o.score = 100
+    @o.should be_valid
+  end
+  
+  specify "should provide an errors object" do
+    @o.score = 100
+    @o.should be_valid
+    @o.errors.should be_empty
+    
+    @o.score = 86
+    @o.should_not be_valid
+    @o.errors[:score].should == ['too low']
+    @o.errors[:blah].should be_empty
+  end
+end
+
+describe Validation::Generator do
+  setup do
+    $testit = nil
+    
+    @c = Class.new do
+      include Validation
+      
+      def self.validates_blah
+        $testit = 1324
+      end
+    end
+  end
+  
+  specify "should instance_eval the block, sending everything to its receiver" do
+    Validation::Generator.new(@c) do
+      blah
+    end
+    $testit.should == 1324
+  end
+end
+
+describe "Validations" do
+  setup do
+    @c = Class.new do
+      attr_accessor :value
+      include Validation
+    end
+    @m = @c.new
+  end
+
+  specify "should validate acceptance_of" do
+    @c.validates_acceptance_of :value
+    @m.should be_valid
+    @m.value = '1'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with accept" do
+    @c.validates_acceptance_of :value, :accept => 'true'
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = 'true'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with allow_nil => false" do
+    @c.validates_acceptance_of :value, :allow_nil => false
+    @m.should_not be_valid
+  end
+
+  specify "should validate confirmation_of" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value
+    
+    @m.value = 'blah'
+    @m.should_not be_valid
+    
+    @m.value_confirmation = 'blah'
+    @m.should be_valid
+  end
+
+  specify "should validate format_of" do
+    @c.validates_format_of :value, :with => /.+_.+/
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = 'abc_def'
+    @m.should be_valid
+  end
+  
+  specify "should raise for validate_format_of without regexp" do
+    proc {@c.validates_format_of :value}.should raise_error(ArgumentError)
+    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError)
+  end
+  
+  specify "should validate length_of with maximum" do
+    @c.validates_length_of :value, :maximum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with minimum" do
+    @c.validates_length_of :value, :minimum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with within" do
+    @c.validates_length_of :value, :within => 2..5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with is" do
+    @c.validates_length_of :value, :is => 3
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '12'
+    @m.should_not be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate length_of with allow_nil" do
+    @c.validates_length_of :value, :is => 3, :allow_nil => true
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of" do
+    @c.validates_numericality_of :value
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of with only_integer" do
+    @c.validates_numericality_of :value, :only_integer => true
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate presence_of" do
+    @c.validates_presence_of :value
+    @m.should_not be_valid
+    @m.value = ''
+    @m.should_not be_valid
+    @m.value = 1234
+    @m.should be_valid
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assistance
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz, Sam Smoot, Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-18 00:00:00 +02:00
+date: 2008-01-21 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -36,6 +36,7 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/time_calculations_spec.rb
+- spec/validation_spec.rb
 - lib/assistance
 - lib/assistance/blank.rb
 - lib/assistance/connection_pool.rb
@@ -44,6 +45,7 @@ files:
 - lib/assistance/inflections.rb
 - lib/assistance/inflector.rb
 - lib/assistance/time_calculations.rb
+- lib/assistance/validation.rb
 - lib/assistance.rb
 - CHANGELOG
 has_rdoc: true