jerome-localized-frontend 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 August Lilleaas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,54 @@
+= Localized Frontend
+
+http://gitorious.org/projects/localized-frontend/
+http://github.com/leethal/localized-frontend/
+
+Localizing the front-end of single language Rails apps.
+
+The localizations are stored in YAML files. Create a spanish.yml file, call 
+LocalizedFrontend.in :spanish somewhere in your app (probably in environment.rb or an
+initializer), and rejoice!
+
+It localizes inflectors (pluralize, singularize etc), Active Record error messages, month
+and day names, form labels (<%= f.label :foo %>) and Array#to_sentence.
+
+== To contributors
+
+Feel free to submit your own translations and localizations! You can mail me patches on
+augustlilleaas@gmail.com, or you can fork the Git repository on 
+http://github.com/leethal/localized-frontend/ and send a pull request. Or write it down on
+paper and mail it to me. Your call!
+
+Keep in mind that the YAML file is whiny - certain keys and values are required in
+order to avoid errors being raised. At the moment, the tests are hardcoded in Norwegian.
+That should probably change, so that one can set the language in an environment
+variable and run the tests in whatever language one might prefer.
+
+Also, the code is fairly hard to grok, as it's mostly monkey patches. Feel free to improve
+the readability of the code!
+
+== What it does
+
+Here's a short list of features (examples are in norwegian)
+
+Localizing %b, %B, %a and %A in Time#strftime, Date#strftime and DateTime#strftime
+
+* Time.now.strftime('%b') => okt
+* Time.now.strftime('%b') => oktober
+* Time.now.strftime('%a') => søn
+* Time.now.strftime('%A') => søndag
+    
+Localized inflections. "bil".pluralize => "biler"
+
+Localizing attribute names in ActiveRecord.
+
+ class Question < ActiveRecord::Base
+   localized_fields :question => "Spørsmål", :answer => "Svar"
+ end
+    
+== TODO
+
+* Make tests runnable in any language. In other words, don't let tests be hardcoded in Norwegian.
+
+
+Copyright (c) 2008 August Lilleaas, released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the translated plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the translated plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Translated'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,2 @@
+* Look for deprecation errors and kill them on sight!
+* http://github.com/rails/rails/commit/4f75840d72b96fff34d65b59480da7d6c7494120

data/init.rb

@@ -0,0 +1 @@
+require 'localized_frontend'

data/lib/localized_frontend.rb

@@ -0,0 +1,15 @@
+require 'localized_frontend/core'
+require 'localized_frontend/inflector_extension'
+require 'localized_frontend/active_record_extension'
+require 'localized_frontend/strftime'
+require 'localized_frontend/to_sentence'
+require 'localized_frontend/form_labels'
+require 'localized_frontend/date_helper'
+
+module LocalizedFrontend
+  # Raised when a localization method is called but the language isn't set. Set it with
+  # <tt>LocalizedFrontend.in</tt>.
+  class LanguageNotSet < StandardError; end
+
+  include Core
+end

data/lib/localized_frontend/active_record_extension.rb

@@ -0,0 +1,13 @@
+%w(translatable_column_names error_messages).each do |extension|
+  require File.join(File.dirname(__FILE__), 'active_record_extension', extension)
+end
+
+module LocalizedFrontend
+  # Active Record extensions. Refer to child modules for the rock 'n roll.
+  module ActiveRecordExtension
+    def self.included(base)
+      include TranslatableColumnNames
+      include ErrorMessages
+    end
+  end
+end

data/lib/localized_frontend/active_record_extension/error_messages.rb

@@ -0,0 +1,29 @@
+module LocalizedFrontend
+  module ActiveRecordExtension
+    # Hooks into Active Record's validations so that error messages returns a localized version of
+    # the column names, if defined. See TranslatableColumnNames for information on how to define
+    # these localizations.
+    module ErrorMessages
+      def self.included(base)
+        replace_default_error_messages
+        hook_human_attribute_name
+      end
+      
+      # Merge the localized definitions into Active Record's definitions.
+      def self.replace_default_error_messages
+        ActiveRecord::Errors.default_error_messages.merge!(LocalizedFrontend['validation_error_messages'].symbolize_keys)
+      end
+      
+      # human_attribute_name is what Active Record calls when looking for the attribute name on
+      # error messages. This method injects a localization attempt that fallbacks on the default
+      # column name representation if no localization was found.
+      def self.hook_human_attribute_name
+        ActiveRecord::Base.class_eval do
+          def self.human_attribute_name(attribute)
+            localized_fields[attribute] || attribute.humanize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/localized_frontend/active_record_extension/translatable_column_names.rb

@@ -0,0 +1,34 @@
+module LocalizedFrontend
+  module ActiveRecordExtension
+    # Makes localized attribute names defineable in models. Example:
+    #
+    #  class Post < ActiveRecord::Base
+    #    localized_fields :title => 'Smuuk smiik smakeke'
+    #  end
+    module TranslatableColumnNames
+      def self.included(base)
+        ActiveRecord::Base.class_inheritable_accessor :localized_attributes
+        ActiveRecord::Base.extend ClassMethods
+      end
+      
+      module ClassMethods
+        # Stores a set of localized attributes in a hash, so that these localized variants can be
+        # used to localize validation error messages.
+        # 
+        #  class Post < ActiveRecord::Base
+        #    localized_fields :title => 'Smuuk smiik smakeke'
+        #    validates_presence_of :title
+        #  end
+        #
+        #  p = Post.new
+        #  p.valid?
+        #  p.errors.full_messages # => ['Smuuk smiik smakeke is required']
+        #  # (fyi, the 'is required' part can also be localized)
+        def localized_fields(options = {})
+          self.localized_attributes ||= HashWithIndifferentAccess.new
+          self.localized_attributes.merge!(options)
+        end
+      end
+    end
+  end
+end

data/lib/localized_frontend/core.rb

@@ -0,0 +1,62 @@
+module LocalizedFrontend
+  # The main module that adds class methods to LocalizedFrontend and creates the hooks we need. See
+  # the individual methods for more information.
+  module Core
+    # Creates the LocalizedFrontend.language accessor and stuff.
+    def self.included(base)
+      base.mattr_accessor :language
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      # Sets the current language.
+      #
+      #  LocalizedFrontend.in :french
+      def in(language)
+        self.language = language
+        first_time_inclusion
+        change_language!
+      end
+
+      # Returns the current language as a hash, or raises LanguageNotSet if (woha) the language isn't set.
+      def current_language(reload = false)
+        begin
+          @current_language = nil if reload
+          @current_language ||= YAML::load_file(File.join(File.dirname(__FILE__), "..", "translations", "#{language}.yml"))
+        rescue Errno::ENOENT
+          raise LocalizedFrontend::LanguageNotSet
+        end
+      end
+      
+      # A shortcut to current language. These are equivalents:
+      #
+      #  LocalizedFrontend.current_language['foos']
+      #  LocalizedFrontend['foos']
+      def [](key)
+        current_language[key]
+      end
+      
+      private
+      
+      # Dirty. Fix, please.
+      def first_time_inclusion
+        return if @included
+        
+        LocalizedFrontend.class_eval do
+          include InflectorExtension
+          include ActiveRecordExtension
+          include Strftime
+          include ToSentence
+          include FormLabels
+        end
+        
+        @included = true
+      end
+      
+      def change_language!
+        # Reload the current language hash.
+        current_language(true)
+      end
+    end
+  end
+end

data/lib/localized_frontend/date_helper.rb

@@ -0,0 +1,36 @@
+module LocalizedFrontend
+  module DateHelper
+    def self.included(base)
+      ActionView::Helpers::DateHelper.class_eval do
+        def select_month_with_localization(date, options = {}, html_options = {})
+          val = date ? (date.kind_of?(Fixnum) ? date : date.month) : ''
+          if options[:use_hidden]
+            hidden_html(options[:field_name] || 'month', val, options)
+          else
+            month_options = []
+            month_names = options[:use_month_names] || (options[:use_short_month] ? LocalizedFrontend['month_names']['abbreviated']: LocalizedFrontend['month_names']['full'])
+            month_names.unshift(nil) if month_names.size < 13
+            1.upto(12) do |month_number|
+              month_name = if options[:use_month_numbers]
+                month_number
+              elsif options[:add_month_numbers]
+                month_number.to_s + ' - ' + month_names[month_number]
+              else
+                month_names[month_number]
+              end
+
+              month_options << ((val == month_number) ?
+                content_tag(:option, month_name, :value => month_number, :selected => "selected") :
+                content_tag(:option, month_name, :value => month_number)
+              )
+              month_options << "\n"
+            end
+            select_html(options[:field_name] || 'month', month_options.join, options, html_options)
+          end
+        end
+      end
+      
+      ActionView::Helpers::DateHelper.alias_method_chain :select_month, :localization
+    end
+  end
+end

data/lib/localized_frontend/form_labels.rb

@@ -0,0 +1,20 @@
+module LocalizedFrontend
+  # The default form builders label method tries to find a localized definition
+  # of the attribute.
+  #
+  #  <%= f.label :title %> (returns 'Localized Version of Title That Is Defined In the Model')
+  module FormLabels
+    def self.included(base)
+      ActionView::Helpers::FormBuilder.class_eval do
+        def label_with_localization(method, text = nil, options = {})
+          if @object
+            text ||= @object.class.localized_attributes ? @object.class.localized_attributes[method] : nil
+          end
+          label_without_localization(method, text, options)
+        end
+      end
+      
+      ActionView::Helpers::FormBuilder.alias_method_chain :label, :localization
+    end
+  end
+end

data/lib/localized_frontend/inflector_extension.rb

@@ -0,0 +1,131 @@
+module LocalizedFrontend
+  # Handles localization of inflections (pluralize, singularize etc.)
+  module InflectorExtension
+    def self.included(base)
+      add_localized_pluralizations_to_string
+      extend_inflector_class
+      initialize_localized_rules
+      set_localized_inflections
+    end
+    
+    # Adds the local_puralize and local_singularize methods to String. These methods are
+    # used to get a localized pluralization/singularization.
+    # 
+    #  LocalizedFrontend.in :norwegian
+    #  "car".pluralize # => "cars"
+    #  "car".local_pluralize # => "carer"
+    #  "bil".local_pluralize # => "biler"
+    def self.add_localized_pluralizations_to_string
+      String.class_eval { include StringInstanceMethods }
+    end
+    
+    # Hooks into the inflector instance and adds the methods we need in order to get
+    # localized inflections. The real meat is the in_localized_scope method.
+    def self.extend_inflector_class
+      Inflector.inflections.class.class_eval { attr_accessor :localize }
+      Inflector.inflections.instance_eval { extend InflectorInstanceMethods }
+    end
+    
+    # We store the localized inflections in a separate set of instance variables. See
+    # InflectorInstanceMethods
+    def self.initialize_localized_rules
+      Inflector.inflections.instance_eval do
+        @localized_plurals, @localized_singulars, @localized_uncountables = [], [], []
+      end
+    end
+    
+    # The real meat that loops through the defined inflections and hooks them into the
+    # monkey patched Inflector.
+    def self.set_localized_inflections
+      Inflector.inflections.plurals
+      Inflector.inflections.in_localized_scope do
+        Inflector.inflections.current_scope('plurals')
+      end
+      Inflector.inflections.in_localized_scope do
+        %w(singular plural irregular).each do |type|
+          next unless LocalizedFrontend['inflections'][type]
+          
+          LocalizedFrontend['inflections'][type].each do |rule, replacement|
+            Inflector.inflections.send(type, case_insensitive_regular_expression(rule), replacement)
+          end
+        end
+        
+        Inflector.inflections.uncountable(LocalizedFrontend['inflections']['uncountable'])
+      end
+    end
+    
+    # That's what the 'true' means. Case insensitive.
+    def self.case_insensitive_regular_expression(rule)
+      Regexp.new(rule, true)
+    end
+    
+    # The in_localized_scope method is the only thing you need here. Everything else is obscure
+    # and retarded.
+    #
+    # The methods +plural+, +singular+ and +uncountable+ is a simple re-definition of the original
+    # method in Inflector. The change is simple - use methods instead of instance variables. So, when
+    # the +plural+ method used to do @plurals.insert, we change it so that it does plurals.insert. Then,
+    # these methods (+singulars+, +plurals+ and +uncountables+) are returning the inflections we want in
+    # the language we request. If +Inflector.inflections.localize+ is set to true, we'll get
+    # @localized_plurals. If it's set to false, we get the default @plurals (which the original,
+    # un-overrided methods was originally using).
+    #
+    # +irregulars+ are not re-defined, as that method is calling the +plural+ and +singular+ methods
+    # anyway. Which we have already overrided.
+    module InflectorInstanceMethods
+      # Sets the scope as localized. This is what String#local_pluralize and friends does.
+      #
+      #  "car".pluralize # => "cars"
+      #  "car".localized_pluralize # => "carer"
+      #  Inflector.inflections.in_localized_scope { "car".pluralize } # => "carer"
+      def in_localized_scope(&block)
+        self.localize = true
+        result = yield
+        self.localize = false
+        
+        result
+      end
+      
+      def current_scope(type)
+        prefix = localize ? "localized_" : nil
+        instance_variable_get("@#{prefix}#{type}") 
+      end
+      
+      def singulars
+        current_scope(:singulars)
+      end
+      
+      def plurals
+        current_scope(:plurals)
+      end
+      
+      def uncountables
+        current_scope(:uncountables)
+      end
+      
+      def plural(rule, replacement)
+        plurals.insert(0, [rule, replacement])
+      end
+      
+      def singular(rule, replacement)
+        singulars.insert(0, [rule, replacement])
+      end
+      
+      def uncountable(*words)
+        (uncountables << words).flatten!
+      end
+    end
+    
+    module StringInstanceMethods
+      # A localized version of String#pluralize
+      def local_pluralize
+        Inflector.inflections.in_localized_scope { pluralize }
+      end
+      
+      # A localized version of String#singularize
+      def local_singularize
+        Inflector.inflections.in_localized_scope { singularize }
+      end
+    end
+  end
+end

data/lib/localized_frontend/strftime.rb

@@ -0,0 +1,36 @@
+module LocalizedFrontend
+  # Localizes Time#strftime, Date#strftime and DateTime#strftime.
+  module Strftime
+    # Includes the InstanceMethods module into Time, Date and DateTime.
+    def self.included(base)
+      [Time, Date, DateTime].each do |klass|
+        klass.class_eval { include InstanceMethods }
+      end
+    end
+    
+    module InstanceMethods
+      def self.included(base)
+        base.alias_method_chain :strftime, :localization
+      end
+      
+      # A rather ugly hack that gsubs the keys we're looking for and replaces it with
+      # localized strings, and then passes the format string to the original strftime
+      # method. "%Y %B" turns into, say, "%Y Juni", and is passed to strftime.
+      #
+      # Time/Date/DateTime#strftime_without_localization can be called in order to 
+      # bypass this.
+      def strftime_with_localization(format = '%F')
+        _weekday = self.wday  - 1
+        _month   = self.month - 1 
+        
+        format.gsub!(/%a/, LocalizedFrontend['day_names']['abbreviated'][_weekday])
+        format.gsub!(/%A/, LocalizedFrontend['day_names']['full'][_weekday])
+        
+        format.gsub!(/%b/, LocalizedFrontend['month_names']['abbreviated'][_month])
+        format.gsub!(/%B/, LocalizedFrontend['month_names']['full'][_month])
+
+        strftime_without_localization(format)
+      end
+    end
+  end
+end

data/lib/localized_frontend/to_sentence.rb

@@ -0,0 +1,19 @@
+module LocalizedFrontend
+  # Localizes the connector and the skip_last_comma settings for Array#to_sentence
+  module ToSentence
+    def self.included(base)
+      Array.class_eval { include InstanceMethods }
+    end
+    
+    module InstanceMethods
+      def self.included(base)
+        base.alias_method_chain :to_sentence, :localization
+      end
+
+      def to_sentence_with_localization(options = {})
+        options.reverse_merge! :connector => LocalizedFrontend['to_sentence']['connector'], :skip_last_comma => LocalizedFrontend['to_sentence']['skip_last_comma']
+        to_sentence_without_localization(options)
+      end
+    end
+  end
+end

data/lib/translations/french.yml

@@ -0,0 +1,59 @@
+day_names:
+  abbreviated:
+    - Dim
+    - Lun
+    - Mar
+    - Mer
+    - Jeu
+    - Ven
+    - Sam
+  full:
+    - Dimanche
+    - Lundi
+    - Mardi
+    - Mercredi
+    - Jeudi
+    - Vendredi
+    - Samedi
+
+month_names:
+  abbreviated:
+    - jan
+    - fév
+    - mar
+    - avr
+    - mai
+    - jun
+    - jul
+    - aou
+    - sep
+    - oct
+    - nov
+    - dec
+  full:
+    - janvier
+    - février
+    - mars
+    - avril
+    - mai
+    - juin
+    - juillet
+    - août
+    - septembre
+    - octobre
+    - novembre
+    - décembre
+
+inflections:
+  plural:
+    '$': 's'
+  singular:
+    's$': ''
+  uncountable:
+
+to_sentence:
+  connector: et
+  skip_last_comma: true
+  
+validation_error_messages:
+  inclusion: n'est pas dans la liste

data/lib/translations/norwegian.yml

@@ -0,0 +1,79 @@
+day_names:
+  abbreviated:
+    - Søn
+    - Man
+    - Tir
+    - Ons
+    - Tor
+    - Fre
+    - Lør
+  full:
+    - Søndag
+    - Mandag
+    - Tirsdag
+    - Onsdag
+    - Torsdag
+    - Fredag
+    - Lørdag
+
+month_names:
+  abbreviated:
+    - Jan
+    - Feb
+    - Mar
+    - Apr
+    - Mai
+    - Jun
+    - Jul
+    - Aug
+    - Sep
+    - Okt
+    - Nov
+    - Des
+  full:
+    - Januar
+    - Februar
+    - Mars
+    - April
+    - Mai
+    - Juni
+    - Juli
+    - August
+    - September
+    - Oktober
+    - November
+    - Desember
+
+inflections:
+  plural:
+    '$': 'er'
+  singular:
+    'er$': ''
+  uncountable:
+    - hus
+    - tak
+
+to_sentence:
+  connector: og
+  skip_last_comma: true
+  
+validation_error_messages:
+  inclusion: er ikke i lista
+  exclusion: er reservert
+  invalid: er ugyldig
+  confirmation: stemmer ikke overens
+  accepted: må aksepteres
+  empty: må fylles ut
+  blank: må fylles ut
+  too_long: er for lang (maks %d tegn)
+  too_short: er for kort (minst %d tegn)
+  wrong_length: har feil lengde (skal være %d tegn)
+  taken: er allerede tatt
+  not_a_number: må være et tall
+  greater_than: må være høyere enn %d
+  greater_than_or_equal_to: må være høyere enn eller lik %d
+  equal_to: må være %d
+  less_than: må være mindre enn %d
+  less_than_or_equal_to: må være mindre enn eller lik %d
+  odd: må være et oddetall
+  even: må være et partall

data/test/active_record_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ActiveRecordExtensionTest < Test::Unit::TestCase
+  def test_table_name_pluralization
+    assert_equal 'posts', Post.table_name
+  end
+  
+  def test_setting_localized_fields
+    assert_equal 'Tittel', Post.localized_fields[:title]
+    assert_equal 'Tittel', Post.localized_fields['title']
+  end
+  
+  def test_overriding_default_error_messages
+    assert_equal ActiveRecord::Errors.default_error_messages[:too_short], LocalizedFrontend['validation_error_messages']['too_short']
+  end
+  
+  def test_actual_error_message_output
+    message = ActiveRecord::Errors.default_error_messages[:blank]
+    p = Post.new
+    p.valid?
+    
+    assert_equal message, p.errors.on(:title)
+    assert p.errors.full_messages.include?("Tittel #{message}")
+  end
+end

data/test/everything_else_test.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class EverythingElseTest < Test::Unit::TestCase
+  def test_to_sentence
+    assert_equal 'Per, Pål og Espen Askeladd', ['Per', 'Pål', 'Espen Askeladd'].to_sentence
+    assert_equal 'Du, jeg, eller meg', ['Du', 'jeg', 'meg'].to_sentence(:connector => 'eller', :skip_last_comma => false)
+  end
+  
+  def test_to_sentence_again
+    assert_equal 'Per, Pål og Espen Askeladd', ['Per', 'Pål', 'Espen Askeladd'].to_sentence
+    assert_equal 'Du, jeg, eller meg', ['Du', 'jeg', 'meg'].to_sentence(:connector => 'eller', :skip_last_comma => false)
+  end
+end

data/test/form_labels_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TranslatedTest < Test::Unit::TestCase
+  def setup
+    LocalizedFrontend.in :norwegian
+    
+    @controller  = DummyController.new
+    @request     = @controller.request
+    
+    @view = ActionView::Base.new
+    @view.assigns['controller'] = @controller
+    @view.assigns['_request']   = @request
+    @view.assigns['_params']    = @request.params
+  end
+  
+  def test_localized_label
+    render '<% form_for(Post.new) do |f| %><%= f.label :excerpt %><%= f.label :cheese %><% end %>'
+    assert @output =~ Regexp.new('<label for="post_excerpt">Ingress</label>')
+    #raise @output.inspect
+  end
+  
+  def test_original_label
+    render '<% form_for(Post.new) do |f| %><%= f.label :excerpt %><%= f.label :cheese %><% end %>'
+    assert @output =~ Regexp.new('<label for="post_cheese">Cheese</label>')
+  end
+  
+  def test_unlocalized_model
+    render '<% form_for(UnlocalizedFoo.new) do |f| %><%= f.label :foo %><% end %>'
+    assert @output =~ Regexp.new('<label for="unlocalized_foo_foo">Foo</label>')
+  end
+  
+  def test_symbol
+    render '<% form_for(:foo) do |f| %><%= f.label :bar %><% end %>'
+  end
+  
+  private
+  
+  def render(template)
+    @output = @view.render_template(ActionView::InlineTemplate.new(@view, template))
+  end
+end

data/test/inflector_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class InflectorTest < Test::Unit::TestCase
+  def test_original_english_inflections
+    assert_equal 'posts', 'post'.pluralize
+    assert_equal 'post', 'posts'.singularize
+  end
+  
+  def test_singularize
+    {"biler" => "bil", "katter" => "katt"}.each do |plural, singular|
+      assert_equal singular, plural.local_singularize
+    end
+  end
+  
+  def test_pluralize
+    {"bil" => "biler", "katt" => "katter"}.each do |singular, plural|
+      assert_equal plural, singular.local_pluralize
+    end
+  end
+  
+  def test_irregular
+    
+  end
+  
+  def test_pluralize_uncountable
+    %w(hus tak).each do |uncountable|
+      assert_equal uncountable, uncountable.local_pluralize
+    end
+  end
+  
+  def test_adding_inflections
+    
+  end
+  
+  def test_case_insensivity
+    assert_equal "BIL", "BILER".local_singularize
+  end
+end

data/test/strftime_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class StrftimeTest < Test::Unit::TestCase
+  def test_localized_strftime_on_time
+    assert_localized_strftime Time.now
+  end
+
+  def test_localized_strftime_on_date
+    assert_localized_strftime Date.today
+  end
+
+  def test_localized_stfrtime_on_datetime
+    assert_localized_strftime DateTime.class_eval { today }
+  end
+  
+  def test_localized_stfrtime_on_april_fools_day
+    assert_equal Time.utc(2008,4,1).strftime("%B"), "April"
+  end
+  
+  private
+
+  def assert_localized_strftime(time)
+    assert_equal LocalizedFrontend['month_names']['abbreviated'][time.month-1], time.strftime("%b")
+    assert_equal LocalizedFrontend['month_names']['full'][time.month-1], time.strftime("%B")
+    
+    assert_equal LocalizedFrontend['day_names']['abbreviated'][time.wday-1], time.strftime("%a")
+    assert_equal LocalizedFrontend['day_names']['full'][time.wday-1], time.strftime("%A")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'action_controller'
+require 'action_controller/test_process'
+
+require File.join(File.dirname(__FILE__), "..", "lib", "localized_frontend")
+LocalizedFrontend.in :norwegian
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :posts do |t|
+    t.string :title, :cheese
+    t.text :excerpt, :body
+  end
+  
+  create_table(:unlocalized_foos) {|t| t.string :foo }
+end
+
+class Post < ActiveRecord::Base
+  localized_fields :title => "Tittel", :excerpt => "Ingress", :body => "Brødtekst"
+
+  validates_presence_of :title, :excerpt, :body
+end
+
+class UnlocalizedFoo < ActiveRecord::Base
+end
+
+# The following is ninjaed from will_paginate.
+ActionController::Routing::Routes.draw do |map| 
+  map.resources :posts, :unlocalized_foos
+  map.connect ':controller/:action/:id'
+end
+ActionController::Base.perform_caching = false
+
+class ActionView::Base
+  def protect_against_forgery?
+    false
+  end
+end
+class DummyRequest
+  attr_accessor :symbolized_path_parameters
+  
+  def initialize
+    @get = true
+    @params = {}
+    @symbolized_path_parameters = { :controller => 'foo', :action => 'bar' }
+  end
+
+  def relative_url_root
+    ''
+  end
+
+  def params(more = nil)
+    @params.update(more) if more
+    @params
+  end
+end
+
+class DummyController
+  attr_reader :request
+  attr_accessor :controller_name
+  
+  def initialize
+    @request = DummyRequest.new
+    @url = ActionController::UrlRewriter.new(@request, @request.params)
+  end
+
+  def params
+    @request.params
+  end
+  
+  def url_for(params)
+    @url.rewrite(params)
+  end
+end

data/test/translated_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TranslatedTest < Test::Unit::TestCase
+  def test_setting_language
+    LocalizedFrontend.in :norwegian
+    assert_equal :norwegian, LocalizedFrontend.language
+  end
+  
+  def test_fails_with_no_language_set
+    LocalizedFrontend.language = nil
+    assert_raises(LocalizedFrontend::LanguageNotSet) { LocalizedFrontend.current_language(true) }
+    assert_raises(LocalizedFrontend::LanguageNotSet) { LocalizedFrontend['month_names'] }
+  end
+  
+  def test_current_language
+    assert LocalizedFrontend.current_language.is_a?(Hash)
+  end
+  
+  def test_accessing_with_brackets
+    assert_equal LocalizedFrontend['month_names'], LocalizedFrontend.current_language['month_names']
+  end
+  
+  def test_changing_language
+    norwegian = LocalizedFrontend.current_language.dup
+    LocalizedFrontend.in :french
+    assert_not_equal norwegian, LocalizedFrontend.current_language
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: jerome-localized-frontend
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- August Lilleaas
+- "J\xC3\xA9r\xC3\xB4me Lipowicz"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: augustlilleaas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- init.rb
+- MIT-LICENSE
+- Rakefile
+- README
+- TODO
+- lib/localized_frontend.rb
+- lib/localized_frontend/active_record_extension.rb
+- lib/localized_frontend/core.rb
+- lib/localized_frontend/date_helper.rb
+- lib/localized_frontend/form_labels.rb
+- lib/localized_frontend/inflector_extension.rb
+- lib/localized_frontend/strftime.rb
+- lib/localized_frontend/to_sentence.rb
+- lib/translations/french.yml
+- lib/translations/norwegian.yml
+- lib/localized_frontend/active_record_extension/error_messages.rb
+- lib/localized_frontend/active_record_extension/translatable_column_names.rb
+has_rdoc: false
+homepage: http://github.com/leethal/localized-frontend/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Localize the frontend of single language Rails apps.
+test_files: 
+- test/active_record_test.rb
+- test/everything_else_test.rb
+- test/form_labels_test.rb
+- test/inflector_test.rb
+- test/strftime_test.rb
+- test/test_helper.rb
+- test/translated_test.rb