translate_routes 3.0.1

data/README.markdown

@@ -0,0 +1,100 @@
+TranslateRoutes 
+===============
+
+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.  
+
+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? ;)
+
+Quick start
+-----------
+
+Let's start with a tiny example. Of course you need to define your routes first, e.g:
+
+    YourApp::Application.routes.draw do
+      match 'contact', :to => 'contact#index', :as => 'contact'
+    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
+
+
+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:
+
+  ActionDispatch::Routing::Translator.i18n('es')
+  
+and if you want to keep the file separated (e.g: config/i18n-routes.yml), the line to append is:
+
+	ActionDispatch::Routing::Translator.translate_from_file('config','i18n-routes.yml')
+
+You can see it working by executing `rake routes` on the shell:
+
+
+    contact_es_es_path /es-ES/contacto {:locale=>"es", :controller=>"contact", :action=>"index"}
+    contact_en_us_path /contact        {:locale=>"'en'", :controller=>"contact", :action=>"index"}
+
+
+As we can see, a new spanish route has been setted up and a `locale` parameter has been added to the routes.
+
+4) 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 
+
+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?
+
+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.
+
+Documentation
+-------------
+You can find additional information in [the translate_routes' wiki](http://wiki.github.com/raul/translate_routes).
+
+Questions, suggestions, bug reports...
+--------------------------------------
+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!  
+
+* 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)
+
+Rails routing resources
+-----------------------
+* 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>  
+    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}#{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
+    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_test_helper.rb

@@ -0,0 +1,33 @@
+# Author: Raul Murciano [http://raul.murciano.net] for Domestika [http://domestika.org]
+# Copyright (c) 2007, Released under the MIT license (see MIT-LICENSE)
+
+require 'rails/test_help'
+
+# Include default lang on your test requests (test requests doesn't support default_url_options):
+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}
+      parameters = lang_pair.merge(parameters) rescue lang_pair
+      process_without_default_language(action, parameters, session, flash, http_method)
+    end
+
+    alias :process_without_default_language :process
+    alias :process :process_with_default_language
+  end
+end
+
+# Add untranslated helper for named routes to integration tests
+ActionController::Integration::Session.class_eval do
+  ['path', 'url'].each do |suffix|
+    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}_#{ActionDispatch::Routing::Translator.locale_suffix(I18n.locale)}_#{suffix}", *args)
+        end
+      DEF_NEW_HELPER
+      eval def_new_helper
+    end
+  end
+end

data/test/translate_routes_test.rb

@@ -0,0 +1,269 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+%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/route_translator"
+
+
+class PeopleController < ActionController::Base;  end
+
+class TranslateRoutesTest < ActionController::TestCase
+  include ActionDispatch::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
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @route_translator = RouteTranslator.new
+  end
+
+  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 '/', :controller => 'people', :action => 'index', :locale => 'en'
+    assert_routing '/es', :controller => 'people', :action => 'index', :locale => 'es'
+  end
+  
+  def test_unnamed_root_route_without_prefix
+    @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
+    @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
+    @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'
+  end
+  
+  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
+  
+  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
+  
+  def test_named_empty_route_without_prefix
+    @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'
+    assert_routing '', :controller => 'people', :action => 'index', :locale => 'es'
+  end
+  
+  def test_named_root_route_without_prefix
+    @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_named_untranslated_route_without_prefix
+    @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'
+    assert_helpers_include :people_en, :people_es, :people
+  end
+  
+  def test_named_translated_route_on_default_locale_without_prefix
+    @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'
+    assert_helpers_include :people_en, :people_es, :people
+  end
+  
+  def test_named_translated_route_on_non_default_locale_without_prefix
+    @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_languages_load_from_file
+    @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
+    @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'
+    assert_helpers_include :people_fr, :people_en, :people_es, :people
+  end
+  
+  def test_i18n_based_translations_setting_locales
+    @routes.draw { match 'people', :to => 'people#index', :as => 'people'}
+    config_default_locale_settings 'en'
+    I18n.backend = StubbedI18nBackend
+    @route_translator.init_i18n_dictionary 'es'
+    translate_routes
+  
+    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
+    @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
+    @route_translator.init_i18n_dictionary
+    translate_routes
+  
+    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
+  
+  def test_action_controller_gets_locale_setter
+    ActionController::Base.instance_methods.include?('set_locale_from_url')
+  end
+  
+  def test_action_controller_gets_locale_suffix_helper
+    ActionController::Base.instance_methods.include?('locale_suffix')
+  end
+  
+  def test_action_view_gets_locale_suffix_helper
+    ActionView::Base.instance_methods.include?('locale_suffix')
+  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 }
+      end
+    end
+  end
+
+  def assert_unrecognized_route(route_path, options)
+    assert_raise ActionController::RoutingError do
+      assert_routing route_path, options
+    end
+  end
+
+  class StubbedI18nBackend
+
+
+    @@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
+      options[:default]
+    end
+
+    def self.available_locales
+      @@translations.keys
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: translate_routes
+version: !ruby/object:Gem::Version 
+  hash: 5
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 1
+  version: 3.0.1
+platform: ruby
+authors: 
+- Raul Murciano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-18 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Translates the Rails routes of your application into the languages defined in your locale files
+email: raul@murciano.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- lib/route_translator.rb
+- lib/translate_routes_test_helper.rb
+- README.markdown
+- test/translate_routes_test.rb
+has_rdoc: true
+homepage: http://github.com/raul/translate_routes
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Translate your Rails routes in a simple manner
+test_files: 
+- test/translate_routes_test.rb