active_form 0.0.1

data/lib/active_form/mixins/collection_element_methods.rb

@@ -0,0 +1,204 @@
+module ActiveForm::Mixins::CollectionElementMethods
+  
+  def self.included(base)
+    base.send(:include, Enumerable)
+    
+    base.send(:alias_method, :values, :element_value)
+    base.send(:alias_method, :value, :element_value)
+        
+    base.send(:alias_method, :selected=, :element_value=)
+    base.send(:alias_method, :update_from_params, :element_value=)
+    base.send(:alias_method, :params=, :element_value=)  
+    base.send(:alias_method, :initial_value=, :element_value=) 
+    base.send(:alias_method, :update_value, :element_value=) 
+    base.send(:alias_method, :values=, :element_value=)
+    base.send(:alias_method, :value=, :element_value=) 
+    base.send(:alias_method, :binding=, :element_value=)
+    base.send(:alias_method, :bind_to, :element_value=)  
+  end
+  
+  def each(&block)
+    options.each(&block)
+  end
+
+  def recurse(&block)
+    options.each do |option|
+      if option.kind_of?(ActiveForm::Element::CollectionOptionGroup)
+        option.options.each(&block)
+      else
+        block.call(option)     
+      end
+    end
+  end
+
+  def element_name
+    elem_name = super
+    elem_name << '[]' if multiple?
+    elem_name
+  end
+
+  def element_value
+    multiple? ? [*super].compact.flatten : [*super].compact.first
+  end
+   
+  def element_value=(val)
+    super(cast_value(multiple? ? [*val].compact.flatten : val.respond_to?(:compact) ? [*val].compact.first : val))
+  end
+  
+  def default_value
+    multiple? ? [] : super
+  end
+  
+  def fallback_value=(value)
+    if multiple?   
+      @fallback_value = value.respond_to?(:to_a) ? value.to_a : [value].flatten
+    else
+      @fallback_value = [*value].compact.first
+    end
+  end
+  
+  def option_labels
+    results = []
+    self.recurse { |option| results << option.label }
+    results
+  end
+  
+  def option_values
+    results = []
+    self.recurse { |option| results << option.value }
+    results
+  end
+  
+  def valid_option?(value)
+    (option_values + [*fallback_value] + [*default_value]).compact.include?(value)
+  end
+  
+  def valid_value?
+    raw_values = [*element_value]
+    (raw_values & option_values).length == raw_values.length
+  end
+  
+  def options
+    @options ||= []
+  end
+ 
+  def options=(values)
+    reset_options!
+    add_options(values)
+  end
+  
+  def add_options(values)
+    values.each { |value| add_option(value) }
+  end
+  alias :append :add_options
+ 
+  def add_option(value)
+    if value.kind_of?(ActiveForm::Element::CollectionOption)
+      self.options << value
+    elsif (value.kind_of?(Array) || value.kind_of?(Set))
+      self.options << ActiveForm::Element::CollectionOption.new(value.first, value.last)
+    else
+      self.options << ActiveForm::Element::CollectionOption.new(value, value)
+    end
+    self
+  end
+  alias :<< :add_option
+  
+  def option(label, value = nil)
+    self << [label, (value || label)]
+  end
+  
+  def reset_options!
+    @options = []
+  end
+  
+  def empty_option=(label = '--')
+    add_empty_option(label)
+  end
+  alias :empty= :empty_option=
+ 
+  def add_empty=(value)
+    add_empty_option if value
+  end
+  
+  def add_empty_option(label = '--', value = :blank)
+    self.options.unshift(ActiveForm::Element::CollectionOption.new(label, value))
+  end
+  alias :add_empty :add_empty_option
+  
+  def add_optgroup(*args, &block)
+    self.options << ActiveForm::Element::CollectionOptionGroup.new(*args, &block)    
+  end
+  alias :option_group :add_optgroup
+
+  def select_first=(bool = true)
+    self.element_value = option_values.first if bool
+  end
+  alias :select_first :select_first=
+
+  def selected_value?(value)
+    multiple? ? (element_value || []).include?(value) : element_value == value
+  end
+  alias :selected? :selected_value?
+  
+  def selected_option_label
+    self.options.inject([]) { |ary, opt| ary << opt.label if selected_value?(opt.value); ary }.join(', ')
+  end
+  
+  def blank?
+    element_value.blank? || !valid_value?
+  end
+  
+  def required=(value)
+    if value.kind_of?(Numeric)
+      min_required = value.kind_of?(Numeric) ? value.to_i : 0 
+      max_required = min_required
+    elsif value.respond_to?(:first) && value.respond_to?(:last)
+      min_required = value.first.to_i
+      max_required = value.last.to_i
+    else
+      min_required = 0
+      max_required = 0
+    end
+    validate_with_count = (min_required > 0 || (min_required == 0 && max_required > 0)) 
+    self.option_flags[:required] = value.to_s.to_boolean || validate_with_count
+    if self.option_flags[:required]
+      if validate_with_count
+        validates_with_option_count :code => 'required', :range => (min_required..max_required)
+      else
+        validates_as_required
+      end
+    else
+      validators.delete_if { |v| v.code == 'required' }
+    end
+  end
+  
+end
+
+class ActiveForm::Element::CollectionOption
+  
+  attr_accessor :label, :value
+  
+  def initialize(label, value)
+    @label, @value = label.to_s, value
+  end
+    
+end
+
+class ActiveForm::Element::CollectionOptionGroup
+  
+  include ActiveForm::Mixins::CollectionElementMethods
+  
+  attr_accessor :label
+  
+  def initialize(label, options = [], &block)
+    @label = label.to_s
+    self.options = options
+    block.call(self) if block_given?
+  end
+  
+  def value
+    @options.collect(&:value)
+  end
+  
+end

data/lib/active_form/mixins/common_methods.rb

@@ -0,0 +1,350 @@
+module ActiveForm::Mixins::CommonMethods
+  
+  def self.included(base)    
+    base.send(:attr_reader, :name)
+    base.send(:attr_writer, :label, :description)
+    base.send(:attr_accessor, :group)
+    
+    base.send(:include, ActiveForm::Mixins::CssMethods)
+    base.send(:include, ActiveForm::Mixins::JavascriptMethods)
+    base.send(:include, ActiveForm::Mixins::ValidationMethods)
+        
+    base.send(:include, StubInstanceMethods)
+    base.send(:extend, StubClassMethods)
+    base.send(:extend, ClassMethods)
+  end
+  
+  def initialize(*args, &block)
+    setup
+    initialize_element(*args, &block)
+    after_initialize
+  end
+  
+  def setup
+    self.class.setup_method(self) if self.class.respond_to?(:setup_method)
+  end
+  
+  def after_initialize
+  end
+  
+  def rebuild!
+    after_initialize
+  end
+  
+  def definition?
+    self.class.definition?
+  end
+  
+  def element?
+    self.class.element?
+  end
+  
+  def container?
+    self.class.container?
+  end
+  
+  def group?
+    self.class.group?
+  end
+  
+  def is_element?(arg)
+    arg.respond_to?(:element?) && arg.element?
+  end
+  
+  def is_container?(arg)
+    arg.respond_to?(:container?) && arg.container?
+  end
+  
+  def blank?
+    element_value.blank?
+  end
+  
+  def option_flags
+    @option_flags ||= HashWithIndifferentAccess.new
+  end
+  
+  def option_flag_names
+    self.class.element_option_flag_names
+  end
+  
+  def option_flag_attributes
+    Hash.new
+  end
+  
+  def html_flags
+    @html_flags ||= HashWithIndifferentAccess.new
+  end
+  
+  def html_flag_names
+    self.class.element_html_flag_names
+  end
+  
+  def html_flag_attributes
+    html_flag_names.inject({}) { |attrs, flag| attrs[flag.to_s] = flag.to_s if send("#{flag}?"); attrs } 
+  end
+  
+  def render_input(builder = create_builder, wrapped = false)
+    render_call(builder, wrapped).call
+  end
+  alias :to_input :render_input
+  
+  def to_html(builder = create_builder, &block)
+    render_wrapper, wrapped = wrapper(&block)   
+    render_wrapper.call(builder, self, render_call(builder, wrapped))
+  end
+  alias :to_s :to_html
+  alias :to_element :to_html
+  
+  def render(builder = create_builder, &block)
+    html = "<!--o" + "[ #{identifier} ]".center(64, '-') + "o-->\n"
+    html << validation_advice.to_s
+    html << to_html(builder, &block)
+    html << script_tag
+    html << "<!--x" + "[ #{identifier} ]".center(64, '-') + "x-->\n"
+    html
+  end
+  
+  def display(builder = create_builder, &block)
+    puts render(builder, &block)
+  end
+  
+  def render_call(builder = create_builder, wrapped = false)
+    if wrapped
+      lambda do
+        skipclass = skip_css_class?
+        skipstyle = skip_css_style?
+        self.skip_css_class = true
+        self.skip_css_style = true
+        frozen? ? render_frozen(builder) : render_element(builder)
+        self.skip_css_class = skipclass
+        self.skip_css_style = skipstyle
+      end
+    else
+      lambda do 
+        frozen? ? render_frozen(builder) : render_element(builder) 
+      end
+    end
+  end
+  
+  def wrapper(&block)
+    if container? && !contained?
+      wrapper_name, default_name = :container_wrapper,  :default_container_wrapper    
+    else
+      wrapper_name, default_name = :element_wrapper,    :default_element_wrapper  
+    end
+    wrapped, wrapper = [true,   block                                   ] if block_given?
+    wrapped, wrapper = [true,   self.method_to_proc(wrapper_name)       ] if wrapper.nil? && self.respond_to?(wrapper_name)   
+    wrapped, wrapper = [true,   self.class.method_to_proc(wrapper_name) ] if wrapper.nil? && self.class.respond_to?(wrapper_name) 
+    wrapped, wrapper = [false,  self.class.method_to_proc(default_name) ] if wrapper.nil?
+    [wrapper, wrapped]
+  end
+
+  def define_container_wrapper(prc = nil, &block)
+    define_singleton_method(:container_wrapper, &(block_given? ? block : prc)) if container?
+  end
+  alias :container_wrapper= :define_container_wrapper
+
+  def reset_container_wrapper
+    undefine_singleton_method(:container_wrapper) rescue nil
+  end
+
+  def define_element_wrapper(prc = nil, &block)
+    define_singleton_method(:element_wrapper, &(block_given? ? block : prc))
+  end
+  alias :element_wrapper= :define_element_wrapper
+  
+  def reset_element_wrapper
+    undefine_singleton_method(:element_wrapper) rescue nil
+  end
+  
+  def value_to_identifier(value)
+    str = value.to_s.downcase.strip
+    str.gsub!(/\s+/, '_')
+    str.gsub!(/[\x00-\x1f]|[\xc0-\xfd][\x80-\xbf]+/) { "#{$&.unpack('U')[0]}" rescue '_' }
+    str.gsub!(/[^a-z0-9_]/, ' ')
+    str.gsub!(/^([\s_]+)/, '')
+    str.gsub!(/([\s_]+)$/, '')
+    str.gsub!(/\s+/, '_')
+    str.gsub!(/_{2,}/, '_')
+    str.strip
+  end
+  
+  module ClassMethods
+    
+    def definition?
+      self.kind_of?(ActiveForm::Definition)
+    end
+    
+    def element?
+      self.included_modules.include?(ActiveForm::Mixins::ElementMethods)
+    end
+  
+    def container?
+      self.included_modules.include?(ActiveForm::Mixins::ContainerMethods)
+    end
+    
+    def group?
+      false
+    end
+    
+    def define_html_flags(*flags)
+      skip_methods = (flags.last == false ? !flags.pop : false)
+      flags.flatten.each do |flag|        
+        self.element_html_flag_names += [flag.to_sym] 
+        unless skip_methods
+          define_method("#{flag}=")  { |value| self.html_flags[flag.to_sym] = value.to_s.to_boolean } unless instance_methods.include?("#{flag}=")
+          define_method("#{flag}?")  { self.html_flags[flag.to_sym] == true } unless instance_methods.include?("#{flag}?")
+          define_method("#{flag}")   { self.html_flags[flag.to_sym] } unless instance_methods.include?("#{flag}")
+        end
+      end
+    end
+    
+    def define_option_flags(*flags)
+      skip_methods = (flags.last == false ? !flags.pop : false)
+      flags.flatten.each do |flag|        
+        self.element_option_flag_names += [flag.to_sym] 
+        unless skip_methods
+          define_method("#{flag}=")  { |value| self.option_flags[flag.to_sym] = value.to_s.to_boolean } unless instance_methods.include?("#{flag}=")
+          define_method("#{flag}?")  { self.option_flags[flag.to_sym] == true } unless instance_methods.include?("#{flag}?")
+          define_method("#{flag}")   { self.option_flags[flag.to_sym] } unless instance_methods.include?("#{flag}")
+        end
+      end
+    end
+    
+    def default_container_wrapper(builder, elem, render)
+      render.call
+    end
+  
+    def define_container_wrapper(prc = nil, &block)
+      define_singleton_method(:container_wrapper, &(block_given? ? block : prc)) if container?
+    end
+    alias :container_wrapper= :define_container_wrapper
+  
+    def reset_container_wrapper
+      undefine_singleton_method(:container_wrapper) rescue nil
+    end
+  
+    def default_element_wrapper(builder, elem, render)
+      render.call
+    end
+      
+    def define_element_wrapper(prc = nil, &block)
+      define_singleton_method(:element_wrapper, &(block_given? ? block : prc))
+    end
+    alias :element_wrapper= :define_element_wrapper
+    
+    def reset_element_wrapper
+      undefine_singleton_method(:element_wrapper) rescue nil
+    end
+    
+  end
+  
+  module StubInstanceMethods
+    
+    def label
+      raise ActiveForm::StubException
+    end
+  
+    def title
+      raise ActiveForm::StubException
+    end
+  
+    def description
+      raise ActiveForm::StubException
+    end
+    
+    def initialize_element(*args)
+      raise ActiveForm::StubException
+    end
+    
+    def initialize_properties      
+    end
+    
+    def identifier
+      raise ActiveForm::StubException
+    end
+    
+    def element_name
+      raise ActiveForm::StubException
+    end
+    
+    def export_value
+      raise ActiveForm::StubException
+    end
+
+    def element_value
+      raise ActiveForm::StubException
+    end
+    
+    def element_value=(value)
+      raise ActiveForm::StubException
+    end
+    
+    def label_attributes
+      raise ActiveForm::StubException
+    end
+    
+    def render_label(builder = create_builder)
+      raise ActiveForm::StubException
+    end
+    
+    def render_frozen(builder = create_builder)
+      raise ActiveForm::StubException
+    end
+    
+    def render_element(builder = create_builder)
+      raise ActiveForm::StubException
+    end
+    
+    def frozen?
+      raise ActiveForm::StubException
+    end
+    
+    def hidden?
+      raise ActiveForm::StubException
+    end
+    
+    def disabled?
+      raise ActiveForm::StubException
+    end
+    
+    def required?
+      raise ActiveForm::StubException
+    end
+        
+    def contained?
+      raise ActiveForm::StubException
+    end
+    
+    def localized?
+      raise ActiveForm::StubException
+    end
+    
+    def localize(*args)
+      raise ActiveForm::StubException
+    end
+    
+    def create_builder
+      Builder::XhtmlMarkup.new(:indent => 2)
+    end
+    
+  end
+  
+  module StubClassMethods
+     
+    def create(*args, &block)
+      raise ActiveForm::StubException
+    end
+     
+    def setup(prc = nil, &block)
+      define_singleton_method(:setup_method, &(block_given? ? block : prc))
+    end
+    alias :setup_proc= :setup
+    
+    def reset_setup
+      undefine_singleton_method(:setup_method) rescue nil
+    end 
+     
+  end
+  
+end