vet 0.1.1

data/LICENSE.text

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Grant Heaslip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,209 @@
+# Vet
+
+Vet is a simple, lightweight, and ORM/framework-agnostic validation library that validates changes individually rather than atomically.
+
+Instead of running validations altogether, like ActiveRecord or DataMapper, it checks the validity of values before they are applied to your object, keeping the in-memory instance clean. This allows valid changes to be accepted and safely written to a data store even when others are invalid, rather than rejecting every change because one didn't validate. It should work with any attribute that has a getter and setter method, and shouldn't interfere with existing validation libraries.
+
+## Installation
+
+Install the gem from rubygems.org:
+
+	gem update --system
+	gem install vet
+
+## Basic usage
+
+Simply add the line "include Vet" to any model. Here's an example:
+
+	class Mario
+	  include Vet
+ 
+	  attr_accessor :lives
+	  attr_accessor :status
+	  attr_accessor :cards
+	  attr_accessor :items
+	end
+
+From now on, whenever you want to modify an attribute of an instance of that class, do the following:
+
+	@instance.vet(attribute_name, new_value, *tests)
+
+Here's an example:
+
+	@mario.vet(:lives, 2, :is_an_integer)
+
+When a test needs to accept a parameter, you send the test as an array in the form [test_name, parameter]:
+
+	@mario.vet(:lives, 2, :is_an_integer, [:is_in_range, 0..99])
+
+If the new value passes the test and is modified, the name of the attribute is added to the object's vet\_modified\_attributes array:
+
+	@mario.vet(:lives, 2, [:is_instance_of_class, Fixnum], [:is_in_range, 0..99])
+	puts @mario.vet_modified_attributes # => [:lives]
+
+On the other hand, if the test fails, the error message the test returns will be added to object's vet\_errors hash, in an array filed under the name of the attribute:
+
+	@mario.vet(:lives, 100, [:is_instance_of_class, Fixnum], [:is_in_range, 0..99])
+	puts @mario.vet_errors # => {:lives => ["Lives must be between 0 and 99."]}
+
+Lastly, if the new value passes the test but is not modified because it is identical to the old value, both the vet\_modified\_attributes array and the vet\_errors hash will be empty:
+
+	@mario.lives = 3
+	@mario.vet(:lives, 3, [:is_instance_of_class, Fixnum], [:is_in_range, 0..99])
+	puts @mario.vet_errors              # => {}
+	puts @mario.vet_modified_attributes # => []
+
+## Configuration
+
+### Defining default tests
+
+Obviously, typing out every test you want to run against an attribute every time it is modified would be repetitive, ugly, and error-prone. Instead, you can define a list of tests to always run against an attribute in the model. Here's an example:
+
+	class Mario
+	  include Vet
+
+	  attr_accessor :lives
+	  attr_accessor :status
+	  attr_accessor :cards
+	  attr_accessor :items
+
+	  def vet_attribute_tests 
+	    {
+	      :lives => 
+	      [
+	        [:is_instance_of_class, Fixnum],
+	        [:is_in_range, 0..99]
+	      ],
+	      :status => 
+	      [
+	        [:is_instance_of_class, Symbol],
+	      ],
+	      :cards => 
+	      [
+	        [:is_instance_of_class, Array],
+	        [:has_length_in_range, 0..3],
+	        [:only_contains_specified_objects, [:mushroom, :flower, :star]]
+	      ],
+	      :items => 
+	      [
+	        [:is_instance_of_class, Array],
+	        [:has_length_in_range, 0..100]
+	      ]
+	    } 
+	  end
+	end
+
+Vet will merge the tests passed through the standard vet method call with the ones specified in the model--duplicate tests aren't a problem. There are some tests, like is\_identical\_to\_confirmation, that you will still need to call in-controller because they require dynamic parameters.
+
+### Custom attribute names
+
+By default, Vet will try to choose appropriate attribute names for use in error messages by replacing dashes and underscores with spaces and capitalizing them appropriately for the sentence. That said, it isn't perfect, and there will be times where your internal attribute names are different than the public ones. Vet lets you specify custom attribute names that will override the generated ones:
+
+	class Mario
+	  include Vet
+
+	  attr_accessor :lives
+	  attr_accessor :status
+	  attr_accessor :cards
+	  attr_accessor :items
+
+	  def vet_attribute_names 
+	    { 
+	      :lives => "Number of lives", 
+	      :status => "Status", 
+	      :cards => "Card collection",
+	      :items => "Item collection"
+	    }
+	  end
+
+	  def vet_attribute_tests 
+	    {
+	      :lives => 
+	      [
+	        [:is_instance_of_class, Fixnum],
+	        [:is_in_range, 0..99]
+	      ],
+	      :status => 
+	      [
+	        [:is_instance_of_class, Symbol],
+	      ],
+	      :cards => 
+	      [
+	        [:is_instance_of_class, Array],
+	        [:has_length_in_range, 0..3],
+	        [:only_contains_specified_objects, [:mushroom, :flower, :star]]
+	      ],
+	      :items => 
+	      [
+	        [:is_instance_of_class, Array],
+	        [:has_length_in_range, 8..100]
+	      ]
+	    } 
+	  end
+	end
+
+	@mario = Mario.new()
+	@mario.vet(:lives, 100, [:is_instance_of_class, Fixnum], [:is_in_range, 0..99])
+	puts @mario.vet_errors # => {:lives => ["Number of lives must be between 0 and 99."]}
+	          # RATHER THAN: => {:lives => ["Lives must be between 0 and 99."]}
+
+## Defining tests
+
+Vet includes a bunch of useful built-in tests that you can check out by looking at the source, but it intentionally doesn't include ORM-specific tests, and there will be other tests that you will need that aren't included. Test definitions are very simple:
+
+	def is_not_empty(attribute, new_value)
+	  unless new_value.empty? == false
+	    add_vet_error(attribute, "must not be empty.") # => false
+	  end
+	end
+
+A test can take 2 or 3 parameters, depending on whether or not it needs to accept a value to test against. For example, here's another test from the source:
+
+	def is_equal_to_value(attribute, new_value, good_value)
+	  unless new_value == good_value
+	    add_vet_error(attribute, "must be #{good_value}.") # => false
+	  end
+	end
+
+If the test fails, it should return add\_vet\_error(attribute, "must be such and such."), which returns false. If the test passes, it should return anything except false, including nil (there's no need to write "...else return true end").
+
+If you *really* want to be explicit, you could write that last test as follows:
+
+	def is_equal_to_value(attribute, new_value, good_value)
+	  if new_value == good_value
+	    return true
+	  else
+	    add_vet_error(attribute, "must be #{good_value}.") # => false
+	    return false
+	  end
+	end
+
+Most of this is completely unnecessary--the add\_vet\_error function automatically returns false, and a nil return (i.e. which would be the case if the shorter version of the test passed), is interpreted as a pass since it isn't equal to false, so there's no need to return true.
+
+### Controlling add\_vet\_error behaviour
+
+add\_vet\_error will generate errors of the form "#{attribute} must not be empty", and will try to make sure the capitalization jives. There are options for when you want to override this behaviour:
+
+**{ATTRIBUTE\_NAME}**
+
+If you put "{ATTRIBUTE\_NAME}" the body of an error, the attribute name will be put there as opposed to at the beginning of it:
+
+	# Generates errors like "Mario's lives must be between 0 and 99."
+	
+	def must_be_between_0_and_99(attribute, new_value)
+	  unless (0..99).include? new_value
+	    add_vet_error(attribute, "Mario's {ATTRIBUTE_NAME} must between 0 and 99.")
+	  end
+	end
+
+**:exclude\_attribute\_name**
+
+If you add the parameter ":exclude\_attribute\_name" to the end of an add\_vet\_error call, it won't try to use the attribute name, generated or specified, in the error message, and will spit out the specified error message text verbatim:
+
+	# Generates errors like "Mario must have between 0 and 99 lives."
+	
+	def must_have_between_0_and_99_lives(attribute, new_value)
+	  unless (0..99).include? new_value
+	    add_vet_error(attribute, "Mario must have between 0 and 99 lives.", :exclude_attribute_name)
+	  end
+	end

data/lib/vet.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+module Vet
+  module_function
+  public
+  
+  attr_accessor :vet_errors # Hash {:attribute1=>["Error"], :attribute3=>["Error", "Error 2"]}
+  attr_accessor :vet_modified_attributes # Array [:attribute2, :attribute4]
+  
+  # -----------------
+  # ----- TESTS -----
+  # -----------------
+  
+  # ----- EQUALITY TESTS -----
+  
+  def is_not_empty(attribute, new_value)
+    unless new_value.empty? == false
+      add_vet_error(attribute, "must not be empty.")
+    end
+  end
+  
+  def is_equal_to_value(attribute, new_value, good_value)
+    unless new_value == good_value
+      add_vet_error(attribute, "must be #{good_value}.")
+    end
+  end
+  
+  def is_identical_to_confirmation(attribute, new_value, confirmation)
+    unless new_value == confirmation
+      add_vet_error(attribute, "must match confirmation.")
+    end
+  end
+  
+  def is_not_equal_to_value(attribute, new_value, bad_value)
+    unless new_value != bad_value
+      add_vet_error(attribute, "must not be #{bad_value}.")
+    end
+  end
+  
+  # ----- PROPERTY TESTS -----
+  
+  def is_instance_of_class(attribute, new_value, class_name)
+    unless new_value.class == class_name
+      add_vet_error(attribute, "must be a #{class_name}.")
+    end
+  end
+  
+  def is_an_integer(attribute, new_value)
+    unless new_value.to_s.match(%r{\A[\d]+\z})
+      add_vet_error(attribute, "must be a whole number.")
+    end
+  end
+  
+  # ----- RANGE TESTS -----
+  
+  def is_in_range(attribute, new_value, range)
+    unless range.include? new_value
+      add_vet_error(attribute, "must be between #{range.first} and #{range.last}.")
+    end
+  end
+  
+  def has_length_in_range(attribute, new_value, range)
+    unless range.include? new_value.length
+      add_vet_error(attribute, "must be between #{range.first} and #{range.last} characters long.")
+    end
+  end
+  
+  def only_contains_specified_objects(attribute, new_value, objects)
+    is_clean = true
+    new_value.each do |object|
+      if objects.include?(object) == false
+        is_clean = false
+      end
+    end
+    
+    if is_clean
+      return true
+    else
+      add_vet_error(attribute, "is not an acceptable value.")
+    end
+  end
+  
+  # ----- REGEX MATCH TESTS -----
+  
+  def is_email_address(attribute, new_value)
+    unless new_value.match(%r{\A([\S]+@[\S]+[\.][\S]{2,})\z})
+      add_vet_error(attribute, "must be a valid email address.")
+    end
+  end
+  
+  def is_uri_friendly(attribute, new_value)
+    unless new_value.match(%r{\A[a-z\d]{1}[a-z\d_-]*[a-z\d]{1}\z|\A[a-z\d]{1}\z})
+      add_vet_error(attribute, "must contain only lower-case alphanumeric characters, underscores, and dashes.")
+    end
+  end
+  
+  # ---------------------------
+  # ----- SUPPORT METHODS -----
+  # ---------------------------
+  
+  # Run tests, and modify the attribute if all tests pass
+  def vet(attribute, new_value, *specified_tests)
+    # Make sure attribute is a symbol
+    attribute = attribute.to_sym
+    
+    # Initialize variables if necessary
+    if self.vet_errors == nil
+      self.vet_errors = {}
+    end
+    if self.vet_modified_attributes == nil
+      self.vet_modified_attributes = []
+    end
+    
+    # Only bother running through tests if the new value is different than the old one
+    if self.send(attribute) != new_value
+      passed_tests = true
+    
+      # Combine tests defined in model with tests specificed on method call if applicable
+      if defined? self.vet_attribute_tests[attribute]
+        tests = specified_tests | self.vet_attribute_tests[attribute]
+      else
+        tests = specified_tests
+      end
+    
+      tests.each do |test|
+        # If test call is an array (i.e. has parameters), use parameters from it
+        if test.class == Array
+          passed_tests = false if self.send(test[0], attribute, new_value, test[1]) == false
+        else
+          passed_tests = false if self.send(test, attribute, new_value) == false 
+        end
+      end
+    
+      # Only modify the attribute if no tests fail
+      if passed_tests
+        self.modify_attribute(attribute, new_value)
+        self.vet_modified_attributes << attribute
+      end
+    
+      # Return true if attribute was changed, false if it wasn't
+      return passed_tests
+    else
+      # Return false if new value was identical to old one
+      return false
+    end
+  end
+  
+  # Simple wrapper for attribute setter method
+  def modify_attribute(attribute, new_value)
+    self.send("#{attribute}=", new_value)
+  end
+  
+  # Add error to appropriate location in vet_errors hash
+  def add_vet_error(attribute, message, *opts)
+    # If message includes {ATTRIBUTE_NAME} keyword, replace it with attribute name.
+    # Otherwise, generate message by prepending the attribute name to message
+    if opts == [:exclude_attribute_name]
+      error_message = message
+    elsif message.gsub!("{ATTRIBUTE_NAME}", attribute_name(attribute).downcase)
+      error_message = message
+    else
+      error_message = "#{attribute_name(attribute).capitalize} #{message}"
+    end
+    
+    # If first error message, encapsulate in an array, otherwise append to existing array
+    if self.vet_errors[attribute] == nil
+      self.vet_errors[attribute] = [error_message]
+    else
+      self.vet_errors[attribute] << error_message
+    end
+    
+    # Return false so test definitions don't all need to themselves (if you're adding an error the test didn't pass)
+    return false
+  end
+  
+  # Return user-defined attribute name if available, otherwise return code attribute name with underscores and dashes removed
+  def attribute_name(attribute)
+    if defined? self.vet_attribute_names[attribute]
+      return self.vet_attribute_names[attribute]
+    else
+      return attribute.to_s.gsub(/[_-]/, " ")
+    end
+  end
+
+end

data/test/vet_test.rb

@@ -0,0 +1,331 @@
+# encoding: utf-8
+require "rubygems"
+require "shoulda"
+require File.expand_path(File.dirname(__FILE__) + '/../lib/vet')
+
+class Mario # From Mario 3 (obviously!)
+  include Vet
+  
+  attr_accessor :lives # Fixnum
+  attr_accessor :status # Symbol (:normal, :super, :racoon, :fire, etc.)
+  attr_accessor :cards # Array of symbols (:mushroom, :flower, or :star), maximum length 3
+  attr_accessor :items # Array of symbols (:super_mushroom, :fire_flower, :super_leaf, etc.), maximum length 6
+  
+  def vet_attribute_names 
+    { 
+      :lives => "Number of lives", 
+      :status => "Status", 
+      :cards => "Card collection",
+      :items => "Item collection"
+    }
+  end
+  
+  def vet_attribute_tests 
+    {
+      :lives => 
+      [
+        [:is_instance_of_class, Fixnum],
+        [:is_in_range, 0..99]
+      ],
+      :status => 
+      [
+        [:is_instance_of_class, Symbol],
+      ],
+      :cards => 
+      [
+        [:is_instance_of_class, Array],
+        [:has_length_in_range, 0..3],
+        [:only_contains_specified_objects, [:mushroom, :flower, :star]]
+      ],
+      :items => 
+      [
+        [:is_instance_of_class, Array],
+        [:has_length_in_range, 0..100]
+      ]
+    } 
+  end
+  
+  def initialize
+    self.lives = 3
+    self.status = :normal
+    self.cards = []
+    self.items = []
+  end
+end
+
+class MarioNoConfiguration # From Mario 3 (obviously!)
+  include Vet
+  
+  attr_accessor :lives # Fixnum
+  attr_accessor :status # Symbol (:normal, :super, :racoon, :fire, etc.)
+  attr_accessor :cards # Array of symbols (:mushroom, :flower, or :star), maximum length 3
+  attr_accessor :items # Array of symbols (:super_mushroom, :fire_flower, :super_leaf, etc.), maximum length 6
+  attr_accessor :note # Extra attribute for miscellaneous tests (sorry, not creative enough to work email addresses into Mario 3 canon)
+  
+  def must_be_between_0_and_99(attribute, new_value)
+    unless (0..99).include? new_value
+      add_vet_error(attribute, "Mario's attribute {ATTRIBUTE_NAME} must between 0 and 99.")
+    end
+  end
+  
+  def must_have_between_0_and_99_lives(attribute, new_value)
+    unless (0..99).include? new_value
+      add_vet_error(attribute, "Mario must have between 0 and 99 lives.", :exclude_attribute_name)
+    end
+  end
+  
+  def initialize
+    self.lives = 3
+    self.status = :normal
+    self.cards = []
+    self.items = []
+    self.note = ""
+  end
+end
+
+class FunctionalityTest < Test::Unit::TestCase
+  context "A class that includes vet" do
+    setup do
+      @mario = Mario.new
+      @mario_no_configuration = MarioNoConfiguration.new
+    end
+    # These tests are redundant to handle both Ruby 1.8 and 1.9
+    should "have method vet" do
+      assert (@mario.public_methods.include? "vet") || (@mario.public_methods.include? :vet)
+    end
+    should "have method vet_errors" do
+      assert (@mario.public_methods.include? "vet_errors") || (@mario.public_methods.include? :vet_errors)
+    end
+    should "have method vet_modified_attributes" do
+      assert (@mario.public_methods.include? "vet_modified_attributes") || (@mario.public_methods.include? :vet_modified_attributes)
+    end
+    
+    should "run tests in vet_attribute_tests" do
+      assert @mario.vet(:lives, 150) == false
+    end
+    should "use attribute names specified in vet_attribute_names" do
+      @mario.vet(:lives, 150)
+      assert @mario.vet_errors[:lives] == ["Number of lives must be between 0 and 99."]
+    end
+    should "generate attribute name when one isn't specified in vet_attribute_names" do
+      @mario_no_configuration.vet(:lives, 150, [:is_in_range, 0..99])
+      assert @mario_no_configuration.vet_errors[:lives] == ["Lives must be between 0 and 99."]
+    end
+    should "replace {ATTRIBUTE_NAME} with attribute name in error message" do
+      @mario_no_configuration.vet(:lives, 150, :must_be_between_0_and_99)
+      assert @mario_no_configuration.vet_errors[:lives] == ["Mario's attribute lives must between 0 and 99."]
+    end
+    should "not include attribute name if :exclude_attribute_name passed to add_error_message in test definition" do
+      @mario_no_configuration.vet(:lives, 150, :must_have_between_0_and_99_lives)
+      assert @mario_no_configuration.vet_errors[:lives] == ["Mario must have between 0 and 99 lives."]
+    end
+    
+    should "not modify attribute if new value is the same as the old one" do
+      assert @mario.vet(:lives, 3) == false
+    end
+    should "not add any errors if new value is the same as the old one" do
+      @mario.vet(:lives, 3, [:is_not_equal_to_value, 3])
+      assert @mario.vet_errors[:lives] == nil
+    end
+    should "not modify attribute if test fails" do
+      @mario.vet(:lives, 150)
+      assert @mario.lives != 150
+    end
+    should "run tests specified in vet call and tests in vet_attribute_tests at the same time" do
+      @mario.vet(:lives, 150, [:is_not_equal_to_value, 150])
+      assert @mario.vet_errors[:lives].length == 2
+    end
+    should "collect errors from multiple attributes" do
+      @mario.vet(:lives, 150)
+      @mario.vet(:status, "Crazy!")
+      assert @mario.vet_errors[:lives] != nil && @mario.vet_errors[:lives].length > 0
+      assert @mario.vet_errors[:status] != nil && @mario.vet_errors[:status].length > 0
+    end
+    
+    should "modify attribute if tests pass" do
+      @mario.vet(:lives, 4)
+      assert @mario.lives == 4
+    end
+    should "add attribute name to vet_modified_attributes array when they are changed" do
+      @mario.vet(:lives, 4)
+      assert @mario.vet_modified_attributes.include? :lives
+    end
+    should "add multiple attribute names to vet_modified_attributes array when they are changed" do
+      @mario.vet(:lives, 4)
+      @mario.vet(:status, :racoon)
+      assert @mario.vet_modified_attributes.include?(:lives)
+      assert @mario.vet_modified_attributes.include?(:status)
+    end
+  end
+end
+
+class TestTests < Test::Unit::TestCase
+  context "Test" do
+    setup do
+      @mario = MarioNoConfiguration.new
+    end
+    
+    context "is_not_empty" do
+      should "pass if value is not empty" do
+        assert @mario.vet(:cards, [:mushroom], :is_not_empty) != false
+      end
+      
+      should "fail if value is empty" do
+        assert @mario.vet(:cards, [], :is_not_empty) == false
+      end
+    end
+    
+    context "is_equal_to_value" do
+      should "pass if value matches parameter" do
+        assert @mario.vet(:lives, 2, [:is_equal_to_value, 2]) != false
+      end
+      
+      should "fail if value doesn't match parameter" do
+        assert @mario.vet(:lives, 2, [:is_equal_to_value, 4]) == false
+      end
+    end
+    
+    context "is_identical_to_confirmation" do
+      should "pass if value matches confirmation" do
+        confirmation = 2
+        assert @mario.vet(:lives, 2, [:is_identical_to_confirmation, confirmation]) != false
+      end
+      should "fail if value doesn't match confirmation" do
+        confirmation = 4
+        assert @mario.vet(:lives, 2, [:is_identical_to_confirmation, confirmation]) == false
+      end
+    end
+    
+    context "is_not_equal_to_value" do
+      should "pass if value doesn't match parameter" do
+        assert @mario.vet(:lives, 2, [:is_not_equal_to_value, 4]) != false
+      end
+      
+      should "fail if value matches parameter" do
+        assert @mario.vet(:lives, 2, [:is_not_equal_to_value, 2]) == false
+      end
+    end
+    
+    context "is_instance_of_class" do
+      should "pass if value is of specified class" do
+        assert @mario.vet(:lives, 2, [:is_instance_of_class, Fixnum]) != false
+      end
+      
+      should "fail if value isn't of specified class" do
+        assert @mario.vet(:lives, "Walrus", [:is_instance_of_class, Fixnum]) == false
+      end
+    end
+    
+    context "is_an_integer" do
+      should "pass if value is an integer" do
+        assert @mario.vet(:lives, 2, :is_an_integer) != false
+      end
+      
+      should "fail if value is not an integer" do
+        assert @mario.vet(:lives, "Donk", :is_an_integer) == false
+      end
+    end
+    
+    context "is_in_range" do
+      should "pass if value is in range" do
+        assert @mario.vet(:lives, 99, [:is_in_range, 0..99]) != false
+      end
+      
+      should "fail if value isn't in range" do
+        assert @mario.vet(:lives, 100, [:is_in_range, 0..99]) == false
+      end
+    end
+    
+    context "has_length_in_range" do
+      should "pass if value has length in range" do
+        assert @mario.vet(:cards, [:mushroom, :flower, :star], [:has_length_in_range, 0..3]) != false
+      end
+      
+      should "fail if value doesn't have length in range" do
+        assert @mario.vet(:cards, [:mushroom, :flower, :star, :star], [:has_length_in_range, 0..3]) == false
+      end
+    end
+    
+    context "only_contains_specified_objects" do
+      should "pass if value only contains specified objects" do
+        assert @mario.vet(:cards, [:mushroom, :flower], [:only_contains_specified_objects, [:mushroom, :flower, :star]]) != false
+      end
+      
+      should "fail if value contains non-specified objects" do
+        assert @mario.vet(:cards, [:mushroom, :flower, :narwhal], [:only_contains_specified_objects, [:mushroom, :flower, :star]]) == false
+      end
+    end
+    
+    context "is_email_address" do
+      should "pass if value is an email address" do
+        assert @mario.vet(:note, "mario@nintendo.com", :is_email_address) != false
+      end
+      should "pass if value is an odd email address" do
+        assert @mario.vet(:note, "m@n.co", :is_email_address) != false 
+      end
+      should "pass if value is an email address with more dots in it" do
+        assert @mario.vet(:note, "mario.mario@nintendo.co.jp", :is_email_address) != false 
+      end
+      # This is debatable, but I don't want to get into policing people's email addresses, and false-positives are a worry
+      should "pass if value is an email address with weird characters in it" do
+        assert @mario.vet(:note, "mar%21a!o@nin%33do.com", :is_email_address) != false
+      end
+      
+      should "fail if value doesn't have @ sign" do
+        assert @mario.vet(:note, "mario+nintendo.com", :is_email_address) == false
+      end
+      should "fail if value doesn't have anything after @ sign" do
+        assert @mario.vet(:note, "mario@", :is_email_address) == false
+      end
+      should "fail if value doesn't have anything before @ sign" do
+        assert @mario.vet(:note, "@nintendo.com", :is_email_address) == false
+      end
+      should "fail if value is empty" do
+        assert @mario.vet(:note, "", :is_email_address) == false
+      end
+    end
+    
+    context "is_uri_friendly" do
+      should "pass if value is a nice uri" do
+        assert @mario.vet(:note, "mario_mario", :is_uri_friendly) != false
+      end
+      should "pass if value is a nice uri with a dash" do
+        assert @mario.vet(:note, "mario-mario", :is_uri_friendly) != false
+      end
+      should "pass if value is a nice uri with a dash and underscore" do
+        assert @mario.vet(:note, "mario-mario_nintendo", :is_uri_friendly) != false
+      end
+      should "pass if value has no punctuation" do
+        assert @mario.vet(:note, "mario", :is_uri_friendly) != false
+      end
+      should "pass if value has numbers in it" do
+        assert @mario.vet(:note, "mario64", :is_uri_friendly) != false
+      end
+      should "pass if value is only numbers" do
+        assert @mario.vet(:note, "64", :is_uri_friendly) != false
+      end
+      should "pass if value is one character long" do
+        assert @mario.vet(:note, "m", :is_uri_friendly) != false
+      end
+      
+      should "fail if value contains invalid characters" do
+        assert @mario.vet(:note, "mario^64", :is_uri_friendly) == false
+      end
+      should "fail if value begins with an underscore" do
+        assert @mario.vet(:note, "_mario", :is_uri_friendly) == false
+      end
+      should "fail if value ends with a dash" do
+        assert @mario.vet(:note, "mario-", :is_uri_friendly) == false
+      end
+      should "fail if value is capitalized" do
+        assert @mario.vet(:note, "Mario", :is_uri_friendly) == false
+      end
+      should "fail if value contains upper-case character" do
+        assert @mario.vet(:note, "MarioMario", :is_uri_friendly) == false
+      end
+      should "fail if value contains space" do
+        assert @mario.vet(:note, "mario mario", :is_uri_friendly) == false
+      end
+    end
+  end
+end

data/vet.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name               = "vet"
+  s.homepage           = "http://github.com/grantheaslip/vet"
+  s.author             = "Grant Heaslip"
+  s.email              = "me@grantheaslip.com"
+  s.summary            = "Validate changes individually, not atomically. ORM/framework-agnostic."
+  s.require_path       = 'lib'
+  s.version            = "0.1.1"
+  s.files              = %w{
+                           LICENSE.text
+                           README.markdown
+                           vet.gemspec
+                           lib/vet.rb
+                           test/vet_test.rb
+                         }
+
+  s.add_development_dependency "shoulda", ">= 2.10.3"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: vet
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Grant Heaslip
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-04 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 33
+        segments: 
+        - 2
+        - 10
+        - 3
+        version: 2.10.3
+  type: :development
+  version_requirements: *id001
+description: 
+email: me@grantheaslip.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE.text
+- README.markdown
+- vet.gemspec
+- lib/vet.rb
+- test/vet_test.rb
+has_rdoc: true
+homepage: http://github.com/grantheaslip/vet
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Validate changes individually, not atomically. ORM/framework-agnostic.
+test_files: []
+