merged in upstream changes

Author: mmoyer

lib/formtastic.rb

@@ -20,10 +20,15 @@ class SemanticFormBuilder < ActionView::Helpers::FormBuilder
     @@inline_order = [ :input, :hints, :errors ]
     @@file_methods = [ :file?, :public_filename ]
     @@priority_countries = ["Australia", "Canada", "United Kingdom", "United States"]
+    @@i18n_lookups_by_default = false
 
     cattr_accessor :default_text_field_size, :all_fields_required_by_default, :required_string,
                    :optional_string, :inline_errors, :label_str_method, :collection_label_methods,
-                   :inline_order, :file_methods, :priority_countries
+                   :inline_order, :file_methods, :priority_countries, :i18n_lookups_by_default
+
+    I18N_SCOPES = [ '{{model}}.{{action}}.{{attribute}}',
+                    '{{model}}.{{attribute}}',
+                    '{{attribute}}']
 
     # Keeps simple mappings in a hash
     INPUT_MAPPINGS = {
@@ -347,6 +352,7 @@ def label(method, options_or_text=nil, options=nil)
         options ||= {}
       end
 
+      text = localized_attribute_string(method, text, :label)
       text ||= humanized_attribute_name(method)
       text  << required_or_optional_string(options.delete(:required))
 
@@ -458,7 +464,7 @@ def method_required?(attribute) #:nodoc:
     #
     def input_simple(type, method, options)
       html_options = options.delete(:input_html) || {}
-      html_options = default_string_options(method).merge(html_options) if STRING_MAPPINGS.include?(type)
+      html_options = default_string_options(method, type).merge(html_options) if STRING_MAPPINGS.include?(type)
 
       self.label(method, options.slice(:label, :required)) +
       self.send(INPUT_MAPPINGS[type], method, html_options)
@@ -907,6 +913,7 @@ def inline_input_for(method, options)
     # Generates hints for the given method using the text supplied in :hint.
     #
     def inline_hints_for(method, options) #:nodoc:
+      options[:hint] = localized_attribute_string(method, options[:hint], :hint)
       return if options[:hint].blank?
       template.content_tag(:p, options[:hint], :class => 'inline-hints')
     end
@@ -995,8 +1002,6 @@ def field_set_and_list_wrapping_for_method(method, options, contents)
     # default is a :string, a similar behaviour to Rails' scaffolding.
     #
     def default_input_type(method) #:nodoc:
-      return :string if @object.nil?
-
       column = @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
 
       if column
@@ -1011,10 +1016,13 @@ def default_input_type(method) #:nodoc:
         # otherwise assume the input name will be the same as the column type (eg string_input)
         return column.type
       else
-        obj = @object.send(method) if @object.respond_to?(method)
+        if @object
+          return :select if find_reflection(method)
+
+          file = @object.send(method) if @object.respond_to?(method)
+          return :file   if file && @@file_methods.any? { |m| file.respond_to?(m) }
+        end
 
-        return :select   if find_reflection(method)
-        return :file     if obj && @@file_methods.any? { |m| obj.respond_to?(m) }
         return :password if method.to_s =~ /password/
         return :string
       end
@@ -1108,7 +1116,7 @@ def find_reflection(method)
     # Generates default_string_options by retrieving column information from
     # the database.
     #
-    def default_string_options(method) #:nodoc:
+    def default_string_options(method, type) #:nodoc:
       column = @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
 
       if column.nil? || column.limit.nil? 
@@ -1166,6 +1174,33 @@ def humanized_attribute_name(method)
       end
     end
 
+    def localized_attribute_string(attr_name, attr_value, i18n_key)
+      if attr_value.is_a?(String)
+        attr_value
+      else
+        use_i18n = attr_value.nil? ? @@i18n_lookups_by_default : attr_value
+        if use_i18n
+          model_name = @object.class.name.underscore
+          action_name = template.params[:action].to_s rescue ''
+          attribute_name = attr_name.to_s
+
+          defaults = I18N_SCOPES.collect do |i18n_scope|
+            i18n_path = i18n_scope.dup
+            i18n_path.gsub!('{{action}}', action_name)
+            i18n_path.gsub!('{{model}}', model_name)
+            i18n_path.gsub!('{{attribute}}', attribute_name)
+            i18n_path.gsub!('..', '.')
+            i18n_path.to_sym
+          end
+          defaults << ''
+
+          i18n_value = ::I18n.t(defaults.shift, :default => defaults,
+                                :scope => "formtastic.#{i18n_key.to_s.pluralize}")
+          i18n_value.blank? ? nil : i18n_value
+        end
+      end
+    end
+
   end
 
   # Wrappers around form_for (etc) with :builder => SemanticFormBuilder.

spec/formtastic_spec.rb

@@ -573,13 +573,20 @@ def custom(arg1, arg2, options = {})
 
           describe 'when not provided' do
 
-            it 'should default to a string for forms without objects' do
+            it 'should default to a string for forms without objects unless column is password' do
               semantic_form_for(:project, :url => 'http://test.host') do |builder|
                 concat(builder.input(:anything))
               end
               output_buffer.should have_tag('form li.string')
             end
 
+            it 'should default to password for forms without objects if column is password' do
+              semantic_form_for(:project, :url => 'http://test.host') do |builder|
+                concat(builder.input(:password))
+              end
+              output_buffer.should have_tag('form li.password')
+            end
+
             it 'should default to a string for methods on objects that don\'t respond to "column_for_attribute"' do
               @new_post.stub!(:method_without_a_database_column)
               @new_post.stub!(:column_for_attribute).and_return(nil)
@@ -688,45 +695,84 @@ def custom(arg1, arg2, options = {})
         end
 
         describe ':label option' do
-
+          
           describe 'when provided' do
-
             it 'should be passed down to the label tag' do
               semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title, :label => "Kustom"))
               end
               output_buffer.should have_tag("form li label", /Kustom/)
             end
-
           end
 
           describe 'when not provided' do
-            describe 'and object is not given' do
-              it 'should default the humanized method name, passing it down to the label tag' do
-                Formtastic::SemanticFormBuilder.label_str_method = :humanize
-
-                semantic_form_for(:project, :url => 'http://test.host') do |builder|
-                  concat(builder.input(:meta_description))
+            describe 'when localized label is NOT provided' do
+              describe 'and object is not given' do
+                it 'should default the humanized method name, passing it down to the label tag' do
+                  Formtastic::SemanticFormBuilder.label_str_method = :humanize
+              
+                  semantic_form_for(:project, :url => 'http://test.host') do |builder|
+                    concat(builder.input(:meta_description))
+                  end
+              
+                  output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+                end
+              end
+              
+              describe 'and object is given' do
+                it 'should delegate the label logic to class human attribute name and pass it down to the label tag' do
+                  @new_post.stub!(:meta_description) # a two word method name
+                  @new_post.class.should_receive(:human_attribute_name).with('meta_description').and_return('meta_description'.humanize)
+              
+                  semantic_form_for(@new_post) do |builder|
+                    concat(builder.input(:meta_description))
+                  end
+              
+                  output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
                 end
-
-                output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
               end
             end
-
-            describe 'and object is given' do
-              it 'should delegate the label logic to class human attribute name and pass it down to the label tag' do
-                @new_post.stub!(:meta_description) # a two word method name
-                @new_post.class.should_receive(:human_attribute_name).with('meta_description').and_return('meta_description'.humanize)
-
+            
+            describe 'when localized label is provided' do
+              before do
+                @localized_label_text = 'Localized title'
+                @default_localized_label_text = 'Default localized title'
+                ::I18n.backend.store_translations :en,
+                  :formtastic => {
+                      :labels => {
+                        :title => @default_localized_label_text,
+                        :post => {
+                          :title => @localized_label_text
+                         }
+                       }
+                    }
+                ::Formtastic::SemanticFormBuilder.i18n_lookups_by_default = false
+              end
+
+              it 'should render a label with localized label (I18n)' do
                 semantic_form_for(@new_post) do |builder|
-                  concat(builder.input(:meta_description))
+                  concat(builder.input(:title, :label => true))
                 end
-
-                output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+                output_buffer.should have_tag('form li label', @localized_label_text)
+              end
+
+              it 'should render a hint paragraph containing an optional localized label (I18n) if first is not set' do
+                ::I18n.backend.store_translations :en,
+                  :formtastic => {
+                      :labels => {
+                        :post => {
+                          :title => nil
+                         }
+                       }
+                    }
+                semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title, :label => true))
+                end
+                output_buffer.should have_tag('form li label', @default_localized_label_text)
               end
             end
           end
-
+          
         end
 
         describe ':hint option' do
@@ -742,12 +788,63 @@ def custom(arg1, arg2, options = {})
           end
 
           describe 'when not provided' do
-            it 'should not render a hint paragraph' do
-              hint_text = "this is the title of the post"
-              semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:title))
+            describe 'when localized hint (I18n) is provided' do
+              before do
+                @localized_hint_text = "This is the localized hint."
+                @default_localized_hint_text = "This is the default localized hint."
+                ::I18n.backend.store_translations :en,
+                  :formtastic => {
+                      :hints => {
+                        :title => @default_localized_hint_text,
+                        :post => {
+                          :title => @localized_hint_text
+                         }
+                       }
+                    }
+                ::Formtastic::SemanticFormBuilder.i18n_lookups_by_default = false
+              end
+              
+              describe 'when provided value (hint value) is set to TRUE' do
+                it 'should render a hint paragraph containing a localized hint (I18n)' do
+                  semantic_form_for(@new_post) do |builder|
+                    concat(builder.input(:title, :hint => true))
+                  end
+                  output_buffer.should have_tag('form li p.inline-hints', @localized_hint_text)
+                end
+                
+                it 'should render a hint paragraph containing an optional localized hint (I18n) if first is not set' do
+                  ::I18n.backend.store_translations :en,
+                  :formtastic => {
+                      :hints => {
+                        :post => {
+                          :title => nil
+                         }
+                       }
+                    }
+                  semantic_form_for(@new_post) do |builder|
+                    concat(builder.input(:title, :hint => true))
+                  end
+                  output_buffer.should have_tag('form li p.inline-hints', @default_localized_hint_text)
+                end
+              end
+              
+              describe 'when provided value (label value) is set to FALSE' do
+                it 'should not render a hint paragraph' do
+                  semantic_form_for(@new_post) do |builder|
+                    concat(builder.input(:title, :hint => false))
+                  end
+                  output_buffer.should_not have_tag('form li p.inline-hints', @localized_hint_text)
+                end
+              end
+            end
+            
+            describe 'when localized hint (I18n) is not provided' do
+              it 'should not render a hint paragraph' do
+                semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title))
+                end
+                output_buffer.should_not have_tag('form li p.inline-hints')
               end
-              output_buffer.should_not have_tag("form li p.inline-hints")
             end
           end
 
@@ -922,31 +1019,33 @@ def custom(arg1, arg2, options = {})
             output_buffer.should have_tag("form li input[@name=\"post[title]\"]")
           end
 
-          it 'should have a maxlength matching the column limit' do
-            @new_post.column_for_attribute(:title).limit.should == 50
-            output_buffer.should have_tag("form li input[@maxlength='50']")
-          end
+          unless type == :numeric
+            it 'should have a maxlength matching the column limit' do
+              @new_post.column_for_attribute(:title).limit.should == 50
+              output_buffer.should have_tag("form li input[@maxlength='50']")
+            end
 
-          it 'should use default_text_field_size for columns longer than default_text_field_size' do
-            default_size = Formtastic::SemanticFormBuilder.default_text_field_size
-            @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => type, :limit => default_size * 2))
+            it 'should use default_text_field_size for columns longer than default_text_field_size' do
+              default_size = Formtastic::SemanticFormBuilder.default_text_field_size
+              @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => type, :limit => default_size * 2))
 
-            semantic_form_for(@new_post) do |builder|
-              concat(builder.input(:title, :as => type))
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title, :as => type))
+              end
+
+              output_buffer.should have_tag("form li input[@size='#{default_size}']")
             end
 
-            output_buffer.should have_tag("form li input[@size='#{default_size}']")
-          end
+            it 'should use the column size for columns shorter than default_text_field_size' do
+              column_limit_shorted_than_default = 1
+              @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => type, :limit => column_limit_shorted_than_default))
 
-          it 'should use the column size for columns shorter than default_text_field_size' do
-            column_limit_shorted_than_default = 1
-            @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => type, :limit => column_limit_shorted_than_default))
+              semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title, :as => type))
+              end
 
-            semantic_form_for(@new_post) do |builder|
-              concat(builder.input(:title, :as => type))
+              output_buffer.should have_tag("form li input[@size='#{column_limit_shorted_than_default}']")
             end
-
-            output_buffer.should have_tag("form li input[@size='#{column_limit_shorted_than_default}']")
           end
 
           it 'should use default_text_field_size for methods without database columns' do