monkey_forms 0.0.16 → 0.0.17

data/lib/monkey_forms/vendor/grouped_validations/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+.bundle
+.rvmrc

data/lib/monkey_forms/vendor/grouped_validations/.rspec

@@ -0,0 +1,2 @@
+--format nested
+--color

data/lib/monkey_forms/vendor/grouped_validations/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/lib/monkey_forms/vendor/grouped_validations/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Adam Meehan
+
+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/lib/monkey_forms/vendor/grouped_validations/README.rdoc

@@ -0,0 +1,146 @@
+= Grouped Validations
+
+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 3.
+
+For Rails 2.x support, try version 0.2.2.
+
+== Installation
+
+Just install the gem
+
+ gem install grouped_validations
+
+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
+name to.
+
+  class Person < ActiveRecord::Base
+    validation_group :name do
+      validates_presence_of :first_name
+      validates_presence_of :last_name
+    end
+
+    validates_presence_of :sex
+  end
+
+You can define validations outside the group as normal.
+
+To check for errors for only a certain group of validations
+
+  p = Person.new
+  p.group_valid?(:name) # => false
+  p.first_name = 'John'
+  p.last_name = 'Smith'
+  p.group_valid?(:name) # => true
+
+If you run the normal valid? method all validations, inside and outside validation groups, will be run.
+
+  p.valid? # => false because sex is not present
+
+You can also check validation for multiple groups
+
+  p.groups_valid?(:group1, :group2)
+
+
+To define validation blocks just use the respective group validation method, like so
+
+  class Person < ActiveRecord::Base
+    validation_group :name do
+      validates_presence_of :first_name
+      validates_presence_of :last_name
+    end
+
+    validate_name           {|r| # something custom on save }
+    validate_name_on_create {|r| # something custom on create }
+    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-2011 Adam Meehan, released under the MIT license

data/lib/monkey_forms/vendor/grouped_validations/Rakefile

@@ -0,0 +1,26 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'Generate documentation for plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'GroupedValidations'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/monkey_forms/vendor/grouped_validations/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/lib/monkey_forms/vendor/grouped_validations/init.rb

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

data/lib/monkey_forms/vendor/grouped_validations/lib/grouped_validations.rb

@@ -0,0 +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 validate(*args, &block)
+      return super unless @_current_validation_group
+
+      options = args.extract_options!.dup
+      unless @_current_validation_group[:with_options]
+        options.reverse_merge!(@_current_validation_group.except(:name)) 
+      end
+
+      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
+
+    def _define_group_validation_callbacks(group)
+      define_callbacks :"validate_#{group}", :scope => 'validate'
+    end
+
+  end
+
+  module InstanceMethods
+
+    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, options[:context])
+      end
+      errors.empty?
+    end
+    alias_method :group_valid?, :groups_valid?
+
+    def grouped_errors(context=nil)
+      original_errors = @errors.dup if @errors
+      @errors = nil
+      grouped = {}
+
+      with_validation_context(context) do
+        _run_validate_callbacks
+        grouped[nil] = @errors
+
+        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
+
+    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/monkey_forms/vendor/grouped_validations/lib/grouped_validations/active_model.rb

@@ -0,0 +1,34 @@
+module ActiveModel
+  module Validations
+
+    module ClassMethods
+
+      def validation_group(group, options={}, &block)
+        raise "The validation_group method requires a block" unless block_given?
+
+        unless include?(GroupedValidations)
+          include GroupedValidations
+        end
+
+        self.validation_groups += [ group ]
+
+        _define_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
+
+    end
+
+  end
+end

data/lib/monkey_forms/vendor/grouped_validations/lib/grouped_validations/version.rb

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

data/lib/monkey_forms/vendor/grouped_validations/spec/grouped_validations_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe GroupedValidations do
+  let(:person) { Person.new }
+
+  before do
+    reset_class Person
+  end
+
+  it "should add validation_group class method" do
+    Person.should respond_to(:validation_group)
+  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 "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
+
+    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
+
+      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
+
+  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
+
+    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
+        end
+      end
+      
+      person.groups_valid?(:first_name_group, :last_name_group)
+      person.should have(2).errors
+    end
+
+    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
+
+      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
+
+    end
+  end
+
+  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
+
+  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
+
+    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 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
+
+    it 'should be empty if no errors' do
+      person.first_name = 'Dave'
+      person.last_name = 'Smith'
+      person.sex = 'Male'
+
+      person.grouped_errors.should be_empty
+    end
+
+  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