active_form 0.0.1

data/lib/active_form/mixins/option_element_methods.rb

@@ -0,0 +1,61 @@
+module ActiveForm::Mixins::OptionElementMethods
+  
+  def self.included(base)
+    base.define_html_flags(:checked, false)
+  end
+  
+  def options=(val)
+    if val.kind_of?(Array)
+      self.fallback_value = val.last
+      self.checked_value = val.first
+    else
+      self.checked_value = val
+    end
+  end
+  alias :option= :options=
+  
+  def checked_value=(value)
+    @checked_value = value
+  end
+  
+  def checked_value
+    @checked_value ||= nil
+  end
+  
+  def valid_option?(value)
+    [self.checked_value, self.fallback_value].include?(value)
+  end
+  
+  def checked?
+    perform_check!
+  end
+  alias :active? :checked? 
+  alias :selected? :checked?
+  
+  def checked
+    self.html_flags[:checked]
+  end
+  
+  def checked=(value)
+    self.html_flags[:checked] = value.to_s.to_boolean
+    self.element_value = (self.html_flags[:checked] ? self.checked_value : self.fallback_value)
+    self.html_flags[:checked]
+  end
+  
+  def perform_check!
+    self.html_flags[:checked] = !self.blank? && self.element_value == self.checked_value
+    self.element_value = (self.html_flags[:checked] ? self.checked_value : self.fallback_value)
+    self.html_flags[:checked]
+  end
+  
+  def required=(value)
+    self.option_flags[:required] = value.to_s.to_boolean
+    if self.option_flags[:required]
+      req = proc { |v| v.element.errors.add(v.message, 'confirm') unless v.element.checked? }
+      validates_with_proc :code => 'required', :proc => req
+    else
+      validators.delete_if { |v| v.code == 'required' }
+    end
+  end
+  
+end

data/lib/active_form/mixins/validation_methods.rb

@@ -0,0 +1,253 @@
+module ActiveForm::Mixins::ValidationMethods
+  
+  def self.included(base)    
+    base.send(:extend, ClassMethods)
+  end
+  
+  def define_validator(type, *args, &block)
+    args.unshift(self)
+    validator = ActiveForm::Validator::build(type, *args, &block)
+    validators << validator
+    validator
+  end
+  
+  def format_message(msg = @@default_msg, error_code = 'default', params = [])
+    msg = (localize(name, "validates_#{error_code}") || msg) if localized?
+    mparams = message_params + params
+    sprintf(msg || '', *mparams)
+  end
+  
+  def message_params
+    [label, element_value]
+  end
+  
+  def get_validation_advice_wrapper
+    if respond_to?(:advice_wrapper)
+      method_to_proc(:advice_wrapper)
+    elsif self.class.respond_to?(:advice_wrapper)
+      self.class.method_to_proc(:advice_wrapper)
+    else
+      self.class.method_to_proc(:default_validation_advice_wrapper)
+    end
+  end
+  
+  def validators_by_type(*types)
+    types.map(&:to_s)
+    self.validators.find_all { |v| types.include?(v.code) }
+  end
+  
+  def required_message=(str)
+    validator = self.validators_by_type('required').first
+    validator.message = str unless validator.nil?
+  end
+  
+  def validation_advice(builder = create_builder)
+    str = server_side_validation_advice(builder)
+    str << client_side_validation_advice(builder) if client_side?
+    str 
+  end
+  
+  def server_side_validation_advice(builder = create_builder, first_only = true)
+    element_errors(first_only).inject('') do |str, error|
+      attrs = { :id => "advice-#{error.identifier}-#{error.element.identifier}", :class => "validation-advice advice-#{error.code}" }
+      get_validation_advice_wrapper.call(builder, error, attrs)
+    end
+  end
+  
+  def all_server_side_validation_advice(builder = create_builder)
+    server_side_validation_advice(builder, false)
+  end
+  
+  def client_side_validation_advice(builder = create_builder)
+    gather_validation_advice.each do |adv|
+      attrs = { :id => "advice-#{adv.identifier}-#{adv.element.identifier}", :style => 'display: none', :class => "validation-advice advice-#{adv.code}" }
+      get_validation_advice_wrapper.call(builder, adv, attrs)
+    end
+    builder.target!
+  end
+  
+  def gather_validation_advice    
+    adv = validators.inject([]) { |ary, v| v.advice.keys.sort.inject(ary) { |a, key| a << v.advice[key] unless v.advice[key].blank? } }
+    each { |elem| adv += elem.gather_validation_advice } if container?
+    adv.compact    
+  end
+  
+  def validation_css_class
+    css = validators.inject(CssAttribute.new) { |cs, v| cs << "#{v.identifier}" }
+    each { |elem| css += elem.validation_css_class } if container?
+    css.compact  
+  end
+  
+  def validation_javascript_definitions
+    js = validators.inject([]) { |ary, v| ary << v.javascript_definition }.compact.join("\n")
+    each { |elem| js += elem.validation_javascript_definitions } if container?
+    js
+  end
+  
+  def client_side?
+    client_side == true || (contained? && container.client_side?)
+  end
+  
+  def client_side_options
+    @client_js_options ||= { :stopOnFirst => false, :useTitles => true }
+  end
+  
+  def client_side
+    @client_side_validation ||= false
+  end
+  
+  def client_side=(value)
+    @client_side_validation = value.to_s.to_boolean
+  end
+
+  def validators
+    @validators ||= []
+  end
+  
+  def errors
+    @errors ||= ActiveForm::Errors.new(self)
+  end
+  
+  def element_errors(first_only = false)
+    elem_errors = first_only ? [errors.first] : errors.all
+    elements.each { |elem| elem_errors += elem.element_errors(first_only) } if container?
+    elem_errors.compact
+  end
+  alias :all_errors :element_errors
+  alias :validation_errors :element_errors
+  
+  def initial_errors
+    element_errors(true)
+  end
+  
+  def each_error(&block)   
+    element_errors.each(&block)
+  end
+  
+  def every_error(&block)   
+    element_errors(true).each(&block)   
+  end
+  alias :every_initial_error :every_error
+  
+  def reset_errors!
+    errors.reset
+  end
+  
+  def valid?
+    initial_errors.empty?
+  end
+  
+  def validate
+    perform_validation && valid?
+  end
+  
+  def validate!
+    return true if validate  
+    raise ActiveForm::ValidationException 
+  end
+  
+  def perform_validation
+    reset_errors!     
+    each { |elem| elem.perform_validation } if container?
+    validators.each(&:validate)
+    validate_element
+    after_validation_callback(self) if respond_to?(:after_validation_callback)
+    return true # so you can write perform_validation && valid?
+  end
+  
+  def clear_validations!
+    reset_errors!
+    recurse(&:clear_validations!) if container?
+  end
+  
+  def validate_element
+    internal_validation(self) if respond_to?(:internal_validation)
+    validation_handler(self) if respond_to?(:validation_handler)
+    self.class.validation_handler(self) if self.class.respond_to?(:validation_handler)
+  end
+  
+  def define_validation(prc = nil, &block)
+    define_singleton_method(:validation_handler, &(block_given? ? block : prc))
+  end
+  alias :validation= :define_validation
+  alias :validation :define_validation
+  
+  def reset_validation
+    undefine_singleton_method(:validation_handler) rescue nil
+  end
+  
+  def javascript_validation_code
+    return nil unless respond_to?(:js_validation_generator) || self.class.respond_to?(:js_validation_generator)
+    vparams = { :name => identifier.dasherize, :msg => "#{label}: validation failed" }
+    code = JavascriptAttribute.new
+    js_validation_generator(self, code, vparams) if respond_to?(:js_validation_generator)
+    self.class.js_validation_generator(self, code, vparams) if self.class.respond_to?(:js_validation_generator)
+    return nil if code.empty? 
+    class_name = "validate-#{vparams[:name]}"
+    css_class << class_name unless container? || css_class.include?(class_name)
+    %|Validation.add('#{class_name}', "#{vparams[:msg]}", function (v) {\n  #{code}\n});|
+  end
+  
+  def javascript_validation(prc = nil, &block)
+    define_singleton_method(:js_validation_generator, &(block_given? ? block : prc))
+  end
+  alias :javascript_validation= :javascript_validation
+  
+  def reset_javascript_validation
+    undefine_singleton_method(:js_validation_generator) rescue nil
+  end
+  
+  def validation_advice_wrapper(prc = nil, &block)
+    define_singleton_method(:advice_wrapper, &(block_given? ? block : prc))
+  end
+  alias :javascript_validation= :javascript_validation
+  
+  def reset_validation_advice_wrapper
+    undefine_singleton_method(:advice_wrapper) rescue nil
+  end
+  
+  def after_validation(prc = nil, &block)
+    define_singleton_method(:after_validation_callback, &(block_given? ? block : prc))
+  end
+  alias :after_validation_callback= :after_validation
+
+  def reset_after_validation_callback
+    undefine_singleton_method(:after_validation_callback) rescue nil
+  end
+
+  module ClassMethods
+    
+    def define_validation(prc = nil, &block)
+      define_singleton_method(:validation_handler, &(block_given? ? block : prc))
+    end
+    alias :validation= :define_validation
+    
+    def reset_validation
+      undefine_singleton_method(:validation_handler) rescue nil
+    end
+    
+    def javascript_validation(prc = nil, &block)
+      define_singleton_method(:js_validation_generator, &(block_given? ? block : prc))
+    end
+    alias :javascript_validation= :javascript_validation
+  
+    def reset_javascript_validation
+      undefine_singleton_method(:js_validation_generator) rescue nil
+    end
+    
+    def default_validation_advice_wrapper(builder, error, attrs)
+      builder.div(error.message, attrs)
+    end
+    
+    def validation_advice_wrapper(prc = nil, &block)
+      define_singleton_method(:advice_wrapper, &(block_given? ? block : prc))
+    end
+    alias :javascript_validation= :javascript_validation
+  
+    def reset_validation_advice_wrapper
+      undefine_singleton_method(:advice_wrapper) rescue nil
+    end
+    
+  end
+  
+end

data/lib/active_form/validator.rb

@@ -0,0 +1,47 @@
+module ActiveForm::Validator
+  
+  include ActiveForm::Mixins::LoaderMethods
+  
+  class NoElemException < StandardError #:nodoc:
+  end
+
+  class MismatchException < StandardError #:nodoc:
+  end
+  
+  class << self  
+  
+    def validator?(klass)
+      klass < ActiveForm::Validator::Base
+    end  
+ 
+    # loader related
+  
+    def load_paths
+      @@load_paths ||= [*base_load_paths]
+    end
+
+    def base_load_paths
+      [::File.join(ActiveForm::BASE_PATH, 'validators')]
+    end
+    
+    def instance(definition_name, klass, *args, &block)
+      item = klass.new(*args, &block)
+      item
+    end
+  
+    def create(definition_name, &block)
+      ActiveForm::Validator::Base::create(definition_name, &block)
+    end 
+  
+    def register(elem_class)
+      if validator?(elem_class) && !self.methods.include?("validates_#{elem_class.loadable_type}")       
+        self.module_eval("
+          def validates_#{elem_class.loadable_type}(*args, &block)
+            define_validator(:#{elem_class.loadable_type}, *args, &block)
+          end")
+      end
+    end
+
+  end
+
+end

data/lib/active_form/validators/alpha.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :alpha do
+  
+  default_message "%s: should contain alphabetical characters only"
+  
+  def validate
+    element.errors << advice[code] unless element.blank? || value.to_s.match(/^[a-zA-Z]+$/)
+  end
+
+end

data/lib/active_form/validators/alphanum.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :alphanum do
+  
+  default_message "%s: should contain alphabetical characters or numbers only"
+  
+  def validate
+    element.errors << advice[code] unless element.blank? || value.to_s.match(/^[a-zA-Z0-9]+$/)
+  end
+  
+end

data/lib/active_form/validators/base.rb

@@ -0,0 +1,132 @@
+class ActiveForm::Validator::Base
+  
+  attr_reader   :element
+  attr_accessor :msg, :code
+  
+  def initialize(*args, &block)
+    setup
+    props = args.last.is_a?(Hash) ? args.pop : {}
+    register_element(args.shift) if is_element?(args.first)
+    self.code = self.class.to_s.demodulize.underscore
+    props.each { |prop, value| send("#{prop}=", value) if respond_to?("#{prop}=") }
+    yield self if block_given?
+  end
+  
+  alias :name :code
+  
+  def setup
+  end
+  
+  def identifier
+    self.code == 'required' ? code : "validate-#{code}"
+  end
+  
+  def javascript_definition
+    self.class.javascript_definition(identifier)
+  end
+  
+  def advice
+    { code => ActiveForm::Error.new(element, message, code, message_params) }
+  end
+  
+  def validate 
+    element.errors << advice[code]
+  end
+  
+  def register_element(elem)
+    @element = elem
+  end
+  
+  def code=(str)
+    @code = str.to_s
+  end
+  
+  def message
+    self.msg || self.class.message
+  end  
+  
+  def message=(str)
+    self.msg = str
+  end
+  
+  def message_params
+    []
+  end
+  
+  def label
+    element.label
+  end
+  
+  def value
+    element.element_value
+  end
+  
+  def value_length
+    str = self.value.to_s
+    charlength = str.respond_to?(:chars) ? str.chars.length : str.length
+  end
+  
+  def collection_length
+    [*self.value].delete_if { |v| v.blank? }.length
+  end
+  
+  def is_element?(arg)
+    arg.respond_to?(:element?) && arg.element?
+  end
+  
+  def js_validation(validation_msg, code)   
+  end
+  
+  class << self
+    
+    def javascript_validation(msg = 'validation failed', jscode = '')
+      self.javascript_validation_code = { :msg => msg, :jscode => yield(jscode) }
+    end
+    
+    def javascript_definition(identifier)
+      return nil if self.javascript_validation_code.blank?    
+      %|Validation.add('#{identifier}', "#{self.javascript_validation_code[:msg]}", function (v) {\n  #{self.javascript_validation_code[:jscode]}\n});|
+    end
+    
+    def message
+      self.default_msg ||= '%s: validation failure'
+    end
+    
+    def default_message=(str)
+      self.default_msg = str
+    end
+    alias :default_message :default_message=
+    
+    def inherited(derivative)
+      ActiveForm::Validator::register(derivative) if derivative.kind_of?(ActiveForm::Validator::Base)
+      derivative.class_inheritable_accessor :default_msg
+      derivative.class_inheritable_accessor :javascript_validation_code
+      super
+    end
+  
+    def create(definition_name, &block)
+      class_name = name_to_class_name(definition_name)
+      if !ActiveForm::Validator.const_defined?(class_name)
+        ActiveForm::Validator.const_set(class_name, Class.new(self))
+        if klass = ActiveForm::Validator.const_get(class_name)
+          klass.module_eval(&block) if block_given?
+          ActiveForm::Validator::register(klass)
+          return klass
+        end
+      end
+      nil
+    end
+    
+    def loadable_type
+      self.name.to_s.demodulize.underscore.to_sym
+    end
+    
+    private
+    
+    def name_to_class_name(definition_name)
+      Inflector::camelize("#{definition_name}")
+    end
+  
+  end
+  
+end