formize 0.0.2

data/lib/formize/definition/element.rb

@@ -0,0 +1,56 @@
+module Formize
+
+  # Main class for Form definitions
+  # It permits to manage tree of form elements
+  class Element
+    attr_reader :parent, :children, :method_name, :id
+    @@count = 0
+
+    def initialize(parent = nil, is_method = false)
+      @parent = parent
+      @children = []
+      @is_method = is_method
+      @@count += 1
+      @id = @@count.to_s(36)
+      @method_name = "_formize_#{@id}"
+    end
+
+    def is_method?
+      @is_method
+    end
+
+    def is_method!(value = true)
+      raise ArgumentError.new("Must be true or false (not #{value.inspect})") unless [TrueClass, FalseClass].include?(value.class)
+      @is_method = value
+    end
+
+    def method_name=(name)
+      raise ArgumentError.new("Name of field_set must be written only with a-z and 0-9 and _ (not #{name.inspect})") unless name.to_s == name.to_s.downcase.gsub(/[^a-z0-9\_]/, '')
+      @method_name = name
+    end
+
+
+    def method_code(options={})
+      varh = options[:html_variable] ||= 'html'
+      code  = "def #{method_name}(record)\n"
+      code << inner_method_code(options).gsub(/^/, '  ')
+      code << "  return #{varh}\n"
+      code << "end\n"
+      return code
+    end
+
+    def method_call_code(options={})
+      return inner_method_code(options) unless self.is_method?
+      return "#{method_name}(record)"
+    end
+
+    def inner_method_code(options={})
+      # raise NotImplementedError.new
+      return content_tag(:strong, "'#{self.class.name} does not implement :#{__method__} method'", options)
+    end
+
+
+  end
+
+
+end

data/lib/formize/definition/field.rb

@@ -0,0 +1,67 @@
+module Formize
+
+
+  # Represents the field element
+  class Field < FormElement
+    attr_reader :name, :options, :column, :record_name, :method, :type, :required, :choices, :input_id, :source, :item_label, :field_id, :reflection, :html_options, :default, :search_attributes
+
+    TYPES = [:check_box, :choice, :date, :datetime, :label, :numeric, :password, :mono_choice, :string, :text_area].freeze
+
+    def initialize(form, parent, name, options={})
+      super(form, parent)
+      @name = name.to_s
+      @options = (options.is_a?(Hash) ? options : {})      
+      @column = form.model.columns_hash[@name]
+      @record_name = form.record_name
+      @method = @name
+      unless @options[:default].nil?
+        @default = (@options[:default].is_a?(String) ? Code.new(@options[:default]) : @options[:default])
+      end
+      @html_options = @options.delete(:html_options)||{}
+      @depend_on = @options.delete(:depend_on)
+      raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.fields[@depend_on].nil?
+      if type = @options.delete(:as)
+        raise ArgumentError.new("Unknown field type (got #{@options[:as].inspect}, expects #{TYPES.join(', ')})") unless TYPES.include? type
+        @type = type
+      else
+        @type = :password if @name.to_s.match /password/
+        if @choices = @options.delete(:choices)
+          if @choices.is_a? Array
+            @type = :choice 
+          elsif [Symbol, Hash].include? @choices.class
+            @type = :mono_choice 
+            @reflection = form.model.reflections[@method.to_sym]
+            @source = @options.delete(:source) # || @reflection.class_name
+            @is_method = true if @options[:new]
+            @method_name = self.form.unique_name + "_inf_" + @name
+            @method = @reflection.primary_key_name
+            unless @item_label = @options.delete(:item_label)
+              model = @reflection.class_name.constantize
+              available_methods = (model.columns_hash.keys+model.instance_methods).collect{|x| x.to_s}
+              @item_label = [:label, :name, :code, :number, :inspect].detect{|x| available_methods.include?(x.to_s)}
+            end
+            @search_attributes = @options[:search] || @reflection.class_name.constantize.content_columns.select{|c| c.type != :boolean and ![:created_at, :updated_at, :lock_version].include?(c.name.to_sym)}.collect{|c| c.name.to_sym}
+          else
+            raise ArgumentError.new("Option :choices must be Array, Symbol or Hash (got #{@choices.class.name})")
+          end
+        end
+        if column
+          @type = :check_box if column.type == :boolean
+          @type = :date if column.type == :date
+          @type = :datetime if column.type==:datetime or column.type==:timestamp
+          @type = :numeric if [:integer, :float, :decimal].include? column.type
+          @type = :text_area if column.type == :text
+        end
+        @type = :label if @form.model.readonly_attributes.include? @record_name
+        @type ||= :string
+      end
+      @required = false
+      @required = !@column.null if @column
+      @required = true if @options.delete(:required).is_a?(TrueClass)
+      @input_id = form.model.name.underscore << '_' << method.to_s
+      @field_id = "ff" << Time.now.to_i.to_s(36) << rand.to_s[2..-1].to_i.to_s(36)
+    end
+
+  end
+
+end

data/lib/formize/definition/field_set.rb

@@ -0,0 +1,40 @@
+module Formize
+
+
+
+  # Represents a group of fields which can depend on other fields
+  class FieldSet < FormElement
+    attr_reader :name, :options, :title, :html_options
+    
+    def initialize(form, parent, name=nil, options={})
+      super(form, parent)
+      @title = nil
+      @name = if name.blank?
+                rand.to_s[2..-1].to_i.to_s(36)
+              else
+                raise ArgumentError.new("Name of field_set must be written only with a-z and 0-9 and _ (not #{name.inspect})") unless name.to_s == name.to_s.downcase.gsub(/[^a-z0-9\_]/, '')
+                @title = name
+                name.to_s
+              end
+      @depend_on = options.delete(:depend_on)
+      raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.fields[@depend_on].nil?
+      @options = (options.is_a?(Hash) ? options : {})
+      @html_options = @options.delete(:html_options)||{}
+    end
+
+
+    def field_set(name=nil, options={}, &block)
+      raise ArgumentError.new("Missing block") unless block_given?
+      field_set = self.new_child(FieldSet, name, options)
+      yield field_set
+    end
+
+    def field(name, options={})
+      self.new_child(Field, name, options)
+    end
+
+  end
+
+
+
+end

data/lib/formize/definition/form.rb

@@ -0,0 +1,89 @@
+module Formize
+
+  # Represents an environment for a form or list of fields of one Record
+  class Form
+    attr_reader :model, :elements, :record_name, :unique_name, :options, :id
+    @@count = 0
+
+
+    def initialize(name, model, options={})
+      @name = name
+      @model = model
+      @options = options
+      @elements = []
+      @@count += 1
+      @id = @@count.to_s(36)
+      @unique_name = @options.delete(:unique_name) unless @options[:unique_name].blank?
+      @unique_name ||= "_formize#{@id}"
+      @record_name = @model.name.underscore
+    end
+
+    def field_set(name=nil, options={}, &block)
+      raise ArgumentError.new("Missing block") unless block_given?
+      field_set = new_element(FieldSet, name, options)
+      yield field_set
+    end
+
+    def field(name, options={})
+      return new_element(Field, name, options)
+    end
+    
+    # def inner_method_code(options={})
+    #   varh = options[:html_variable] || 'html'
+    #   code = "#{varh} = ''\n"
+    #   for child in children
+    #     code << "#{varh} << " << child.method_call_code << "\n"
+    #   end
+    #   code << "return #{varh}\n"
+    #   return code
+    # end
+
+    def controller_method_name
+      @options[:controller_method_name] || "formize_#{model.underscore}"
+    end
+
+    def view_method_name
+      @options[:method_name] || "_form_#{model.underscore}"
+    end
+
+    def action_name
+      @options[:action_name] || :formize
+    end
+
+    # def methodics
+    #   return elements.collect{|e| e.methodics}.flatten
+    # end
+
+    def mono_choices
+      return elements.collect{|e| e.mono_choices}.flatten
+    end
+
+    def fields
+      return elements.inject(HashWithIndifferentAccess.new){|h, e| h.merge!(e.fields)}
+    end
+
+    def dependents
+      return elements.collect{|e| e.dependents}.flatten
+    end
+
+    def all_elements
+      return elements.collect{|e| e.all_elements}.flatten
+    end
+
+    def dependents_on(element)
+      return elements.collect{|e| e.dependents_on(element)}.flatten
+    end
+
+
+    private
+
+    def new_element(klass, *args)
+      raise ArgumentError.new("Bad child type (#{klass.name}). Must be an Formize::FormElement") unless klass < FormElement
+      element = klass.new(self, nil, *args)
+      @elements << element
+      return element
+    end
+
+  end
+
+end

data/lib/formize/definition/form_element.rb

@@ -0,0 +1,140 @@
+module Formize
+    
+  # Main class for form elements
+  class FormElement
+    attr_reader :form, :parent, :children, :unique_name, :id, :depend_on, :html_id
+    @@count = 0
+
+    def initialize(form, parent = nil)
+      raise ArgumentError.new("Bad form (#{form.class.name}). Must be an Formize::Form") unless form.is_a? Formize::Form
+      @form = form
+      @parent = parent
+      @depend_on = nil
+      @children = []
+      @@count += 1
+      @id = @@count.to_s(36)
+      @html_id = "fz#{@id}"
+      @unique_name = self.form.unique_name + "_" + @html_id
+    end
+
+
+    def dependeds
+      l = (self.parent ? self.parent.dependeds : [])
+      l << {:name=>self.depend_on} unless self.depend_on.blank?
+      return l
+    end
+
+    def arguments
+      args = []
+      args << {:name=>form.record_name}
+      # args += self.dependeds
+      # args << {:name=>@depend_on} if @depend_on
+      return args
+    end
+
+    def prototype
+      return "#{@unique_name}(" + arguments.collect{|x| x[:name]}.join(', ') + ")"
+    end
+
+    # def method_name=(name)
+    #   raise ArgumentError.new("Name of field_set must be written only with a-z and 0-9 and _ (not #{name.inspect})") unless name.to_s == name.to_s.downcase.gsub(/[^a-z0-9\_]/, '')
+    #   @method_name = name
+    # end
+
+
+    # def method_code(options={})
+    #   varh = options[:html_variable] ||= 'html'
+    #   code  = "def #{method_name}(record)\n"
+    #   code << inner_method_code(options).gsub(/^/, '  ')
+    #   code << "  return #{varh}\n"
+    #   code << "end\n"
+    #   return code
+    # end
+
+    # def method_call_code(options={})
+    #   return inner_method_code(options) unless self.is_method?
+    #   return "#{method_name}(record)"
+    # end
+
+    # def inner_method_code(options={})
+    #   # raise NotImplementedError.new
+    #   return content_tag(:strong, "'#{self.class.name} does not implement :#{__method__} method'", options)
+    # end
+
+
+
+    # def is_method?
+    #   @depend_on.nil?
+    # end
+
+    # def methodics
+    #   elements = []
+    #   for child in self.children
+    #     elements += child.methodics
+    #   end
+    #   elements << self if self.is_method?
+    #   return elements
+    # end
+
+    def mono_choices
+      elements = []
+      for child in self.children
+        elements += child.mono_choices
+      end
+      elements << self if self.class == Formize::Field and self.type == :mono_choice
+      return elements      
+    end
+
+    def fields
+      elements = HashWithIndifferentAccess.new()
+      for child in self.children
+        elements.merge!(child.fields)
+      end
+      elements[self.name] = self if self.class == Formize::Field
+      return elements
+    end
+
+    def dependents
+      elements = []
+      for child in self.children
+        elements += child.dependents
+      end
+      elements << self if self.options[:depend_on]
+      return elements      
+    end
+
+    
+    def all_elements
+      elements = self.children.collect{|c| c.all_elements}.flatten
+      elements << self
+      return elements      
+    end
+
+
+    # Find form elements
+    def dependents_on(element)
+      elements = []
+      for child in self.children
+        elements += child.dependents_on(element)
+      end
+      elements << self if self.depend_on and self.depend_on.to_s == element.name.to_s # form.fields[self.depend_on].name == element.name
+      return elements
+    end
+
+
+
+
+    protected
+
+    def new_child(klass, *args)
+      raise ArgumentError.new("Bad child type (#{klass.name}). Must be an Formize::FormElement") unless klass < FormElement
+      element = klass.new(self.form, self, *args)
+      @children << element
+      return element
+    end
+
+
+  end
+
+
+end

data/lib/formize/definition.rb

@@ -0,0 +1,5 @@
+# require 'formize/definition/element'
+require 'formize/definition/form'
+require 'formize/definition/form_element'
+require 'formize/definition/field_set'
+require 'formize/definition/field'

data/lib/formize/form_helper.rb

@@ -0,0 +1,62 @@
+module Formize
+  module FormHelper
+
+    # Generates a form with all its fields as defined in controller.
+    # If no name is given, it uses the name of the controller to find the corresponding model
+    def formize_form(*args)
+      name, options = nil, {}
+      name = args[0] if args[0].is_a? Symbol
+      options = args[-1] if args[-1].is_a? Hash
+      self.send("_#{options[:controller]||self.controller_name}_#{__method__}_#{name||self.controller_name}_tag")
+    end
+
+    # Generates all the fields as defined in controller with the <form> tag.
+    # If no name is given, it uses the name of the controller to find the corresponding model
+    def formize_fields(*args)
+      name, options = nil, {}
+      name = args[0] if args[0].is_a? Symbol
+      options = args[-1] if args[-1].is_a? Hash
+      self.send("_#{options[:controller]||self.controller_name}_#{__method__}_#{name||self.controller_name}_tag")
+    end
+
+    # Permits to use content_tag in helpers with easy add
+    def hard_content_tag(name, options={}, escape=true, &block)
+      content = ''
+      yield content
+      return content_tag(name, content, options, escape)
+    end
+
+    # Returns a list of radio buttons for specified attribute (identified by +method+)
+    # on an object assigned to the template (identified by +object_name+). It works like +select+
+    def radio(object_name, method, choices, options = {}, html_options = {})
+      html = ""
+      html_options[:class] ||= :rad
+      for choice in choices
+        html << content_tag(:span, radio_button(object_name, method, choice[1]) + '&nbsp;'.html_safe + label(object_name, method, choice[0], :value=>choice[1]), html_options)
+      end
+      return html
+    end
+
+    # Returns a text field which has the same behavior of +select+ but  with a search 
+    # action which permits to find easily in very long lists...
+    def unroll(object_name, method, choices, options = {}, input_options={}, html_options = {})
+      object = instance_variable_get("@#{object_name}")
+      label = options[:label]
+      if label.is_a?(String) or label.is_a?(Symbol)
+        label = Proc.new{|x| x.send(label)}
+      elsif !label.is_a?(Proc)
+        label = Proc.new{|x| x.inspect}
+      end
+      html  = ""
+      html << hidden_field(object_name, method, input_options)
+      html << tag(:input, :type=>:text, "data-unroll"=>url_for(choices), "data-value-container"=>"#{object_name}_#{method}", :value=>label.call(object.send(method.to_s.gsub(/_id$/, ''))), :size=>html_options.delete(:size)||32)
+      return content_tag(:span, html, html_options)
+    end
+
+
+
+  end
+
+end
+
+ActionView::Base.send :include, Formize::FormHelper