whyvalidationssuckin96 1.0.0

data/lib/whyvalidationssuckin96/rails/active_record.rb

@@ -0,0 +1,94 @@
+require 'whyvalidationssuckin96'
+require 'active_record'
+require 'active_record/base'
+require 'active_record/callbacks'
+require 'whyvalidationssuckin96/rails/macros'
+
+module WhyValidationsSuckIn96
+  
+  module ActiveRecord
+    RemovableInstanceMethods = %w[invalid? validate_on_create validate_on_update validate errors]
+    RemovableClassMethods = %w[validate validate_on_create validate_on_update validates_format_of validates_each
+                               validates_inclusion_of validates_size_of validates_confirmation_of validates_exclusion_of
+                               validates_uniqueness_of validates_associated validates_acceptance_of
+                               validates_numericality_of validates_presence_of validates_length_of]
+    
+    def self.included(klass_or_mod)
+      remove_active_record_validation_related_methods_from(klass_or_mod)
+      klass_or_mod.instance_eval do
+        include WhyValidationsSuckIn96::ValidationSupport
+        include WhyValidationsSuckIn96::ActiveRecord::InstanceMethods
+      end
+    end
+    
+  private
+  
+    # FIXME - holy mother of god is this a nasty method
+    def self.remove_active_record_validation_related_methods_from(klass_or_mod)
+      method_map = {klass_or_mod => RemovableInstanceMethods, (class<<klass_or_mod;self;end) => RemovableClassMethods}
+      method_map.each do |context, removable_methods|
+        context.instance_eval do 
+          removable_methods.each do |removable_method|
+            begin
+              remove_method removable_method
+            rescue => e
+              undef_method removable_method
+            end
+          end # removable_methods.each
+        end   # context.instance_eval
+      end     # method_map.each
+    end
+    
+    module InstanceMethods    
+      
+      def self.included(klass_or_mod)
+        klass_or_mod.module_eval do
+          alias_method :valid_without_callbacks?, :valid_with_lifecycle_checking?
+        end
+      end
+
+    private
+    
+      def validations_for_current_lifecycle
+        validations_for_save + (new_record? ? validations_for_create : validations_for_update)
+      end
+      
+      def valid_with_lifecycle_checking?
+        validations_for_current_lifecycle.collect do |validation|
+          validation.validates?
+        end.all?
+      end
+      
+      def validations_for_update
+        all_validations.select do |validation|
+          validation.options[:on] == :update
+        end
+      end
+      
+      def validations_for_create
+        all_validations.select do |validation|
+          validation.options[:on] == :create
+        end
+      end
+      
+      def validations_for_save
+        all_validations.select do |validation|
+          validation.options[:on].nil? || validation.options[:on] == :save
+        end
+      end
+      
+    end # InstanceMethods
+  end   # ActiveRecord
+end     # WhyValidationsSuckIn96
+
+module ActiveRecord
+  class RecordInvalid < ActiveRecordError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super
+    end
+  end # RecordInvalid
+end   # ActiveRecord
+
+ActiveRecord::Base.instance_eval { include WhyValidationsSuckIn96::ActiveRecord }

data/lib/whyvalidationssuckin96/rails/macros/validates_uniqueness.rb

@@ -0,0 +1,87 @@
+require 'whyvalidationssuckin96/skippable_validation'
+require 'whyvalidationssuckin96/attribute_based_validation'
+
+module WhyValidationsSuckIn96
+  
+  # Checks to see if a given attribute is present in any other records in the databaser
+  #
+  # @example Default usage
+  #   setup_validations do
+  #     validates_uniqueness_of :name
+  #   end
+  #
+  # @example Check in a case sensitive fashion
+  #   setup_validations do
+  #     validates_uniqueness_of :name, :case_sensitive => true
+  #   end
+  #
+  # @example Scope uniqueness to another attribute
+  #   setup_validations do
+  #     validates_uniqueness_of :name, :scope => :account_id
+  #   end
+  #
+  # @example Scope uniqueness to multiple other attributes
+  #   setup_validations do
+  #     validates_uniqueness_of :name, :scope => [:account_id, :domain]
+  #   end
+  #
+  # @example When used with STI, check only uniqueness of records of the current type
+  #   setup_validations do
+  #     validates_uniqueness_of :name, :base_class_scope => false
+  #   end
+  class ValidatesUniqueness < Validation
+    DefaultOptions = {:message => "has already been taken", :case_sensitive => false, :base_class_scope => true}
+    
+    include WhyValidationsSuckIn96::SkippableValidation
+    include WhyValidationsSuckIn96::AttributeBasedValidation
+    
+    def validate
+      super
+      results = find_results
+      result_ids = results.collect { |r| r[scope_primary_key] }
+      if results.empty? || result_ids.include?(validatable[scope_primary_key])
+        pass
+      elsif !results.empty? && options[:case_sensitive]
+        (results.any? { |r| r[attribute].to_s == attribute_value.to_s }) ? fail : pass
+      else
+        fail
+      end
+    end
+  
+  private
+    
+    def find_results
+      scope_class.send(:with_exclusive_scope) do
+        scope_class.send(:with_scope, :find => {:conditions => find_conditions}) do
+          scope_class.find(:all, :conditions => scope_conditions)
+        end
+      end
+    end
+    
+    def scope_columns
+      Array(options[:scope])
+    end
+    
+    def find_conditions
+      ["LOWER(#{scope_class.connection.quote_column_name(attribute.to_s)}) = LOWER(?)", attribute_value]
+    end
+    
+    def scope_conditions
+      scope_columns.inject({}) do |conds,col|
+        conds[col] = validatable[col]
+        conds
+      end
+    end
+    
+    def scope_primary_key
+      scope_class.primary_key
+    end
+    
+    def scope_class
+      options[:base_class_scope] ? validatable.class.base_class : validatable.class
+    end
+
+  end # Validation
+
+  ValidationBuilder.register_macro :validates_uniqueness_of, WhyValidationsSuckIn96::ValidatesUniqueness
+end   # WhyValidationsSuckIn96

data/lib/whyvalidationssuckin96/rails/macros.rb

@@ -0,0 +1 @@
+require 'whyvalidationssuckin96/rails/macros/validates_uniqueness'

data/lib/whyvalidationssuckin96/skippable_validation.rb

@@ -0,0 +1,59 @@
+module WhyValidationsSuckIn96
+  # A mixin to handle specifying :if and :unless options to check before performing validation.
+  #
+  # @example Validate if a given block returns true
+  #   setup_validations do
+  #     validates_associated :tracks, :if => lambda { !validatable.tracks.empty? }
+  #   end
+  #
+  # @example Validate if a given method on the validatable object returns true
+  #   setup_validations do
+  #     validates_associated :tracks, :if => :allow_validation
+  #   end
+  #   
+  #   def allow_validation
+  #     false
+  #   end
+  #
+  # @example Validate unless a given block returns true
+  #   setup_validations do
+  #     validates_associated :tracks, :unless => lambda { validatable.tracks.empty? }
+  #   end
+  #
+  # @example Validate unless a given method on the validatable object returns true
+  #   setup_validations do
+  #     validates_associated :tracks, :unless => :disallow_validation
+  #   end
+  #   
+  #   def disallow_validation
+  #     true
+  #   end
+  module SkippableValidation
+    
+    def validate
+      skip if skip_validation?
+    end
+    
+  private
+  
+    def skip
+      throw :validation_done, nil
+    end
+    
+    def skip_validation?
+      skip_if? || skip_unless?
+    end
+    
+    def skip_unless?
+      return false unless options.has_key?(:unless)
+      check = options[:unless].is_a?(Proc) ? instance_eval(&options[:unless]) : validatable.send(options[:unless])
+      check == true
+    end
+    
+    def skip_if?
+      return false unless options.has_key?(:if)
+      check = options[:if].is_a?(Proc) ? instance_eval(&options[:if]) : validatable.send(options[:if])
+      check == false
+    end
+  end # SkippableValidation
+end   # WhyValidationsSuckIn96

data/lib/whyvalidationssuckin96/validation.rb

@@ -0,0 +1,88 @@
+module WhyValidationsSuckIn96
+  
+  # Base class to use when implementing validations.
+  class Validation
+    
+    # A hash of default options for the validation to use.
+    DefaultOptions = {}
+    
+    # The options the validation was initialized with
+    attr_accessor :options
+    
+    # The object the validation is validating
+    attr_reader :validatable
+    
+    class << self
+      attr_accessor :name
+    end
+    
+    # @param  [Object] validatable                An object to be validated
+    # @param  [Hash]   options                    The options to set up the validation with
+    def initialize(validatable, options = {})
+      @validatable = validatable
+      @options = self.class::DefaultOptions.merge(options)
+    end
+    
+    # Creates a new subclass of this class, used when defining custom validations with a block
+    def self.new_subclass(name, def_block)
+      Class.new(self) do
+        self.name = name.to_sym
+        define_method(:validate, &def_block)
+        private :validate
+    
+        def inspect
+          "#<WhyValidationsSuckIn96::Validation subclass for validating '#{self.class.name}'> #{super}"
+        end
+      end
+    end
+    
+    # Has this validation passed?
+    # @return [true, false]
+    def passed?
+      @passed == true
+    end
+
+    # Has this validation failed?
+    # @return [true, false]
+    def failed?
+      @passed == false
+    end
+    
+    # Has this validation run?
+    # @return [true, false]
+    def has_run?
+      @passed != nil
+    end
+    
+    # Performs the validation, returning true or false if the validation passes or fails,
+    # or nil if the validation will not run.
+    # @return [true, false, nil]
+    def validates?
+      reset
+      @passed = catch :validation_done do
+        validate
+        pass
+      end
+    end
+    
+    # The failure message for this validation.
+    def message
+      @options[:message] || "failed validation"
+    end
+    
+  private
+    
+    def reset
+      @passed = nil
+    end
+    
+    def pass
+      throw :validation_done, true
+    end
+    
+    def fail
+      throw :validation_done, false
+    end
+    
+  end # Validation
+end   # WhyValidationsSuckIn96

data/lib/whyvalidationssuckin96/validation_builder.rb

@@ -0,0 +1,56 @@
+require 'whyvalidationssuckin96/validation'
+
+module WhyValidationsSuckIn96
+  class ValidationBuilder
+    
+    # @param [Module, Class] klass_or_mod     The Class or Module to add validations to
+    # @param [Proc]          definition_block The block to evaluate to define validations
+    def initialize(klass_or_mod, definition_block)
+      @klass_or_mod = klass_or_mod
+      @definition_block = definition_block
+    end
+    
+    def create_validations!
+      instance_eval(&@definition_block)
+    end
+    
+    # Registers a macro to be used in setup_validations blocks
+    # @param [Symbol] macro_name       The name to register this macro with
+    # @param [Class]  validation_class The class implementing the validation
+    def self.register_macro(macro_name, validation_class)
+      define_method(macro_name) do |*args|
+        attrs, options = extract_options(args)
+        attrs.each do |attr|
+          add_validation(validation_class, options.merge(:attribute => attr))
+        end
+      end
+    end
+    
+  private
+  
+    def add_validation(klass, options)
+      @klass_or_mod.validation_collection << [klass, options]
+    end
+    
+    def validate(validation_name, options = {}, &def_block)
+      existing = @klass_or_mod.validation_collection.detect do |validation, opts|
+        validation.name == validation_name
+      end
+      
+      if existing
+        @klass_or_mod.validation_collection.delete(existing)
+      end
+      
+      add_validation(new_validation(validation_name, def_block), options)
+    end
+    
+    def extract_options(args_array)
+      args, opts = args_array.last.is_a?(Hash) ? [args_array[0..-2], args_array.last] : [args_array, {}]
+    end
+    
+    def new_validation(validation_name, def_block)
+      WhyValidationsSuckIn96::Validation.new_subclass(validation_name, def_block)
+    end
+    
+  end # ValidationBuilder
+end   # WhyValidationsSuckIn96

data/lib/whyvalidationssuckin96/validation_support.rb

@@ -0,0 +1,74 @@
+require 'whyvalidationssuckin96/validation_builder'
+
+module WhyValidationsSuckIn96
+  module ValidationSupport
+    
+    def self.included(klass_or_mod)
+      klass_or_mod.module_eval do
+        extend WhyValidationsSuckIn96::ValidationSupport::ClassMethods
+        include WhyValidationsSuckIn96::ValidationSupport::InstanceMethods
+      end
+    end
+    
+    # Instance methods added to any class or module that mixes in ValidationSupport
+    module InstanceMethods
+      
+      # Is this object invalid?
+      # @return [true, false]
+      def invalid?
+        !valid?
+      end
+      
+      # Is this object valid?
+      # @return [true, false]
+      def valid?
+        all_validations.collect do |validation|
+          validation.validates?
+        end.all?
+      end
+      
+      # An array of instances of failed validations
+      # @return [Array]
+      def failed_validations
+        all_validations.select { |validation| validation.failed? }
+      end
+      
+      # An array of instances of passed validations
+      # @return [Array]
+      def passed_validations
+        all_validations.select { |validation| validation.passed? }
+      end
+      
+      # An array of instances of all validations for this object
+      # @return [Array]
+      def all_validations
+        @all_validations ||= self.class.validation_collection.collect do |(vc,opts)|
+          vc.new(self, opts)
+        end
+      end
+      
+    end # InstanceMethods
+    
+    module ClassMethods
+      
+      # An array of arrays, the first element of each being the validation subclass that will be instantiated
+      # when validation is performed, the last element being the options the validation will be instantiated
+      # with.
+      # @return [Array]
+      def validation_collection
+        @validation_collection ||= begin
+          ancestor_with_validations = ancestors[1..-1].detect{|anc| anc.respond_to?(:validation_collection) }
+          ancestor_with_validations ? ancestor_with_validations.validation_collection.dup : []
+        end
+      end
+      
+      # Sets up validations for the class or module this module has been mixed into
+      def setup_validations(&definition_block)
+        self.validation_collection ||= ancestors.detect{|anc| !anc.validation_collection.nil?}.validation_collection.dup
+        builder = ValidationBuilder.new(self, definition_block)
+        builder.create_validations!
+      end
+      
+    end # ClassMethods
+  end   # ValidationSupport
+end     # WhyValidationsSuckIn96

data/lib/whyvalidationssuckin96.rb

@@ -0,0 +1,4 @@
+require 'whyvalidationssuckin96/constants'
+require 'whyvalidationssuckin96/ext/blank'
+require 'whyvalidationssuckin96/validation_support'
+require 'whyvalidationssuckin96/macros'

data/test/attribute_based_validation_test.rb

@@ -0,0 +1,58 @@
+require 'teststrap'
+require 'whyvalidationssuckin96/attribute_based_validation'
+
+context "attribute based validation mixin" do
+  context "when mixed into a class" do
+    
+    setup do
+      Class.new(WhyValidationsSuckIn96::Validation) do
+        include WhyValidationsSuckIn96::SkippableValidation
+        include WhyValidationsSuckIn96::AttributeBasedValidation
+        
+        def validate
+          super
+          pass
+        end
+        
+      end # Class.new
+    end   # setup
+    
+    should "fail if no attribute is specified during construction" do
+      topic.new(Object.new)
+    end.raises(ArgumentError, "The attribute to validate must be specified as :attribute")
+    
+    should "add an attribute accessor" do
+      topic.new(Object.new, :attribute => :foo).attribute
+    end.equals(:foo)
+    
+    context "when using :allow_nil" do
+      
+      should "skip validation if the validatable object is #nil?" do
+        inst = topic.new(OpenStruct.new(:test => nil), :allow_nil => true, :attribute => :test)
+        inst.validates?
+        inst.has_run?
+      end.equals(false)
+      
+      should "not skip validation of the validatable object is non-#nil?" do
+        inst = topic.new(OpenStruct.new(:test => Object.new), :allow_nil => true, :attribute => :test)
+        inst.validates?
+        inst.has_run?
+      end
+    end # when using :allow_nil
+    
+    context "when using :allow_blank" do
+      should "skip validation if the validatable object is #blank?" do
+        inst = topic.new(OpenStruct.new(:test => ""), :allow_blank => true, :attribute => :test)
+        inst.validates?
+        inst.has_run?
+      end.equals(false)
+      
+      should "not skip validation if the validatable object is non-#blank?" do
+        inst = topic.new(OpenStruct.new(:test => "bzzt"), :allow_blank => true, :attribute => :test)
+        inst.validates?
+        inst.has_run?
+      end
+    end # when using :allow_blank
+    
+  end     # when mixed into a class
+end       # skippable validation mixin

data/test/macros/validates_acceptance_test.rb

@@ -0,0 +1,64 @@
+require 'teststrap'
+
+context "validates acceptance" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_acceptance_of')
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesAcceptance.new(Object.new, :attribute => :accepted)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("must be accepted")
+  
+    should "default the :allow_nil option to true" do
+      topic.options[:allow_nil]
+    end
+
+    should "default the :accept option to allow the string '1'" do
+      topic.options[:accept]
+    end.equals("1")
+  end # with some default options
+  
+  context "validating an object" do
+    validatable = OpenStruct.new(:accepted => false)
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesAcceptance.new(validatable, :attribute => :accepted)
+    end
+    
+    should "fail if the return value of the given attribute doesnt match the :accept option" do
+      validatable.accepted = false
+      topic.validates?
+    end.equals(false)
+    
+    should "pass if the return value of the given attribute matches the :accept option" do
+      validatable.accepted = topic.options[:accept]
+      topic.validates?
+    end
+    
+    context "with some non-default options" do
+      setup do
+        WhyValidationsSuckIn96::ValidatesAcceptance.new(validatable, :attribute => :accepted, :accept => :what, :message => "bleh")
+      end
+
+      should "have a different message" do
+        topic.message
+      end.equals("bleh")
+      
+      should "fail if the return value of the given attribute doesnt match the :accept option" do
+        validatable.accepted = false
+        topic.validates?
+      end.equals(false)
+      
+      should "pass if the return value of the given attribute matches the :accept option" do
+        validatable.accepted = :what
+        topic.validates?
+      end
+    end # with some non-default options
+  end   # validating an object
+end     # validates acceptance

data/test/macros/validates_associated_test.rb

@@ -0,0 +1,60 @@
+require 'teststrap'
+
+context "validates associated" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_associated')
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesAssociated.new(Object.new, :attribute => :things)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("is invalid")
+  end # with some default options
+  
+  context "validating a singular association" do
+    associated = OpenStruct.new(:valid? => true)
+    validatable = OpenStruct.new(:thing => associated)
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesAssociated.new(validatable, :attribute => :thing)
+    end
+    
+    should "be valid if associated object is valid" do
+      def associated.valid?; true; end
+      topic.validates?
+    end
+    
+    should "be invalid if associated object is invalid" do
+      def associated.valid?; false; end
+      topic.validates?
+    end.equals(false)
+  end # validating a singular association
+  
+  context "validating a collection association" do
+    associated = [OpenStruct.new(:valid? => true), OpenStruct.new(:valid? => false)]
+    validatable = OpenStruct.new(:things => associated)
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesAssociated.new(validatable, :attribute => :things)
+    end
+    
+    should "be valid if all associated objects are valid" do
+      associated.each do |assoc|
+        def assoc.valid?; true; end
+      end
+      topic.validates?
+    end
+    
+    should "be invalid if any associated objects are invalid" do
+      associated.each do |assoc|
+        def assoc.valid?; false; end
+      end
+      topic.validates?
+    end.equals(false)
+  end # validating a collection association
+end   # validates associated