rails-translate-routes-na 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "activesupport", ">= 3.1"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem 'sqlite3'
+  gem "minitest"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    minitest (2.10.1)
+    multi_json (1.0.4)
+    rake (0.9.2.2)
+    sqlite3 (1.3.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.1)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  minitest
+  sqlite3

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Francesc Pla
+
+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,301 @@
+# NB
+
+**This is a fork from the initial https://github.com/raul/rails-translate-routes project**
+
+**I renamed the gem to rails-translate-routes-na for easier dependency management within my apps**
+
+
+# rails-translate-routes
+
+**Important change from version 0.0.5 (Feb 2012) to 0.1.0 (June 2012)**: if you're updating from an earlier version take into account that now translations defined in routes.yml are namespaced to avoid conflicts with other translations from app (thanks to cawel for the patch). To upgrade you just have to add the namespace `routes` to your `routes.yml (see example in the below docs).
+
+Rails >=3.1 routes translations based on Raul's translate_routes (https://github.com/raul/translate_routes).
+
+It's currently a stripped down version of the forked gem, adding some bugfixes for rails 3.1 and features I needed for my project. See doc below to see what it can do.
+
+translate_routes & i18n_routes seems to be unmaintained projects so I decided to start a fork of the first one for my own projects, I can't promise high dedication but I'll try to maintain it for my own use and take care all patches & bugs submitted, help is welcome!
+
+## Installation
+
+Add it to your Gemfile:
+
+    gem 'rails-translate-routes'
+
+## Basic usage
+
+Let's imagine you have a SampleApp with products and a contact page. A typical `routes.rb` file should look like:
+
+    SampleApp::Application.routes.draw do
+      resources :products
+      match 'contact', :to => 'pages#contact'
+    end
+
+Running `rake routes we have:
+
+        products GET    /products(.:format)          {:action=>"index", :controller=>"products"}
+                 POST   /products(.:format)          {:action=>"create", :controller=>"products"}
+     new_product GET    /products/new(.:format)      {:action=>"new", :controller=>"products"}
+    edit_product GET    /products/:id/edit(.:format) {:action=>"edit", :controller=>"products"}
+         product GET    /products/:id(.:format)      {:action=>"show", :controller=>"products"}
+                 PUT    /products/:id(.:format)      {:action=>"update", :controller=>"products"}
+                 DELETE /products/:id(.:format)      {:action=>"destroy", :controller=>"products"}
+         contact        /contact(.:format)           {:action=>"contact", :controller=>"pages"}
+
+We want to have them in two languages english and spanish, to accomplish this with rails-translate-routes:
+
+1) We have to activate the translations appending this line to the end of `routes.rb
+
+    ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml')
+
+2) Now we can write translations on a standard YAML file (e.g: in `config/locales/routes.yml`), including all the locales and their translations:
+
+    en:
+      routes:
+        # you can leave empty locales, for example the default one
+    es:
+      routes:
+        products: productos
+        contact: contacto
+        new: crear
+
+3) Include this filter in your `ApplicationController:
+
+    before_filter :set_locale_from_url
+
+Also remember to include language detection to your app, a simple example of an `ApplicationController
+
+    class ApplicationController < ActionController::Base
+      protect_from_forgery
+
+      before_filter :set_locale
+      before_filter :set_locale_from_url
+
+      private
+
+      def set_locale
+        I18n.locale = params[:locale] || ((lang = request.env['HTTP_ACCEPT_LANGUAGE']) && lang[/^[a-z]{2}/])
+      end
+    end
+
+And that's it! Now if we execute `rake routes`
+
+        products_en GET    /products(.:format)              {:action=>"index", :controller=>"products"}
+        products_es GET    /es/productos(.:format)          {:action=>"index", :controller=>"products"}
+                    POST   /products(.:format)              {:action=>"create", :controller=>"products"}
+                    POST   /es/productos(.:format)          {:action=>"create", :controller=>"products"}
+     new_product_en GET    /products/new(.:format)          {:action=>"new", :controller=>"products"}
+     new_product_es GET    /es/productos/new(.:format)      {:action=>"new", :controller=>"products"}
+    edit_product_en GET    /products/:id/edit(.:format)     {:action=>"edit", :controller=>"products"}
+    edit_product_es GET    /es/productos/:id/edit(.:format) {:action=>"edit", :controller=>"products"}
+         product_en GET    /products/:id(.:format)          {:action=>"show", :controller=>"products"}
+         product_es GET    /es/productos/:id(.:format)      {:action=>"show", :controller=>"products"}
+                    PUT    /products/:id(.:format)          {:action=>"update", :controller=>"products"}
+                    PUT    /es/productos/:id(.:format)      {:action=>"update", :controller=>"products"}
+                    DELETE /products/:id(.:format)          {:action=>"destroy", :controller=>"products"}
+                    DELETE /es/productos/:id(.:format)      {:action=>"destroy", :controller=>"products"}
+         contact_en        /contact(.:format)               {:action=>"contact", :controller=>"pages"}
+         contact_es        /es/contacto(.:format)           {:action=>"contact", :controller=>"pages"}
+            root_en        /                                {:controller=>"public", :action=>"index"}
+            root_es        /es                              {:controller=>"public", :action=>"index"}
+
+The application recognizes the different routes and sets the `I18n.locale` value in controllers, but what about the routes generation? As you can see on the previous rake routes execution, the `contact_es_path` and `contact_en_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 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.
+
+## URL structure options
+
+### Default URL structure
+
+By default it generates the following url structure:
+
+    /
+    /es
+    /products/
+    /es/productos/
+    /contact/
+    /es/contacto/
+
+
+### All languages prefixed
+
+In case you want the default languages to be scoped resulting in the following structure:
+
+    /en
+    /es
+    /en/products/
+    /es/productos/
+    /en/contact/
+    /es/contacto/
+
+You can specify the following option:
+
+    ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml', { :prefix_on_default_locale => true })
+
+If you use the `prefix_on_default_locale` you will have to make the proper redirect on your root controller from http://www.sampleapp.com/ to http://www.sampleapp.com/en or http://www.sampleapp.com/es rails-translate-routes adds an extra unstranslated root path:
+
+    root_en        /en                              {:controller=>"pages", :action=>"index"}
+    root_es        /es                              {:controller=>"pages", :action=>"index"}
+       root        /                                {:controller=>"pages", :action=>"index"}
+
+A simple example of a redirection to user locale in index method:
+
+    def index
+      unless params[ :locale]
+        # it takes I18n.locale from the previous example set_locale as before_filter in application controller
+        redirect_to eval("root_#{I18n.locale}_path")
+      end
+
+      # rest of the controller logic ...
+    end
+
+### No prefixed languages
+
+In case you don't want the language prefix in the url path because you have a domain or subdomain per language (or any other reason). Resulting in this structure:
+
+    /
+    /products/
+    /productos/
+    /contact/
+    /contacto/
+
+You can specify the following option:
+
+    ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml', { :no_prefixes => true })
+
+Note that the `no_prefixes` option will override the `prefix_on_default_locale` option.
+
+### Keep untranslated routes
+
+In case you want to keep access to untranslated routes, for easier api or ajax integration for example. Resulting in this structure:
+
+    /en/available-products
+    /fr/produits-disponibles/
+    /products/
+
+You can specify the following option:
+
+    ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml', { :keep_untranslated_routes => true })
+
+This option is not meant to be used with `no_prefixes`.
+
+### Namespaced backends
+
+I usually build app backend in namespaced controllers, routes, ... using translated routes will result in duplicated routes or prefixed ones. In most cases you won't want to have the backend in several languages, you can set `routes.rb` this way:
+
+    SampleApp::Application.routes.draw do
+      resources :products
+      match 'contact', :to => 'pages#contact'
+    end
+
+    ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml', { :prefix_on_default_locale => true })
+
+    SampleApp::Application.routes.draw do
+      namespace :admin do
+        resources :products
+        root :to => "admin_products#index"
+      end
+    end
+
+### Translation of routes inside engines
+
+If you need to translate routes inside a mounted engine, like the example below:
+
+    MyEngine::Engine.routes.draw do
+      match "route_to_translate" => "controller#action", :as => :to_translate
+    end
+
+    Rails.application.routes.draw do
+      match 'untranslated' => ...
+
+      mount MyEngine::Engine => "/my_engine"
+    end
+
+    # You want to get routes like this
+    # ---------------------------------
+    untranslated  /untranslated(.:format) home#index
+    my_engine     /my_engine              MyEngine::Engine
+
+    Routes for MyEngine::Engine:
+            to_translate_en  /en/translated(.:format)     my_engine/controller#action {:locale=>"en"}
+            to_translate_fr  /fr/traduit(.:format)        my_engine/controller#action {:locale=>"fr"}
+
+All you need to do is to add rails-translate-routes to your engine gemspec and use the option :custom_route_set as follows
+
+  # inside your engine/config/routes
+  ActionDispatch::Routing::Translator.translate_from_file('config/locales/routes.yml', { :custom_route_set => MyEngine::Engine.routes })
+
+## Translation YAML options
+
+By default translations of routes are specified on a single YAML file (e.g: in `config/locales/routes.yml`), but in some cases you might want to split the routes translations on several files. For example having all application translations files a in folder per language:
+
+    # config/locales/en
+    rails_defaults.yml
+    application.yml
+    routes.yml
+
+    # config/locales/es
+    rails_defaults.yml
+    application.yml
+    routes.yml
+
+To pass several YAML files to rails-translate-routes you can pass an array of paths:
+
+    ActionDispatch::Routing::Translator.translate_from_file(I18n.available_locales.map { |locale| "config/locales/#{locale}/routes.yml" }, { :prefix_on_default_locale => true })
+
+## Testing
+
+Once your app is locale-aware, the routes are dependent on the locale. This means that in functional tests, you need to explicitly include the locale like so:
+
+    get :show, :id => 1, :locale => 'en'
+
+But in case you would prefer the locale to be implicit or simply because you don't want to add the locale param to all your previous functional tests, you can require the `lib/controller_test_helper` file (typically from your test helper file) and then this will work fine:
+
+    get :show, :id => 1
+
+## TODO
+
+Help is welcome ;)
+
+* make basic testing
+
+## Credits
+
+Thanks to:
+
+Contributors of the current gem:
+  * Martin Carel (https://github.com/cawel)
+  * Johan Gyllenspetz (https://github.com/gyllen)
+  * Nico Ritsche (https://github.com/ncri)
+  * Jean-Loup Fenaux (https://github.com/jlfenaux)
+  * Cyril Mouge (https://github.com/shingara)
+  * Nicolas Arbogast (https://github.com/NicoArbogast)
+  * Stephan van Eijkelenburg (https://github.com/stephanvane)
+  * Víctor Martín (https://github.com/eltercero)
+
+Main development of forked gem:
+  * Raul Murciano (http://github.com/raul)
+
+Contributors of forked gem:
+  * Aitor Garay-Romero (http://github.com/aitorgr)
+  * Christian Hølmer (http://github.com/hoelmer)
+  * Nico Ritsche (https://github.com/ncri)
+  * 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)
+
+## Similar projects
+
+Another fork of translate_routes, a much cleaner approach with better testing but less flexible than rails-translate-routes:
+
+* route_translator (https://github.com/enriclluelles/route_translator)
+
+Also there are other two projects for translating routes in Rails (which I know of), both of them are unfortunately unmaintained but you may want to check them out if you use old Rails versions or have different needs.
+
+* translate_routes (https://github.com/raul/translate_routes)
+* i18n_routing (https://github.com/kwi/i18n_routing)
+
+## Other i18n related projects
+
+If you also need to translate models check out: https://github.com/francesc/rails-translate-models

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rails-translate-routes-na"
+  gem.homepage = "http://github.com/francesc/rails-translate-routes-na"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple gem to translate routes in Rails 3.x}
+  gem.description = %Q{Simple gem to translate routes in Rails 3.x based on translate_routes}
+  gem.email = "francesc@francesc.net"
+  gem.authors = ["Francesc Pla"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rails-translate-routes-na #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/controller_test_helper.rb

@@ -0,0 +1,19 @@
+# This monkey patch injects the locale in the controller's params
+# Reason: ActionController::TestCase doesn't support "default_url_options"
+#
+# Example: when the request you are testing needs the locale, e.g.
+#   get :show, :id => 1, :locale => 'en'
+#
+# if the monkey patch was loaded, you can just do:
+#   get :show, :id => 1
+
+class ActionController::TestCase
+
+  module Behavior
+    def process_with_default_locale(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
+      parameters = { :locale => I18n.default_locale.to_s }.merge(parameters || {} )
+      process_without_default_locale(action, parameters, session, flash, http_method)
+    end
+    alias_method_chain :process, :default_locale
+  end
+end

data/lib/rails-translate-routes.rb

@@ -0,0 +1,462 @@
+# coding: UTF-8
+
+# This class knows nothing about Rails.root or Rails.application.routes,
+# and therefore is easier to test without a Rails app.
+class RailsTranslateRoutes
+  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
+
+  def prefix_on_default_locale
+    @prefix_on_default_locale ||= I18n.default_locale.to_s
+  end
+
+  def prefix_on_default_locale= locale
+    @prefix_on_default_locale = locale.to_s
+  end
+
+  def no_prefixes
+    @no_prefixes ||= false
+  end
+
+  def no_prefixes= no_prefixes
+    @no_prefixes = no_prefixes
+  end
+
+  # option allowing to keep untranslated routes
+  # *Ex:
+  #   *resources :users
+  #   *translated routes
+  #     en/members
+  #     fr/membres
+  #     /users
+  def keep_untranslated_routes
+    @keep_untranslated_routes ||= false
+  end
+
+  def keep_untranslated_routes= keep_untranslated_routes
+    @keep_untranslated_routes = keep_untranslated_routes
+  end
+
+  def custom_route_set
+    @custom_route_set ||= Rails.application.routes
+  end
+
+  def custom_route_set= custom_route_set
+    @custom_route_set = custom_route_set
+  end
+
+  class << self
+    # Default locale suffix generator
+    def locale_suffix locale
+      locale.to_s.underscore
+    end
+
+    # Creates a RailsTranslateRoutes 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 RailsTranslateRoutes 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 RailsTranslateRoutes 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 = RailsTranslateRoutes.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 (supports a single file or an array to have translations splited in several folders)
+    def add_dictionary_from_file file_path
+      file_path.class == Array ? files = file_path : files = [ file_path ]
+
+      yaml = Hash.new
+      files.each do |file|
+        yaml.merge! YAML.load_file(File.join(Rails.root, file))
+      end
+
+      yaml.each_pair do |locale, translations|
+        merge_translations locale, translations['routes']
+      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
+      route_set ||= custom_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, ...]
+
+      if Rails.version >= '3.2'
+        original_routes.routes.delete_if{|r| r.path.spec.to_s == '/assets'  }
+      else
+        original_routes.delete_if{|r| r.path == '/assets'}
+      end
+
+      original_named_routes = route_set.named_routes.routes.dup  # Hash {:name => :route}
+
+      if Rails.version >= '3.2'
+        translated_routes = []
+        original_routes.each do |original_route|
+          translations_for(original_route).each do |translated_route_args|
+            translated_routes << translated_route_args
+          end
+        end
+
+        reset_route_set route_set
+
+        translated_routes.each do |translated_route_args|
+          route_set.add_route *translated_route_args
+        end
+      else
+        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
+      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
+
+      if root_route = original_named_routes[:root]
+        add_root_route root_route, route_set
+      end
+
+    end
+
+    # Add unmodified root route to route_set
+    def add_root_route root_route, route_set
+      if @prefix_on_default_locale
+        if Rails.version >= '3.2'
+          conditions = { :path_info => root_route.path.spec.to_s }
+          conditions[:request_method] = parse_request_methods root_route.verb if root_route.verb != //
+          route_set.add_route root_route.app, conditions, root_route.requirements, root_route.defaults, root_route.name
+        else
+          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
+      end
+    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
+          
+          # !!! very dirty hack to ensure it works inside Engines
+          # 
+          helper_container.send :define_method, :method_missing do |*args|
+            metod = args.shift
+            if metod[/_path/] || metod[/_url/] and self.class != helper_container
+              self.class.send :define_method, metod do |*arguments|
+                locale = arguments.collect{|arg| arg.is_a?(Hash)}.first.try(:[], :locale)
+                send metod.to_s.gsub(/path$/, "#{locale || I18n.locale}_path").gsub(/url$/, "#{locale || I18n.locale}_url"), *arguments
+              end
+              send *args.unshift(metod)
+            else
+              super *args.unshift(metod)
+            end
+          end
+        end
+
+        new_helper_name.to_sym
+      end
+    end
+
+    # Generate translations for a single route for all available locales
+    def translations_for route
+      translated_routes = []
+      available_locales.map do |locale|
+        translated_routes << translate_route(route, locale)
+      end
+
+      # add untranslated_route without url helper if we want to keep untranslated routes
+      translated_routes << untranslated_route(route) if @keep_untranslated_routes
+      translated_routes
+    end
+
+    # Generate translation for a single route for one locale
+    def translate_route route, locale
+      if Rails.version >= '3.2'
+        conditions = { :path_info => translate_path(route.path.spec.to_s, locale) }
+        conditions[:request_method] = parse_request_methods route.verb if route.verb != //
+        if route.constraints
+          route.constraints.each do |k,v|
+            conditions[k] = v unless k == :request_method
+          end
+        end
+        defaults = route.defaults.merge LOCALE_PARAM_KEY => locale.dup
+      else
+        conditions = { :path_info => translate_path(route.path, locale) }
+        conditions[:request_method] = parse_request_methods route.conditions[:request_method] if route.conditions.has_key? :request_method
+        defaults = route.defaults.merge LOCALE_PARAM_KEY => locale
+      end
+
+      requirements = route.requirements.merge LOCALE_PARAM_KEY => locale
+      new_name = "#{route.name}_#{locale_suffix(locale)}" if route.name
+
+      [route.app, conditions, requirements, defaults, new_name]
+    end
+
+    # Re-generate untranslated routes (original routes) with name set to nil (which prevents conflict with default untranslated_urls)
+    def untranslated_route route
+      conditions = {}
+      if Rails.version >= '3.2'
+        conditions[:path_info] = route.path.spec.to_s
+        conditions[:request_method] = parse_request_methods route.verb if route.verb != //
+        conditions[:subdomain] = route.constraints[:subdomain] if route.constraints
+      else
+        conditions[:path_info] = route.path
+        conditions[:request_method] = parse_request_methods route.conditions[:request_method] if route.conditions.has_key? :request_method
+      end
+      requirements = route.requirements
+      defaults = route.defaults
+
+      [route.app, conditions, requirements, defaults]
+    end
+
+    # Add prefix for all non-default locales
+    def add_prefix? locale
+      if @no_prefixes
+        false
+      elsif !default_locale?(locale) || @prefix_on_default_locale
+        true
+      else
+        false
+      end
+    end
+
+    # Translates a path and adds the locale prefix.
+    def translate_path path, locale
+      new_path = split_translate_join path, locale, [')','(','/'], false
+      new_path = split_translate_join path, locale, [')','(','/']
+      new_path = "/:locale#{new_path || '/'}" if add_prefix?(locale)
+      new_path = '/' if new_path.blank?
+      new_path
+    end
+    
+    def split_translate_join(segment, locale, separators, translate = true)
+      separator = separators[0]
+      final_optional_segments = segment[Regexp.new("(#{'\\' + separator })$")] || ""
+      segment.split(separator).map do |s|
+        if separators[1..-1].any?
+          split_translate_join(s, locale, separators[1..-1], translate)
+        else
+          translate ? translate_path_segment(s,locale) : s
+        end
+      end.join(separator) + (final_optional_segments != "/" ? final_optional_segments : '')
+    end
+
+    # Tries to translate a single path segment. If the path segment
+    # contains sth. like an 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
+
+    # expects methods regexp to be in a format: /^GET$/ or /^GET|POST$/ and returns array ["GET", "POST"]
+    def parse_request_methods methods_regexp
+      methods_regexp.source.gsub(/\^([a-zA-Z\|]+)\$/, "\\1").split("|")
+    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(route_set = nil, &block)
+          route_set ||= custom_route_set
+          RailsTranslateRoutes.init_with_yield(&block).translate route_set
+        end
+
+        def translate_from_file(file_path, options = {})
+          file_path = %w(config locales routes.yml) if file_path.blank?
+          r = RailsTranslateRoutes.init_from_file(file_path)
+          r.prefix_on_default_locale = true if options && options[:prefix_on_default_locale] == true
+          r.no_prefixes = true if options && options[:no_prefixes] == true
+          r.keep_untranslated_routes = true if options && options[:keep_untranslated_routes] == true
+          r.custom_route_set = options[:custom_route_set] if options
+          r.translate r.custom_route_set
+        end
+
+        def i18n *locales
+          RailsTranslateRoutes.init_with_i18n(*locales).translate
+        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[RailsTranslateRoutes::LOCALE_PARAM_KEY]
+    default_url_options = {RailsTranslateRoutes::LOCALE_PARAM_KEY => I18n.locale}
+  end
+end
+
+# Add locale_suffix to controllers, views and mailers
+RailsTranslateRoutes::ROUTE_HELPER_CONTAINER.each do |klass|
+  klass.class_eval do
+    private
+    def locale_suffix locale
+      RailsTranslateRoutes.locale_suffix locale
+    end
+  end
+end

data/rails-translate-routes-na.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "rails-translate-routes-na"
+  s.version = File.open('./VERSION').read
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Francesc Pla"]
+  s.date = "2012-08-03"
+  s.description = "Simple gem to translate routes in Rails 3.x based on translate_routes"
+  s.email = "francesc@francesc.net"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/controller_test_helper.rb",
+    "lib/rails-translate-routes.rb",
+    "rails-translate-routes-na.gemspec",
+    "test/helper.rb",
+    "test/test_rails-translate-routes.rb"
+  ]
+  s.homepage = "http://github.com/francesc/rails-translate-routes-na"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Simple gem to translate routes in Rails 3.x"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.1"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.1"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.1"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,17 @@
+# coding: UTF-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rails-translate-routes'

data/test/test_rails-translate-routes.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRailsTranslateRoutes < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: rails-translate-routes-na
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Francesc Pla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70364424245020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70364424245020
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70364424243760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70364424243760
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70364424258160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70364424258160
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70364424255200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70364424255200
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70364424267680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70364424267680
+description: Simple gem to translate routes in Rails 3.x based on translate_routes
+email: francesc@francesc.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/controller_test_helper.rb
+- lib/rails-translate-routes.rb
+- rails-translate-routes-na.gemspec
+- test/helper.rb
+- test/test_rails-translate-routes.rb
+homepage: http://github.com/francesc/rails-translate-routes-na
+licenses:
+- MIT
+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.17
+signing_key: 
+specification_version: 3
+summary: Simple gem to translate routes in Rails 3.x
+test_files: []