grouped_validations 0.2.2 → 0.3.0

data/Gemfile

@@ -0,0 +1,7 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gem 'rspec', '~> 2.0.0'
+gem 'activesupport', '~> 3.0.0'
+gem 'activemodel', '~> 3.0.0'
+gem 'ruby-debug'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.1)
+      activesupport (= 3.0.1)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activesupport (3.0.1)
+    builder (2.1.2)
+    columnize (0.3.1)
+    diff-lcs (1.1.2)
+    i18n (0.4.2)
+    linecache (0.43)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    ruby-debug (0.10.3)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.3.0)
+    ruby-debug-base (0.10.3)
+      linecache (>= 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 3.0.0)
+  activesupport (~> 3.0.0)
+  rspec (~> 2.0.0)
+  ruby-debug

data/README.rdoc

@@ -1,10 +1,12 @@
 = Grouped Validations
 
-Allows you to define validation groups in ActiveRecord for more control over what validations you want to run.
+Allows you to define ActiveModel validation groups for more control over what validations you want to run.
 
 This can be useful for multi-page forms or wizard style data entry.
 
-Works with Rails 2.3 and Rails 3 (ActiveRecord only).
+Works with Rails 3.
+
+For Rails 2.x support, try version 0.2.2.
 
 == Installation
 
@@ -16,6 +18,7 @@ Add it to your Rails environment gems
 
   config.gem 'grouped_validations'
 
+
 == Usage
 
 Define validations as you would normally but inside a validation_group block which you pass a group
@@ -62,8 +65,82 @@ To define validation blocks just use the respective group validation method, lik
     validate_name_on_update {|r| # something custom on update }
   end
 
+
+== Group Options
+
+You can use a validation group like similar to the with_options method, but for validation methods only.
+
+If you pass in an options hash, those options will be applied to each valiation method in the block.
+
+  validation_group :name, :if => :ready? do
+    validates_presence_of :first_name
+    validates_presence_of :last_name
+  end
+
+Which effectively the same as doing the following:
+
+    validates_presence_of :first_name, :if => :ready?
+    validates_presence_of :last_name, :if => :ready?
+
+If you set an option for a specific validation method, it will not be overriden with the validation group
+options.
+
+  validation_group :name, :if => :ready? do
+    validates_presence_of :first_name
+    validates_presence_of :last_name, :if => {|r| !r.popstar? }
+  end
+
+The last_name attribute will be required unless the person is a popstar.
+
+The options should work for any validation method which calls the validate class method internally. This includes
+all the default validations.
+
+For more precision on when to merge the groups options you can pass an argument to the block and use it like a
+with_options call. Then only those validation methods call on the argument will have the options merged in.
+
+  validation_group :name, :if => :ready? do |options|
+    # Options merged
+    options.validates_presence_of :first_name
+
+    # No options merged
+    validates_presence_of :last_name
+  end
+
+
+== Grouped Errors
+
+The errors for the model can be returned as hash with the group names as the keys. If you have a number of groups
+you can deal with the error messages in specific ways per group.
+
+  validation_group :name do
+    validates_presence_of :first_name
+    validates_presence_of :last_name
+  end
+
+  validates_presence_of :sex
+
+To access all errors outside of a validation group, use nil as the key:
+
+  person.grouped_errors[nil]
+
+Use the group name as the key for all errors in that group:
+
+  person.grouped_errors[:name]
+
+Be aware that the validations will all be run. If you have just called <tt>valid?</tt> then the same validations will be run
+again and the current state of the object is used. This is for consideration if the validations are expensive, time
+sensitive or you have changed the object after calling <tt>valid?</tt>.
+
+You can use the <tt>grouped_errors</tt> method instead of <tt>valid?</tt> to check on a valid object like so:
+
+  # Validations all run
+  if person.grouped_errors.empty?
+    # object is valid
+  end
+
+
 == Credits
 
 * Adam Meehan (http://github.com/adzap)
 
-Copyright (c) 2010 Adam Meehan, released under the MIT license
+Copyright (c) 2010-2011 Adam Meehan, released under the MIT license

data/Rakefile

@@ -1,47 +1,19 @@
-require 'rubygems'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rubygems/specification'
-require 'spec/rake/spectask'
-require 'lib/grouped_validations/version'
-
-GEM_NAME = "grouped_validations"
-GEM_VERSION = GroupedValidations::VERSION
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-spec = Gem::Specification.new do |s|
-  s.name = GEM_NAME
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.rubyforge_project = GEM_NAME
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README.rdoc"]
-  s.summary = "Define validation groups in ActiveRecord for greater control over which validations to run."
-  s.description = s.summary
-  s.author = "Adam Meehan"
-  s.email = "adam.meehan@gmail.com"
-  s.homepage = "http://github.com/adzap/grouped_validations"
-
-  s.require_path = 'lib'
-  s.autorequire = GEM_NAME
-  s.files = %w(MIT-LICENSE README.rdoc Rakefile) + Dir.glob("{lib,spec}/**/*")
-end
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
 
 desc 'Default: run specs.'
 task :default => :spec
 
-spec_files = Rake::FileList["spec/**/*_spec.rb"]
-
 desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = spec_files
-  t.spec_opts = ["-c"]
-end
+RSpec::Core::RakeTask.new(:spec)
 
 desc "Generate code coverage"
-Spec::Rake::SpecTask.new(:coverage) do |t|
-  t.spec_files = spec_files
+RSpec::Core::RakeTask.new(:coverage) do |t|
   t.rcov = true
-  t.rcov_opts = ['--exclude', 'spec,/var/lib/gems']
+  t.rcov_opts = ['--exclude', 'spec']
 end
 
 desc 'Generate documentation for plugin.'
@@ -52,19 +24,3 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{gem install pkg/#{GEM_NAME}-#{GEM_VERSION}}
-end
-
-desc "create a gemspec file"
-task :make_spec do
-  File.open("#{GEM_NAME}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
-  end
-end

data/grouped_validations.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "grouped_validations/version"
+
+Gem::Specification.new do |s|
+  s.name        = %q{grouped_validations}
+  s.version     = GroupedValidations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Meehan"]
+  s.email       = %q{adam.meehan@gmail.com}
+  s.homepage    = %q{http://github.com/adzap/grouped_validations}
+  s.summary     = %q{Define validation groups in a model for greater control over which validations are run.}
+  s.description = s.summary
+
+  s.rubyforge_project = %q{grouped_validations}
+
+  s.files            = `git ls-files`.split("\n") - %w{ .gitignore .rspec autotest }
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.require_paths    = ["lib"]
+  s.autorequire      = %q{grouped_validations}
+end

data/init.rb

@@ -0,0 +1 @@
+require 'grouped_validations'

data/lib/grouped_validations.rb

@@ -1,61 +1,93 @@
+require 'active_model/validations'
+require 'grouped_validations/active_model'
+
 module GroupedValidations
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :validation_groups
+    self.validation_groups = []
+  end
 
   module ClassMethods
 
-    def validation_group(group, &block)
-      raise "The validation_group method requires a block" unless block_given?
+    def validate(*args, &block)
+      return super unless @_current_validation_group
 
-      unless self.include?(GroupedValidations::InstanceMethods)
-        include GroupedValidations::InstanceMethods
+      options = args.extract_options!.dup
+      unless @_current_validation_group[:with_options]
+        options.reverse_merge!(@_current_validation_group.except(:name)) 
       end
 
-      self.validation_groups ||= []
-      self.validation_groups << group
-
-      define_group_validation_callbacks group
+      if options.key?(:on)
+        options = options.dup
+        options[:if] = Array.wrap(options[:if])
+        options[:if] << "validation_context == :#{options[:on]}"
+      end
+      args << options
+      set_callback(:"validate_#{@_current_validation_group[:name]}", *args, &block)
+    end
 
-      @current_validation_group = group
-      class_eval &block
-      @current_validation_group = nil
+    def _define_group_validation_callbacks(group)
+      define_callbacks :"validate_#{group}", :scope => 'validate'
     end
 
   end
 
   module InstanceMethods
-    def self.included(base)
-      base.alias_method_chain :valid?, :groups
-      base.class_eval do
-        class << self
-          if ActiveRecord::VERSION::MAJOR < 3
-            alias_method_chain :validation_method, :groups
-          else
-            alias_method_chain :validate, :groups
-          end
-        end
+
+    def valid?(context=nil)
+      super
+      validation_groups.each do |group|
+        _run_group_validation_callbacks(group, context)
       end
+      errors.empty?
     end
 
     def groups_valid?(*groups)
+      options = groups.extract_options!
       errors.clear
       groups.each do |group|
         raise "Validation group '#{group}' not defined" unless validation_groups.include?(group)
-        run_group_validation_callbacks group
+        _run_group_validation_callbacks(group, options[:context])
       end
       errors.empty?
     end
-    alias group_valid? groups_valid?
+    alias_method :group_valid?, :groups_valid?
 
-  end
+    def grouped_errors(context=nil)
+      original_errors = @errors.dup if @errors
+      @errors = nil
+      grouped = {}
 
-end
+      with_validation_context(context) do
+        _run_validate_callbacks
+        grouped[nil] = @errors
 
-ActiveRecord::Base.class_eval do
-  extend GroupedValidations::ClassMethods
-  class_inheritable_accessor :validation_groups
-end
+        validation_groups.each do |group|
+          @errors = nil
+          send(:"_run_validate_#{group}_callbacks")
+          grouped[group] = @errors
+        end
+      end
+      grouped.values.all?(&:empty?) ? {} : grouped
+    ensure
+      @errors = original_errors
+    end
+
+    def _run_group_validation_callbacks(group, context=nil)
+      with_validation_context(context) do
+        send(:"_run_validate_#{group}_callbacks")
+      end
+    end
 
-if ActiveRecord::VERSION::MAJOR < 3
-  require 'grouped_validations/active_record'
-else
-  require 'grouped_validations/active_model'
+    def with_validation_context(context)
+      context ||= (persisted? ? :update : :create)
+      current_context, self.validation_context = validation_context, context
+      yield
+    ensure
+      self.validation_context = current_context
+    end
+
+  end
 end

data/lib/grouped_validations/active_model.rb

@@ -1,43 +1,34 @@
-module GroupedValidations
+module ActiveModel
+  module Validations
 
-  module ClassMethods
+    module ClassMethods
 
-    def define_group_validation_callbacks(group)
-      define_callbacks :"validate_#{group}", :terminator => "result == false", :scope => 'validate'
-    end
+      def validation_group(group, options={}, &block)
+        raise "The validation_group method requires a block" unless block_given?
 
-    def validate_with_groups(*args, &block)
-      if @current_validation_group
-        options = args.last
-        if options.is_a?(Hash) && options.key?(:on)
-          options[:if] = Array(options[:if])
-          options[:if] << "self.validation_context == :#{options[:on]}"
+        unless include?(GroupedValidations)
+          include GroupedValidations
         end
-        set_callback(:"validate_#{@current_validation_group}", *args, &block)
-      else
-        validate_without_groups(*args, &block)
-      end
-    end
 
-  end
+        self.validation_groups += [ group ]
 
-  module InstanceMethods
+        _define_group_validation_callbacks(group)
 
-    def valid_with_groups?(context=nil)
-      valid_without_groups?(context)
-      (validation_groups || []).each do |group|
-        run_group_validation_callbacks group
+        options[:name] = group
+
+        if block.arity == 1
+          @_current_validation_group = options.merge(:with_options => true)
+          with_options(options.except(:name)) do |config|
+            yield config
+          end
+        else
+          @_current_validation_group = options
+          yield
+        end
+        @_current_validation_group = nil
       end
-      errors.empty?
-    end
 
-    def run_group_validation_callbacks(group)
-      current_context, self.validation_context = validation_context, (new_record? ? :create : :update)
-      send(:"_run_validate_#{group}_callbacks")
-    ensure
-      self.validation_context = current_context
     end
 
   end
-
 end

data/lib/grouped_validations/version.rb

@@ -1,3 +1,3 @@
 module GroupedValidations
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/spec/grouped_validations_spec.rb

@@ -1,6 +1,8 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe GroupedValidations do
+  let(:person) { Person.new }
+
   before do
     reset_class Person
   end
@@ -9,123 +11,242 @@ describe GroupedValidations do
     Person.should respond_to(:validation_group)
   end
 
-  it "should not include instance methods by default" do
-    ActiveRecord::Base.include?(GroupedValidations::InstanceMethods).should be_false
-  end
+  describe ".validation_group" do
+    it "should store defined validation group names" do
+      Person.class_eval do
+        validation_group(:dummy) { }
+      end
+      Person.validation_groups.should == [:dummy]
+    end
 
-  it "should store defined validation group names" do
-    Person.validation_group(:dummy) { }
-    Person.validation_groups.should == [:dummy]
-  end
+    it "it should add group_valid? method which takes a group name param" do
+      Person.class_eval do
+        validation_group(:dummy) { }
+      end
+      
+      person.group_valid?(:dummy)
+    end
 
-  it "it should add group_valid? method which takes a group name param" do
-    Person.validation_group(:dummy) { }
-    p = Person.new
-    p.group_valid?(:dummy)
-  end
+    context "with options" do
+      context "as implicit block" do
+        it 'should pass options for group to validations' do
+          Person.class_eval do
+            validation_group(:name, :if => lambda {|r| r.last_name.nil? }) do
+              validates_presence_of :first_name
+            end
+          end
+
+          person.group_valid?(:name)
+          person.should have(1).errors
+
+          person.last_name = 'smith'
+          person.group_valid?(:name)
+          person.should have(0).errors
+        end
+
+        it 'should not override explicit validation method options' do
+          Person.class_eval do
+            validation_group(:name, :if => lambda { true }) do
+              validates_presence_of :first_name, :if =>  lambda { false }
+            end
+          end
+
+          person.group_valid?(:name)
+          person.should have(0).errors
+        end
+      end
 
-  it "should raise exception if valiation group not defined on group_valid check" do
-    p = Person.new
-    lambda { p.group_valid?(:dummy) }.should raise_exception
+      context "as block argument" do
+        it 'should pass options for group to validations' do
+          Person.class_eval do
+            validation_group(:name, :if => lambda {|r| r.last_name.nil? }) do |options|
+              options.validates_presence_of :first_name
+            end
+          end
+
+          person.group_valid?(:name)
+          person.should have(1).errors
+
+          person.last_name = 'smith'
+          person.group_valid?(:name)
+          person.should have(0).errors
+        end
+
+        it 'should not override explicit options' do
+          Person.class_eval do
+            validation_group(:name, :if => lambda {|r| r.last_name.nil? }) do |options|
+              options.validates_presence_of :first_name, :if => lambda { false }
+            end
+          end
+
+          person.group_valid?(:name)
+          person.should have(0).errors
+        end
+
+        it 'should not apply options to validations methods not using block argument' do
+          Person.class_eval do
+            validation_group(:name, :if => lambda { false }) do |options|
+              options.validates_presence_of :first_name
+              validates_presence_of :last_name
+            end
+          end
+
+          person.group_valid?(:name)
+          person.errors[:first_name].should be_empty
+          person.errors[:last_name].should_not be_empty
+        end
+      end
+    end
   end
 
-  it "should run the validations defined inside the validation group" do
-    Person.validation_group :name do
-      validates_presence_of :first_name
-      validates_presence_of :last_name
+  describe "#group_valid?" do
+    it "should run the validations defined inside the validation group" do
+      Person.class_eval do
+        validation_group :name do
+          validates_presence_of :first_name
+          validates_presence_of :last_name
+        end
+      end
+      
+      person.group_valid?(:name)
+      person.should have(2).errors
+
+      person.first_name = 'Dave'
+      person.last_name = 'Smith'
+      person.group_valid?(:name)
+      person.should have(0).errors
     end
 
-    p = Person.new
-    p.group_valid?(:name)
-    p.should have(2).errors
-
-    p.first_name = 'Dave'
-    p.last_name = 'Smith'
-    p.group_valid?(:name)
-    p.should have(0).errors
-  end
+    it "should raise exception if valiation group not defined" do
+      expect { person.group_valid?(:dummy) }.should raise_exception
+    end
 
-  it "should run all validation groups passed to groups_valid?" do
-    Person.class_eval do
-      validation_group :first_name_group do
-        validates_presence_of :first_name
-      end
-      validation_group :last_name_group do
-        validates_presence_of :last_name
+    it "should run all validation groups passed to groups_valid?" do
+      Person.class_eval do
+        validation_group :first_name_group do
+          validates_presence_of :first_name
+        end
+        validation_group :last_name_group do
+          validates_presence_of :last_name
+        end
       end
+      
+      person.groups_valid?(:first_name_group, :last_name_group)
+      person.should have(2).errors
     end
 
-    p = Person.new
-    p.groups_valid?(:first_name_group, :last_name_group)
-    p.should have(2).errors
-  end
-
-  it "should run all validation including groups when valid? method called" do
-    Person.class_eval do
-      validation_group :first_name_group do
-        validates_presence_of :first_name
+    context "with validation context" do
+      it "should run only validations for explicit context" do
+        Person.class_eval do
+          validation_group :name do
+            validates_presence_of :last_name, :on => :update
+          end
+        end
+        
+        person.persisted = false
+        person.last_name = nil
+        person.group_valid?(:name, :context => :create)
+        person.should have(0).errors
+
+        person.persisted = true
+        person.group_valid?(:name, :context => :update)
+        person.should have(1).errors
+
+        person.last_name = 'Smith'
+        person.group_valid?(:name)
+        person.should have(0).errors
       end
-      validation_group :last_name_group do
-        validates_presence_of :last_name
+
+      it "should run only validations for implicit model context" do
+        Person.class_eval do
+          validation_group :name do
+            validates_presence_of :first_name, :on => :create
+          end
+        end
+
+        person.persisted = false
+        person.group_valid?(:name)
+        person.should have(1).errors
+
+        person.first_name = 'Dave'
+        person.group_valid?(:name)
+        person.should have(0).errors
+
+        person.persisted = true
+        person.first_name = nil
+        person.group_valid?(:name)
+        person.should have(0).errors
       end
 
-      validates_presence_of :sex
     end
+  end
 
-    p = Person.new
-    p.valid?
-    p.should have(3).errors
+  describe "#valid?" do
+    it "should run all validation including groups when valid? method called" do
+      Person.class_eval do
+        validation_group :first_name_group do
+          validates_presence_of :first_name
+        end
+        validation_group :last_name_group do
+          validates_presence_of :last_name
+        end
+        validates_presence_of :sex
+      end
+      
+      person.valid?
+      person.should have(3).errors
+    end
   end
 
-  it "should respect :on => :create validation option" do
-    Person.validation_group :name do
-      validates_presence_of :first_name, :on => :create
+  describe "#grouped_errors" do
+    before do
+      Person.class_eval do
+        validation_group :first_name_group do
+          validates_presence_of :first_name
+        end
+        validation_group :last_name_group do
+          validates_presence_of :last_name
+        end
+        validates_presence_of :sex
+      end
     end
 
-    p = Person.new
-    p.group_valid?(:name)
-    p.should have(1).errors
-    p.first_name = 'Dave'
-    p.group_valid?(:name)
-    p.should have(0).errors
-
-    p.save.should be_true
-    p.first_name = nil
-    p.group_valid?(:name)
-    p.should have(0).errors
-  end
+    it 'should return hash of error hashes with validation groups as keys' do
+      errors = person.grouped_errors
+      errors[:first_name_group].should == {:first_name => ["can't be blank"]}
+      errors[:last_name_group].should  == {:last_name  => ["can't be blank"]}
+    end
 
-  it "should respect :on => :update validation option" do
-    Person.validation_group :name do
-      validates_presence_of :last_name, :on => :update
+    it 'should return hash of errors for validations outside a validation group, for nil key' do
+      errors = person.grouped_errors
+      errors[nil][:sex].should == ["can't be blank"]
     end
 
-    p = Person.new
-    p.last_name = nil
-    p.group_valid?(:name)
-    p.should have(0).errors
-
-    p.save.should be_true
-    p.group_valid?(:name)
-    p.should have(1).errors
-    p.last_name = 'Smith'
-    p.group_valid?(:name)
-    p.should have(0).errors
-  end
+    it 'should be empty if no errors' do
+      person.first_name = 'Dave'
+      person.last_name = 'Smith'
+      person.sex = 'Male'
 
-  it "should allow a validation group to appended with subsequent blocks" do
-    Person.class_eval do
-      validation_group :name do
-        validates_presence_of :first_name
-      end
-      validation_group :name do
-        validates_presence_of :last_name
-      end
+      person.grouped_errors.should be_empty
     end
 
-    p = Person.new
-    p.group_valid?(:name)
-    p.should have(2).errors
   end
 
+  # Can no longer be done. Unless I find a work around.
+  # it "should allow a validation group to appended with subsequent blocks" do
+  #   Person.class_eval do
+  #     validation_group :name do
+  #       validates_presence_of :first_name
+  #     end
+  #     validation_group :name do
+  #       validates_presence_of :last_name
+  #     end
+  #   end
+
+  #   
+  #   person.group_valid?(:name)
+  #   puts person.errors.inspect
+  #   person.should have(2).errors
+  # end
+
 end

data/spec/spec_helper.rb

@@ -1,36 +1,32 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/spec')
+require 'rspec'
 
-require 'rubygems'
-require 'active_record'
-require 'active_support'
+require 'active_support/all'
+require 'active_model'
 
 require 'grouped_validations'
 
-ActiveRecord::Migration.verbose = false
-ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+class TestModel
+  include ActiveSupport::Callbacks
+  include ActiveModel::Validations
 
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :people, :force => true do |t|
-    t.string   :first_name
-    t.string   :last_name
-    t.integer  :sex
-  end
+  attr_accessor :persisted, :first_name, :last_name, :sex
+  alias_method :persisted?, :persisted
 end
 
-class Person < ActiveRecord::Base
+class Person < TestModel
 end
 
 module SpecHelper
   def reset_class(klass, &block)
+    superklass = klass.superclass
     name = klass.name.to_sym
     Object.send(:remove_const, name)
-    Object.const_set(name, Class.new(ActiveRecord::Base))
+    Object.const_set(name, Class.new(superklass))
     new_klass = Object.const_get(name)
     new_klass.class_eval &block if block_given?
   end
 end
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.include SpecHelper
 end

metadata

@@ -2,12 +2,12 @@
 name: grouped_validations
 version: !ruby/object:Gem::Version 
   hash: 19
-  prerelease: false
+  prerelease: 
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Adam Meehan
@@ -15,11 +15,11 @@ autorequire: grouped_validations
 bindir: bin
 cert_chain: []
 
-date: 2010-08-10 00:00:00 +10:00
+date: 2011-03-29 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
-description: Define validation groups in ActiveRecord for greater control over which validations to run.
+description: Define validation groups in a model for greater control over which validations are run.
 email: adam.meehan@gmail.com
 executables: []
 
@@ -28,13 +28,16 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
+- grouped_validations.gemspec
+- init.rb
+- lib/grouped_validations.rb
 - lib/grouped_validations/active_model.rb
-- lib/grouped_validations/active_record.rb
 - lib/grouped_validations/version.rb
-- lib/grouped_validations.rb
 - spec/grouped_validations_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -67,9 +70,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: grouped_validations
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
-summary: Define validation groups in ActiveRecord for greater control over which validations to run.
-test_files: []
-
+summary: Define validation groups in a model for greater control over which validations are run.
+test_files: 
+- spec/grouped_validations_spec.rb
+- spec/spec_helper.rb

data/lib/grouped_validations/active_record.rb

@@ -1,47 +0,0 @@
-module GroupedValidations
-
-  module ClassMethods
-
-    def define_group_validation_callbacks(group)
-      base_name = :"validate_#{group}"
-      define_callbacks base_name, :"#{base_name}_on_create", :"#{base_name}_on_update"
-    end
-
-    def validation_method_with_groups(on)
-      if @current_validation_group
-        base_name = :"validate_#{@current_validation_group}"
-        case on
-          when :save   then base_name
-          when :create then :"#{base_name}_on_create"
-          when :update then :"#{base_name}_on_update"
-        end
-      else
-        validation_method_without_groups on
-      end
-    end
-
-  end
-
-  module InstanceMethods
-
-    def valid_with_groups?
-      valid_without_groups?
-      (validation_groups || []).each do |group|
-        run_group_validation_callbacks group
-      end
-      errors.empty?
-    end
-
-    def run_group_validation_callbacks(group)
-      base_name = :"validate_#{group}"
-      run_callbacks(base_name)
-      if new_record?
-        run_callbacks(:"#{base_name}_on_create")
-      else
-        run_callbacks(:"#{base_name}_on_update")
-      end
-    end
-
-  end
-
-end