formize 0.0.9 → 0.0.10

data/lib/formize/form_helper.rb

@@ -1,6 +1,34 @@
 module Formize
   module FormHelper
 
+    # Code picked from Justin French's formtastic gem
+    FIELD_ERROR_PROC = proc do |html_tag, instance_tag|
+      html_tag
+    end
+
+    def with_custom_field_error_proc(&block)
+      default_field_error_proc = ::ActionView::Base.field_error_proc
+      ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
+      yield
+    ensure
+      ::ActionView::Base.field_error_proc = default_field_error_proc
+    end
+
+
+
+    # Include all stylesheets, javascripts and locales
+    # For Rails 3.0, not needed in Rails 3.1
+    def formize_include_tag(options={})
+      options[:locale] ||= I18n.locale
+      html  = ""
+      html << javascript_include_tag('jquery.ui.formize')
+      html << javascript_include_tag('locales/jquery.ui.datepicker-' + locale.to_s)
+      html << javascript_include_tag('formize')
+      html << stylesheet_link_tag('jquery-ui')
+      html << stylesheet_link_tag('formize') unless options[:skip_stylesheet]
+      return html.html_safe
+    end
+
     # 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)
@@ -23,7 +51,14 @@ module Formize
     def hard_content_tag(name, options={}, escape=true, &block)
       content = ''
       yield content
-      return content_tag(name, content, options, escape)
+      return content_tag(name, content.html_safe, options, escape)
+    end
+
+    # Permits to create a submit button well named for the given record
+    def submit_for(record, value=nil, options={})
+      value, options = nil, value if value.is_a?(Hash)
+      value ||= ::I18n.translate("helpers.submit.#{record.new_record? ? 'create' : 'update'}", :model=>record.class.model_name.human, :record=>record.class.model_name.human.mb_chars.downcase)
+      submit_tag(value, options.reverse_merge(:id => "#{record.class.name.underscore}_submit"))
     end
 
     # Returns a list of radio buttons for specified attribute (identified by +method+)
@@ -49,10 +84,63 @@ module Formize
       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)
+      html << tag(:input, :type=>:text, "data-unroll"=>url_for(choices.merge(:format=>:json)), "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_safe, html_options)
     end
 
+    
+    # Returns a text field for selecting a Date with a hidden field containing
+    # the well formatted date
+    # Options are:
+    #  - +:format+: If +format+ is a +String+ it specify date format using a little subset of strftime options
+    #               %d, %j, %a, %A, %m, %b, %B, %y and %Y
+    #               else if +format+ is a +Symbol+ it uses I18n to find format
+    def date_field(object_name, method, options = {})
+      object = instance_variable_get("@#{object_name}")
+      format = options[:format]||:default
+      raise ArgumentError.new("Option :format must be a Symbol referencing a translation 'date.formats.<format>'")unless format.is_a?(Symbol)
+      if localized_value = object.send(method)
+        localized_value = I18n.localize(localized_value, :format=>format)
+      end
+      format = I18n.translate('date.formats.'+format.to_s) 
+      conv = {
+        'dd' => '%d',
+        'oo' => '%j',
+        'D'  => '%a',
+        'DD' => '%A',
+        'mm' => '%m',
+        'M'  => '%b',
+        'MM' => '%B',
+        'y'  => '%y',
+        'yy' => '%Y'
+      }
+      conv.each{|js, rb| format.gsub!(rb, js)}
+      html  = ""
+      html << hidden_field(object_name, method)
+      html << tag(:input, :type=>:text, "data-datepicker"=>"#{object_name}_#{method}", "data-date-format"=>format, :value=>localized_value, "data-locale"=>I18n.locale, :size=>options.delete(:size)||10)
+      return html
+    end
+
+    
+    # Returns a text field for selecting a Date with hour 
+    # with a hidden field containing the well formatted datetime
+    def datetime_field(object_name, method, options = {})
+      object = instance_variable_get("@#{object_name}")
+      html  = ""
+      html << hidden_field(object_name, method)
+      html << tag(:input, :type=>:text, "data-datepicker"=>"#{object_name}_#{method}", :size=>options.delete(:size)||10)
+      return html
+    end
+
+    
+    # Returns a text area which can be resized in the south-east corner
+    # Works exactly the same as +textarea+
+    def resizable_text_area(object_name, method, options = {})
+      # options["data-resize-in"] = "ri"+rand.to_s[2..-1].to_i.to_s(36)
+      # return content_tag(:div, text_area(object_name, method, options), :id=>options["data-resize-in"])
+      options["data-resizable"] = "true"
+      return text_area(object_name, method, options)
+    end
 
 
   end

data/lib/formize/generator.rb

@@ -62,6 +62,9 @@ module Formize
             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::Field) and dependent.reflection
+            event << "  #{record_name}.#{dependent.reflection.primary_key_name} = params[:selected].to_i if params[:selected]\n"
+          end
           event << "  render(:inline=>'<%=#{dependent.prototype}-%>', :locals=>#{locals.inspect})\n"
           event << "end\n"
         end
@@ -73,7 +76,7 @@ module Formize
       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])}
+      list = code.split("\n"); list.each_index{|x| puts((x+1).to_s.rjust(4)+": "+list[x])}
       return code
     end
 
@@ -96,23 +99,39 @@ module Formize
       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 << "  #{varh} << " << element.method_call_code.gsub(/^/, '  ').strip << "\n"
+        code << view_method_call(element, varh).strip.gsub(/^/, '    ') << "\n"
       end
-      code << "  return #{varh}\n"
+      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 << "  return form_for(#{form.record_name}) do\n"
-      code << "    #{form.options[:view_fields_method_name]}(#{form.record_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 << "    end\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])}
+      list = code.split("\n"); list.each_index{|x| puts((x+1).to_s.rjust(4)+": "+list[x])}
       return code
     end
     
@@ -155,7 +174,7 @@ module Formize
       code  = "def #{element.prototype}\n"
       code << "  #{varh} = ''\n"
       code << view_partial_code(element, varh).strip.gsub(/^/, '  ') << "\n"
-      code << "  return #{varh}\n"
+      code << "  return #{varh}.html_safe\n"
       code << "end\n"
       return code
     end
@@ -171,14 +190,14 @@ module Formize
     end
 
     def wrapper_attrs(element)
-      html_options = (element.respond_to?(:html_options) ? element.html_options : {})
+      html_options = (element.respond_to?(:html_options) ? element.html_options.dup : {})
       html_options[:id] = element.html_id
       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.fields[depended[:name]]
-          url[df.input_id.to_sym] = Code.new(df.reflection.nil? ? df.name : "#{df.name}.id")
-        end
+        # for depended in element.dependeds
+        #   df = form.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})")
       end
       special_method = "#{element.class.name.split('::')[-1].underscore}_#{__method__}".to_sym
@@ -206,43 +225,6 @@ module Formize
       return code
     end
 
-    # def field_set_view_method_code(field_set, varh='html')
-    #   code  = "def #{field_set.prototype}\n"
-    #   code << "  #{varh} = ''\n"
-    #   code << field_set_view_partial_code(field_set, varh).strip.gsub(/^/, '  ') << "\n"
-    #   code << "  return #{varh}\n"
-    #   code << "end\n"
-    #   return code
-    # end
-
-    # def field_set_view_method_call(field_set, varh='varh')
-    #   code = ""
-    #   call = if @partials.include?(field_set)
-    #            "#{varh} << #{field_set.prototype}\n"
-    #          else
-    #            field_set_view_partial_code(field_set, varh).strip << "\n"
-    #          end
-
-    #   if field_set.depend_on
-    #     depended_field = form.fields[field_set.depend_on]
-    #     code << "#{field_set.depend_on} = #{form.record_name}.#{depended_field.name}\n"
-    #     if ref = depended_field.reflection
-    #       code << "#{field_set.depend_on} ||= #{field_datasource(depended_field)}.first\n"
-    #     end
-    #     code << "if #{field_set.depend_on}\n"
-    #     code << call.strip.gsub(/^/, '  ') << "\n"
-    #     code << "else\n"
-    #     opt = {:id=>field_set.html_id, :class=>"waiting", "data-refresh"=>Code.new("url_for(:controller=>:#{controller.controller_name}, :action=>:#{form.action_name}, :refresh=>'#{field_set.html_id}')")}
-    #     code << "  #{varh} << tag(:div, #{opt.inspect})\n"
-
-    #     code << "end\n"
-    #   else
-    #     code = call
-    #   end
-
-    #   return code
-    # end
-
     #####################################################################################
     #                             F I E L D     M E T H O D S                           #
     #####################################################################################
@@ -251,70 +233,49 @@ module Formize
       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(',') 
+        input_attrs["data-dependents"] = deps.collect{|d| "##{d.html_id}"}.join(',') 
       end
 
       # Initialize html attributes
       html_options = wrapper_attrs(field)
 
       varc = field.html_id
-      code  = "#{varh} << hard_content_tag(:div, #{html_options.inspect}) do |#{varc}|\n"
+      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} ||= #{field.default.inspect}\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"
+      code << "  end\n"
+      code << "  #{varc} << '</td></tr>'\n"
       code << "end\n"
       return code
     end
 
-    # def field_view_method_code(field, varh='html')
-    #   code  = "def #{field.prototype}\n"
-    #   code << "  #{varh} = ''\n"
-    #   code << field_view_partial_code(field, varh).strip.gsub(/^/, '  ') << "\n"
-    #   code << "  return #{varh}\n"
-    #   code << "end\n"
-    #   return code
-    # end
-
-    # def field_view_method_call(field, varh='varh')
-    #   code = ""
-    #   call = if @partials.include?(field)
-    #            "#{varh} << #{field.prototype}\n"
-    #          else
-    #            field_view_partial_code(field, varh).strip << "\n"
-    #          end
-
-    #   if field.depend_on
-    #     depended_field = form.fields[field.depend_on]
-    #     code << "#{field.depend_on} = #{form.record_name}.#{depended_field.name}\n"
-    #     code << "if #{field.depend_on}\n"
-    #     code << call.strip.gsub(/^/, '  ') << "\n"
-    #     code << "else\n"
-    #     attrs = field_wrapper_attrs(field)
-    #     attrs[:class] = "#{attrs[:class]} waiting".strip
-    #     code << "  #{varh} << tag(:div, #{attrs.inspect})\n"
-    #     code << "end\n"
-    #   else
-    #     code = call
-    #   end
-
-    #   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)
@@ -333,9 +294,10 @@ module Formize
     end
 
     def field_wrapper_attrs(field, html_options={})
-      html_options[:class] = "field #{html_options[:class]}".strip
+      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
 
@@ -356,12 +318,13 @@ module Formize
     end
 
     def field_date_input(field, attrs={}, varc='varc')
-      attrs[:size] ||= 16
+      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
 
@@ -395,9 +358,9 @@ module Formize
     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
+      # 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"
@@ -406,7 +369,7 @@ module Formize
       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.options[:finder_sql].nil?
+      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"
@@ -432,7 +395,7 @@ module Formize
           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 = form.model.reflections[field.method.to_s[0..-4].to_sym]
+        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
@@ -440,7 +403,7 @@ module Formize
         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(tg(:new), #{new_item_url.inspect}, #{html_options.inspect}).html_safe, :class=>:tool).html_safe, :class=>\"toolbar mini-toolbar\") if authorized?(#{new_item_url.inspect})\n"
+        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
       return code
     end
@@ -461,7 +424,7 @@ module Formize
         df = form.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_for(#{url.inspect}), #{options.inspect}, #{attrs.inspect})"
+      return "#{varc} << unroll(:#{field.record_name}, :#{field.method}, #{url.inspect}, #{options.inspect}, #{attrs.inspect})"
     end
 
     def field_string_input(field, attrs={}, varc='varc')
@@ -477,7 +440,7 @@ module Formize
       attrs[:cols] ||= 40
       attrs[:rows] ||= 3
       attrs[:class] = "#{attrs[:class]} #{attrs[:cols]==80 ? :code : nil}".strip
-      return "#{varc} << text_area(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
+      return "#{varc} << resizable_text_area(:#{field.record_name}, :#{field.method}, #{attrs.inspect})\n"
     end
 
 
@@ -510,11 +473,11 @@ module Formize
 
     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 = reflection.class_name.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
@@ -550,12 +513,11 @@ module Formize
       end
       
       select = (model.table_name+".id AS id, "+attributes_hash.collect{|k,v| v+" AS "+k}.join(", ")).inspect
-      joins = options[:joins] ? ", :joins=>"+options[:joins].inspect : ""
       
       code  = ""
       code << "conditions = [#{query.join(' AND ').inspect+parameters}]\n"
-      code << "search = params[:search]\n"
-      code << "words = search.lower.split(/[\\s\\,]+/)\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"
@@ -572,8 +534,14 @@ module Formize
       code << "  end\n"
       code << "  conditions[0] << ')'\n"
       code << "end\n"
-      order = ", :order=>"+attributes.collect{|key| "#{key[0]} ASC"}.join(', ').inspect
-      limit = ", :limit=>"+(options[:limit]||12).to_s
+
+      # 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-%>'>" 
@@ -586,8 +554,14 @@ module Formize
       end
       html << '</li><%end-%></ul>'
 
-      code << "#{foreign_records} = #{field_datasource(field)}.find(:all, :conditions=>conditions"+joins+order+limit+")\n"
-      code << "render :inline=>#{html.inspect}, :locals=>{:#{foreign_records}=>#{foreign_records}, :search=>search}\n"
+      # 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
 

data/lib/generators/formize/install/install_generator.rb

@@ -4,11 +4,35 @@ module Formize
 
   class InstallGenerator < ::Rails::Generators::Base
     source_root File.expand_path('../templates', __FILE__)
+    class_option :no_ui, :type => :boolean, :default => false, :desc => "Do not include special jQuery-UI JavaScripts"
+    class_option :no_locales, :type => :boolean, :default => false, :desc => "Do not include locales for jQuery-UI date picker"
+    class_option :no_stylesheet, :type => :boolean, :default => false, :desc => "Do not include stylesheet of jQuery-UI"
 
     unless ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR >= 1
       def copy_assets
         copy_file '../../../../assets/javascripts/formize.js',  'public/javascripts/formize.js'
-        # copy_file '../../../../assets/stylesheets/formize.css', 'public/stylesheets/formize.css'
+
+        unless options[:no_ui]
+          copy_file '../../../../assets/javascripts/jquery.ui.formize.js',  'public/javascripts/jquery.ui.formize.js'
+        end
+
+        unless options[:no_locales]
+          for locale in Dir.glob(File.expand_path('../../../../assets/javascripts/locales/*.js', __FILE__))
+            file = locale.split(/[\\\/]+/)[-1]
+            copy_file "../../../../assets/javascripts/locales/#{file}",  "public/javascripts/locales/#{file}"
+          end
+        end
+
+        copy_file '../../../../assets/stylesheets/formize.css', 'public/stylesheets/formize.css'
+
+        unless options[:no_stylesheet]
+          copy_file '../../../../assets/stylesheets/jquery-ui.css', 'public/stylesheets/jquery-ui.css'
+          for image in Dir.glob(File.expand_path('../../../../assets/images/*.png', __FILE__))
+            file = image.split(/[\\\/]+/)[-1]
+            copy_file "../../../../assets/images/#{file}",  "public/images/#{file}"
+          end
+        end
+
       end
     end