formtastic 1.2.2 → 1.2.3.beta

data/README.textile

@@ -135,6 +135,7 @@ The difference is subtle, with most blocks in Rails 3 requiring the addition of
       ...
     <% end %>
   <% end %>
+</pre>
   
 This README is currently documenting the Rails 2 way only. If you're using Rails 3 and your forms aren't rendering everything as expected, try changing @<%@ to @<%=@.
 
@@ -649,20 +650,13 @@ We currently support both Rails 2 and Rails 3, under Ruby 1.8.7-ish (and 1.9.2-i
 
 <pre>
   $ cd ~/code/formtastic
-  $ rvm gemset create formtastic-rails3
-  $ rvm gemset use formtastic-rails3
-  $ gem install bundler
-  $ bundle install
-  $ rake spec
-  $ rm Gemfile.lock
-  $ rvm gemset create formtastic-rails2
-  $ rvm gemset use formtastic-rails2
-  $ gem install bundler
-  $ RAILS_2=true bundle install
-  $ rake spec
-  $ touch .rvmrc
-  $ echo "rvm gemset use formtastic-rails-3" > .rvmrc
-  $ cd ~/code/formtastic
+  $ rvm gemset create formtastic      # If that's your thing
+  $ rvm gemset use formtastic         # Add that to your .rvmrc too
+  $ bundle install                    # Initial bundle command to build Gemfile.lock
+  $ RAILS_2=true bundle update rails  # Updates gemfile to run agains rails 2
+  $ RAILS_2=true rake                 # Run tests against rails 2
+  $ bundle update rails               # Updates gemfile to run agains rails 3
+  $ rake                              # Run tests against rails 3
 </pre>
 
 

data/generators/form/form_generator.rb

@@ -105,7 +105,7 @@ class FormGenerator < Rails::Generator::NamedBase
     end
     
     def source_root
-      File.expand_path('../../../lib/generators/templates', __FILE__)
+      File.expand_path('../../../lib/generators/templates/rails2', __FILE__)
     end
 
 end

data/lib/formtastic.rb

@@ -6,11 +6,20 @@ require File.join(File.dirname(__FILE__), *%w[formtastic railtie]) if defined?(:
 module Formtastic #:nodoc:
 
   class SemanticFormBuilder < ActionView::Helpers::FormBuilder
-    class_inheritable_accessor :default_text_field_size, :default_text_area_height, :default_text_area_width, :all_fields_required_by_default, :include_blank_for_select_by_default,
-                   :required_string, :optional_string, :inline_errors, :label_str_method, :collection_value_methods, :collection_label_methods, :file_metadata_suffixes,
-                   :inline_order, :custom_inline_order, :file_methods, :priority_countries, :i18n_lookups_by_default, :escape_html_entities_in_hints_and_labels,
-                   :default_commit_button_accesskey, :default_inline_error_class, :default_hint_class, :default_error_list_class, :instance_reader => false
-
+    
+    configurables = [
+      :default_text_field_size, :default_text_area_height, :default_text_area_width, :all_fields_required_by_default, :include_blank_for_select_by_default,
+      :required_string, :optional_string, :inline_errors, :label_str_method, :collection_value_methods, :collection_label_methods, :file_metadata_suffixes,
+      :inline_order, :custom_inline_order, :file_methods, :priority_countries, :i18n_lookups_by_default, :escape_html_entities_in_hints_and_labels,
+      :default_commit_button_accesskey, :default_inline_error_class, :default_hint_class, :default_error_list_class
+    ]
+    
+    if respond_to?(:class_attribute)
+      class_attribute *configurables
+    else
+      class_inheritable_accessor *configurables
+    end
+    
     cattr_accessor :custom_namespace
 
     self.default_text_field_size = nil
@@ -88,9 +97,9 @@ module Formtastic #:nodoc:
     #
     #   <% semantic_form_for @employee do |form| %>
     #     <% form.inputs do -%>
-    #       <%= form.input :secret, :value => "Hello" %>
     #       <%= form.input :name, :label => "Full Name" %>
-    #       <%= form.input :manager_id, :as => :radio %>
+    #       <%= form.input :manager, :as => :radio %>
+    #       <%= form.input :secret, :as => :password, :input_html => { :value => "xxxx" } %>
     #       <%= form.input :hired_at, :as => :date, :label => "Date Hired" %>
     #       <%= form.input :phone, :required => false, :hint => "Eg: +1 555 1234" %>
     #       <%= form.input :email %>
@@ -99,6 +108,8 @@ module Formtastic #:nodoc:
     #   <% end %>
     #
     def input(method, options = {})
+      options = options.dup # Allow options to be shared without being tainted by Formtastic
+      
       options[:required] = method_required?(method) unless options.key?(:required)
       options[:as]     ||= default_input_type(method, options)
 
@@ -114,7 +125,7 @@ module Formtastic #:nodoc:
         options[:label_html][:for] ||= options[:input_html][:id]
       end
 
-      input_parts = (self.class.custom_inline_order[options[:as]] || self.class.inline_order).dup
+      input_parts = (custom_inline_order[options[:as]] || inline_order).dup
       input_parts = input_parts - [:errors, :hints] if options[:as] == :hidden
 
       list_item_content = input_parts.map do |type|
@@ -282,8 +293,8 @@ module Formtastic #:nodoc:
         field_set_and_list_wrapping(*(args << html_options), &block)
       else
         if @object && args.empty?
-          args  = self.association_columns(:belongs_to)
-          args += self.content_columns
+          args  = association_columns(:belongs_to)
+          args += content_columns
           args -= RESERVED_COLUMNS
           args.compact!
         end
@@ -351,10 +362,10 @@ module Formtastic #:nodoc:
         end
       else
         key = :submit
-        object_name = @object_name.to_s.send(self.class.label_str_method)
+        object_name = @object_name.to_s.send(label_str_method)
       end
 
-      text = (self.localized_string(key, text, :action, :model => object_name) ||
+      text = (localized_string(key, text, :action, :model => object_name) ||
               ::Formtastic::I18n.t(key, :model => object_name)) unless text.is_a?(::String)
 
       button_html = options.delete(:button_html) || {}
@@ -364,9 +375,9 @@ module Formtastic #:nodoc:
       wrapper_html = options.delete(:wrapper_html) || {}
       wrapper_html[:class] = (wrapper_html_class << wrapper_html[:class]).flatten.compact.join(' ')
 
-      accesskey = (options.delete(:accesskey) || self.class.default_commit_button_accesskey) unless button_html.has_key?(:accesskey)
+      accesskey = (options.delete(:accesskey) || default_commit_button_accesskey) unless button_html.has_key?(:accesskey)
       button_html = button_html.merge(:accesskey => accesskey) if accesskey
-      template.content_tag(:li, Formtastic::Util.html_safe(self.submit(text, button_html)), wrapper_html)
+      template.content_tag(:li, Formtastic::Util.html_safe(submit(text, button_html)), wrapper_html)
     end
 
     # A thin wrapper around #fields_for to set :builder => Formtastic::SemanticFormBuilder
@@ -451,7 +462,7 @@ module Formtastic #:nodoc:
     def inline_errors_for(method, options = {}) #:nodoc:
       if render_inline_errors?
         errors = error_keys(method, options).map{|x| @object.errors[x] }.flatten.compact.uniq
-        send(:"error_#{self.class.inline_errors}", [*errors], options) if errors.any?
+        send(:"error_#{inline_errors}", [*errors], options) if errors.any?
       else
         nil
       end
@@ -490,7 +501,7 @@ module Formtastic #:nodoc:
         @methods_for_error ||= {}
         @methods_for_error[method] ||= begin
           methods_for_error = [method.to_sym]
-          methods_for_error << self.class.file_metadata_suffixes.map{|suffix| "#{method}_#{suffix}".to_sym} if is_file?(method, options)
+          methods_for_error << file_metadata_suffixes.map{|suffix| "#{method}_#{suffix}".to_sym} if is_file?(method, options)
           methods_for_error << [association_primary_key(method)] if association_macro_for_method(method) == :belongs_to
           methods_for_error.flatten.compact.uniq
         end
@@ -502,13 +513,13 @@ module Formtastic #:nodoc:
       end
 
       def render_inline_errors?
-        @object && @object.respond_to?(:errors) && INLINE_ERROR_TYPES.include?(self.class.inline_errors)
+        @object && @object.respond_to?(:errors) && INLINE_ERROR_TYPES.include?(inline_errors)
       end
 
       # Collects content columns (non-relation columns) for the current form object class.
       #
       def content_columns #:nodoc:
-        self.model_name.constantize.content_columns.collect { |c| c.name.to_sym }.compact rescue []
+        model_name.constantize.content_columns.collect { |c| c.name.to_sym }.compact rescue []
       end
 
       # Collects association columns (relation columns) for the current form object class.
@@ -529,12 +540,12 @@ module Formtastic #:nodoc:
 
       # Returns nil, or a symbol like :belongs_to or :has_many
       def association_macro_for_method(method) #:nodoc:
-        reflection = self.reflection_for(method)
+        reflection = reflection_for(method)
         reflection.macro if reflection
       end
 
       def association_primary_key(method)
-        reflection = self.reflection_for(method)
+        reflection = reflection_for(method)
         reflection.options[:foreign_key] if reflection && !reflection.options[:foreign_key].blank?
         :"#{method}_id"
       end
@@ -610,7 +621,7 @@ module Formtastic #:nodoc:
           if @object && @object.class.respond_to?(:validators_on)
             !@object.class.validators_on(attribute_sym).find{|validator| (validator.kind == :presence || validator.kind == :inclusion) && (validator.options.present? ? options_require_validation?(validator.options) : true)}.nil?
           else
-            self.class.all_fields_required_by_default
+            all_fields_required_by_default
           end
         end
       end
@@ -640,8 +651,8 @@ module Formtastic #:nodoc:
         html_options[:id] ||= field_id
         label_options = options_for_label(options)
         label_options[:for] ||= html_options[:id]
-        self.label(method, label_options) <<
-        self.send(self.respond_to?(form_helper_method) ? form_helper_method : :text_field, method, html_options)
+        label(method, label_options) <<
+          send(respond_to?(form_helper_method) ? form_helper_method : :text_field, method, html_options)
       end
 
       # Outputs a label and standard Rails text field inside the wrapper.
@@ -698,7 +709,7 @@ module Formtastic #:nodoc:
         options ||= {}
         html_options = options.delete(:input_html) || strip_formtastic_options(options)
         html_options[:id] ||= generate_html_id(method, "")
-        self.hidden_field(method, html_options)
+        hidden_field(method, html_options)
       end
 
       # Outputs a label and a select box containing options from the parent
@@ -802,7 +813,7 @@ module Formtastic #:nodoc:
         html_options[:multiple] = html_options[:multiple] || options.delete(:multiple)
         html_options.delete(:multiple) if html_options[:multiple].nil?
 
-        reflection = self.reflection_for(method)
+        reflection = reflection_for(method)
         if reflection && [ :has_many, :has_and_belongs_to_many ].include?(reflection.macro)
           html_options[:multiple] = true if html_options[:multiple].nil?
           html_options[:size]     ||= 5
@@ -823,19 +834,19 @@ module Formtastic #:nodoc:
           group_association = options[:group_association] || detect_group_association(method, options[:group_by])
 
           # Here comes the monster with 8 arguments
-          self.grouped_collection_select(input_name, group_collection,
+          grouped_collection_select(input_name, group_collection,
                                          group_association, group_label_method,
                                          value, label,
                                          strip_formtastic_options(options), html_options)
         else
           collection = find_collection_for_column(method, options)
 
-          self.select(input_name, collection, strip_formtastic_options(options), html_options)
+          select(input_name, collection, strip_formtastic_options(options), html_options)
         end
 
         label_options = options_for_label(options).merge(:input_name => input_name)
         label_options[:for] ||= html_options[:id]
-        self.label(method, label_options) << select_html
+        label(method, label_options) << select_html
       end
 
       # Outputs a timezone select input as Rails' time_zone_select helper. You
@@ -850,8 +861,8 @@ module Formtastic #:nodoc:
         html_options[:id] ||= field_id
         label_options = options_for_label(options)
         label_options[:for] ||= html_options[:id]
-        self.label(method, label_options) <<
-        self.time_zone_select(method, options.delete(:priority_zones),
+        label(method, label_options) <<
+        time_zone_select(method, options.delete(:priority_zones),
           strip_formtastic_options(options), html_options)
       end
 
@@ -928,7 +939,7 @@ module Formtastic #:nodoc:
           html_options[:id] = input_id
 
           li_content = template.content_tag(:label,
-            Formtastic::Util.html_safe("#{self.radio_button(input_name, value, html_options)} #{escape_html_entities(label)}"),
+            Formtastic::Util.html_safe("#{radio_button(input_name, value, html_options)} #{escape_html_entities(label)}"),
             :for => input_id
           )
 
@@ -1167,7 +1178,7 @@ module Formtastic #:nodoc:
           html_options[:id] = input_id
 
           li_content = template.content_tag(:label,
-            Formtastic::Util.html_safe("#{self.create_check_boxes(input_name, html_options, value, unchecked_value, hidden_fields)} #{escape_html_entities(label)}"),
+            Formtastic::Util.html_safe("#{create_check_boxes(input_name, html_options, value, unchecked_value, hidden_fields)} #{escape_html_entities(label)}"),
             :for => input_id
           )
 
@@ -1176,7 +1187,7 @@ module Formtastic #:nodoc:
         end
 
         fieldset_content = legend_tag(method, options)
-        fieldset_content << self.create_hidden_field_for_check_boxes(input_name, value_as_class) unless hidden_fields
+        fieldset_content << create_hidden_field_for_check_boxes(input_name, value_as_class) unless hidden_fields
         fieldset_content << template.content_tag(:ol, Formtastic::Util.html_safe(list_item_content.join))
         template.content_tag(:fieldset, fieldset_content)
       end
@@ -1207,7 +1218,7 @@ module Formtastic #:nodoc:
       # otherwise the helper uses the output generated by the rails check_box method.
       def create_check_boxes(input_name, html_options = {}, checked_value = "1", unchecked_value = "0", hidden_fields = false) #:nodoc:
         return template.check_box_tag(input_name, checked_value, html_options[:checked], html_options) unless hidden_fields == true
-        self.check_box(input_name, html_options, checked_value, unchecked_value)
+        check_box(input_name, html_options, checked_value, unchecked_value)
       end
 
       # Outputs a country select input, wrapping around a regular country_select helper.
@@ -1225,18 +1236,18 @@ module Formtastic #:nodoc:
       #   f.input :location, :as => :country, :priority_countries => /Australia/ # set your own
       #
       def country_input(method, options)
-        raise "To use the :country input, please install a country_select plugin, like this one: http://github.com/rails/iso-3166-country-select" unless self.respond_to?(:country_select)
+        raise "To use the :country input, please install a country_select plugin, like this one: http://github.com/rails/iso-3166-country-select" unless respond_to?(:country_select)
 
         html_options = options.delete(:input_html) || {}
-        priority_countries = options.delete(:priority_countries) || self.class.priority_countries
+        priority_countries = options.delete(:priority_countries) || self.priority_countries
 
         field_id = generate_html_id(method, "")
         html_options[:id] ||= field_id
         label_options = options_for_label(options)
         label_options[:for] ||= html_options[:id]
 
-        self.label(method, label_options) <<
-        self.country_select(method, priority_countries, strip_formtastic_options(options), html_options)
+        label(method, label_options) <<
+        country_select(method, priority_countries, strip_formtastic_options(options), html_options)
       end
 
       # Outputs a label containing a checkbox and the label text. The label defaults
@@ -1261,7 +1272,7 @@ module Formtastic #:nodoc:
         # the label() method will insert this nested input into the label at the last minute
         options[:label_prefix_for_nested_input] = input
 
-        template.hidden_field_tag("#{@object_name}[#{method}]", unchecked_value, :id => nil) << self.label(method, options)
+        template.hidden_field_tag("#{@object_name}[#{method}]", unchecked_value, :id => nil) << label(method, options)
       end
 
       # Generates an input for the given method using the type supplied with :as.
@@ -1274,21 +1285,21 @@ module Formtastic #:nodoc:
       def inline_hints_for(method, options) #:nodoc:
         options[:hint] = localized_string(method, options[:hint], :hint)
         return if options[:hint].blank? or options[:hint].kind_of? Hash
-        hint_class = options[:hint_class] || self.class.default_hint_class
+        hint_class = options[:hint_class] || default_hint_class
         template.content_tag(:p, Formtastic::Util.html_safe(options[:hint]), :class => hint_class)
       end
 
       # Creates an error sentence by calling to_sentence on the errors array.
       #
       def error_sentence(errors, options = {}) #:nodoc:
-        error_class = options[:error_class] || self.class.default_inline_error_class
+        error_class = options[:error_class] || default_inline_error_class
         template.content_tag(:p, Formtastic::Util.html_safe(errors.to_sentence.untaint), :class => error_class)
       end
 
       # Creates an error li list.
       #
       def error_list(errors, options = {}) #:nodoc:
-        error_class = options[:error_class] || self.class.default_error_list_class
+        error_class = options[:error_class] || default_error_list_class
         list_elements = []
         errors.each do |error|
           list_elements <<  template.content_tag(:li, Formtastic::Util.html_safe(error.untaint))
@@ -1299,7 +1310,7 @@ module Formtastic #:nodoc:
       # Creates an error sentence containing only the first error
       #
       def error_first(errors, options = {}) #:nodoc:
-        error_class = options[:error_class] || self.class.default_inline_error_class
+        error_class = options[:error_class] || default_inline_error_class
         template.content_tag(:p, Formtastic::Util.html_safe(errors.first.untaint), :class => error_class)
       end
 
@@ -1309,9 +1320,9 @@ module Formtastic #:nodoc:
       def required_or_optional_string(required) #:nodoc:
         string_or_proc = case required
           when true
-            self.class.required_string
+            required_string
           when false
-            self.class.optional_string
+            optional_string
           else
             required
         end
@@ -1375,7 +1386,7 @@ module Formtastic #:nodoc:
 
         if title.blank?
           valid_name_classes = [::String, ::Symbol]
-          valid_name_classes.delete(::Symbol) if !block_given? && (args.first.is_a?(::Symbol) && self.content_columns.include?(args.first))
+          valid_name_classes.delete(::Symbol) if !block_given? && (args.first.is_a?(::Symbol) && content_columns.include?(args.first))
           title = args.shift if valid_name_classes.any? { |valid_name_class| args.first.is_a?(valid_name_class) }
         end
         title = localized_string(title, title, :title) if title.is_a?(::Symbol)
@@ -1390,7 +1401,7 @@ module Formtastic #:nodoc:
 
         template.content_tag(:fieldset,
             template.content_tag(:legend,
-                self.label(method, options_for_label(options).merge(:for => options.delete(:label_for))), :class => 'label'
+                label(method, options_for_label(options).merge(:for => options.delete(:label_for))), :class => 'label'
               ) <<
             template.content_tag(:ol, Formtastic::Util.html_safe(contents))
           )
@@ -1417,7 +1428,7 @@ module Formtastic #:nodoc:
       # default is a :string, a similar behaviour to Rails' scaffolding.
       #
       def default_input_type(method, options = {}) #:nodoc:
-        if column = self.column_for(method)
+        if column = column_for(method)
           # Special cases where the column type doesn't map to an input method.
           case column.type
           when :string
@@ -1429,7 +1440,7 @@ module Formtastic #:nodoc:
             return :phone     if method.to_s =~ /(phone|fax)/
             return :search    if method.to_s =~ /^search$/
           when :integer
-            return :select    if self.reflection_for(method)
+            return :select    if reflection_for(method)
             return :numeric
           when :float, :decimal
             return :numeric
@@ -1443,7 +1454,7 @@ module Formtastic #:nodoc:
           return column.type
         else
           if @object
-            return :select  if self.reflection_for(method)
+            return :select  if reflection_for(method)
 
             return :file    if is_file?(method, options)
           end
@@ -1458,7 +1469,7 @@ module Formtastic #:nodoc:
         @files ||= {}
         @files[method] ||= (options[:as].present? && options[:as] == :file) || begin
           file = @object.send(method) if @object && @object.respond_to?(method)
-          file && self.class.file_methods.any?{|m| file.respond_to?(m)}
+          file && file_methods.any?{|m| file.respond_to?(m)}
         end
       end
 
@@ -1493,7 +1504,7 @@ module Formtastic #:nodoc:
       def find_raw_collection_for_column(column, options) #:nodoc:
         collection = if options[:collection]
           options.delete(:collection)
-        elsif reflection = self.reflection_for(column)
+        elsif reflection = reflection_for(column)
           options[:find_options] ||= {}
 
           if conditions = reflection.options[:conditions]
@@ -1532,8 +1543,8 @@ module Formtastic #:nodoc:
         end
 
         # Order of preference: user supplied method, class defaults, auto-detect
-        label = options[:label_method] || label || self.class.collection_label_methods.find { |m| sample.respond_to?(m) }
-        value = options[:value_method] || value || self.class.collection_value_methods.find { |m| sample.respond_to?(m) }
+        label = options[:label_method] || label || collection_label_methods.find { |m| sample.respond_to?(m) }
+        value = options[:value_method] || value || collection_value_methods.find { |m| sample.respond_to?(m) }
 
         [label, value]
       end
@@ -1548,7 +1559,7 @@ module Formtastic #:nodoc:
       # Detects the method to call for fetching group members from the groups when grouping select options
       #
       def detect_group_association(method, group_by)
-        object_to_method_reflection = self.reflection_for(method)
+        object_to_method_reflection = reflection_for(method)
         method_class = object_to_method_reflection.klass
 
         method_to_group_association = method_class.reflect_on_association(group_by)
@@ -1606,7 +1617,7 @@ module Formtastic #:nodoc:
       #   has_and_belongs_to_many will act like has_many
       #
       def generate_association_input_name(method) #:nodoc:
-        if reflection = self.reflection_for(method)
+        if reflection = reflection_for(method)
           if [:has_and_belongs_to_many, :has_many].include?(reflection.macro)
             "#{method.to_s.singularize}_ids"
           else
@@ -1678,16 +1689,17 @@ module Formtastic #:nodoc:
         end
 
         validation_max_limit = get_maxlength_for(method)
-        column = self.column_for(method)
+        column = column_for(method)
 
         if type == :text
-          { :rows => self.class.default_text_area_height, :cols => self.class.default_text_area_width }
-        elsif type == :numeric || column.nil? || column.limit.nil?
+          { :rows => default_text_area_height, 
+            :cols => default_text_area_width }
+        elsif type == :numeric || column.nil? || !column.respond_to?(:limit) || column.limit.nil?
           { :maxlength => validation_max_limit,
-            :size => self.class.default_text_field_size }
+            :size => default_text_field_size }
         else
           { :maxlength => validation_max_limit || column.limit,
-            :size => self.class.default_text_field_size }
+            :size => default_text_field_size }
         end
       end
 
@@ -1733,12 +1745,12 @@ module Formtastic #:nodoc:
         if @object && @object.class.respond_to?(:human_attribute_name)
           humanized_name = @object.class.human_attribute_name(method.to_s)
           if humanized_name == method.to_s.send(:humanize)
-            method.to_s.send(self.class.label_str_method)
+            method.to_s.send(label_str_method)
           else
             humanized_name
           end
         else
-          method.to_s.send(self.class.label_str_method)
+          method.to_s.send(label_str_method)
         end
       end
 
@@ -1769,7 +1781,7 @@ module Formtastic #:nodoc:
         if value.is_a?(::String)
           escape_html_entities(value)
         else
-          use_i18n = value.nil? ? self.class.i18n_lookups_by_default : (value != false)
+          use_i18n = value.nil? ? i18n_lookups_by_default : (value != false)
 
           if use_i18n
             model_name, nested_model_name  = normalize_model_name(self.model_name.underscore)
@@ -1828,13 +1840,13 @@ module Formtastic #:nodoc:
 
       def set_include_blank(options)
         unless options.key?(:include_blank) || options.key?(:prompt)
-          options[:include_blank] = self.class.include_blank_for_select_by_default
+          options[:include_blank] = include_blank_for_select_by_default
         end
         options
       end
 
       def escape_html_entities(string) #:nodoc:
-        if self.class.escape_html_entities_in_hints_and_labels
+        if escape_html_entities_in_hints_and_labels
           # Acceppt html_safe flag as indicator to skip escaping
           string = template.escape_once(string) unless string.respond_to?(:html_safe?) && string.html_safe? == true
         end
@@ -1898,7 +1910,7 @@ module Formtastic #:nodoc:
 
     def semantic_remote_form_for_wrapper(record_or_name_or_array, *args, &proc)
       options = args.extract_options!
-      if self.respond_to? :remote_form_for
+      if respond_to? :remote_form_for
         semantic_remote_form_for_real(record_or_name_or_array, *(args << options), &proc)
       else
         options[:remote] = true

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

@@ -6,10 +6,8 @@ module Formtastic
     source_root File.expand_path('../../../templates', __FILE__)
 
     def copy_files
-      empty_directory 'config/initializers'
       template        'formtastic.rb', 'config/initializers/formtastic.rb'
 
-      empty_directory 'public/stylesheets'
       template        'formtastic.css',         'public/stylesheets/formtastic.css'
       template        'formtastic_changes.css', 'public/stylesheets/formtastic_changes.css'
     end

data/lib/generators/templates/_form.html.erb

@@ -1,4 +1,4 @@
-<%% f.inputs do %>
+<%%= f.inputs do %>
 <% attributes.each do |attribute| -%>
   <%%= f.input :<%= attribute.name %> %>
 <% end -%>

data/lib/generators/templates/_form.html.haml

@@ -1,4 +1,4 @@
-- f.inputs do
+= f.inputs do
 <% attributes.each do |attribute| -%>
   = f.input :<%= attribute.name %>
 <% end -%>

data/lib/generators/templates/formtastic.rb

@@ -1,5 +1,13 @@
 # encoding: utf-8
 
+# --------------------------------------------------------------------------------------------------
+# Please note: If you're subclassing Formtastic::SemanticFormBuilder in a Rails 3 project, 
+# Formtastic uses class_attribute for these configuration attributes instead of the deprecated 
+# class_inheritable_attribute. The behaviour is slightly different with subclasses (especially 
+# around attributes with Hash or Array) values, so make sure you understand what's happening. 
+# See the documentation for class_attribute in ActiveSupport for more information.
+# --------------------------------------------------------------------------------------------------
+
 # Set the default text field size when input is a string. Default is nil.
 # Formtastic::SemanticFormBuilder.default_text_field_size = 50
 

data/lib/generators/templates/rails2/_form.html.erb

@@ -0,0 +1,5 @@
+<%% f.inputs do %>
+<% attributes.each do |attribute| -%>
+  <%%= f.input :<%= attribute.name %> %>
+<% end -%>
+<%% end %>

data/lib/generators/templates/rails2/_form.html.haml

@@ -0,0 +1,4 @@
+- f.inputs do
+<% attributes.each do |attribute| -%>
+  = f.input :<%= attribute.name %>
+<% end -%>

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: formtastic
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
+  hash: 31098189
+  prerelease: true
   segments: 
   - 1
   - 2
-  - 2
-  version: 1.2.2
+  - 3
+  - beta
+  version: 1.2.3.beta
 platform: ruby
 authors: 
 - Justin French
@@ -154,6 +155,8 @@ files:
 - lib/generators/templates/formtastic.css
 - lib/generators/templates/formtastic.rb
 - lib/generators/templates/formtastic_changes.css
+- lib/generators/templates/rails2/_form.html.erb
+- lib/generators/templates/rails2/_form.html.haml
 - lib/locale/en.yml
 - rails/init.rb
 - MIT-LICENSE