mack-notifier 0.8.1 → 0.8.2

data/lib/gems/validatable-1.6.7/lib/object_extension.rb

@@ -0,0 +1,21 @@
+class Object #:nodoc:
+  module InstanceExecHelper #:nodoc:
+  end
+  include InstanceExecHelper
+  def instance_eval_with_params(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/gems/validatable-1.6.7/lib/requireable.rb

@@ -0,0 +1,26 @@
+module Validatable
+  module Requireable #:nodoc:
+    module ClassMethods #:nodoc:
+      def requires(*args)
+        required_options.concat args        
+      end
+      
+      def required_options
+        @required_options ||= []
+      end
+    end
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+    
+    def requires(options)
+      required_options = self.class.required_options.inject([]) do |errors, attribute|
+        errors << attribute.to_s unless options.has_key?(attribute)
+        errors
+      end
+      raise ArgumentError.new("#{self.class} requires options: #{required_options.join(', ')}") if required_options.any?
+      true
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/understandable.rb

@@ -0,0 +1,31 @@
+module Validatable
+  module Understandable #:nodoc:
+    module ClassMethods #:nodoc:
+      def understands(*args)
+        understandings.concat args
+      end
+
+      def understandings
+        @understandings ||= []
+      end
+
+      def all_understandings
+        return understandings + self.superclass.all_understandings if self.superclass.respond_to? :all_understandings
+        understandings
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def must_understand(hash)
+      invalid_options = hash.inject([]) do |errors, (key, value)|
+        errors << key.to_s unless self.class.all_understandings.include?(key)
+        errors
+      end
+      raise ArgumentError.new("invalid options: #{invalid_options.join(', ')}") if invalid_options.any?
+      true
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validatable.rb

@@ -0,0 +1,19 @@
+require 'forwardable'
+require File.expand_path(File.dirname(__FILE__) + '/object_extension')
+require File.expand_path(File.dirname(__FILE__) + '/errors')
+require File.expand_path(File.dirname(__FILE__) + '/validatable_class_methods')
+require File.expand_path(File.dirname(__FILE__) + '/macros')
+require File.expand_path(File.dirname(__FILE__) + '/validatable_instance_methods')
+require File.expand_path(File.dirname(__FILE__) + '/included_validation')
+require File.expand_path(File.dirname(__FILE__) + '/child_validation')
+require File.expand_path(File.dirname(__FILE__) + '/understandable')
+require File.expand_path(File.dirname(__FILE__) + '/requireable')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validation_base')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_format_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_presence_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_acceptance_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_confirmation_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_length_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_true_for')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_numericality_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_each')

data/lib/gems/validatable-1.6.7/lib/validatable_class_methods.rb

@@ -0,0 +1,85 @@
+module Validatable
+  module ClassMethods #:nodoc:
+    
+    def validate_children(instance, group)
+      self.children_to_validate.each do |child_validation|
+        next unless child_validation.should_validate?(instance)
+        child = instance.send child_validation.attribute
+        if (child.respond_to?(:valid_for_group?))
+          child.valid_for_group?(group)
+        else
+          child.valid?
+        end
+        child.errors.each do |attribute, messages|
+          if messages.is_a?(String)
+            add_error(instance, child_validation.map[attribute.to_sym] || attribute, messages)
+          else
+            messages.each do |message|
+              add_error(instance, child_validation.map[attribute.to_sym] || attribute, message)
+            end
+          end
+        end
+      end
+    end
+    
+    def all_before_validations
+      if self.superclass.respond_to? :all_before_validations
+        return before_validations + self.superclass.all_before_validations 
+      end
+      before_validations
+    end
+    
+    def before_validations
+      @before_validations ||= []
+    end
+
+    def all_validations
+      if self.respond_to?(:superclass) && self.superclass.respond_to?(:all_validations)
+        return validations + self.superclass.all_validations 
+      end
+      validations
+    end
+
+    def validations
+      @validations ||= []
+    end
+    
+    def add_error(instance, attribute, msg)
+      instance.errors.add(attribute, msg)
+    end
+    
+    def validation_keys_include?(key)
+      validations.map { |validation| validation.key }.include?(key)
+    end
+    
+    def validations_to_include
+      @validations_to_include ||= []
+    end
+    
+    protected
+    
+    def add_validations(args, klass)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each do |attribute|
+        new_validation = klass.new self, attribute, options
+        self.validations << new_validation
+        self.create_valid_method_for_groups new_validation.groups
+      end
+    end
+    
+    def create_valid_method_for_groups(groups)
+      groups.each do |group|
+        self.class_eval do
+          define_method "valid_for_#{group}?".to_sym do
+            valid_for_group?(group)
+          end
+        end
+      end
+    end
+    
+    def children_to_validate
+      @children_to_validate ||= []
+    end
+    
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validatable_instance_methods.rb

@@ -0,0 +1,106 @@
+module Validatable
+  def self.included(klass) #:nodoc:
+    klass.extend Validatable::ClassMethods
+    klass.extend Validatable::Macros
+  end
+  
+  # call-seq: valid?
+  #
+  # Returns true if no errors were added otherwise false. Only executes validations that have no :groups option specified
+  def valid?
+    valid_for_group?(nil)
+  end
+  
+  # call-seq: errors
+  #
+  # Returns the Errors object that holds all information about attribute error messages.
+  def errors
+    @errors ||= Validatable::Errors.new
+  end
+  
+  def valid_for_group?(group) #:nodoc:
+    run_before_validations
+    errors.clear
+    self.class.validate_children(self, group)
+    self.validate(group)
+    errors.empty?
+  end
+  
+  def times_validated(key) #:nodoc:
+    times_validated_hash[key] || 0
+  end
+  
+  def increment_times_validated_for(validation) #:nodoc:
+    if validation.key != nil
+      if times_validated_hash[validation.key].nil?
+        times_validated_hash[validation.key] = 1
+      else
+        times_validated_hash[validation.key] += 1
+      end
+    end
+  end
+
+  # call-seq: validate_only(key)
+  #
+  # Only executes a specified validation. The argument should follow a pattern based on the key of the validation.
+  #   Examples:
+  #     * validates_presence_of :name can be run with obj.validate_only("presence_of/name")
+  #     * validates_presence_of :birthday, :key => "a key" can be run with obj.validate_only("presence_of/a key")
+  def validate_only(key)
+    validation_name, attribute_name = key.split("/")
+    validation_name = validation_name.split("_").collect{|word| word.capitalize}.join
+    validation_key = "#{self.class.name}/Validatable::Validates#{validation_name}/#{attribute_name}"
+    validation = self.class.all_validations.find { |validation| validation.key == validation_key }
+    raise ArgumentError.new("validation with key #{validation_key} could not be found") if validation.nil?
+    errors.clear
+    run_validation(validation)
+  end
+
+  protected
+  def times_validated_hash #:nodoc:
+    @times_validated_hash ||= {}
+  end
+
+  def validate(group) #:nodoc:
+    validation_levels.each do |level|
+      validations_for_level_and_group(level, group).each do |validation|
+        run_validation(validation) if validation.should_validate?(self)
+      end
+      return unless self.errors.empty?
+    end
+  end
+
+  def run_validation(validation) #:nodoc:
+    validation_result = validation.valid?(self)
+    add_error(validation.attribute, validation.message(self)) unless validation_result
+    increment_times_validated_for(validation)
+    validation.run_after_validate(validation_result, self, validation.attribute)
+  end
+  
+  def run_before_validations #:nodoc:
+    self.class.all_before_validations.each do |block|
+      instance_eval &block
+    end
+  end
+  
+  def add_error(attribute, message) #:nodoc:
+    self.class.add_error(self, attribute, message)
+  end
+  
+  def validations_for_level_and_group(level, group) #:nodoc:
+    validations_for_level = self.all_validations.select { |validation| validation.level == level }
+    return validations_for_level.select { |validation| validation.groups.empty? } if group.nil?
+    validations_for_level.select { |validation| validation.groups.include?(group) }
+  end
+  
+  def all_validations #:nodoc:
+    res = self.class.validations_to_include.inject(self.class.all_validations) do |result, included_validation_class|
+      result += self.send(included_validation_class.attribute).all_validations
+      result
+    end
+  end
+  
+  def validation_levels #:nodoc:
+    self.class.all_validations.inject([1]) { |result, validation| result << validation.level }.uniq.sort
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_acceptance_of.rb

@@ -0,0 +1,11 @@
+module Validatable
+  class ValidatesAcceptanceOf < ValidationBase #:nodoc:
+    def valid?(instance)
+      instance.send(self.attribute) == "true"
+    end
+    
+    def message(instance)
+      super || "must be accepted"
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_confirmation_of.rb

@@ -0,0 +1,15 @@
+module Validatable
+  class ValidatesConfirmationOf < ValidationBase #:nodoc:
+    option :case_sensitive
+    default :case_sensitive => true
+    
+    def valid?(instance)
+      return instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
+      instance.send(self.attribute).to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
+    end
+    
+    def message(instance)
+      super || "doesn't match confirmation"
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_each.rb

@@ -0,0 +1,14 @@
+module Validatable
+  class ValidatesEach < ValidationBase #:nodoc:
+    required_option :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic)
+      true # return true so no error is added. should look in the future at doing this different.
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_format_of.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesFormatOf < ValidationBase #:nodoc:
+    required_option :with
+  
+    def valid?(instance)
+      not (instance.send(self.attribute).to_s =~ self.with).nil?
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_length_of.rb

@@ -0,0 +1,25 @@
+module Validatable
+  class ValidatesLengthOf < ValidationBase #:nodoc:
+    option :minimum, :maximum, :is, :within, :allow_nil
+    
+    def message(instance)
+      super || "is invalid"
+    end
+    
+    def valid?(instance)
+      valid = true
+      value = instance.send(self.attribute)
+      
+      if value.nil?
+        return true if allow_nil
+        value = ""
+      end
+      
+      valid &&= value.length <= maximum unless maximum.nil? 
+      valid &&= value.length >= minimum unless minimum.nil?
+      valid &&= value.length == is unless is.nil?
+      valid &&= within.include?(value.length) unless within.nil?
+      valid
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validates_numericality_of.rb

@@ -0,0 +1,16 @@
+module Validatable 
+  class ValidatesNumericalityOf < ValidationBase #:nodoc:
+    option :only_integer
+    
+    def valid?(instance)
+      value = instance.send(self.attribute).to_s
+      regex = self.only_integer ? /\A[+-]?\d+\Z/ : /^\d*\.{0,1}\d+$/
+      not (value =~ regex).nil?
+    end
+    
+    def message(instance)
+      super || "must be a number"
+    end
+  end
+end
+

data/lib/gems/validatable-1.6.7/lib/validations/validates_presence_of.rb

@@ -0,0 +1,13 @@
+module Validatable 
+  class ValidatesPresenceOf < ValidationBase #:nodoc:
+    def valid?(instance)
+      return false if instance.send(self.attribute).nil?
+      instance.send(self.attribute).respond_to?(:strip) ? instance.send(self.attribute).strip.length != 0 : true
+    end
+    
+    def message(instance)
+      super || "can't be empty"
+    end
+  end
+end
+

data/lib/gems/validatable-1.6.7/lib/validations/validates_true_for.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesTrueFor < ValidationBase #:nodoc:
+    required_option :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic) == true
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/gems/validatable-1.6.7/lib/validations/validation_base.rb

@@ -0,0 +1,88 @@
+module Validatable
+  class ValidationBase #:nodoc:
+    class << self
+      def required_option(*args)
+        option(*args)
+        requires(*args)
+      end
+      
+      def option(*args)
+        attr_accessor(*args)
+        understands(*args)
+      end
+      
+      def default(hash)
+        defaults.merge! hash
+      end
+      
+      def defaults
+        @defaults ||= {}
+      end
+      
+      def all_defaults
+        return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
+        defaults
+      end
+      
+      def after_validate(&block)
+        after_validations << block
+      end
+      
+      def after_validations
+        @after_validations ||= []
+      end
+      
+      def all_after_validations
+        return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
+        after_validations
+      end
+    end
+
+    include Understandable
+    include Requireable
+    
+    option :message, :if, :times, :level, :groups, :key, :after_validate
+    default :level => 1, :groups => []
+    attr_accessor :attribute
+    
+    def initialize(klass, attribute, options={})
+      must_understand options
+      requires options
+      self.class.all_understandings.each do |understanding|
+        options[understanding] = self.class.all_defaults[understanding] unless options.has_key? understanding
+        self.instance_variable_set("@#{understanding}", options[understanding])
+      end
+      self.attribute = attribute
+      self.groups = [self.groups] unless self.groups.is_a?(Array)
+      self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
+      raise_error_if_key_is_dup(klass)
+    end
+    
+    def raise_error_if_key_is_dup(klass)
+      message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
+      raise ArgumentError.new(message) if klass.validation_keys_include? self.key
+    end
+    
+    def should_validate?(instance)
+      result = validate_this_time?(instance)
+      result &&= instance.instance_eval(&self.if) unless self.if.nil?
+      result
+    end
+    
+    def message(instance)
+      @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
+    end
+    
+    def validate_this_time?(instance)
+      return true if @times.nil?
+      self.times > instance.times_validated(self.key)
+    end
+    
+    def run_after_validate(result, instance, attribute)
+      self.class.all_after_validations.each do |block|
+        block.call result, instance, attribute
+      end
+      instance.instance_eval_with_params result, attribute, &self.after_validate unless self.after_validate.nil?
+    end
+  end
+end