route_translator 2.0.1 → 3.0.0

data/test/test_helper.rb

@@ -1,91 +1,107 @@
+require 'test/unit'
+require 'minitest/mock'
+require 'minitest/unit'
 
-class StubbedI18nBackend
-  @@translations = {
-    'es' => { 'people' => 'gente'},
-    'fr' => {} # empty on purpose to test behaviour on incompleteness scenarios
-  }
+require "rails"
+require "action_controller/railtie"
 
-  def self.translate(locale, key, options)
-    @@translations[locale.to_s][key] || options[:default]
-  rescue
-    options[:default]
-  end
+require 'route_translator'
+
+module ActionDispatch
+  class TestRequest < Request
+    def initialize(env = {})
+      super(DEFAULT_ENV.merge(env))
 
-  def self.available_locales
-    @@translations.keys
+      self.host        = 'test.host'
+      self.remote_addr = '0.0.0.0'
+      self.user_agent  = 'Rails Testing'
+    end
   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
+    def draw_routes(&block)
+      @routes.draw(&block)
+      if @routes.respond_to?(:install_helpers)
+        @routes.install_helpers 
+      else
+        ActionView::Base.send(:include, @routes.url_helpers)
+        ActionController::Base.send(:include, @routes.url_helpers)
+      end
     end
 
-    def named_route(name)
-      @routes.routes.detect{ |r| r.name == name }
+    def config_default_locale_settings(locale)
+      I18n.default_locale = locale
     end
 
-    def formatted_root_route?
-      !(defined?(ActionPack) && ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR > 0)
+    def config_force_locale(boolean)
+      RouteTranslator.config.force_locale = boolean
     end
 
-    def setup_application
-      return if defined?(@@app)
+    def config_generate_unlocalized_routes(boolean)
+      RouteTranslator.config.generate_unlocalized_routes = boolean
+    end
 
-      app = @@app = Class.new(Rails::Application)
-      app.config.active_support.deprecation = :stderr
-      app.paths["log"] = "#{tmp_path}/log/test.log"
-      app.paths["config/routes"] = File.join(app_path, routes_config)
-      app.initialize!
-      Rails.application = app
+    def config_translation_file (file)
+      RouteTranslator.config.translation_file = file
     end
 
-    def app
-      @@app
+    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 tmp_path(*args)
-      @tmp_path ||= File.join(File.dirname(__FILE__), "tmp")
-      File.join(@tmp_path, *args)
+    def named_route(name)
+      @routes.routes.detect{ |r| r.name == name }
     end
 
-    def app_path(*args)
-      tmp_path(*%w[app] + args)
+    def formatted_root_route?
+      b = ActionPack::VERSION::MAJOR == 3 && ActionPack::VERSION::MINOR > 0
+      b ||= ActionPack::VERSION::MAJOR == 4
+      !b
     end
 
-    def routes_file(contents)
-      fn = File.join(app_path, routes_config)
-      FileUtils.mkdir_p File.dirname(fn)
-      File.open(fn, 'w') do |f|
-        f.puts contents
+    def print_routes(route_set)
+      all_routes = route_set.routes
+
+      routes = all_routes.collect do |route|
+
+        reqs = route.requirements.dup
+        reqs[:to] = route.app unless route.app.class.name.to_s =~ /^ActionDispatch::Routing/
+        reqs = reqs.empty? ? "" : reqs.inspect
+
+        {:name => route.name.to_s, :verb => route.verb.to_s, :path => route.path.try(:spec).to_s, :reqs => reqs}
       end
-      app.routes_reloader.paths.unshift(fn)
-    end
 
-    def routes_config
-      @@routes_config ||= File.join("config", "routes.rb")
-    end
+      name_width = routes.map{ |r| r[:name].length }.max
+      verb_width = routes.map{ |r| r[:verb].length }.max
+      path_width = routes.map{ |r| r[:path].to_s.length }.max
 
-    def print_routes (route_set)
-      require 'rails/application/route_inspector'
-      inspector = Rails::Application::RouteInspector.new
-      puts inspector.format(route_set.routes, ENV['CONTROLLER']).join "\n"
+      routes.each do |r|
+        puts "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].to_s.ljust(path_width)} #{r[:reqs]}"
+      end
     rescue LoadError
     end
 
     def assert_helpers_include(*helpers)
+      controller = ActionController::Base.new
+      view = ActionView::Base.new
       helpers.each do |helper|
         ['url', 'path'].each do |suffix|
-          [@controller, @view].each { |obj| assert_respond_to obj, "#{helper}_#{suffix}".to_sym }
+          [controller, view].each { |obj| assert_respond_to obj, "#{helper}_#{suffix}".to_sym }
         end
       end
     end
 
+    # Hack for compatibility between Rails 4 and Rails 3
     def assert_unrecognized_route(route_path, options)
       assert_raise ActionController::RoutingError do
+        begin
         assert_routing route_path, options
+        rescue Minitest::Assertion => m
+          raise ActionController::RoutingError.new("")
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: route_translator
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,26 +10,26 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-20 00:00:00.000000000 Z
+date: 2013-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.7.0
 - !ruby/object:Gem::Dependency
-  name: guard-test
+  name: sinatra
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -52,17 +52,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/route_translator.rb
-- lib/route_translator/railtie.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/routes_reloader.rb
-- lib/route_translator/test_request.rb
+- lib/route_translator/extensions.rb
+- lib/route_translator/extensions/action_controller.rb
+- lib/route_translator/extensions/mapper.rb
+- lib/route_translator/extensions/route_set.rb
+- lib/route_translator/translator.rb
 - lib/route_translator/version.rb
-- lib/tasks/route_translator.rake
+- test/dummy/app/controllers/dummy_controller.rb
+- test/dummy/config.ru
+- test/dummy/config/application.rb
+- test/dummy/config/boot.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/initializers/secret_token.rb
+- test/dummy/config/initializers/session_store.rb
+- test/dummy/config/locales/all.yml
+- test/dummy/config/routes.rb
+- test/dummy/dummy_mounted_app.rb
+- test/dummy/script/rails
+- test/integration_test.rb
 - test/locales/routes.yml
-- test/route_translator_test.rb
+- test/routing_test.rb
 - test/test_helper.rb
 homepage: http://github.com/enriclluelles/route_translator
 licenses: []
@@ -89,6 +98,18 @@ signing_key:
 specification_version: 3
 summary: Translate your Rails routes in a simple manner
 test_files:
+- test/dummy/app/controllers/dummy_controller.rb
+- test/dummy/config.ru
+- test/dummy/config/application.rb
+- test/dummy/config/boot.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/initializers/secret_token.rb
+- test/dummy/config/initializers/session_store.rb
+- test/dummy/config/locales/all.yml
+- test/dummy/config/routes.rb
+- test/dummy/dummy_mounted_app.rb
+- test/dummy/script/rails
+- test/integration_test.rb
 - test/locales/routes.yml
-- test/route_translator_test.rb
+- test/routing_test.rb
 - test/test_helper.rb

data/lib/route_translator/railtie.rb

@@ -1,23 +0,0 @@
-module RouteTranslator
-  class Railtie < ::Rails::Railtie
-    config.route_translator = ActiveSupport::OrderedOptions.new
-
-    initializer "route_translator.set_configs" do |app|
-      options = app.config.route_translator
-      options.force_locale ||= false
-      options.generate_unlocalized_routes ||= false
-      options.translation_file ||= File.join(%w[config i18n-routes.yml])
-
-      ActiveSupport.on_load :route_translator do
-        options.each do |k, v|
-          k = "#{k}="
-          if config.respond_to?(k)
-            config.send k, v
-          else
-            raise "Invalid option key: #{k}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/route_translator/route_set.rb

@@ -1,50 +0,0 @@
-%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 = absolute_path(file_path)
-
-      reset_dictionary
-      Dir[file_path].each do |file|
-        add_dictionary_from_file(file)
-      end
-      translate
-    end
-
-private
-
-    def absolute_path (file_path)
-      file_path ||= RouteTranslator.config.translation_file
-      file_path = Rails.root.join(file_path) if defined?(Rails)
-      file_path
-    end
-
-public
-
-    include Helpers
-    include Translator
-    include DictionaryManagement
-  end
-end

data/lib/route_translator/route_set/dictionary_management.rb

@@ -1,76 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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}
-
-        # The filter method exists if the "routing-filter" gem is used
-        original_filters = set.respond_to?(:filters) ? set.filters.dup : []
-
-        routes_to_create = []
-        original_routes.each do |original_route|
-          if localized_routes && localized_routes.include?(original_route.to_s)
-            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
-          # Always generate unlocalized routes?
-          if RouteTranslator.config.generate_unlocalized_routes
-            route = untranslated_route original_route
-            routes_to_create << route
-          end
-        end
-
-        reset!
-
-        routes_to_create.each do |r|
-          add_route(*r)
-        end
-
-        if original_filters.any?
-          set.filters << original_filters
-          set.filters.flatten!
-        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('/')
-
-        # Add locale prefix if it's not the default locale,
-        # or forcing locale to all routes,
-        # or already generating actual unlocalized routes
-        if !default_locale?(locale) ||
-          RouteTranslator.config.force_locale ||
-          RouteTranslator.config.generate_unlocalized_routes
-          new_path = "/#{locale.downcase}#{new_path}"
-        end
-
-        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