formize 0.1.1 → 1.0.0

data/lib/formize.rb

@@ -15,6 +15,10 @@ module Formize
     end
   end
 
+  # Module used to "stock" labelling methods for items
+  module CompiledLabels
+  end
+
   extend ActiveSupport::Autoload
 
   def self.configure(name, value = nil) # :nodoc:
@@ -50,71 +54,7 @@ module Formize
   # How many select options can be displayed before to become a +unroll+
   configure :select_count_max, 7
 
-
-
-
-
-  # Compile a monolithic javascript file formize.js with all included
-  def self.compile!
-    # js_dir = Pathname.new(File.dirname(__FILE__)).join("..", "assets", "javascripts")
-    js_dir = File.join(File.dirname(__FILE__), "assets", "javascripts")
-    File.open("#{js_dir}/formize.js", "wb") do |js|
-
-      js.write "(function($) {\n"
-      for file in Dir.glob("#{js_dir}/locales/jquery.ui.datepicker*.js").sort
-        File.open(file, "rb") do |f|
-          source = f.read
-          source.gsub!("jQuery(function($){", '')
-          source.gsub!(/\/\*[^\*\/]*\*\//, '')
-          source.gsub!(/\$\.datepicker\.setDefaults\(\$\.datepicker\.regional\[\'\w\w(\-\w\w)?\'\]\)\;/, '')
-          source.gsub!("});", '')
-          source = source.strip.split(/\n/).collect{|l| l.strip}.join(" ").strip.sub(/^.*\$/, '$')
-          js.write source
-          # js.write f.read
-          js.write "\n"
-        end
-      end
-      js.write "})(jQuery);\n"
-
-
-      # File.open("#{js_dir}/jquery.ui.timepicker.js", "rb") do |f|
-      #   js.write f.read
-      #   js.write "\n"
-      # end
-
-
-      # js.write "(function($) {\n"
-      # for file in Dir.glob("#{js_dir}/locales/jquery.ui.timepicker*.js").sort
-      #   File.open(file, "rb") do |f|
-      #     source = f.read
-      #     source.gsub!("(function($) {", '')
-      #     source.gsub!(/\/\*[^\*\/]*\*\//, '')
-      #     source.gsub!(/\$\.timepicker\.setDefaults\(\$\.timepicker\.regional\[\'\w\w(\-\w\w)?\'\]\)\;/, '')
-      #     source.gsub!("})(jQuery)\;", '')
-      #     source = source.strip.split(/\n/).collect{ |l| l.gsub(/^\s*/, '')}.join(" ").sub(/^.*\$/, '$')
-      #     js.write source
-      #     js.write "\n"
-      #   end
-      # end
-      # js.write "})(jQuery);\n"
-
-
-      File.open("#{js_dir}/jquery.ui.formize.js", "rb") do |f|
-        js.write f.read
-        js.write "\n"
-      end
-    end
-
-  end
-
-
-
-
-
-
-
-  autoload :Definition
   autoload :Helpers
-  autoload :ActionController
   autoload :Generator
+  autoload :ActionController
 end

data/lib/formize/action_controller.rb

@@ -18,11 +18,13 @@ module Formize
           response.headers["X-Return-Code"] = "success"
           response.headers["X-Saved-Record-Id"] = resource.id.to_s
           format.html { params[:dialog] ? head(status) : redirect_to(options[:url] || resource) }
-          format.xml  { render :xml => resource, :status => status, :location => resource }
+          format.json { render :json => resource.to_json, :status => status, :location => resource}
+          format.xml  { render  :xml => resource.to_xml,  :status => status, :location => resource }
         else
           response.headers["X-Return-Code"] = "invalid"
           format.html { render :action => (resource.new_record? ? "new" : "edit")}
-          format.xml  { render :xml => resource.errors, :status => :unprocessable_entity }
+          format.json { render :json => resource.errors.to_json, :status => :unprocessable_entity }
+          format.xml  { render  :xml => resource.errors.to_xml,  :status => :unprocessable_entity }
         end
       end
     end
@@ -31,51 +33,78 @@ module Formize
     
     module ClassMethods
 
-      # Generates controller and view method working together
-      # This methods allows to develop dynamic forms without using partials
-      # and another action, only formize or formize_*.
-      def formize(*args, &block)
-        name, options = nil, {}
-        name = args[0] if args[0].is_a? Symbol
-        options = args[-1] if args[-1].is_a? Hash
-        name ||= self.controller_name.to_sym
-        model = (options[:model]||name).to_s.classify.constantize
-        options[:controller_method_name] = "formize#{'_'+name.to_s if name != self.controller_name.to_sym}"
-        options[:view_form_method_name]   = "_#{self.controller_name}_formize_form_#{name}_tag"
-        options[:view_fields_method_name] = "_#{self.controller_name}_formize_fields_#{name}_tag"
-        options[:method_name] = options[:view_fields_method_name]
-        options[:best_name] = "#{self.controller_name}#{'_'+name.to_s if name != self.controller_name.to_sym}"
-        form = Formize::Definition::Form.new(name, model, options)
-        if block_given?
-          yield form
-        else
-          formize_by_default(form)
-        end
-        generator = Formize::Generator::Base.new(form, self)
-        class_eval(generator.controller_code, "#{__FILE__}:#{__LINE__}")
-        ActionView::Base.send(:class_eval, generator.view_code, "#{__FILE__}:#{__LINE__}")
-      end
-
-      private
-
-      # Generates list of usable field 
-      def formize_by_default(form)
-        form.field_set(:general) do |f|
-          for column in form.model.columns
-            next if column.name =~ /_count$/ or [:id, :created_at, :updated_at, :lock_version, :type, :creator_id, :updater_id].include?(column.name.to_sym)
-            if column.name =~ /_id$/
-              reflections = form.model.reflections.select{ |k, x| x.send(Formize.foreign_key).to_s == column.name.to_s }
-              if reflections.size == 1
-                f.field(column.name.gsub(/_id$/, ''), :choices=>:all, :source=>:foreign_class, :new=>true)
-                # elsif reflections.size > 1 # AMBIGUITY
-                # elsif reflections.size < 1 # NOTHING
-              end
-            else
-              f.field(column.name)
-            end
-          end
+      # Generates a default action which is the resource for a unroll box.
+      # It generates an helper which takes in account selected columns for displaying.
+      # The label used to display items is based on the used columns. These columns can be
+      # used with I18n. The key used is: +views.unroll.<controller>.<action>+
+      # 
+      # @macro [new] options_details
+      #   @param [Hash] options Options to build controller action
+      #   @option options [Array] :columns The columns which are used for search and display
+      #     All the content columns are used by default.
+      #     A column can be a Symbol/String with its name or Hash with keys (+:name+,
+      #     +:filter+, +:interpolation_key+)
+      #   @option options [Array,Hash] :conditions Default conditions used in the search query
+      #   @option options [String, Hash, Array] :joins To make a join like in +find+
+      #   @option options [Integer] :limit (80) Maximum count of items in results
+      #   @option options [String] :partial Specify a partial for HTML autocompleter
+      #   @option options [String] :filter ('%X%') Filter format used to build search query. 
+      #     Specific filters can be specified for each column. 
+      #
+      # @overload search_for(name, model, options={})
+      #   Defines a controller method +search_for_NAME+ which searches for records
+      #   of the class +MODEL+.
+      #   @param [Symbol] name Name of the datasource
+      #   @param [String, Symbol] name Name of the model to use for searching
+      #   @macro options_details
+      #
+      # @overload search_for(name, options={})
+      #   Defines a controller method +search_for_NAME+ which searches for records
+      #   of the class +NAME+.
+      #   @param [Symbol] name
+      #     Name of the datasource. This name is used to find the model name
+      #   @macro options_details
+      #
+      # @overload search_for(options={})
+      #   Defines a controller method +search_for+ which searches for records corresponding to the
+      #   resource controller name. +OrdersController#search_for+ searches for orders.
+      #   @macro options_details
+      #
+      # @example Search clients with Person model
+      #   # app/controller/orders_controller.rb
+      #   class OrdersController < ApplicationController
+      #     ...
+      #     search_for :clients, :person
+      #     ...
+      #   end
+      # 
+      # @example Search all accounts where name contains search and number starts with search
+      #   # app/controller/orders_controller.rb
+      #   class PeopleController < ApplicationController
+      #     ...
+      #     search_for :accounts, :columns=>[:name, 'number:X%']
+      #     ...
+      #   end
+      #   
+      # @example Search for orders among all others
+      #   # app/controller/orders_controller.rb
+      #   class OrdersController < ApplicationController
+      #     ...
+      #     search_for
+      #     ...
+      #   end
+      def search_for(*args)
+        options = args.delete_at(-1) if args[-1].is_a? Hash
+        name, model = args[0], args[1]
+        action_name = "#{__method__}#{'_'+name.to_s if name}"
+        model = model || name || controller_name
+        if [String, Symbol].include?(model.class)
+          model = model.to_s.classify.constantize             
         end
-        return form
+        return unless model.table_exists?
+        generator = Generator::Base.new(self, action_name, model, options)
+        class_eval(generator.controller_action, "#{__FILE__}:#{__LINE__}")
+        Formize::CompiledLabels.send(:class_eval, generator.item_label_code, "#{__FILE__}:#{__LINE__}")
       end
 
     end

data/lib/formize/generator.rb

@@ -1,494 +1,206 @@
 module Formize
+  module Generator
 
-  # Permits to not quote text in inspect method
-  class Code < String # :nodoc:
-
-    def inspect
-      self.to_s
-    end
-
-  end
+    class Column
+      attr_reader :name, :filter, :interpolation_key, :column
+
+      # @@count = 0
+
+      def initialize(model, name, options={})
+        @model = model
+        @name = name.to_s
+        @filter = options.delete(:filter) || "%X%"
+        @code = options.delete(:code)
+        @interpolation_key = options.delete(:interpolation_key) || @name.gsub(/\W/, '_')
+        klass = @model
+        @through = (options.delete(:through) || []).collect do |reflection|
+          unless klass.reflections[reflection.to_sym]
+            raise Exception.new("Model #{klass.name} has no reflections #{reflection.inspect}")
+          end
+          klass = klass.reflections[reflection.to_sym].class_name.constantize
+          reflection.to_sym
+        end || []
+        @column = foreign_model.columns_hash[@name]
+      end
+
+      def sql_name
+        return "#{foreign_model.table_name}.#{@name}"
+      end
+
+      def value_code(record='record')
+        code  = "("
+        value = "(#{record}#{'.'+@through.join('.') unless @through.empty?}.#{name})"
+        @through.each_index do |i|
+          code << "#{record}.#{@through[0..i].join('.')}.nil? ? '' : "
+        end
+        code << if @code
+                  @code.gsub(/RECORD/, record).gsub(/DATUM/, value)
+                elsif[:date, :datetime, :timestamp].include? self.type
+                  "(#{value}.nil? ? '' : ::I18n.localize(#{value}))"
+                else
+                  value
+                end
+        code << ")"
+        code << ".to_s" unless name.to_s == "count"
+        return code
+      end
 
-  module Generator
-    class Base
-      
-      attr_accessor :form, :elements, :record_name, :partial, :controller
+      def type
+        @column.type
+      end
 
-      def initialize(form, controller)
-        @form = form
-        @controller = controller
-        @record_name = @form.record_name
-        @elements = form.all_elements
-        @partials = @elements.select{|e| !e.depend_on.nil? or e.options[:new]}
+      def foreign_model
+        model = @model
+        for reflection in @through
+          model = model.reflections[reflection].class_name.constantize
+        end
+        return model
       end
 
+    end
+
 
-      # Generates the controller method from a form object
-      def controller_code
-        code  = "def #{form.controller_method_name}\n"
+    class Base
 
-        # Mono_choice search/filter
-        items = form.mono_choices
-        if items.size > 0
-          code << "  if params[:unroll]\n"
-          events = form.mono_choices.collect do |mono_choice|
-            event = "if params[:unroll] == '#{mono_choice.html_id}'\n"
+      attr_accessor :action_name, :controller, :options
 
-            for depended in mono_choice.dependeds
-              df = form.all_fields[depended[:name]]
-              event << "  #{df.name} = " << (df.reflection.nil? ? "params[:#{df.input_id}]" : "#{df.reflection.class_name}.find_by_id(params[:#{df.input_id}])") << "\n"
-              # locals[df.name.to_sym] = Code.new(df.name)
-            end
+      def initialize(controller, action_name, model, options={})
+        @controller = controller
+        @action_name = action_name.to_sym
+        @options = (options.is_a?(Hash) ? options : {})
+        @model = model
+        columns = @options.delete(:columns)
+        columns ||= @model.content_columns.collect{|x| x.name.to_sym}.delete_if{|c| [:lock_version, :created_at, :updated_at].include?(c)}
+        columns = [columns] unless columns.is_a? Array
+        # Normalize columns
+        @columns = columns.collect do |c| 
+          c = c.to_s.split(/\:/) if [String, Symbol].include? c.class
+          c = if c.is_a? Hash
+                Column.new(@model, c.delete(:name), c)
+              elsif c.is_a? Array
+                sliced = c[0].split('.')
+                Column.new(@model, sliced[-1], :filter=>c[1], :interpolation_key=>c[2], :through=>sliced[0..-2])
+              else
+                raise Exception.new("Bad column: #{c.inspect}")
+              end
+          c
+        end
+      end
+
+
+
+      def controller_code()
+        foreign_record  = @model.name.underscore
+        foreign_records = foreign_record.pluralize
+        foreign_records = "many_#{foreign_records}" if foreign_record == foreign_records
 
-            event << mono_choice_search_code(mono_choice).strip.gsub(/^/, '  ') << "\n"
-            event << "end\n"
+        query = []
+        parameters = ''
+        initial_conditions = ""
+        if @options[:conditions].is_a? Hash
+          @options[:conditions].each do |key, value| 
+            query << (key.is_a?(Symbol) ? @model.table_name+"."+key.to_s : key.to_s)+'=?'
+            parameters += ', ' + sanitize_conditions(value)
           end
-          code << events.collect{|e| e.gsub(/^/, '    ')}.join
-          code << "  end\n"
-        end
-        
-        # Dependencies refresh
-        items = @partials
-        if items.size > 0
-          code << "  if params[:refresh]\n"
-          code << "    #{record_name}   = #{form.model.name}.find(params[:id]) if params[:id].to_i > 0\n"
-          code << "    #{record_name} ||= #{form.model.name}.new\n"
-          code << "    @#{record_name} = #{record_name}\n"
-          events = items.collect do |dependent|
-            event  = "if params[:refresh] == '#{dependent.html_id}'\n"
-            locals = {record_name.to_sym => Code.new(record_name)}
-            for depended in dependent.dependeds
-              df = form.all_fields[depended[:name]]
-              event << "  #{record_name}.#{df.name} = " << (df.reflection.nil? ? "params[:#{df.input_id}]" : "#{df.reflection.class_name}.find_by_id(params[:#{df.input_id}])") << "\n"
-              # locals[df.name.to_sym] = Code.new(df.name)
-            end
-            if dependent.is_a?(Formize::Definition::Field) and dependent.reflection
-              event << "  #{record_name}.#{dependent.reflection.send(Formize.foreign_key)} = params[:selected].to_i if params[:selected]\n"
-            end
-            event << "  render(:inline=>'<%=#{dependent.prototype}-%>', :locals=>#{locals.inspect})\n"
-            event << "end\n"
+          initial_conditions = query.join(' AND ').inspect+parameters
+        elsif @options[:conditions].is_a? Array
+          conditions = @options[:conditions]
+          if conditions[0].is_a?(String)  # SQL
+            query << conditions[0].to_s
+            parameters += ', '+conditions[1..-1].collect{|p| sanitize_conditions(p)}.join(', ') if conditions.size>1
+          else
+            raise Exception.new("First element of an Array can only be String or Symbol.")
           end
-          code << events.collect{|e| e.gsub(/^/, '    ')}.join
-          code << "  end\n"
+          initial_conditions = query.join(' AND ').inspect+parameters
+        elsif @options[:conditions].is_a? String
+          initial_conditions = "("+@options[:conditions].gsub(/\s*\n\s*/, ';')+")"
+        elsif !@options[:conditions].blank?
+          raise ArgumentError.new("Option :conditions can be a Hash, an Array or String (not #{@options[:conditions].class}:#{@options[:conditions].inspect})")
         end
         
-        # End
-        code << "end\n"  
-        code.gsub!(/end\s*if/, 'elsif')
-        # raise code
-        # list = code.split("\n"); list.each_index{|x| puts((x+1).to_s.rjust(4)+": "+list[x])}
-        return code
-      end
-
-
-
-      # Generates the view method from a form object
-      def view_code
         code  = ""
-
-        varh = 'html'
-
-        # Build view methods assimilated to partials
-        for element in @partials
-          code << "# #{element.class.name}: #{element.html_id}/#{element.name}\n"
-          code << view_method_code(element, varh)
-        end
-
-
-        code << "\n"
-        code << "def #{form.options[:view_fields_method_name]}(#{form.record_name}=nil)\n"
-        code << "  #{form.record_name} = @#{form.record_name} unless #{form.record_name}.is_a?(#{form.model.name})\n"
-        code << "  #{varh} = ''\n"
-        code << "  with_custom_field_error_proc do\n"
-        for element in form.elements
-          code << view_method_call(element, varh).strip.gsub(/^/, '    ') << "\n"
+        code << "search, conditions = params[:term], []\n"
+        code << "if params[:id].to_i > 0\n"
+        code << "  conditions[0] = '#{@model.table_name}.id = ?'\n"
+        code << "  conditions << params[:id].to_i\n"
+        code << "else\n"
+        code << "  words = search.to_s.mb_chars.downcase.strip.normalize.split(/[\\s\\,]+/)\n"
+        code << "  if words.size > 0\n"
+        code << "    conditions[0] = '('\n"
+        code << "    words.each_index do |index|\n"
+        code << "      word = words[index].to_s\n"
+        code << "      conditions[0] << ') AND (' if index > 0\n"
+        if ActiveRecord::Base.connection.adapter_name == "MySQL"
+          code << "      conditions[0] << "+@columns.collect{|column| "LOWER(CAST(#{column.sql_name} AS CHAR)) LIKE ?"}.join(' OR ').inspect+"\n"
+        else
+          code << "      conditions[0] << "+@columns.collect{|column| "LOWER(CAST(#{column.sql_name} AS VARCHAR)) LIKE ?"}.join(' OR ').inspect+"\n"
         end
-        code << "  end\n"
-        code << "  return #{varh}.html_safe\n"
-        code << "end\n"
-
-        code << "\n"
-        code << "def #{form.options[:view_form_method_name]}(#{form.record_name}=nil)\n"
-        code << "  #{form.record_name} = @#{form.record_name} unless #{form.record_name}.is_a?(#{form.model.name})\n"
-        code << "  #{varh} = ''\n"
-        code << "  if #{form.record_name}.errors.any?\n"
-        code << "    #{varh} << hard_content_tag(:div, :class=>'errors') do |fe|\n"
-        code << "      fe << content_tag(:h2, ::I18n.translate('activerecord.errors.template.body', :count=>#{form.record_name}.errors.size))\n"
-        code << "      if #{form.record_name}.errors[:base].any?\n"
-        code << "        fe << '<ul>'\n"
-        code << "        for error in #{form.record_name}.errors[:base]\n"
-        code << "          fe << content_tag(:li, error)\n"
-        code << "        end\n"
-        code << "        fe << '</ul>'\n"
-        code << "      end\n"
+        code << "      conditions += ["+@columns.collect{|column| column.filter.inspect.gsub('X', '"+word+"').gsub(/(^\"\"\+|\+\"\"\+|\+\"\")/, '')}.join(", ")+"]\n"
         code << "    end\n"
+        code << "    conditions[0] << ')'\n"
         code << "  end\n"
-        code << "  #{varh} << form_for(#{form.record_name}, :html=>(params[:dialog] ? {'data-dialog'=>params[:dialog]} : {})) do\n"
-        code << "    concat(#{form.options[:view_fields_method_name]}(#{form.record_name}))\n"
-        code << "    concat(submit_for(#{form.record_name}))\n"
-        code << "  end\n"
-        code << "  return #{varh}.html_safe\n"
         code << "end\n"
 
-        # raise code
-        # list = code.split("\n"); list.each_index{|x| puts((x+1).to_s.rjust(4)+": "+list[x])}
-        return code
-      end
-      
-
-
-
-      
-      def view_partial_code(element, varh='varh')
-        # send("#{element.class.name.split('::')[-1].underscore}_#{__method__}", element, varh)
-        special_method = "#{element.class.name.split('::')[-1].underscore}_#{__method__}".to_sym
-        code = ""
-        partial_code = send(special_method, element, varh)
-        dependeds = element.dependeds.collect{|d| d[:name]}
-        if dependeds.size > 0
-          for depended in dependeds
-            depended_field = form.all_fields[depended]
-            code << "#{depended_field.name} = #{form.record_name}.#{depended_field.name}\n"
-            if depended_field.reflection
-              code << "#{depended_field.name} ||= #{field_datasource(depended_field)}.first\n"
-            end
-          end
-
-          code << "if #{dependeds.join(' and ')}\n"
-
-          code << partial_code.strip.gsub(/^/, '  ') << "\n"
+        joins = (@options[:joins] ? ".joins(#{@options[:joins].inspect}).includes(#{@options[:joins].inspect})" : "")
+        order = (@options[:order] ? ".order(#{@options[:order].inspect})" : ".order("+@columns.collect{|c| "#{c.sql_name} ASC"}.join(', ').inspect+")")
+        limit = ".limit(#{@options[:limit]||80})"
 
-          code << "else\n"
-          code << "  #{varh} << content_tag(:div, '', #{wrapper_attrs(element).inspect})\n"
-          code << "end\n"
-        else
-          code = partial_code
-        end
-
-        # General condition
-        if element.options[:if]
-          code = "if #{options[:if]}\n"+code.strip.gsub(/^/, '  ')+"\nend\n"
-        elsif element.options[:unless]
-          code = "unless #{options[:unless]}\n"+code.strip.gsub(/^/, '  ')+"\nend\n"
-        end
-        return code
-      end
+        partial = @options[:partial]
 
-      def view_method_code(element, varh='varh')
-        # send("#{element.class.name.split('::')[-1].underscore}_#{__method__}", element, varh)
-        special_method = "#{element.class.name.split('::')[-1].underscore}_#{__method__}".to_sym
-        return send(special_method, element, varh) if self.respond_to?(special_method)
-        code  = "def #{element.prototype}\n"
-        code << "  #{varh} = ''\n"
-        code << view_partial_code(element, varh).strip.gsub(/^/, '  ') << "\n"
-        code << "  return #{varh}.html_safe\n"
-        code << "end\n"
-        return code
-      end
-
-      def view_method_call(element, varh='varh')
-        special_method = "#{element.class.name.split('::')[-1].underscore}_#{__method__}".to_sym
-        return send(special_method, element, varh) if self.respond_to?(special_method)
-        if @partials.include?(element)
-          return "#{varh} << #{element.prototype}\n"
+        html  = "<ul><% for #{foreign_record} in #{foreign_records} -%><li id='<%=#{foreign_record}.id-%>'>" 
+        html << "<% content = item_label_for_#{@action_name}_in_#{@controller.controller_name}(#{foreign_record})-%>"
+        if partial
+          html << "<%=render(:partial=>#{partial.inspect}, :locals =>{:#{foreign_record}=>#{foreign_record}, :content=>content, :search=>search})-%>"
         else
-          return view_partial_code(element, varh).strip << "\n"
-        end
-      end
-
-      def wrapper_attrs(element)
-        html_options = (element.respond_to?(:html_options) ? element.html_options.dup : {})
-        html_options[:id] = element.html_id
-        if element.options[:hidden_if]
-          field = form.all_fields[element.options[:hidden_if]]
-          raise ArgumentError.new("Option :hidden_if must reference a check_box field (Not #{field.type.inspect})") unless field.type == :check_box
-          html_options['data-hidden-if'] = field.input_id
-        elsif element.options[:shown_if]
-          field = form.all_fields[element.options[:shown_if]]
-          raise ArgumentError.new("Option :shown_if must reference a check_box field (Not #{field.type.inspect})") unless field.type == :check_box
-          html_options['data-shown-if'] = field.input_id
-        end
-        if @partials.include?(element)
-          url = {:controller => controller.controller_name.to_sym, :action=>form.action_name.to_sym, :refresh=>element.html_id}
-          # for depended in element.dependeds
-          #   df = form.all_fields[depended[:name]]
-          #   # url[df.input_id.to_sym] = Code.new(df.reflection.nil? ? df.name : "#{df.name}.id")
-          # end
-          html_options["data-refresh"] = Code.new("url_for(#{url.inspect})")
+          html << "<%=highlight(content, search)-%>"
         end
-        special_method = "#{element.class.name.split('::')[-1].underscore}_#{__method__}".to_sym
-        return send(special_method, element, html_options) if self.respond_to?(special_method)      
-        return html_options
-      end
-
-      #####################################################################################
-      #                         F I E L D _ S E T     M E T H O D S                       #
-      #####################################################################################
-
-      def group_view_partial_code(group, varh='varh')
-        # Initialize html attributes
-        html_options = wrapper_attrs(group)
+        html << '</li><%end-%></ul>'
 
-        varc = group.html_id # "group_#{group.html_id}"
-        code  = "#{varh} << hard_content_tag(:div, #{html_options.inspect}) do |#{varc}|\n"
-        for child in group.children
-          code << view_method_call(child, varc).strip.gsub(/^/, '  ') << "\n"
-        end
+        code << "#{foreign_records} = #{@model.name}"
+        code << ".where(#{initial_conditions})" unless initial_conditions.blank?
+        code << ".where(conditions)"+joins+order+limit+"\n"
+        # Render HTML is old Style
+        code << "respond_to do |format|\n"
+        code << "  format.html { render :inline=>#{html.inspect}, :locals=>{:#{foreign_records}=>#{foreign_records}, :search=>search} }\n"
+        code << "  format.json { render :json=>#{foreign_records}.collect{|#{foreign_record}| {:label=>#{item_label(foreign_record)}, :id=>#{foreign_record}.id}}.to_json }\n"
+        code << "  format.yaml { render :yaml=>#{foreign_records}.collect{|#{foreign_record}| {'label'=>#{item_label(foreign_record)}, 'id'=>#{foreign_record}.id}}.to_yaml }\n"
+        code << "  format.xml  { render :xml=>#{foreign_records}.collect{|#{foreign_record}| {:label=>#{item_label(foreign_record)}, :id=>#{foreign_record}.id}}.to_xml }\n"
         code << "end\n"
         return code
       end
-      
 
-      def field_set_view_partial_code(field_set, varh='varh')
-        # Initialize html attributes
-        html_options = wrapper_attrs(field_set)
 
-        varc = field_set.html_id # "field_set_#{field_set.html_id}"
-        code  = "#{varh} << hard_content_tag(:fieldset, #{html_options.inspect}) do |#{varc}|\n"
-        unless field_set.title.nil?
-          code << "  #{varc} << content_tag(:legend, ::I18n.translate('labels.#{field_set.title}'))\n"
-        end
-        for child in field_set.children
-          code << view_method_call(child, varc).strip.gsub(/^/, '  ') << "\n"
-        end
+      def controller_action()
+        code  = "def #{@action_name}\n"
+        code << self.controller_code.strip.gsub(/^/, '  ')+"\n"
         code << "end\n"
+        # list = code.split("\n"); list.each_index{|x| puts((x+1).to_s.rjust(4)+": "+list[x])}
         return code
       end
 
-      #####################################################################################
-      #                             F I E L D     M E T H O D S                           #
-      #####################################################################################
-      
-      def field_view_partial_code(field, varh='varh')
-        input_attrs = (field.options[:input_options].is_a?(Hash) ? field.options[:input_options] : {})
-        # deps = form.dependents_on(field)
-        # if deps.size > 0
-        #   input_attrs["data-dependents"] = deps.collect{|d| "##{d.html_id}"}.join(',') 
-        # end
-        for method, name in {:dependents_on=>"dependents", :shown_if=>"show", :hidden_if=>"hide"}
-          elements = form.send(method, field)
-          if elements.size > 0
-            input_attrs["data-#{name}"] = elements.collect{|d| "##{d.html_id}"}.join(',')
-          end
-        end
-
-        # Initialize html attributes
-        html_options = wrapper_attrs(field)
 
-        varc = field.html_id
-        code  = "#{varh} << hard_content_tag(:table, #{html_options.inspect}) do |#{varc}|\n"
-        code << "  #{varc} << '<tr><td class=\"label\">'\n"
-        code << "  #{varc} << label(:#{form.record_name}, :#{field.name}, nil, :class=>'attr')\n"
-        code << "  #{varc} << '</td><td class=\"input\">'\n"
-        code << "  #{form.record_name}.#{field.name} ||= (#{Code.new(field.default)})\n" if field.default
-        code << self.send("field_#{field.type}_input", field, input_attrs, varc).strip.gsub(/^/, '  ') << "\n"
-        code << "  if @#{form.record_name}.errors['#{field.name}'].any?\n"
-        code << "    #{varc} << '<ul class=\"inline-errors\">'\n"
-        code << "    for error in @#{form.record_name}.errors['#{field.name}']\n"
-        code << "      #{varc} << content_tag(:li, error)\n"
-        code << "    end\n"
-        code << "    #{varc} << '</ul>'\n"
+      def item_label_code()
+        record = 'record'
+        code  = "def self.item_label_for_#{@action_name}_in_#{@controller.controller_name}(#{record})\n"
+        code << "  if #{record}.is_a? #{@model.name}\n"
+        code << "    return #{item_label(record)}\n"
+        code << "  else\n"
+        code << "    return ''\n"
         code << "  end\n"
-        code << "  #{varc} << '</td></tr>'\n"
-        code << "end\n"
-        return code
-      end
-
-      def field_datasource(field)
-        source = field.source
-        source = Formize.default_source unless [Array, String, Symbol].include?(source.class)
-        if source.is_a?(Array)
-          return "#{source[0]}.#{field.choices}"
-        elsif source == :foreign_class
-          # return field.reflection.class_name if field.choices.to_s == "all"
-          return "#{field.reflection.class_name}.#{field.choices}"
-        elsif source == :class
-          # return form.model.name if field.choices.to_s == "all"
-          return "#{form.model.name}.#{field.choices}"
-        else
-          return "#{source}.#{field.choices}"
-        end
-      end
-      
-      # Returns the name of the class of the source
-      # 
-      def field_datasource_class_name(field)
-        source = field.source
-        source = Formize.default_source unless [Array, String, Symbol].include?(source.class)
-        if source.is_a?(Array)
-          return source[1]
-        elsif source == :foreign_class
-          return field.reflection.class_name
-        elsif source == :class
-          return form.model.name
-        else
-          return source.to_s.classify
-        end
-      end
-      
-      def field_input_options(field)
-      end
-
-      def field_wrapper_attrs(field, html_options={})
-        html_options[:class] = "fz field #{html_options[:class]}".strip
-        html_options[:class] = "#{html_options[:class]} #{field.type.to_s.gsub('_', '-')}".strip
-        html_options[:class] = "#{html_options[:class]} required".strip if field.required
-        html_options[:class] = Code.new("\"#{html_options[:class]}\#{' invalid' if @#{field.form.record_name}.errors['#{field.name}'].any?}\"")
-        return html_options
-      end
-
-
-
-
-      def field_check_box_input(field, attrs={}, varc='varc')
-        return "#{varc} << check_box(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_choice_input(field, attrs={}, varc='varc')
-        code = if field.choices.size <= Formize.radio_count_max
-                 field_radio_input(field, attrs, varc)
-               else
-                 field_select_input(field, attrs, varc)
-               end
-        return code
-      end
-
-      def field_date_input(field, attrs={}, varc='varc')
-        attrs[:size] ||= 10
-        return "#{varc} << date_field(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_datetime_input(field, attrs={}, varc='varc')
-        attrs[:size] ||= 16
-        # TODO define Date format
-        return "#{varc} << datetime_field(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_label_input(field, attrs={}, varc='varc')
-        attrs[:class] = (attrs[:class]+" readonly").strip
-        return "#{varc} << content_tag(:span, @:#{field.record_name}.#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_numeric_input(field, attrs={}, varc='varc')
-        attrs[:size] ||= 16
-        return "#{varc} << text_field(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_password_input(field, attrs={}, varc='varc')
-        attrs[:size] ||= 24
-        return "#{varc} << password_field(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_radio_input(field, attrs={}, varc='varc')
-        return "#{varc} << radio(:#{field.record_name}, :#{field.method}, #{field.choices.inspect}, #{attrs.inspect})\n"
-        # return "#{varc} << " << field.choices.collect{|x| "content_tag(:span, radio_button(:#{field.record_name}, :#{field.method}, #{x[1].inspect}) << ' ' << content_tag(:label, #{x[0].inspect}, :for=>'#{field.input_id}_#{x[1]}'), :class=>'rad')"}.join(" << ") << "\n"
-      end
-
-      def field_select_input(field, attrs={}, varc='varc')
-        if (include_blank = attrs.delete(:include_blank)).is_a? String
-          field.choices.insert(0, [include_blank, ''])
-        end
-        return "#{varc} << select(:#{field.record_name}, :#{field.method}), #{field.choices.inspect}, #{attrs.inspect})\n"
-      end
-
-      def field_mono_choice_input(field, attrs={}, varc='varc')
-        source_model = field_datasource_class_name(field).constantize
-        reflection = source_model.reflections[field.choices]
-        # if reflection.nil?
-        #   raise Exception.new("#{source_model.name} must have a reflection :#{field.choices}.")
-        # end
-        count = "#{field.choices}_count"
-        select_first_if_empty = "  #{record_name}.#{field.name} ||= #{field_datasource(field)}.first\n"
-        code  = "#{count} = #{field_datasource(field)}.count\n"
-        code << "if (#{count} == 0)\n"
-        code << field_mono_select_input(field, attrs, varc).strip.gsub(/^/, '  ') << "\n"
-        code << "elsif (#{count} <= #{Formize.radio_count_max})\n"
-        code << select_first_if_empty
-        code << field_mono_radio_input(field, attrs, varc).strip.gsub(/^/, '  ') << "\n"
-        if !reflection or (reflection and reflection.options[:finder_sql].nil?)
-          code << "elsif (#{count} <= #{Formize.select_count_max})\n"
-          code << select_first_if_empty
-          code << field_mono_select_input(field, attrs, varc).strip.gsub(/^/, '  ') << "\n"
-          code << "else\n"
-          code << select_first_if_empty
-          code << field_mono_unroll_input(field, attrs, varc).strip.gsub(/^/, '  ') << "\n"
-        else
-          code << "else\n"
-          code << select_first_if_empty
-          code << field_mono_select_input(field, attrs, varc).strip.gsub(/^/, '  ') << "\n"
-        end
         code << "end\n"
-        
-        new_item_url = field.options.delete(:new)
-        if new_item_url.is_a? Symbol
-          new_item_url = {:controller=>new_item_url.to_s.pluralize.to_sym} 
-        elsif new_item_url.is_a? TrueClass
-          new_item_url = {}
-        end
-
-        if new_item_url.is_a?(Hash)
-          for k, v in new_item_url
-            new_item_url[k] = Code.new(v) if v.is_a?(String)
-          end
-          edit_item_url = {} unless edit_item_url.is_a? Hash
-          if field.method.to_s.match(/_id$/) and refl = field.reflection # form.model.reflections[field.method.to_s[0..-4].to_sym]
-            new_item_url[:controller] ||= refl.class_name.underscore.pluralize
-            edit_item_url[:controller] ||= new_item_url[:controller]
-          end
-          new_item_url[:action] ||= :new
-          edit_item_url[:action] ||= :edit
-          data = field.options.delete(:update)||field.html_id
-          html_options = {"data-add-item"=>data, :class=>"icon im-new"}
-          code << "#{varc} << content_tag(:span, content_tag(:span, link_to(::I18n.translate('form.new'), #{new_item_url.inspect}, #{html_options.inspect}).html_safe, :class=>:tool).html_safe, :class=>\"toolbar mini-toolbar\")\n" #  if authorized?(#{new_item_url.inspect})
-        end
+        # puts code
         return code
       end
 
-      def field_mono_radio_input(field, attrs={}, varc='varc')
-        return "#{varc} <<  radio(:#{field.record_name}, :#{field.method}, #{field_datasource(field)}.collect{|item| [item.#{field.item_label}, item.id]}, {}, #{attrs.inspect})"
-      end
+      private
 
-      def field_mono_select_input(field, attrs={}, varc='varc')
-        return "#{varc} << select(:#{field.record_name}, :#{field.method}, #{field_datasource(field)}.collect{|item| [item.#{field.item_label}, item.id]}, {}, #{attrs.inspect})"
+      def item_label(record, options={})
+        return "::I18n.translate('views.unroll.#{@controller.controller_name}.#{@action_name}', "+@columns.collect{|c| ":#{c.interpolation_key}=>#{c.value_code(record)}"}.join(', ')+", :default=>[:'labels.#{@action_name}', '"+@columns.collect{|c| "%{#{c.interpolation_key}}"}.join(', ')+"']).gsub(/%s/, \"\\u{00A0}\")"
       end
-      
-      def field_mono_unroll_input(field, attrs={}, varc='varc')
-        options = {}
-        options[:label] ||= Code.new("Proc.new{|r| \"#{mono_choice_label(field, 'r')}\"}")
-        url = {:controller=>controller.controller_name, :action=>form.action_name, :unroll=>field.html_id}
-        for depended in field.dependeds
-          df = form.all_fields[depended[:name]]
-          url[df.input_id.to_sym] = Code.new(df.reflection.nil? ? df.name : "#{df.name}.id")
-        end
-        return "#{varc} << unroll(:#{field.record_name}, :#{field.method}, #{url.inspect}, #{options.inspect}, #{attrs.inspect})"
-      end
-
-      def field_string_input(field, attrs={}, varc='varc')
-        attrs[:size] ||= 24
-        if field.column and !field.column.limit.nil?
-          attrs[:size] = field.column.limit if field.column.limit<attrs[:size]
-          attrs[:maxlength] = field.column.limit
-        end
-        return "#{varc} << text_field(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-      def field_text_area_input(field, attrs={}, varc='varc')
-        attrs[:cols] ||= 40
-        attrs[:rows] ||= 3
-        attrs[:class] = "#{attrs[:class]} #{attrs[:cols]==80 ? :code : nil}".strip
-        return "#{varc} << resizable_text_area(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
-      end
-
-
-
-
-
-
-      protected
 
       def sanitize_conditions(value)
         if value.is_a? Array
-          if value.size==1 and value[0].is_a? String
+          if value.size == 1 and value[0].is_a? String
             value[0].to_s
           else
             value.inspect
@@ -502,107 +214,8 @@ module Formize
         end
       end
 
-      
-      def mono_choice_label(choice, varr='record')
-        return "\#\{#{varr}.#{choice.item_label}\}"
-      end
-
-      def mono_choice_search_code(field)
-        source_model = field_datasource_class_name(field).constantize
-        # reflection = source_model.reflections[field.choices]
-        # if reflection.nil?
-        #   raise Exception.new("#{source_model.name} must have a reflection :#{field.choices}.")
-        # end
-        model = field.reflection.class_name.constantize #reflection.class_name.constantize
-        foreign_record  = model.name.underscore
-        foreign_records = "#{source_model.name.underscore}_#{field.choices}"
-        options = field.options
-        attributes = field.search_attributes
-        attributes = [attributes] unless attributes.is_a? Array
-        attributes_hash = {}
-        attributes.each_index do |i|
-          attribute = attributes[i]
-          attributes[i] = [
-                           (attribute.to_s.match(/\./) ? attribute.to_s : model.table_name+'.'+attribute.to_s.split(/\:/)[0]),
-                           (attribute.to_s.match(/\:/) ? attribute.to_s.split(/\:/)[1] : (options[:filter]||'%X%')),
-                           '_a'+i.to_s]
-          attributes_hash[attributes[i][2]] = attributes[i][0]
-        end
-        query = []
-        parameters = ''
-        if options[:conditions].is_a? Hash
-          options[:conditions].each do |key, value| 
-            query << (key.is_a?(Symbol) ? model.table_name+"."+key.to_s : key.to_s)+'=?'
-            parameters += ', ' + sanitize_conditions(value)
-          end
-        elsif options[:conditions].is_a? Array
-          conditions = options[:conditions]
-          case conditions[0]
-          when String  # SQL
-            #               query << '["'+conditions[0].to_s+'"'
-            query << conditions[0].to_s
-            parameters += ', '+conditions[1..-1].collect{|p| sanitize_conditions(p)}.join(', ') if conditions.size>1
-            #                query << ')'
-          else
-            raise Exception.new("First element of an Array can only be String or Symbol.")
-          end
-        end
-        
-        select = (model.table_name+".id AS id, "+attributes_hash.collect{|k,v| v+" AS "+k}.join(", ")).inspect
-        
-        code  = ""
-        code << "conditions = [#{query.join(' AND ').inspect+parameters}]\n"
-        code << "search = params[:term]\n"
-        code << "words = search.to_s.mb_chars.downcase.strip.normalize.split(/[\\s\\,]+/)\n"
-        code << "if words.size > 0\n"
-        code << "  conditions[0] << '#{' AND ' if query.size>0}('\n"
-        code << "  words.each_index do |index|\n"
-        code << "    word = words[index].to_s\n"
-        code << "    conditions[0] << ') AND (' if index > 0\n"
-
-        if ActiveRecord::Base.connection.adapter_name == "MySQL"
-          code << "    conditions[0] << "+attributes.collect{|key| "LOWER(CAST(#{key[0]} AS CHAR)) LIKE ?"}.join(' OR ').inspect+"\n"
-        else
-          code << "    conditions[0] << "+attributes.collect{|key| "LOWER(CAST(#{key[0]} AS VARCHAR)) LIKE ?"}.join(' OR ').inspect+"\n"
-        end
-
-        code << "    conditions += ["+attributes.collect{|key| key[1].inspect.gsub('X', '"+word+"').gsub(/(^\"\"\+|\+\"\"\+|\+\"\")/, '')}.join(", ")+"]\n"
-        code << "  end\n"
-        code << "  conditions[0] << ')'\n"
-        code << "end\n"
-
-        # joins = options[:joins] ? ", :joins=>"+options[:joins].inspect : ""
-        # order = ", :order=>"+attributes.collect{|key| "#{key[0]} ASC"}.join(', ').inspect
-        # limit = ", :limit=>"+(options[:limit]||80).to_s
-        joins = options[:joins] ? ".joins(#{options[:joins].inspect})" : ""
-        order = ".order("+attributes.collect{|key| "#{key[0]} ASC"}.join(', ').inspect+")"
-        limit = ".limit(#{options[:limit]||80})"
-
-        partial = options[:partial]
-
-        html  = "<ul><%for #{foreign_record} in #{foreign_records}-%><li id='<%=#{foreign_record}.id-%>'>" 
-        html << "<%content=#{foreign_record}.#{field.item_label}-%>"
-        # html << "<%content="+attributes.collect{|key| "#{foreign_record}['#{key[2]}'].to_s"}.join('+", "+')+" -%>"
-        if partial
-          html << "<%=render(:partial=>#{partial.inspect}, :locals =>{:#{foreign_record}=>#{foreign_record}, :content=>content, :search=>search})-%>"
-        else
-          html << "<%=highlight(content, search)-%>"
-        end
-        html << '</li><%end-%></ul>'
-
-        # code << "#{foreign_records} = #{field_datasource(field)}.find(:all, :conditions=>conditions"+joins+order+limit+")\n"
-        code << "#{foreign_records} = #{field_datasource(field).gsub(/\.all$/, '')}.where(conditions)"+joins+order+limit+"\n"
-        # Render HTML is old Style
-        code << "respond_to do |format|\n"
-        code << "  format.html { render :inline=>#{html.inspect}, :locals=>{:#{foreign_records}=>#{foreign_records}, :search=>search} }\n"
-        code << "  format.json { render :json=>#{foreign_records}.collect{|#{foreign_record}| {:label=>#{foreign_record}.#{field.item_label}, :id=>#{foreign_record}.id}}.to_json }\n"
-        code << "  format.xml { render :xml=>#{foreign_records}.collect{|#{foreign_record}| {:label=>#{foreign_record}.#{field.item_label}, :id=>#{foreign_record}.id}}.to_xml }\n"
-        code << "end\n"      
-        return code
-      end
+    end
 
+  end
 
-      
-    end
-  end  
 end