route_translator 1.0.0

data/.travis.yml

@@ -0,0 +1,7 @@
+script: "bundle exec rake test"
+rvm:
+  - 1.9.3
+gemfile:
+  - gemfiles/Gemfile.rails-3.0.x
+  - gemfiles/Gemfile.rails-3.1.x
+  - Gemfile

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rails", "~> 3.2.6"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Raul Murciano [http://raul.murciano.net], Domestika INTERNET S.L. [http://domestika.org], 2012 Enric Lluelles [http://enric.lluell.es]
+
+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.md

@@ -0,0 +1,128 @@
+RouteTranslator
+===============
+
+[![Build Status](https://secure.travis-ci.org/enriclluelles/route_translator.png)](http://travis-ci.org/enriclluelles/route_translator)
+
+RouteTranslator is a gem to allow you to manage the translations of your
+app routes with a simple dictionary format
+
+It started as a fork of the awesome [translate_routes](https://github.com/raul/translate_routes) plugin by [Raúl Murciano](https://github.com/raul) and then I made changes as I needed until it became the actual code
+
+Right now it works with all the different flavous of rails3 (3.0, 3.1, 3.2) but I'm planning to make it compatible with rails 2.3 too. I'll see how it goes
+
+
+Quick Start
+-----------
+
+1. If you have this `routes.rb` file originally:
+
+  ```ruby
+      MyApp::Application.routes.draw do
+
+        namespace :admin do
+          resources :cars
+        end
+
+        resources :cars
+      end
+  ```
+
+    the output of `rake routes.rb` would be this:
+
+  ```
+          admin_cars GET    /admin/cars(.:format)          admin/cars#index
+                     POST   /admin/cars(.:format)          admin/cars#create
+       new_admin_car GET    /admin/cars/new(.:format)      admin/cars#new
+      edit_admin_car GET    /admin/cars/:id/edit(.:format) admin/cars#edit
+           admin_car GET    /admin/cars/:id(.:format)      admin/cars#show
+                     PUT    /admin/cars/:id(.:format)      admin/cars#update
+                     DELETE /admin/cars/:id(.:format)      admin/cars#destroy
+                cars GET    /cars(.:format)                cars#index
+                     POST   /cars(.:format)                cars#create
+             new_car GET    /cars/new(.:format)            cars#new
+            edit_car GET    /cars/:id/edit(.:format)       cars#edit
+                 car GET    /cars/:id(.:format)            cars#show
+                     PUT    /cars/:id(.:format)            cars#update
+                     DELETE /cars/:id(.:format)            cars#destroy
+  ```
+
+2. Add the gem to your `Gemfile`:
+
+    ```ruby
+      gem 'route_translator'
+    ```
+
+   And execute `bundle install`
+
+3. Wrap the groups of routes that you want to translate inside a
+   `localized` block:
+
+   ```ruby
+      MyApp::Application.routes.draw do
+
+        namespace :admin do
+          resources :cars
+        end
+
+        localized do
+          resources :cars
+        end
+      end
+
+      MyApp::Application.routes.translate_from_file #you can pass the file path as a param here
+                                                    #the deault is config/i18n-routes.yml
+   ```
+
+    And add the translations to a YAML file, for example
+`config/i18n-routes.yml`:
+
+    ```yaml
+    es:
+      cars: coches
+      new: nuevo
+    fr:
+      cars: voitures
+      new: nouveau
+    ```
+
+4. Your routes are translated! Here's the output of your `rake routes` now:
+
+    ```
+        admin_cars GET    /admin/cars(.:format)           admin/cars#index
+                   POST   /admin/cars(.:format)           admin/cars#create
+     new_admin_car GET    /admin/cars/new(.:format)       admin/cars#new
+    edit_admin_car GET    /admin/cars/:id/edit(.:format)  admin/cars#edit
+         admin_car GET    /admin/cars/:id(.:format)       admin/cars#show
+                   PUT    /admin/cars/:id(.:format)       admin/cars#update
+                   DELETE /admin/cars/:id(.:format)       admin/cars#destroy
+           cars_en GET    /cars(.:format)                 cars#index {:locale=>"en"}
+           cars_es GET    /es/coches(.:format)            cars#index {:locale=>"es"}
+           cars_fr GET    /fr/voitures(.:format)          cars#index {:locale=>"fr"}
+                   POST   /cars(.:format)                 cars#create {:locale=>"en"}
+                   POST   /es/coches(.:format)            cars#create {:locale=>"es"}
+                   POST   /fr/voitures(.:format)          cars#create {:locale=>"fr"}
+        new_car_en GET    /cars/new(.:format)             cars#new {:locale=>"en"}
+        new_car_es GET    /es/coches/nuevo(.:format)      cars#new {:locale=>"es"}
+        new_car_fr GET    /fr/voitures/nouveau(.:format)  cars#new {:locale=>"fr"}
+       edit_car_en GET    /cars/:id/edit(.:format)        cars#edit {:locale=>"en"}
+       edit_car_es GET    /es/coches/:id/edit(.:format)   cars#edit {:locale=>"es"}
+       edit_car_fr GET    /fr/voitures/:id/edit(.:format) cars#edit {:locale=>"fr"}
+            car_en GET    /cars/:id(.:format)             cars#show {:locale=>"en"}
+            car_es GET    /es/coches/:id(.:format)        cars#show {:locale=>"es"}
+            car_fr GET    /fr/voitures/:id(.:format)      cars#show {:locale=>"fr"}
+                   PUT    /cars/:id(.:format)             cars#update {:locale=>"en"}
+                   PUT    /es/coches/:id(.:format)        cars#update {:locale=>"es"}
+                   PUT    /fr/voitures/:id(.:format)      cars#update {:locale=>"fr"}
+                   DELETE /cars/:id(.:format)             cars#destroy {:locale=>"en"}
+                   DELETE /es/coches/:id(.:format)        cars#destroy {:locale=>"es"}
+                   DELETE /fr/voitures/:id(.:format)      cars#destroy {:locale=>"fr"}
+    ```
+
+    Note that the route inside a `localized` are translated
+
+5. Include this filter in your `ApplicationController` if you want to set
+   the I18n.locale value from the value set in the route
+
+    ```ruby
+        before_filter :set_locale_from_url
+    ```

data/Rakefile

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

data/gemfiles/Gemfile.rails-3.0.x

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem "route_translator", :path => ".."
+
+gem "rails", "~>3.0.1"

data/gemfiles/Gemfile.rails-3.1.x

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem "route_translator", :path => ".."
+
+gem "rails", "~>3.1.0"

data/lib/route_translator.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+require 'action_controller'
+require 'action_mailer'
+require 'action_dispatch'
+require 'route_translator/route_set'
+
+module RouteTranslator
+
+  TRANSLATABLE_SEGMENT = /^([-_a-zA-Z0-9]+)(\()?/.freeze
+  LOCALE_PARAM_KEY = :locale
+  ROUTE_HELPER_CONTAINER = [
+    ActionController::Base,
+    ActionView::Base,
+    ActionMailer::Base,
+    ActionDispatch::Routing::UrlFor
+  ].freeze
+
+  def self.locale_suffix locale
+    locale.to_s.underscore
+  end
+
+  # Attributes
+
+  module Controller
+    def set_locale_from_url
+      I18n.locale = params[RouteTranslator::LOCALE_PARAM_KEY]
+    end
+  end
+
+  module Mapper
+    #yield the block and add all the routes created
+    #in it to the localized_routes array
+    def localized
+      routes_before = @set.routes.map(&:to_s)
+      yield
+      routes_after = @set.routes.map(&:to_s)
+      @set.localized_routes ||= []
+      @set.localized_routes.concat(routes_after - routes_before)
+      @set.localized_routes.uniq!
+    end
+  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
+
+ActionController::Base.send(:include, RouteTranslator::Controller)
+ActionDispatch::Routing::Mapper.send(:include, RouteTranslator::Mapper)
+ActionDispatch::Routing::RouteSet.send(:include, RouteTranslator::RouteSet)

data/lib/route_translator/route_set.rb

@@ -0,0 +1,36 @@
+%w(helpers translator dictionary_management).each do |f|
+  require File.expand_path(File.join(File.dirname(__FILE__), 'route_set', f))
+end
+
+
+module RouteTranslator
+  module RouteSet
+    include DictionaryManagement
+    include Translator
+
+    attr_accessor :dictionary, :localized_routes
+
+    #Use the i18n setting from the app
+    def translate_with_i18n(*wanted_locales)
+      init_i18n_dictionary(*wanted_locales)
+      translate
+    end
+
+    #Use yield the block passing and empty dictionary as a paramenter
+    def translate_with_dictionary(&block)
+      yield_dictionary &block
+      translate
+    end
+
+    #Use the translations from the specified file
+    def translate_from_file(file_path = nil)
+      file_path ||= defined?(Rails) && File.join(Rails.root, %w(config i18-routes.yml))
+      load_dictionary_from_file(file_path)
+      translate
+    end
+
+    include Helpers
+    include Translator
+    include DictionaryManagement
+  end
+end

data/lib/route_translator/route_set/dictionary_management.rb

@@ -0,0 +1,76 @@
+module RouteTranslator
+  module RouteSet
+    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
+  end
+end

data/lib/route_translator/route_set/helpers.rb

@@ -0,0 +1,29 @@
+module RouteTranslator
+  module RouteSet
+    module Helpers
+      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
+
+      def locale_suffix locale
+        RouteTranslator.locale_suffix locale
+      end
+    end
+  end
+end

data/lib/route_translator/route_set/translator.rb

@@ -0,0 +1,140 @@
+module RouteTranslator
+  module RouteSet
+    module Translator
+      # Translate a specific RouteSet, usually Rails.application.routes, but can
+      # be a RouteSet of a gem, plugin/engine etc.
+      def translate
+        Rails.logger.info "Translating routes (default locale: #{default_locale})" if defined?(Rails) && defined?(Rails.logger)
+
+        # save original routes and clear route set
+        original_routes = routes.dup
+        original_named_routes = named_routes.routes.dup  # Hash {:name => :route}
+
+        routes_to_create = []
+        original_routes.each do |original_route|
+          if localized_routes && localized_routes.include?(original_route.to_s) then
+            translations_for(original_route).each do |translated_route_args|
+              routes_to_create << translated_route_args
+            end
+          else
+            route = untranslated_route original_route
+            routes_to_create << route
+          end
+        end
+
+        reset!
+
+        routes_to_create.each do |r|
+          add_route(*r)
+        end
+
+
+        Hash[original_named_routes.select{|k,v| localized_routes && localized_routes.include?(v.to_s)}].each_key do |route_name|
+          named_routes.helpers.concat add_untranslated_helpers_to_controllers_and_views(route_name)
+        end
+
+        finalize!
+        named_routes.install
+      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|
+              if respond_to? "#{old_name}_#{locale_suffix(I18n.locale)}_#{suffix}"
+                send "#{old_name}_#{locale_suffix(I18n.locale)}_#{suffix}", *args
+              else
+                send "#{old_name}_#{locale_suffix(I18n.default_locale)}_#{suffix}", *args
+              end
+            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.dup) #we duplicate the locale string to ensure it's not frozen
+        end
+      end
+
+      # Generate translation for a single route for one locale
+      def translate_route route, locale
+        path_regex = route.path.respond_to?(:spec) ? route.path.spec : route.path
+
+        conditions = route.conditions.dup.merge({
+          :path_info => translate_path(path_regex.dup.to_s, locale)
+        })
+
+        conditions[:request_method] = request_method_array(conditions[:request_method]) if conditions[:request_method]
+
+        requirements = route.requirements.dup.merge!(LOCALE_PARAM_KEY => locale)
+        defaults = route.defaults.dup.merge LOCALE_PARAM_KEY => locale
+
+        new_name = "#{route.name}_#{locale_suffix(locale)}" if route.name
+
+        [route.app, conditions, requirements, defaults, new_name]
+      end
+
+      def untranslated_route route
+        path_regex = route.path.respond_to?(:spec) ? route.path.spec : route.path
+
+        conditions = route.conditions.dup.merge({
+          :path_info => path_regex.to_s
+        })
+
+        conditions[:request_method] = request_method_array(conditions[:request_method]) if conditions[:request_method]
+
+        [route.app, conditions, route.requirements.dup, route.defaults.dup, route.name]
+      end
+
+      def request_method_array(reg)
+        reg.source.gsub(%r{\^|\$}, "").split("|")
+      end
+
+      # Translates a path and adds the locale prefix.
+      def translate_path(path, locale)
+        final_optional_segments = path.slice!(/(\(.+\))$/)
+        new_path = path.split("/").map{|seg| translate_path_segment(seg, locale)}.join('/')
+        new_path = "/#{locale.downcase}#{new_path}" unless default_locale?(locale)
+        new_path = "/" if new_path.blank?
+        "#{new_path}#{final_optional_segments}"
+      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!
+        clear!
+        named_routes.module.instance_methods.each do |method|
+          named_routes.module.send(:remove_method, method)
+        end
+      end
+    end
+  end
+end

data/lib/route_translator/version.rb

@@ -0,0 +1,3 @@
+module RouteTranslator
+  VERSION = '1.0.0'
+end

data/lib/tasks/route_translator.rake

@@ -0,0 +1,35 @@
+namespace :translate_routes => :environment do
+
+  desc "Updates yaml translation files for the given languages"
+  task :update_yaml, :langs, :needs => :environment do |task, args|
+    segments = ActionController::Routing::Translator.original_static_segments
+    
+    if args[:langs].is_a?(String)    
+      langs = args[:langs] + ' ' + ActionController::Routing::Translator.default_locale            
+      langs.split.uniq.each do |lang|
+
+        file_path = File.join(config_path, "routes_#{lang}.yml");
+
+        if File.exists?(file_path)
+          puts "Updating #{file_path}"
+          translations = YAML.load_file(file_path)          
+          f = File.open(file_path,'w')
+        else
+          puts "Creating #{file_path}"
+          translations = {}
+          f = File.new(file_path, 'w')
+        end
+
+        f.write "#{lang}:\n"
+        segments.each do |s|
+          translation = translations[lang][s] rescue ''
+          f.write "  #{s}: #{translation}\n"
+        end
+        f.close
+      end
+
+    else
+      puts 'Missing parameters, usage example: rake translate_routes:update_yaml["fr de es"]'
+    end
+  end
+end

data/route_translator.gemspec

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require File.expand_path('../lib/route_translator/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "route_translator"
+  s.version = RouteTranslator::VERSION
+
+  s.authors = ["Raul Murciano", "Enric Lluelles"]
+  s.email = %q{enric@lluell.es}
+
+  s.homepage = %q{http://github.com/enriclluelles/route_translator}
+
+  s.description = %q{Translates the Rails routes of your application into the languages defined in your locale files}
+  s.summary = %q{Translate your Rails routes in a simple manner}
+
+  s.files = `git ls-files`.split($\) - %w(.gitignore test_runner)
+  s.test_files = `git ls-files test`.split($\)
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency("mocha")
+end

data/test/locales/routes.yml

@@ -0,0 +1,10 @@
+# es:
+#   people: gente
+#   
+# en:
+
+es:
+  people: gente
+  products: productos
+
+en:  

data/test/route_translator_test.rb

@@ -0,0 +1,328 @@
+require 'test/unit'
+require 'mocha'
+
+require 'route_translator'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+
+class PeopleController < ActionController::Base;  end
+class ProductsController < ActionController::Base;  end
+
+class TranslateRoutesTest < ActionController::TestCase
+  include ActionDispatch::Assertions::RoutingAssertions
+  include RouteTranslator::TestHelper
+
+  def config_default_locale_settings(locale)
+    I18n.default_locale = locale
+  end
+
+  def setup
+    @controller = ActionController::Base.new
+    @view = ActionView::Base.new
+    @routes = ActionDispatch::Routing::RouteSet.new
+  end
+
+  def test_unnamed_root_route
+    @routes.draw do
+      localized do
+        root :to => 'people#index'
+      end
+    end
+    config_default_locale_settings 'en'
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        root :to => 'people#index'
+      end
+    end
+    config_default_locale_settings 'es'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    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 do
+      localized do
+        match 'foo', :to => 'people#index'
+      end
+    end
+    config_default_locale_settings 'en'
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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' }
+    @routes.draw do
+      localized do
+        match 'people', :to => 'people#index'
+      end
+    end
+
+    config_default_locale_settings 'es'
+
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index'
+      end
+    end
+    config_default_locale_settings 'en'
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index'
+      end
+    end
+    config_default_locale_settings 'en'
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    # 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 do
+      localized do
+        root :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'es'
+    @routes.translate_with_dictionary{|t|  t['es'] = {};  t['en'] = {'people' => 'gente'}; }
+
+    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 do
+      localized do
+        root :to => 'people#index'
+      end
+    end
+
+    config_default_locale_settings 'es'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    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 do
+      localized do
+        match 'foo', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'es'
+    @routes.translate_with_dictionary{ |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+
+    config_default_locale_settings 'es'
+
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+
+    config_default_locale_settings 'en'
+
+    @routes.translate_with_dictionary{|t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    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 do
+      localized do
+        root :to => 'people#index', :as => 'root'
+      end
+    end
+
+    @routes.translate_with_dictionary{ |t| t['en'] = {}; t['es'] = {'people' => 'gente'} }
+
+    if formatted_root_route?
+      assert_equal '/(.:format)', path_string(named_route('root_en'))
+      assert_equal '/es(.:format)', path_string(named_route('root_es'))
+    else
+      assert_equal '/', path_string(named_route('root_en'))
+      assert_equal '/es', path_string(named_route('root_es'))
+    end
+  end
+
+  def test_routes_locale_prefixes_are_never_downcased
+    @routes.draw do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'en'
+
+    @routes.translate_with_dictionary{ |t| t['en'] = {}; t['ES'] = {'people' => 'Gente'} }
+
+    assert_routing '/es/Gente', :controller => 'people', :action => 'index', :locale => 'ES'
+  end
+
+  def test_languages_load_from_file
+    @routes.draw do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'en'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'fr'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'en'
+
+    I18n.backend = StubbedI18nBackend
+
+    @routes.translate_with_i18n('es')
+
+    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 do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+    end
+    config_default_locale_settings 'en'
+    I18n.stubs(:available_locales).at_least_once.returns StubbedI18nBackend.available_locales
+    I18n.backend = StubbedI18nBackend
+
+    @routes.translate_with_i18n
+
+    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_2_localized_blocks
+    @routes.draw do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+      localized do
+        match 'products', :to => 'products#index', :as => 'products'
+      end
+    end
+    config_default_locale_settings 'en'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
+    assert_routing '/es/productos', :controller => 'products', :action => 'index', :locale => 'es'
+  end
+
+  def test_not_localizing_routes_outside_blocks
+    @routes.draw do
+      localized do
+        match 'people', :to => 'people#index', :as => 'people'
+      end
+      match 'products', :to => 'products#index', :as => 'products'
+    end
+    config_default_locale_settings 'en'
+
+    @routes.translate_from_file(File.expand_path('locales/routes.yml', File.dirname(__FILE__)))
+
+    assert_routing '/es/gente', :controller => 'people', :action => 'index', :locale => 'es'
+    assert_routing '/products', :controller => 'products', :action => 'index'
+    assert_unrecognized_route '/es/productos', :controller => 'products', :action => 'index', :locale => 'es'
+  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
+
+end

data/test/test_helper.rb

@@ -0,0 +1,49 @@
+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
+
+module RouteTranslator
+  module TestHelper
+    def path_string(route)
+      path = route.respond_to?(:path) ? route.path : route.to_s.split(' ')[1]
+      path.respond_to?(:spec) ? path.spec.to_s : path.to_s
+    end
+
+    def named_route(name)
+      @routes.routes.detect{ |r| r.name == name }
+    end
+
+    def formatted_root_route?
+      !(defined?(ActionPack) && ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR > 0)
+    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
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: route_translator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Raul Murciano
+- Enric Lluelles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Translates the Rails routes of your application into the languages defined
+  in your locale files
+email: enric@lluell.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- gemfiles/Gemfile.rails-3.0.x
+- gemfiles/Gemfile.rails-3.1.x
+- lib/route_translator.rb
+- lib/route_translator/route_set.rb
+- lib/route_translator/route_set/dictionary_management.rb
+- lib/route_translator/route_set/helpers.rb
+- lib/route_translator/route_set/translator.rb
+- lib/route_translator/version.rb
+- lib/tasks/route_translator.rake
+- route_translator.gemspec
+- test/locales/routes.yml
+- test/route_translator_test.rb
+- test/test_helper.rb
+homepage: http://github.com/enriclluelles/route_translator
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Translate your Rails routes in a simple manner
+test_files:
+- test/locales/routes.yml
+- test/route_translator_test.rb
+- test/test_helper.rb