active_form 0.0.1

data/lib/active_form/facets/select_minute.rb

@@ -0,0 +1,17 @@
+ActiveForm::Element::SelectNumericRange::create :select_minute do
+  
+  def range
+    (0..59)
+  end
+  
+  def casting_filter(value)
+    value = case value
+      when Date then value.to_time.min
+      when Time then value.min
+      when Array, Range then value.to_a
+      else value.to_i rescue 0
+    end
+    super(value)
+  end
+  
+end

data/lib/active_form/facets/select_month.rb

@@ -0,0 +1,46 @@
+ActiveForm::Element::SelectNumericRange::create :select_month do
+  
+  define_option_flags :use_short_month, :add_month_numbers, :use_month_numbers
+  
+  def to_monthname
+    multiple? ? element_value.map { |i| number_to_label(i) } : number_to_label(element_value)
+  end
+  
+  def export_value
+    exp_value = super
+    if self.type_cast == :string
+      to_monthname
+    else
+      exp_value
+    end
+  end 
+  
+  def range
+    (1..12)
+  end
+  
+  def casting_for_string
+    [nil, nil]
+  end
+  
+  def casting_filter(value)
+    value = case value
+      when Date, Time then value.month
+      when Array, Range then value.to_a
+      else value.to_i rescue 0
+    end
+    super(value)
+  end
+  
+  def number_to_label(month_number)
+    month_names = use_short_month? ? Date::ABBR_MONTHNAMES : Date::MONTHNAMES rescue {}
+    if use_month_numbers? || month_names.empty?
+      month_number.zero_padded(2)
+    elsif add_month_numbers?
+      month_number.zero_padded(2) + ' - ' + month_names[month_number]
+    else
+      month_names[month_number]
+    end
+  end
+  
+end

data/lib/active_form/facets/select_numeric_range.rb

@@ -0,0 +1,59 @@
+ActiveForm::Element::Select::create :select_numeric_range do
+  
+  attr_accessor :increment, :range, :subset
+  
+  def casting_filter(value)
+    multiple? && value.respond_to?(:map) ? value.map { |val| normalize_value(val) } : normalize_value(value)
+  end
+  
+  def element_value
+    v = [*super].compact.map { |val| normalize_value(val) }.uniq
+    multiple? ? v : v.first
+  end
+  alias :values :element_value
+  alias :value :element_value
+  
+  def normalize_value(value)
+    integer = value.respond_to?(:to_i) ? value.to_i : 0
+    valid_opts = self.option_values
+    incr = (self.increment || 1)  
+    min_value = self.range.first  
+    max_value = self.range.last
+    min = min_value.nearest(incr)
+    min = min + incr if min < min_value && incr > 1
+    max = max_value.nearest(incr)
+    max = max - incr if max > max_value && incr > 1  
+    if valid_opts.include?(integer)
+      val = integer
+    else
+      val = integer.nearest(incr)
+      if val > min && val < max && !valid_opts.include?(val) 
+        val = valid_opts.detect { |v| v >= integer } 
+      end
+    end
+    (val > min_value ? (val > max_value ? max : val) : min)
+  end
+  
+  def options
+    opts = []
+    opts << ActiveForm::Element::CollectionOption.new('--', :blank) if include_empty?
+    option_range = self.subset.kind_of?(Array) ? self.subset & self.range.to_a : self.range
+    if self.increment > 1 && self.range.kind_of?(Range)
+      (option_range).step(self.increment) { |i| opts << ActiveForm::Element::CollectionOption.new(number_to_label(i), i) }
+    else
+      option_range.to_a.each { |i| opts << ActiveForm::Element::CollectionOption.new(number_to_label(i), i) }
+    end
+    opts
+  end
+  
+  def number_to_label(i)
+    i.zero_padded(2)
+  end
+  
+  def update_options_and_attributes(hash)
+    self.increment = hash.delete(:increment) || hash.delete('increment') || 1
+    self.range = hash.delete(:range) || hash.delete('range') unless self.range.blank?
+    super(hash)
+  end
+  
+end

data/lib/active_form/facets/select_second.rb

@@ -0,0 +1,17 @@
+ActiveForm::Element::SelectNumericRange::create :select_second do
+  
+  def range
+    (0..59)
+  end
+  
+  def casting_filter(value)
+    value = case value
+      when Date then value.to_time.sec
+      when Time then value.sec
+      when Array, Range then value.to_a
+      else value.to_i rescue 0
+    end
+    super(value)
+  end
+  
+end

data/lib/active_form/facets/select_time.rb

@@ -0,0 +1,10 @@
+class ActiveForm::Element::SelectTime < ActiveForm::Element::SelectTimebased  
+ 
+  self.default_format = [:hour, :minute]
+  self.allowed_parts = [:hour, :minute, :second]
+ 
+  def self.element_type
+    :select_time
+  end
+  
+end

data/lib/active_form/facets/select_timebased.rb

@@ -0,0 +1,145 @@
+class ActiveForm::Element::SelectTimebased < ActiveForm::Element::Section    
+  
+  TIME_FORMAT = [:year, :month, :day, :hour, :minute, :second].freeze
+  DEFAULT_VALUES = { :year => 2000, :month => 1, :day => 1, :hour => 12, :minute => 0, :second => 0 }.freeze
+  VALUE_CALL_MAP = { :year => :year, :month => :month, :day => :day, :hour => :hour, :minute => :min, :second => :sec }.freeze
+  
+  def self.inherited(derivative)
+    super
+    derivative.class_inheritable_accessor :default_format
+    derivative.class_inheritable_accessor :allowed_parts
+    derivative.default_format = TIME_FORMAT
+    derivative.allowed_parts = TIME_FORMAT
+  end
+  
+  class_inheritable_accessor :default_format
+  class_inheritable_accessor :allowed_parts
+  self.default_format = TIME_FORMAT
+  self.allowed_parts = TIME_FORMAT
+  
+  attr_reader :now
+  attr_accessor :format
+  attr_accessor :start_year, :end_year, :range
+  
+  attr_accessor :year_label, :month_label, :day_label
+  attr_accessor :year_increment, :month_increment, :day_increment
+  
+  attr_accessor :hour_label, :minute_label, :second_label
+  attr_accessor :hour_increment, :minute_increment, :second_increment
+  
+  def self.element_type
+    :select_timebased
+  end
+    
+  def now=(value)
+    @now = case value
+      when Date then value.to_time
+      when Time then value
+      else nil
+    end
+  end
+  
+  def render_element(builder = create_builder)
+    builder.div(element_attributes) { render_elements(builder) }
+  end
+  
+  def include_empty=(bool = true)
+    self.update_elements(:include_empty => bool)
+  end
+  alias :include_empty :include_empty=
+  
+  def update_from_params(params, force = false)
+    super(casting_filter(params), force)
+  end
+    
+  alias :original_export_value :export_value   
+    
+  def export_value(values = ActiveForm::Values.new)
+    export_value_as(self.type_cast)
+  end
+  
+  def export_value_as(type)
+    cast_value_to(original_export_value, type)
+  end
+  
+  def cast_value_to(value, type = :string)
+    if [:date, :time, :hash, :array, :string, :yaml].include?(type)
+      time_hash = default_element_values.merge(time_to_values(self.now, true)).merge(value)
+      (self.class.allowed_parts - elements_format).each { |part| time_hash[part] = 0 }
+      return time_hash if type == :hash
+      time_array = TIME_FORMAT.collect { |part| time_hash[part] || 0 }
+      return time_array if type == :array
+      time = Time.send(ActiveForm::Element::Base.default_timezone, *time_array) rescue nil
+      return time.to_date if type == :date && time.respond_to?(:to_date) 
+      return time.to_formatted_s(:db) if type == :string && time.respond_to?(:to_formatted_s)
+      return time.to_yaml if type == :yaml
+      time
+    else
+      value
+    end
+  end
+  
+  def type_cast=(type = :string) 
+    @type_cast = type.to_sym
+  end
+  
+  def casting_filter(value)
+    time = case value
+      when Date then value.to_time
+      when Time then value
+      when String then self.class.string_to_time(value)
+      when Hash then return ActiveForm::Values.new(value)
+      else nil 
+    end
+    return default_element_values if time.nil?
+    time_to_values(time)
+  end
+      
+  def after_initialize
+    elements_format.each do |part|
+      if self.class.allowed_parts.include?(part)
+        defaults = {}
+        defaults[:label] = self.send("#{part}_label") rescue part.to_s
+        defaults[:increment] = self.send("#{part}_increment") || 1 rescue 1 
+        if part == :year
+          defaults[:range] = self.range if self.range.kind_of?(Range) 
+          defaults[:start_year] = self.start_year if self.start_year.kind_of?(Integer) 
+          defaults[:end_year] = self.end_year if self.end_year.kind_of?(Integer)  
+        end
+        self.define_element("select_#{part}", "#{part}", defaults) do |e|
+          e.define_element_wrapper do |builder, elem, render|
+            builder.span(:id => "elem_#{elem.identifier}", :class => elem.css, :style => elem.style) { render.call(builder) }
+          end
+        end
+      elsif !part.kind_of?(Symbol)
+        self << part
+      end
+    end
+    update_values(default_element_values)
+  end
+  
+  private
+  
+  def elements_format
+    (self.format || self.class.default_format)
+  end
+  
+  def default_element_values
+    (elements_format & self.class.allowed_parts).inject(ActiveForm::Values.new) do |values, part| 
+      values[part] = default_value_for(part)
+      values 
+    end
+  end
+  
+  def time_to_values(time, all = false)
+    (all ? TIME_FORMAT : (elements_format & self.class.allowed_parts)).inject(ActiveForm::Values.new) do |values, part|
+      values[part] = time.send(VALUE_CALL_MAP[part]) if time.respond_to?(VALUE_CALL_MAP[part])    
+      values
+    end   
+  end
+  
+  def default_value_for(part)
+    (now.kind_of?(Time) && now.respond_to?(VALUE_CALL_MAP[part]) ? now.send(VALUE_CALL_MAP[part]) : DEFAULT_VALUES[part].to_i) rescue 0
+  end
+  
+end

data/lib/active_form/facets/select_weekday.rb

@@ -0,0 +1,46 @@
+ActiveForm::Element::SelectNumericRange::create :select_weekday do
+  
+  define_option_flags :use_short_day, :weekend_only, :weekdays_only
+  
+  def to_dayname
+    multiple? ? element_value.map { |i| number_to_label(i) } : number_to_label(element_value)
+  end
+  
+  def export_value
+    exp_value = super
+    if self.type_cast == :string
+      to_dayname
+    else
+      exp_value
+    end
+  end 
+  
+  def range
+    if weekend_only?
+      [6, 0]
+    elsif weekdays_only?
+      (1..5)
+    else
+      (0..6)
+    end
+  end
+  
+  def casting_for_string
+    [nil, nil]
+  end
+  
+  def casting_filter(value)
+    value = case value
+      when Date, Time then value.wday
+      when Array, Range then value.to_a
+      else value.to_i rescue 0
+    end
+    super(value)
+  end
+  
+  def number_to_label(day_number)
+    day_names = use_short_day? ? Date::ABBR_DAYNAMES : Date::DAYNAMES rescue {}
+    day_names[day_number]
+  end
+  
+end

data/lib/active_form/facets/select_year.rb

@@ -0,0 +1,24 @@
+ActiveForm::Element::SelectNumericRange::create :select_year do
+  
+  def range
+    @range ||= Range.new(Time.now.year - 5,  Time.now.year + 5)
+  end
+  
+  def start_year=(int)
+    @range = Range.new(int.to_i, self.range.last)
+  end
+  
+  def end_year=(int)
+    @range = Range.new(self.range.first, int.to_i)
+  end
+  
+  def casting_filter(value)
+    value = case value
+      when Date, Time then value.year
+      when Array, Range then value.to_a
+      else value.to_i rescue 0
+    end
+    super(value)
+  end
+  
+end

data/lib/active_form/mixins/attribute_methods.rb

@@ -0,0 +1,33 @@
+module ActiveForm::Mixins::AttributeMethods
+  
+  def self.included(base)
+    [:type].each { |m| base.send(:undef_method, m) rescue nil }
+    base.send(:extend, ClassMethods)
+  end
+  
+  def attributes
+    @attributes ||= HashWithIndifferentAccess.new
+  end
+  
+  def default_attributes
+    { :id => identifier, :class => css }
+  end
+  
+  def attribute_names
+    [:style, :javascript, :title, :lang] + self.class.element_attribute_names.to_a
+  end
+  
+  module ClassMethods
+    
+    def define_attributes(*attrs)
+      attrs.push(:lang) unless self.element_attribute_names.include?(:lang)
+      attrs.flatten.each do |attribute|      
+        self.element_attribute_names += [attribute.to_sym]  
+        define_method("#{attribute}=")  { |value| attributes[attribute] = value } unless instance_methods.include?("#{attribute}=")        
+        define_method("#{attribute}")   { attributes[attribute] } unless instance_methods.include?("#{attribute}")
+      end
+    end
+    
+  end
+  
+end

data/lib/active_form/mixins/casting.rb

@@ -0,0 +1,152 @@
+module ActiveForm
+  module Mixins
+    module Casting
+   
+      def self.included(base)    
+        base.send(:extend, ClassMethods)
+        base.send(:attr_reader, :type_cast)
+      end
+   
+      def cast_value(value)
+        if self.respond_to?(:casting_filter)
+          self.casting_filter(value)
+        elsif self.class.respond_to?(:casting_filter)
+          self.class.casting_filter(value)
+        else
+          value
+        end
+      end
+    
+      def type_cast=(type = :string) 
+        if self.respond_to?("casting_for_#{type}")
+          @type_cast = type.to_sym
+          cast, intern = self.send("casting_for_#{type}")
+          define_casting_filter(cast) if cast
+          define_formatting_filter(intern) if intern
+        end
+      end
+    
+      def casting_for_string
+        [lambda { |value| value.is_a?(String) ? value : value.to_s }, nil]
+      end
+      alias :casting_for_text :casting_for_string
+    
+      def casting_for_integer
+        [lambda { |value| value.is_a?(Integer) ? value : value.to_i rescue value ? 1 : 0 }, nil]
+      end
+    
+      def casting_for_yaml
+        [self.class.method_to_proc(:yaml_to_data), self.class.method_to_proc(:data_to_yaml)]
+      end
+    
+      def casting_for_float
+        [lambda { |value| value.is_a?(Float) ? value : value.to_f rescue 0 }, nil]
+      end
+    
+      def casting_for_array
+        [lambda { |value| value.is_a?(Array) ? value : [*value] }, lambda { |value| [*value].join(', ') }]
+      end
+      
+      def casting_for_datetime
+        [self.class.method_to_proc(:string_to_time), self.class.method_to_proc(:time_to_string)]
+      end
+      alias :casting_for_timestamp :casting_for_datetime
+    
+      def casting_for_time
+        [self.class.method_to_proc(:string_to_dummy_time), self.class.method_to_proc(:time_to_string)]
+      end
+    
+      def casting_for_date
+        [self.class.method_to_proc(:string_to_date), self.class.method_to_proc(:date_to_string)]
+      end
+    
+      def casting_for_boolean
+        [self.class.method_to_proc(:value_to_boolean), self.class.method_to_proc(:boolean_to_value)]
+      end
+    
+      def define_casting_filter(prc = nil, &block)
+        define_singleton_method(:casting_filter, &(block_given? ? block : prc))
+      end
+      alias :casting_filter= :define_casting_filter
+
+      def reset_casting_filter
+        define_singleton_method(:casting_filter) rescue nil
+      end
+   
+      module ClassMethods
+      
+        def define_casting_filter(prc = nil, &block)
+          define_singleton_method(:casting_filter, &(block_given? ? block : prc))
+        end
+        alias :casting_filter= :define_casting_filter
+
+        def reset_casting_filter
+          define_singleton_method(:casting_filter) rescue nil
+        end  
+        
+        # type casting methods
+      
+        def binary_to_string(value)
+          value
+        end
+        
+        def data_to_yaml(value)
+          value.to_yaml
+        end
+        
+        def yaml_to_data(value)
+          return value unless value.is_a?(String)
+          YAML::load(value) rescue nil
+        end
+      
+        def string_to_date(string)
+          return string unless string.is_a?(String)
+          date_array = ParseDate.parsedate(string)
+          # treat 0000-00-00 as nil
+          Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
+        end
+
+        def date_to_string(date)
+          date.respond_to?(:to_formatted_s) ? date.to_formatted_s(:long) : date.to_s
+        end
+
+        def string_to_time(string)
+          return string unless string.is_a?(String)
+          if string.strip.match(/^(\d{1,2})[:\.](\d{1,2})([:\.](\d{1,2}))?$/)
+            current_time = Time.now
+            string = "#{current_time.year}-#{current_time.month}-#{current_time.day} #{string}"
+          end
+          # treat 0000-00-00 00:00:00 as nil
+          time_array = ParseDate.parsedate(string)[0..5]
+          Time.send(ActiveForm::Element::Base.default_timezone, *time_array) rescue nil
+        end
+
+        def time_to_string(time)
+          time.respond_to?(:to_formatted_s) ? time.to_formatted_s(:long) : time.to_s
+        end
+
+        def string_to_dummy_time(string)
+          return string unless string.is_a?(String)
+          time_array = ParseDate.parsedate(string)
+          # pad the resulting array with dummy date information
+          time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
+          Time.send(ActiveForm::Element::Base.default_timezone, *time_array) rescue nil
+        end
+        
+        def value_to_boolean(value)
+          return value if value==true || value==false
+          case value.to_s.downcase
+          when "true", "t", "1" then true
+          else false
+          end
+        end      
+      
+        def boolean_to_value(boolean)
+          boolean ? "true" : "false"
+        end
+      
+      end
+  
+    end
+  end
+end