active_form 0.0.1

data/lib/active_form/validators/digits.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :digits do
+  
+  default_message "%s: should contain digits (0-9) only"
+  
+  def validate
+    element.errors << advice[code] unless element.blank? || value.to_s =~ /^\d+$/
+  end
+
+end

data/lib/active_form/validators/email.rb

@@ -0,0 +1,29 @@
+require 'resolv'
+
+ActiveForm::Validator::Base.create :email do
+  
+  REGEX = /^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}$/
+  
+  default_message "%s: is not a valid email address"
+  
+  attr_accessor :resolve
+  
+  def validate
+    email = value.to_s
+    element.errors << advice[code] unless email.blank? || (email =~ REGEX && (self.resolve ? resolve_address(email) : true))
+  end
+
+  private
+  
+  def resolve_address(email)
+    hostname = email[(email =~ /@/)+1..email.length]
+    valid = true
+    begin
+      Resolv::DNS.new.getresource(hostname, Resolv::DNS::Resource::IN::MX)
+    rescue Resolv::ResolvError
+      valid = false
+    end
+    return valid
+  end
+
+end

data/lib/active_form/validators/format.rb

@@ -0,0 +1,15 @@
+ActiveForm::Validator::Base.create :format do
+  
+  default_message "%s: has an invalid format"
+  
+  attr_accessor :regexp
+  
+  def setup
+    self.regexp = /.*/
+  end
+  
+  def validate
+    element.errors << advice[code] unless element.blank? || (self.regexp.kind_of?(Regexp) && value.to_s.match(self.regexp))
+  end
+  
+end

data/lib/active_form/validators/length_range.rb

@@ -0,0 +1,24 @@
+ActiveForm::Validator::Base.create :length_range do
+  
+  # format position 3 contains the minimum value
+  # format position 4 contains the maximum value
+  # format position 5 contains the actual value length (server side only)
+  default_message "%1$s: length should be within %3$s and %4$s characters"
+  
+  attr_accessor :range
+
+  def setup
+    self.range = (0..1)
+  end
+
+  def validate
+    length_range = self.range.respond_to?(:include?) ? self.range : []
+    element.errors << advice[code] unless length_range.include?(self.value_length)
+  end
+  
+  def message_params
+    first = self.range.first rescue 0; last = self.range.last rescue 0
+    [first, last, self.value_length]
+  end
+  
+end

data/lib/active_form/validators/number.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :number do
+  
+  default_message "%s: should be numeric"
+  
+  def validate
+    element.errors << advice[code] unless element.blank? || value.to_s.match(/^[0-9\.,]+$/)
+  end
+  
+end

data/lib/active_form/validators/option_count.rb

@@ -0,0 +1,24 @@
+ActiveForm::Validator::Base.create :option_count do
+  
+  # format position 3 contains the minimum value
+  # format position 4 contains the maximum value
+  # format position 5 contains the actual value length (server side only)
+  default_message "%1$s: you need to select %3$s items"
+  
+  attr_accessor :range
+  
+  def setup
+    self.range = (0..1)
+  end
+  
+  def validate
+    length_range = self.range.respond_to?(:include?) ? self.range : []
+    element.errors << advice[code] unless length_range.include?(self.collection_length)
+  end
+  
+  def message_params
+    first = self.range.first rescue 0; last = self.range.last rescue 0
+    [first, last, collection_length]
+  end
+  
+end

data/lib/active_form/validators/proc.rb

@@ -0,0 +1,22 @@
+ActiveForm::Validator::Base.create :proc do
+
+  default_message '%s: validation failed'
+
+  def initialize(*args, &block)
+    @proc = block if block_given?
+    super(*args)
+  end
+
+  def proc=(proc)
+    @proc = proc
+  end
+
+  def validate
+    @proc.call(self)
+  end
+  
+  def advice
+    Hash.new
+  end
+
+end

data/lib/active_form/validators/required.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :required do
+  
+  default_message "%s: can't be blank"
+  
+  def validate
+    element.errors << advice[code] if element.blank?
+  end
+  
+end

data/lib/active_form/validators/set.rb

@@ -0,0 +1,21 @@
+ActiveForm::Validator::Base.create :set do
+  
+  # format position 3 contains the allowed values
+  default_message "%1$s: invalid value"
+  
+  attr_accessor :set
+
+  def setup
+    self.set = []
+  end
+
+  def validate
+    value_set = self.set.respond_to?(:include?) ? self.set : []
+    element.errors << advice[code] unless value_set.include?(self.value)
+  end
+  
+  def message_params
+    [ [*self.set].join(', ') ]
+  end
+  
+end

data/lib/active_form/validators/time_range.rb

@@ -0,0 +1,30 @@
+ActiveForm::Validator::Base.create :time_range do
+  
+  # format position 3 contains the minimum value
+  # format position 4 contains the maximum value
+  # format position 5 contains the actual value length (server side only)
+  default_message "%1$s: specify a valid time or date between %3$s and %4$s"
+  
+  attr_accessor :range
+
+  def setup
+    self.range = (5.years.ago.beginning_of_year..6.years.from_now.beginning_of_year)
+  end
+  
+  def validate 
+    if self.range.respond_to?(:include?)
+      element_value = element.export_value_as(self.range.first.kind_of?(Time) ? :time : :date)
+      element.errors << advice[code] unless self.range.include?(element_value)
+    end
+  end
+
+  def message_params
+    first = self.range.first.to_s(:long) rescue Date.today.to_s(:long); last = self.range.last.to_s(:long) rescue Date.today.to_s(:long)
+    [first, last, self.value_length]
+  end
+  
+  # TODO
+  def js_validation(validation_msg, code)   
+  end
+  
+end

data/lib/active_form/validators/uri.rb

@@ -0,0 +1,54 @@
+require 'loob/uri_validator'
+
+ActiveForm::Validator::Base.create :uri do
+  
+  attr_accessor :messages
+  # possible error statuses: 
+  # :invalid_scheme
+  # :invalid_host
+  # :invalid_content_type
+  # :invalid_format
+  # :moved_permanently
+  # :not_accessible
+  
+  # format position 3 contains the validation error status (server side only)
+  default_message "%s: is not a valid location"
+  
+  attr_reader :uri_validator
+  
+  delegate :response_codes, :content_types, :schemes, :hosts, :port, :to => :uri_validator
+  delegate :response_codes=, :content_types=, :schemes=, :hosts=, :port=, :to => :uri_validator
+  
+  def initialize(*args, &block) 
+    @uri_validator = Loob::UriValidator.new
+    setup # trigger setup after creation
+    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}=") } 
+    self.messages = {}
+    self.messages.default = self.message     
+    yield self if block_given?
+  end
+ 
+  def validate
+    unless value.blank? || uri_validator.valid_uri?(value)
+      element.errors << advice[uri_validator.error.to_s]
+    end
+  end
+
+  def advice
+    list = {}
+    list.default = ActiveForm::Error.new(element, messages[:default], code, message_params)
+    list[code] = list.default
+    [:invalid_scheme, :invalid_host, :invalid_content_type, :invalid_format, :moved_permanently, :not_accessible].each do |mkey|
+      list[mkey.to_s] = ActiveForm::Error.new(element, messages[mkey], mkey.to_s, message_params) if messages.key?(mkey)
+    end
+    list
+  end
+
+  def message_params
+    [uri_validator.error.to_s.titleize || 'OK']
+  end
+
+end

data/lib/active_form/version.rb

@@ -0,0 +1,9 @@
+module ActiveForm #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/active_form/views/fieldsets.rb

@@ -0,0 +1,34 @@
+# TODO work in progress
+
+ActiveForm::Definition.define_container_wrapper do |builder, elem, render|      
+  builder.form(elem.element_attributes) {  
+    builder.fieldset(:class => 'form') { 
+      builder.legend(elem.label, :class => 'form')
+      elem.render_elements(builder) 
+    }
+    builder << elem.script_tag
+  }   
+end
+
+ActiveForm::Definition.define_element_wrapper do |builder, elem, render|
+  style = StyleAttribute.new
+  style << 'display: none' if elem.hidden?
+  builder.fieldset(:style => style) {
+    builder.legend { elem.render_label(builder) }
+    builder.div(:id => "sub-#{elem.identifier}", &render)
+  }
+end  
+
+ActiveForm::Element::Base.define_element_wrapper do |builder, elem, render|
+  builder.div(:id => "elem_#{elem.identifier}", :class => elem.css, :style => elem.style) {
+    elem.render_label(builder)
+    render.call(builder)
+  }
+end
+
+ActiveForm::Element::Section.define_element_wrapper do |builder, elem, render|
+  builder.fieldset(:class => 'section') {
+    builder.legend(elem.label, :class => 'section')
+    builder.div(:id => "section-#{elem.identifier}", &render)
+  }
+end

data/lib/active_form/views/plain.rb

@@ -0,0 +1,32 @@
+# TODO work in progress
+
+ActiveForm::Definition.define_container_wrapper do |builder, elem, render|      
+  builder.form(elem.element_attributes) {
+    builder.h3(elem.label)
+    elem.render_elements(builder) 
+    builder << elem.script_tag
+  }   
+end
+
+# ActiveForm::Definition.define_element_wrapper do |builder, elem, render|
+#   style = StyleAttribute.new
+#   style << 'display: none' if elem.hidden?
+#   builder.div(:style => style) {
+#     builder.h4 { elem.render_label(builder) }
+#     builder.div(:id => "sub-#{elem.identifier}", &render)
+#   }
+# end  
+
+ActiveForm::Element::Base.define_element_wrapper do |builder, elem, render|
+  builder.div(:id => "elem_#{elem.identifier}", :class => elem.css, :style => elem.style) {
+    elem.render_label(builder)
+    render.call(builder)
+  }
+end
+
+ActiveForm::Element::Section.define_element_wrapper do |builder, elem, render|
+  builder.div(:class => 'section') {
+    builder.h4(elem.label, :id => "section-#{elem.identifier}-title")
+    builder.div(:id => "section-#{elem.identifier}", &render)
+  }
+end

data/lib/active_form/views/tables.rb

@@ -0,0 +1,28 @@
+# TODO work in progress
+
+ActiveForm::Definition.define_container_wrapper do |builder, elem, render|      
+  builder.form(elem.element_attributes) {
+    builder.table {
+      builder.thead { builder.tr { builder.th(elem.label, :colspan => 2) } }
+      builder.tbody { elem.render_elements(builder) }
+    }
+    builder << elem.script_tag
+  }   
+end
+
+ActiveForm::Definition.define_element_wrapper do |builder, elem, render|
+  style = StyleAttribute.new
+  style << 'display: none' if elem.hidden?
+  builder.tr { builder.td { builder.table(:style => style, &render) } }
+end  
+
+ActiveForm::Element::Base.define_element_wrapper do |builder, elem, render|
+  builder.tr(:class => 'label') { builder.td(:colspan => 2) { elem.render_label(builder) } }
+  builder.tr(:id => "elem_#{elem.identifier}", :class => elem.css, :style => elem.style) { builder.td(:class => 'elem', :colspan => 2, &render) }
+end
+
+ActiveForm::Element::Section.define_element_wrapper do |builder, elem, render|
+  builder.tr(:class => 'header') { builder.td(:colspan => 2) { builder.h3(:onclick => "$('section-#{elem.identifier}').toggle()") { elem.render_label(builder) } } }
+  builder.tr(:class => 'advice') { builder.td(:colspan => 2) { builder << elem.validation_advice } }
+  builder.tr { builder.td { builder.div(:id => "section-#{elem.identifier}") { builder.table(:style => 'background: lightblue;', &render) } } }
+end

data/lib/active_form/widget.rb

@@ -0,0 +1,43 @@
+module ActiveForm::Widget
+  
+  include ActiveForm::Mixins::LoaderMethods
+  
+  class << self
+
+    def element?(klass)
+      klass.respond_to?(:element?) && klass.element?
+    end
+
+    # loader related
+
+    def load_paths
+      @@load_paths ||= [*base_load_paths]
+    end
+
+    def base_load_paths
+      [ ::File.join(ActiveForm::BASE_PATH, 'widgets') ]
+    end
+
+    def instance(definition_name, klass, *args, &block)
+      args.unshift(definition_name) if args.empty? || args.first.kind_of?(Hash)
+      item = klass.new(*args)
+      item.instance_eval(&block) if block_given?
+      item
+    end
+    
+    def create(definition_name, &block)
+      ActiveForm::Widget::Base::create(definition_name, &block)
+    end
+
+    def register(elem_class)
+      if element?(elem_class) && !self.methods.include?("#{elem_class.loadable_type}_element")
+        self.module_eval("
+          def #{elem_class.loadable_type}_widget(*args, &block)
+            define_widget(:#{elem_class.loadable_type}, *args, &block)
+          end")
+      end
+    end
+
+  end
+
+end

data/lib/active_form/widgets/base.rb

@@ -0,0 +1,28 @@
+class ActiveForm::Widget::Base < ActiveForm::Element::Section
+  
+  def self.inherited(derivative)
+    ActiveForm::Widget::register(derivative) if derivative.kind_of?(ActiveForm::Widget::Base)
+    super
+  end
+  
+  def self.create(definition_name, &block)
+    class_name = type_classname(definition_name)
+    if !ActiveForm::Widget.const_defined?(class_name)
+      ActiveForm::Widget.const_set(class_name, Class.new(self))
+      if klass = ActiveForm::Widget.const_get(class_name)
+        klass.setup_proc = (block_given? ? block : prc) 
+        return klass
+      end
+    end
+    nil
+  end
+  
+  def self.type_classname(type)
+    type.to_s.camelize
+  end
+  
+  def self.element_type
+    "#{self.name.to_s.demodulize.underscore}_widget".to_sym
+  end
+  
+end