translate_routes_rails_2_3 0.0.2 → 3.0.3

data/README.markdown

@@ -1,71 +1,69 @@
-TranslateRoutes 
+TranslateRoutes
 ===============
 
-This branch works with Rails 2.3.x, you can find branches for Rails [2.1.x](http://github.com/raul/translate_routes/tree/rails2.1) and [2.2.x](http://github.com/raul/translate_routes/tree/rails2.2)
+This branch works with Rails 3.x, you can find branches for Rails [2.1.x](http://github.com/raul/translate_routes/tree/rails2.1), [2.2.x](http://github.com/raul/translate_routes/tree/rails2.2) and [2.3.x](http://github.com/raul/translate_routes/tree/rails2.3)
 
-This Rails plugin provides a simple way to translate your URLs to any number of languages, even on a fully working application.  
+This Rails plugin provides a simple way to translate your URLs to any number of languages, even on a fully working application.
 
-It works fine with all kind of routing definitions, including RESTful and named routes.  
+It works fine with all kind of routing definitions, including RESTful and named routes.
 **Your current code will remain untouched**: your current routing code, helpers and links will be translated transparently - even in your tests.
 (Un)installing it is a very clean and simple process, so why don't you give it a chance? ;)
 
-This version works only with Rails 2.3.x. You can find all available versions in [the wiki](http://wiki.github.com/raul/translate_routes).
-
-Sample application
-------------------
-There is a [sample application](http://github.com/raul/translate_routes_demo/tree/master) which can be very useful to see how to integrate this plugin on your Rails application. The application itself includes all the required steps: 3 lines, an optional filter and a yaml translations file were used.
+Installation
+------------
+Add translate_routes to your `Gemfile`:
+  
+    gem 'translate_routes'
+    
+And let bundle do the rest:
 
+    bundle install
 
-Quick start
+Quick Start
 -----------
 
-Let's start with a tiny example. Of course you need to define your routes first, e.g:
+1) Let's imagine you have this `routes.rb` file:
 
-    ActionController::Routing::Routes.draw do |map| 
-      map.contact 'contact', :controller => 'contact', :action => 'index'
+    TranslateRoutesApp::Application.routes.draw do
+      match 'contact' => 'contact#index'
     end
 
-1) Download the plugin to your app's `/vendor/plugins` directory.
-
-2) Write your translations on a standard YAML file (e.g: i18n-routes.yml), including the locales and it translations pairs:
-
-    es:
-      contact: contacto
-
+You can see the available routes with the `rake routes` task:
 
-3) Append a line to your routes.rb file to activate the translations. If you loaded the translations file with
-your other I18n translations files, the line will be:
 
-    ActionController::Routing::Translator.i18n('es')
-  
-and if you want to keep the file separated (e.g: config/i18n-routes.yml), the line to append is:
+    contact  /contact(.:format) {:controller=>"contact", :action=>"index"}
 
-	ActionController::Routing::Translator.translate_from_file('config','i18n-routes.yml')
+2) Now write your translations on a standard YAML file (e.g: in `/config/i18n-routes.yml`), including all the locales and their translations pairs:
 
-You can see it working by executing `rake routes` on the shell:
+    en:
+      # you can leave empty locales, for example the default one
+    es:
+      contact: contacto
 
+3) Append this line in your `routes.rb` file to activate the translations specifying the path of the translations file:
 
-    contact_es_es_path /es-ES/contacto {:locale=>"es", :controller=>"contact", :action=>"index"}
-    contact_en_us_path /contact        {:locale=>"'en'", :controller=>"contact", :action=>"index"}
+    ActionDispatch::Routing::Translator.translate_from_file('config','i18n-routes.yml')
 
+4) Execute `rake routes` to see the new routes:
 
-As we can see, a new spanish route has been setted up and a `locale` parameter has been added to the routes.
+    contact_es  /es/contacto(.:format) {:controller=>"contact", :action=>"index"}
+    contact_en  /contact(.:format)     {:controller=>"contact", :action=>"index"}
 
-4) Include this filter in your ApplicationController:
+5) Include this filter in your ApplicationController:
 
     before_filter :set_locale_from_url
 
-Now your application recognizes the different routes and sets the `I18n.locale` value on your controllers, 
-but what about the routes generation? As you can see on the previous `rake routes` execution, the 
-`contact_es_es_path` and `contact_en_us_path` routing helpers have been generated and are 
-available in your controllers and views. Additionally, a `contact_path` helper has been generated, which 
-generates the routes according to the current request's locale. This way your link 
+Now your application recognizes the different routes and sets the `I18n.locale` value in your controllers,
+but what about the routes generation? As you can see on the previous `rake routes` execution, the
+`contact_es_es_path` and `contact_en_us_path` routing helpers have been generated and are
+available in your controllers and views. Additionally, a `contact_path` helper has been generated, which
+generates the routes according to the current request's locale. This way your link
 
 This means that if you use named routes **you don't need to modify your application links** because the routing helpers are automatically adapted to the current locale.
 
-5) Hey, but what about my tests?
+6) Hey, but what about my tests?
 
-Of course, your functional and integration testing involves some requests. 
+Of course, your functional and integration testing involves some requests.
 The plugin includes some code to add a default locale parameter so they can remain untouched.
 Append it to your `test_helper` and it will be applied.
 
@@ -80,24 +78,30 @@ Feedback, questions and comments will be always welcome at raul@murciano.net
 Credits
 -------
 * Main development:
-  * Raul Murciano <http://raul.murciano.net> - code  
-  * Domestika INTERNET S.L <http://domestika.org> - incredible support, really nice people to work with!  
+  * Raul Murciano <http://raul.murciano.net> - code
+  * Domestika INTERNET S.L <http://domestika.org> - incredible support, really nice people to work with!
 
 * Contributors:
   * [Aitor Garay-Romero](http://github.com/aitorgr)
   * [Christian Hølmer](http://github.com/hoelmer)
   * Nico Ritsche
   * [Cedric Darricau](http://github.com/devsigner)
+  * [Olivier Gonzalez](http://github.com/gonzoyumo)
+  * [Kristian Mandrup](http://github.com/kristianmandrup)
+  * [Pieter Visser](http://github.com/pietervisser)
+  * [Marian Theisen](http://github.com/cice)
+  * [Enric Lluelles](http://github.com/enriclluelles)
+  * [Jaime Iniesta](http://github.com/jaimeiniesta)
 
 Rails routing resources
 -----------------------
-* David Black's 'Rails Routing' ebook rocks! - 'Ruby for Rails' too, BTW.  
+* David Black's 'Rails Routing' ebook rocks! - 'Ruby for Rails' too, BTW.
 * Obie Fernandez's 'The Rails Way' - the definitive RoR reference, great work Obie!
 * As a part of the impressive Rails Guides set there is an [awesome document about rails routing](http://guides.rails.info/routing_outside_in.html) by Mike Gunderloy:
 
 
 License
 -------
-    Copyright (c) 2007 Released under the MIT license (see MIT-LICENSE)  
-    Raul Murciano <http://raul.murciano.net>  
+    Copyright (c) 2007 Released under the MIT license (see MIT-LICENSE)
+    Raul Murciano <http://raul.murciano.net>
     Domestika INTERNET S.L. <http://domestika.org>

data/lib/route_translator.rb

@@ -0,0 +1,306 @@
+
+# This class knows nothing
+# about Rails.root or Rails.application.routes, and therefor is easier to
+# test without an Rails App.
+class RouteTranslator
+  TRANSLATABLE_SEGMENT = /^(\w+)(\()?/.freeze
+  LOCALE_PARAM_KEY = :locale.freeze
+  ROUTE_HELPER_CONTAINER = [
+    ActionController::Base,
+    ActionView::Base,
+    ActionMailer::Base,
+    ActionDispatch::Routing::UrlFor
+  ].freeze
+
+  # Attributes
+
+  attr_accessor :dictionary
+
+  def available_locales
+    @available_locales ||= I18n.available_locales.map(&:to_s)
+  end
+
+  def available_locales= locales
+    @available_locales = locales.map(&:to_s)
+  end
+
+  def default_locale
+    @default_locale ||= I18n.default_locale.to_s
+  end
+
+  def default_locale= locale
+    @default_locale = locale.to_s
+  end
+
+  def default_locale? locale
+    default_locale == locale.to_s
+  end
+
+
+  class << self
+    # Default locale suffix generator
+    def locale_suffix locale
+      locale.to_s.underscore
+    end
+
+    # Creates a RouteTranslator instance, using I18n dictionaries of
+    # your app
+    def init_with_i18n *wanted_locales
+      new.tap do |t|
+        t.init_i18n_dictionary *wanted_locales
+      end
+    end
+
+    # Creates a RouteTranslator instance and evaluates given block
+    # with an empty dictionary
+    def init_with_yield &block
+      new.tap do |t|
+        t.yield_dictionary &block
+      end
+    end
+
+    # Creates a RouteTranslator instance and reads the translations
+    # from a specified file
+    def init_from_file file_path
+      new.tap do |t|
+        t.load_dictionary_from_file file_path
+      end
+    end
+  end
+
+  module DictionaryManagement
+    # Resets dictionary and yields the block wich can be used to manually fill the dictionary
+    # with translations e.g.
+    #   route_translator = RouteTranslator.new
+    #   route_translator.yield_dictionary do |dict|
+    #     dict['en'] = { 'people' => 'people' }
+    #     dict['de'] = { 'people' => 'personen' }
+    #   end
+    def yield_dictionary &block
+      reset_dictionary
+      yield @dictionary
+      set_available_locales_from_dictionary
+    end
+
+    # Resets dictionary and loads translations from specified file
+    # config/locales/routes.yml:
+    #   en:
+    #     people: people
+    #   de:
+    #     people: personen
+    # routes.rb:
+    #   ... your routes ...
+    #   ActionDispatch::Routing::Translator.translate_from_file
+    # or, to specify a custom file
+    #   ActionDispatch::Routing::Translator.translate_from_file 'config', 'locales', 'routes.yml'
+    def load_dictionary_from_file file_path
+      reset_dictionary
+      add_dictionary_from_file file_path
+    end
+
+    # Add translations from another file to the dictionary.
+    def add_dictionary_from_file file_path
+      yaml = YAML.load_file(file_path)
+      yaml.each_pair do |locale, translations|
+        merge_translations locale, translations
+      end
+      set_available_locales_from_dictionary
+    end
+
+    # Merge translations for a specified locale into the dictionary
+    def merge_translations locale, translations
+      locale = locale.to_s
+      if translations.blank?
+        @dictionary[locale] ||= {}
+        return
+      end
+      @dictionary[locale] = (@dictionary[locale] || {}).merge(translations)
+    end
+
+    # Init dictionary to use I18n to translate route parts. Creates
+    # a hash with a block for each locale to lookup keys in I18n dynamically.
+    def init_i18n_dictionary *wanted_locales
+      wanted_locales = available_locales if wanted_locales.blank?
+      reset_dictionary
+      wanted_locales.each do |locale|
+        @dictionary[locale] = Hash.new do |hsh, key|
+          hsh[key] = I18n.translate key, :locale => locale #DISCUSS: caching or no caching (store key and translation in dictionary?)
+        end
+      end
+      @available_locales = @dictionary.keys.map &:to_s
+    end
+
+    private
+    def set_available_locales_from_dictionary
+      @available_locales = @dictionary.keys.map &:to_s
+    end
+
+    # Resets dictionary
+    def reset_dictionary
+      @dictionary = { default_locale => {}}
+    end
+  end
+  include DictionaryManagement
+
+  module Translator
+    # Translate a specific RouteSet, usually Rails.application.routes, but can
+    # be a RouteSet of a gem, plugin/engine etc.
+    def translate route_set
+      Rails.logger.info "Translating routes (default locale: #{default_locale})" if defined?(Rails) && defined?(Rails.logger)
+
+      # save original routes and clear route set
+      original_routes = route_set.routes.dup                     # Array [routeA, routeB, ...]
+
+      original_named_routes = route_set.named_routes.routes.dup  # Hash {:name => :route}
+
+      reset_route_set route_set
+
+      original_routes.each do |original_route|
+        translations_for(original_route).each do |translated_route_args|
+          route_set.add_route *translated_route_args
+        end
+      end
+
+      original_named_routes.each_key do |route_name|
+        route_set.named_routes.helpers.concat add_untranslated_helpers_to_controllers_and_views(route_name)
+      end
+      
+    end
+
+    # Add unmodified root route to route_set
+    def add_root_route root_route, route_set
+      root_route.conditions[:path_info] = root_route.conditions[:path_info].dup
+      route_set.set.add_route *root_route
+      route_set.named_routes[root_route.name] = root_route
+      route_set.routes << root_route
+    end
+
+    # Add standard route helpers for default locale e.g.
+    #   I18n.locale = :de
+    #   people_path -> people_de_path
+    #   I18n.locale = :fr
+    #   people_path -> people_fr_path
+    def add_untranslated_helpers_to_controllers_and_views old_name
+      ['path', 'url'].map do |suffix|
+        new_helper_name = "#{old_name}_#{suffix}"
+        
+        ROUTE_HELPER_CONTAINER.each do |helper_container|
+          helper_container.send :define_method, new_helper_name do |*args|
+            send "#{old_name}_#{locale_suffix(I18n.locale)}_#{suffix}", *args
+          end
+        end
+
+        new_helper_name.to_sym
+      end
+    end
+
+    # Generate translations for a single route for all available locales
+    def translations_for route
+      available_locales.map do |locale|
+        translate_route route, locale
+      end
+    end
+
+    # Generate translation for a single route for one locale
+    def translate_route route, locale
+      conditions = { :path_info => translate_path(route.path, locale) }
+      conditions[:request_method] = route.conditions[:request_method].source.upcase if route.conditions.has_key? :request_method
+      requirements = route.requirements.merge LOCALE_PARAM_KEY => locale
+      defaults = route.defaults.merge LOCALE_PARAM_KEY => locale
+      new_name = "#{route.name}_#{locale_suffix(locale)}" if route.name
+
+      [route.app, conditions, requirements, defaults, new_name]
+    end
+
+    # Add prefix for all non-default locales
+    def add_prefix? locale
+      !default_locale?(locale)
+    end
+
+    # Translates a path and adds the locale prefix.
+    def translate_path path, locale
+      final_optional_segments = path.match(/(\(.+\))$/)[1] rescue nil   # i.e: (.:format)
+      path_segments = path.gsub(final_optional_segments,'').split("/")
+      new_path = path_segments.map{ |seg| translate_path_segment(seg, locale) }.join('/')
+      new_path = "/#{locale.downcase}#{new_path}" if add_prefix? locale
+      new_path = '/' if new_path.blank?
+      final_optional_segments ? new_path + final_optional_segments : new_path
+    end
+
+    # Tries to translate a single path segment. If the path segment
+    # contains sth. like a optional format "people(.:format)", only
+    # "people" will be translated, if there is no translation, the path
+    # segment is blank or begins with a ":" (param key), the segment
+    # is returned untouched
+    def translate_path_segment segment, locale
+      return segment if segment.blank? or segment.starts_with?(":")
+
+      match = TRANSLATABLE_SEGMENT.match(segment)[1] rescue nil
+
+      (translate_string(match, locale) || segment).downcase
+    end
+
+    def translate_string str, locale
+      @dictionary[locale.to_s][str.to_s]
+    end
+
+    private
+    def reset_route_set route_set
+      route_set.clear!
+      remove_all_methods_in route_set.named_routes.module
+    end
+
+    def remove_all_methods_in mod
+      mod.instance_methods.each do |method|
+        mod.send :remove_method, method
+      end
+    end
+  end
+  include Translator
+
+  def locale_suffix locale
+    self.class.locale_suffix locale
+  end
+end
+
+# Adapter for Rails 3 Apps
+module ActionDispatch
+  module Routing
+    module Translator
+      class << self
+        def translate &block
+          RouteTranslator.init_with_yield(&block).translate Rails.application.routes
+        end
+
+        def translate_from_file *file_path
+          file_path = %w(config locales routes.yml) if file_path.blank?
+          RouteTranslator.init_from_file(File.join(Rails.root, *file_path)).translate Rails.application.routes
+        end
+
+        def i18n *locales
+          RouteTranslator.init_with_i18n(*locales).translate Rails.application.routes
+        end
+      end
+    end
+  end
+end
+
+# Add set_locale_from_url to controllers
+ActionController::Base.class_eval do
+  private
+  # called by before_filter
+  def set_locale_from_url
+    I18n.locale = params[RouteTranslator::LOCALE_PARAM_KEY]
+    default_url_options.merge! RouteTranslator::LOCALE_PARAM_KEY => I18n.locale
+  end
+end
+
+# Add locale_suffix to controllers, views and mailers
+RouteTranslator::ROUTE_HELPER_CONTAINER.each do |klass|
+  klass.class_eval do
+    private
+    def locale_suffix locale
+      RouteTranslator.locale_suffix locale
+    end
+  end
+end

data/lib/translate_routes.rb

@@ -1,219 +1 @@
-# Author: Raul Murciano [http://raul.murciano.net] for Domestika [http://domestika.org]
-# Copyright (c) 2007, Released under the MIT license (see MIT-LICENSE)
-
-module ActionController
-
-  module Routing
-
-    module Translator
-      
-      mattr_accessor :prefix_on_default_locale
-      @@prefix_on_default_locale = false
-
-      mattr_accessor :locale_param_key
-      @@locale_param_key = :locale  # set to :locale for params[:locale]
-
-      mattr_accessor :original_routes, :original_named_routes, :original_names, :dictionaries
-
-      def self.translate
-        init_dictionaries
-        yield @@dictionaries
-        @using_i18n = false
-        Translator.translate_current_routes
-      end
-
-      def self.translate_from_file(*path)
-        init_dictionaries
-        path = %w(locales routes.yml) if path.blank?
-        file_path =  File.join(RAILS_ROOT, path)
-        yaml = YAML.load_file(file_path)
-        yaml.each_pair{ |k,v| @@dictionaries[k.to_s] = v || {} }
-        @using_i18n = false
-        Translator.translate_current_routes
-      end
-
-      def self.i18n(*locales)
-        init_dictionaries
-        locales = I18n.available_locales if locales.blank? && I18n.respond_to?(:available_locales)
-        locales.each{ |locale| @@dictionaries[locale] = {} }
-        @using_i18n = true
-        Translator.translate_current_routes
-      end
-      
-      private
-
-        def self.default_locale
-          I18n.default_locale.to_s
-        end
-
-        def self.init_dictionaries
-          @@dictionaries = { default_locale => {} }
-        end
-
-        def self.available_locales
-          @@dictionaries.keys.map(&:to_s).uniq
-        end
-
-        def self.original_static_segments
-          static_segments = []
-          (@@original_routes || Routes.routes).each do |r|
-            r.segments.select do |s| 
-              static_segments << s.value if s.instance_of?(ActionController::Routing::StaticSegment)
-            end
-          end
-          static_segments.uniq.sort
-        end
-
-        # code shared by translation and application helpers,
-        # it generates a suffix code for a given locale: en-US -> en_us
-        def self.locale_suffix_code
-          'locale.to_s.underscore'
-        end
-
-        class_eval <<-FOO
-           def self.locale_suffix(locale)
-             #{self.locale_suffix_code}
-           end
-        FOO
-        def self.translate_current_routes
-          
-          RAILS_DEFAULT_LOGGER.info "Translating routes (default locale: #{default_locale})" if defined? RAILS_DEFAULT_LOGGER
-          
-          @@original_routes = Routes.routes.dup                     # Array [routeA, routeB, ...]
-          @@original_named_routes = Routes.named_routes.routes.dup  # Hash {:name => :route}
-          @@original_names = @@original_named_routes.keys
-          
-          Routes.clear!
-          new_routes = []
-          new_named_routes = {}
-
-          @@original_routes.each do |old_route|
-
-            old_name = @@original_named_routes.index(old_route)
-            # process and add the translated ones
-            trans_routes, trans_named_routes = translate_route(old_route, old_name)
-
-            if old_name
-              new_named_routes.merge! trans_named_routes
-            end
-
-            new_routes.concat(trans_routes)
-          
-          end
-        
-          Routes.routes = new_routes
-          new_named_routes.each { |name, r| Routes.named_routes.add name, r }
-          
-          @@original_names.each{ |old_name| add_untranslated_helpers_to_controllers_and_views(old_name) }
-        end
-
-        # The untranslated helper (root_path instead root_en_path) redirects according to the current locale
-        def self.add_untranslated_helpers_to_controllers_and_views(old_name)
-          
-          ['path', 'url'].each do |suffix|
-            new_helper_name = "#{old_name}_#{suffix}"
-            def_new_helper = <<-DEF_NEW_HELPER
-              def #{new_helper_name}(*args)
-                send("#{old_name}_\#{locale_suffix(I18n.locale)}_#{suffix}", *args)
-              end
-            DEF_NEW_HELPER
-
-            [ActionController::Base, ActionView::Base, ActionMailer::Base].each { |d| d.module_eval(def_new_helper) }
-            ActionController::Routing::Routes.named_routes.helpers << new_helper_name.to_sym
-          end
-        end
-
-        def self.add_prefix?(lang)
-          @@prefix_on_default_locale || lang != default_locale
-        end
-
-        def self.translate_static_segment(segment, locale)
-          if @using_i18n
-            tmp = I18n.locale
-            I18n.locale = locale
-            value = I18n.t segment.value, :default => segment.value.dup
-            I18n.locale = tmp
-          else
-            value = @@dictionaries[locale][segment.value] || segment.value.dup
-          end
-          StaticSegment.new(value, :raw => segment.raw, :optional => segment.optional?)
-        end
-
-        def self.locale_segments(orig, locale)
-          segments = []
-          
-          if add_prefix?(locale) # initial prefix i.e: /en-US
-            divider = DividerSegment.new(orig.segments.first.value, :optional => false) # divider ('/')
-            static = StaticSegment.new(locale, :optional => false) # static ('en-US')
-            segments += [divider, static]
-          end
-          
-          orig.segments.each do |s|
-            if s.instance_of?(StaticSegment)
-              new_segment = translate_static_segment(s, locale)
-            else
-              new_segment = s.dup # just reference the original
-            end
-            segments << new_segment
-          end
-          segments
-        end
-
-        def self.locale_requirements(orig, locale)
-          orig.requirements.merge(@@locale_param_key => locale)
-        end
-
-        def self.translate_route_by_locale(orig, locale, orig_name=nil)
-          segments = locale_segments(orig, locale)
-          requirements = locale_requirements(orig, locale)
-          conditions = orig.conditions
-          
-          Route.new(segments, requirements, conditions).freeze
-        end
-
-        def self.root_route?(route)
-          route.segments.length == 1
-        end
-
-        def self.translate_route(route, route_name = nil)
-          new_routes = []
-          new_named_routes = {}
-          
-          if root_route?(route) && prefix_on_default_locale
-            # add the root route "as is" in addition to the translated versions
-            new_routes << route
-            new_named_routes[route_name] = route
-          end
-
-          available_locales.each do |locale|
-            translated = translate_route_by_locale(route, locale, route_name)
-            new_routes << translated          
-            locale_suffix = locale_suffix(locale)
-            new_named_routes["#{route_name}_#{locale_suffix}".to_sym] = translated if route_name
-          end
-          [new_routes, new_named_routes]
-        end
-      
-    end
-    
-  end
-end
-
-# Add set_locale_from_url to controllers
-ActionController::Base.class_eval do 
-  private
-    def set_locale_from_url
-      I18n.locale = params[ActionController::Routing::Translator.locale_param_key]
-      default_url_options({ActionController::Routing::Translator => I18n.locale })
-    end
-end
-
-# Add locale_suffix to controllers, views and mailers
-[ActionController::Base, ActionView::Base, ActionMailer::Base].map do |klass|
-  klass.class_eval do
-    private
-      def locale_suffix(locale)
-        eval ActionController::Routing::Translator.locale_suffix_code
-      end
-  end
-end
+require 'route_translator'

data/lib/translate_routes_test_helper.rb

@@ -1,10 +1,10 @@
 # Author: Raul Murciano [http://raul.murciano.net] for Domestika [http://domestika.org]
 # Copyright (c) 2007, Released under the MIT license (see MIT-LICENSE)
 
-require 'test_help'
+require 'rails/test_help'
 
 # Include default lang on your test requests (test requests doesn't support default_url_options):
-ActionController::TestProcess.class_eval do
+ActionController::TestCase.class_eval do
   unless method_defined?(:process_without_default_language)
     def process_with_default_language(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
       lang_pair = {:locale, I18n.default_locale.to_s}
@@ -20,11 +20,11 @@ end
 # Add untranslated helper for named routes to integration tests
 ActionController::Integration::Session.class_eval do
   ['path', 'url'].each do |suffix|
-    ActionController::Routing::Translator.original_names.each do |old_name|
+    ActionDispatch::Routing::Translator.original_names.each do |old_name|
       new_helper_name = "#{old_name}_#{suffix}"
       def_new_helper = <<-DEF_NEW_HELPER
         def #{new_helper_name}(*args)                      
-          send("#{old_name}_#{ActionController::Routing::Translator.locale_suffix(I18n.default_locale)}_#{suffix}", *args)
+          send("#{old_name}_#{ActionDispatch::Routing::Translator.locale_suffix(I18n.locale)}_#{suffix}", *args)
         end
       DEF_NEW_HELPER
       eval def_new_helper

data/test/translate_routes_test.rb

@@ -1,181 +1,103 @@
 require 'test/unit'
 require 'rubygems'
+require 'mocha'
 
-%w(actionpack activesupport actionmailer).each{ |gem_lib| gem gem_lib, '2.3.10' }
-%w(activesupport actionpack actionmailer action_controller).each{ |lib| require lib }
+%w(actionpack activesupport actionmailer).each{ |gem_lib| gem gem_lib, '3.0.1' }
+%w(active_support action_pack action_mailer action_controller action_dispatch).each{ |lib| require lib }
 
 plugin_root = File.join(File.dirname(__FILE__), '..')
-require "#{plugin_root}/lib/translate_routes"
-RAILS_ROOT = plugin_root
+require "#{plugin_root}/lib/route_translator"
+
 
 class PeopleController < ActionController::Base;  end
 
 class TranslateRoutesTest < ActionController::TestCase
+  include ActionDispatch::Assertions::RoutingAssertions
 
-  include ActionController::Assertions::RoutingAssertions
+  def config_default_locale_settings(locale)
+    I18n.default_locale = locale
+  end
+
+  def translate_routes
+    @route_translator.translate @routes
+    @routes.finalize!
+    @routes.named_routes.install
+  end
 
   def setup
     @controller = ActionController::Base.new
     @view = ActionView::Base.new
-    ActionController::Routing::Routes.clear!
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @route_translator = RouteTranslator.new
   end
 
-
-  # Unnamed routes with prefix on default locale:
-
-  def test_unnamed_empty_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect '', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
-  end
-  
-  def test_unnamed_root_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect '/', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', true)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
-  
-    assert_routing '/', :controller => 'people', :action => 'index'
-    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
-  end
-  
-  def test_unnamed_untranslated_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect 'foo', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es/foo', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en/foo', :controller => 'people', :action => 'index', :locale => 'en'
-  end
-  
-  def test_unnamed_translated_route_on_default_locale_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'    
-  end
-    
-  def test_unnamed_translated_route_on_non_default_locale_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect 'people', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+  def test_unnamed_root_route
+    @routes.draw { root :to => 'people#index' }
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
-    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'    
-  end
-  
-  
-  # Unnamed routes without prefix on default locale:
-  
-  def test_unnamed_empty_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect '', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
     assert_routing '/', :controller => 'people', :action => 'index', :locale => 'en'
+    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
   end
   
   def test_unnamed_root_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect '/', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
+    @routes.draw { root :to => 'people#index' }
+    config_default_locale_settings 'es'
+    @route_translator.load_dictionary_from_file File.expand_path('locales/routes.yml', File.dirname(__FILE__))
+    translate_routes
   
     assert_routing '/', :controller => 'people', :action => 'index', :locale => 'es'
     assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
     assert_unrecognized_route '/es', :controller => 'people', :action => 'index', :locale => 'es'
   end
   
-  def test_unnamed_untranslated_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.connect 'foo', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-    
+  def test_unnamed_untranslated_route
+    @routes.draw { match 'foo', :to => 'people#index' }
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
+  
     assert_routing '/es/foo', :controller => 'people', :action => 'index', :locale => 'es'
     assert_routing '/foo', :controller => 'people', :action => 'index', :locale => 'en'
   end
   
-  def test_unnamed_translated_route_on_default_locale_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+  def test_unnamed_translated_route_on_default_locale
+    @routes.draw { match 'people', :to => 'people#index' }
+    config_default_locale_settings 'es'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
     assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'
-    assert_routing 'gente', :controller => 'people', :action => 'index', :locale => 'es'
+    assert_routing '/gente', :controller => 'people', :action => 'index', :locale => 'es'
   end
   
-  def test_unnamed_translated_route_on_non_default_locale_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+  def test_unnamed_translated_route_on_non_default_locale
+    @routes.draw { match 'people', :to => 'people#index' }
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
     assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
   end
   
-  
-  # Named routes with prefix on default locale:
-  
-  def test_named_empty_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.people '', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
-    assert_helpers_include :people_en, :people_es, :people
-  end
-  
-  def test_named_root_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.root :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', true)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
-  
-    assert_routing '/', :controller => 'people', :action => 'index'
-    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
-  end
-  
-  def test_named_untranslated_route_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'foo', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es/foo', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en/foo', :controller => 'people', :action => 'index', :locale => 'en'
-    assert_helpers_include :people_en, :people_es, :people
-  end
-  
-  def test_named_translated_route_on_default_locale_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'
-    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_helpers_include :people_en, :people_es, :people
-  end
-  
-  def test_named_translated_route_on_non_default_locale_with_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index' }
-    config_default_locale_settings('en', true)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
-  
-    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
-    assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'
-    assert_helpers_include :people_en, :people_es, :people
+  def test_named_translated_route_with_prefix_must_have_locale_as_static_segment
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people' }
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
+    
+    # we check the string representation of the route,
+    # if it stores locale as a dynamic segment it would be represented as: "/:locale/gente"
+    assert_equal "/es/gente(.:format)", path_string(named_route('people_es'))
   end
   
-  # Named routes without prefix on default locale:
-  
   def test_named_empty_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people '', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate { |t|  t['es'] = {};  t['en'] = {'people' => 'gente'}; }
+    @routes.draw { root :to => 'people#index', :as => 'people' }
+    config_default_locale_settings 'es'
+    @route_translator.yield_dictionary { |t|  t['es'] = {};  t['en'] = {'people' => 'gente'}; }
+    translate_routes
   
     assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing '/', :controller => 'people', :action => 'index', :locale => 'es'
@@ -183,9 +105,10 @@ class TranslateRoutesTest < ActionController::TestCase
   end
   
   def test_named_root_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.root :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
+    @routes.draw { root :to => 'people#index' }
+    config_default_locale_settings 'es'
+    @route_translator.load_dictionary_from_file File.expand_path('locales/routes.yml', File.dirname(__FILE__))
+    translate_routes
   
     assert_routing '/', :controller => 'people', :action => 'index', :locale => 'es'
     assert_routing '/en', :controller => 'people', :action => 'index', :locale => 'en'
@@ -193,9 +116,10 @@ class TranslateRoutesTest < ActionController::TestCase
   end
   
   def test_named_untranslated_route_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'foo', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    @routes.draw { match 'foo', :to => 'people#index', :as => 'people' }
+    config_default_locale_settings 'es'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
     assert_routing '/en/foo', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing 'foo', :controller => 'people', :action => 'index', :locale => 'es'
@@ -203,9 +127,10 @@ class TranslateRoutesTest < ActionController::TestCase
   end
   
   def test_named_translated_route_on_default_locale_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('es', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'es'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
     assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing 'gente', :controller => 'people', :action => 'index', :locale => 'es'
@@ -213,30 +138,58 @@ class TranslateRoutesTest < ActionController::TestCase
   end
   
   def test_named_translated_route_on_non_default_locale_without_prefix
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
-    ActionController::Routing::Translator.translate { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    translate_routes
   
     assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
     assert_helpers_include :people_en, :people_es, :people
   end
+
+  def test_formatted_root_route
+    @routes.draw{ root :to => 'people#index', :as => 'root' }
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+    assert_equal '/(.:format)', path_string(named_route('root'))
+    translate_routes
+    assert_equal '/(.:format)', path_string(named_route('root_en'))
+    assert_equal '/es(.:format)', path_string(named_route('root_es'))
+  end
+  
+  def test_routes_translations_are_always_downcased
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['es'] = {'people' => 'Gente'} }
+    translate_routes
+    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
+  end
+
+  def test_routes_locale_prefixes_are_always_downcased
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
+    @route_translator.yield_dictionary { |t| t['en'] = {}; t['ES'] = {'people' => 'Gente'} }
+    translate_routes
+    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'ES'
+  end
   
   def test_languages_load_from_file
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
-    
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
+    @route_translator.load_dictionary_from_file File.expand_path('locales/routes.yml', File.dirname(__FILE__))
+    translate_routes
+  
     assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
     assert_helpers_include :people_en, :people_es, :people
   end
   
   def test_languages_load_from_file_without_dictionary_for_default_locale
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('fr', false)
-    ActionController::Routing::Translator.translate_from_file 'test', 'locales', 'routes.yml'
-    
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'fr'
+    @route_translator.load_dictionary_from_file File.expand_path('locales/routes.yml', File.dirname(__FILE__))
+    translate_routes
+  
     assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'fr'
     assert_routing '/en/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
@@ -244,26 +197,28 @@ class TranslateRoutesTest < ActionController::TestCase
   end
   
   def test_i18n_based_translations_setting_locales
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
     I18n.backend = StubbedI18nBackend
-    ActionController::Routing::Translator.i18n('es')
+    @route_translator.init_i18n_dictionary 'es'
+    translate_routes
   
-    assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'    
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
+    assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_helpers_include :people_en, :people_es, :people
   end
   
   def test_i18n_based_translations_taking_i18n_available_locales
-    ActionController::Routing::Routes.draw { |map| map.people 'people', :controller => 'people', :action => 'index'}
-    config_default_locale_settings('en', false)
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
     I18n.stubs(:available_locales).at_least_once.returns StubbedI18nBackend.available_locales
     I18n.backend = StubbedI18nBackend
-    ActionController::Routing::Translator.i18n
+    @route_translator.init_i18n_dictionary
+    translate_routes
   
-    assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_routing '/fr/people', :controller => 'people', :action => 'index', :locale => 'fr'
     assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
+    assert_routing '/people', :controller => 'people', :action => 'index', :locale => 'en'
     assert_helpers_include :people_fr, :people_en, :people_es, :people
   end
   
@@ -280,44 +235,50 @@ class TranslateRoutesTest < ActionController::TestCase
   end
 
   private
-  
+
+  # Given a route defined as a string like this:
+  # 'ANY    /es(.:format)                            {:controller=>"people", :action=>"index"}'
+  # returns "/es(.:format)"
+  def path_string(route)
+    route.to_s.split(' ')[1]
+  end
+
+  def named_route(name)
+    @routes.routes.select{ |r| r.name == name }.first
+  end
+
   def assert_helpers_include(*helpers)
     helpers.each do |helper|
-      ['_url', '_path'].each do |suffix|    
-        [@controller, @view].each { |obj| assert_respond_to obj, "#{helper}#{suffix}".to_sym }
+      ['url', 'path'].each do |suffix|
+        [@controller, @view].each { |obj| assert_respond_to obj, "#{helper}_#{suffix}".to_sym }
       end
     end
   end
-  
+
   def assert_unrecognized_route(route_path, options)
     assert_raise ActionController::RoutingError do
       assert_routing route_path, options
     end
   end
 
-  def config_default_locale_settings(locale, with_prefix)
-    I18n.default_locale = locale
-    ActionController::Routing::Translator.prefix_on_default_locale = with_prefix
-  end
-
   class StubbedI18nBackend
-    
-    
-    @@translations = { 
-      'es' => { 'people' => 'gente'}, 
+
+
+    @@translations = {
+      'es' => { 'people' => 'gente'},
       'fr' => {} # empty on purpose to test behaviour on incompleteness scenarios
     }
-    
+
     def self.translate(locale, key, options)
       @@translations[locale.to_s][key] || options[:default]
-    rescue 
+    rescue
       options[:default]
     end
 
     def self.available_locales
       @@translations.keys
     end
-    
+
   end
-  
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: translate_routes_rails_2_3
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 1
   prerelease: 
   segments: 
+  - 3
   - 0
-  - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 3.0.3
 platform: ruby
 authors: 
 - Raul Murciano
@@ -26,13 +26,11 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- ChangeLog
 - README.markdown
 files: 
+- lib/route_translator.rb
 - lib/translate_routes.rb
-- lib/translate_routes_i18n_available_locales.rb
 - lib/translate_routes_test_helper.rb
-- ChangeLog
 - README.markdown
 - test/translate_routes_test.rb
 has_rdoc: true
@@ -68,6 +66,6 @@ rubyforge_project:
 rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
-summary: Translate your Rails routes in a simple manner (Rails2.3 branch)
+summary: Translate your Rails routes in a simple manner
 test_files: 
 - test/translate_routes_test.rb

data/ChangeLog

@@ -1,22 +0,0 @@
--- 0.98
-  Accepted patch from hoelmer: Updated rake task to use I18n yaml format.
--- 0.97
-  Accepted patch from Aitor Garay-Romero: root routes with prefix now doesn't set the locale parameter.
-
--- rails2.2 branch -> master
-
--- branch rails2.2 v0.9 (Oct 27th 2008)
-  * Developed after Rails2.2rc1 release, with i18n support. Beta, not backward compatible with Rails < 2.2
-
--- 0.96.1 (Aug 5th 2008)
-  * Fixed by Mathieu Fosse: helpers didn't worked as expected when locale_param_key is undefined
-
--- 0.96 (Jun 10th 2008)
-  * Added update_yaml task, suggested by Francesc Esplugas
-
--- 0.95 (Jan 21st 2008)
-  * Still beta version
-  * Added yaml files support for dictionaries
-
--- 0.9 (Dec 27th 2007)
-  * Beta version

data/lib/translate_routes_i18n_available_locales.rb

@@ -1,23 +0,0 @@
-# monkeypatch I18n to get the available locales
-# (not strictly needed to use translate_routes, but recommended anyway)
-module I18n
-  class << self
-    def available_locales
-      backend.available_locales
-    end
-  end
-
-  module Backend
-    class Simple
-      def available_locales
-        init_translations unless initialized?
-        translations.keys
-      end
-    end
-  end
-end
-
-# load translation files from RAILS_ROOT/locales
-[:rb, :yml].each do |format|
-  I18n.load_path = Dir[File.join(RAILS_ROOT, 'locales', '*.{rb,yml}') ]
-end