route_translator 4.2.5 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10ceb80395c63ce7a1a2bff26fee839e70b7e6c0
-  data.tar.gz: d58781515b4edf999fce7b437e0189f9902607c9
+  metadata.gz: ba50272fd47e4a93ea47418a84de0cf5489eaee4
+  data.tar.gz: 0b4458fa81aea378ecb5fe39c50b655d7c637a97
 SHA512:
-  metadata.gz: a3fc636732fc8f7ac6cd1a91664be5a362aa6213a097f1457ca91786f5107525110dd9b0c3ff0971417e7330d14a6df050c7065f98bc04494a24db5ad80ccd7f
-  data.tar.gz: 68f23b5611d193b1195118e620e3aab594865906d9c4f6167aa974fa3e4e3cc5272928d2078abdde7a4e2e834c159bde5172b06610cec2af3b725c510063a5b3
+  metadata.gz: e082a7feb66e67415ac691ce77939cf3a9f8f90aa5199ca285837c7d1fe9ad6d1f8ee40bbf659206ade3aa2e72cb224ba2c4de3a9e3b12f00fd8fff1faf08c66
+  data.tar.gz: cb761bd633952e302c7a76223f96992c2f9caee66a0babbf7fc56b0a7e0508686df7ddc28dd71174b86487fe2d52032ff871972a4b3f14cb07f28af80b6db65b

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 4.3.0 (2016-03-03)
+
+* Refactor translator module
+
 ## 4.2.5 (2016-02-11)
 
 * Fix: Generate correct route when a segment is preceded by a dot (#132)

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2007 Raul Murciano [http://raul.murciano.net], Domestika INTERNET S.L. [http://domestika.org], 2015 Enric Lluelles [http://enric.lluell.es]
+Copyright (c) 2007 Raul Murciano [http://raul.murciano.net], Domestika INTERNET S.L. [http://domestika.org], 2015 Enric Lluelles [http://enric.lluell.es], 2016 Geremia Taglialatela
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.org/enriclluelles/route_translator.svg?branch=master)](https://travis-ci.org/enriclluelles/route_translator)
 [![Dependency Status](https://gemnasium.com/enriclluelles/route_translator.svg)](https://gemnasium.com/enriclluelles/route_translator)
 [![Code Climate](https://codeclimate.com/github/enriclluelles/route_translator/badges/gpa.svg)](https://codeclimate.com/github/enriclluelles/route_translator)
-[![Coverage Status](https://coveralls.io/repos/enriclluelles/route_translator/badge.svg?branch=master&service=github)](https://coveralls.io/github/enriclluelles/route_translator?branch=master)
+[![Coverage Status](https://coveralls.io/repos/github/enriclluelles/route_translator/badge.svg?branch=master)](https://coveralls.io/github/enriclluelles/route_translator?branch=master)
 
 RouteTranslator is a gem to allow you to manage the translations of your app routes with a simple dictionary format.
 
@@ -223,7 +223,18 @@ If `host_locales` option is set, the following options will be forced (even if y
 
 This is to avoid odd behaviour brought about by route conflicts and because `host_locales` forces and hides the host-locale dynamically.
 
+### Testing
+Testing your controllers with routes-translator is easy, just add a locale parameter for your localized routes. Otherwise, an ActionController::UrlGenerationError will raise.
 
+```ruby
+describe 'GET index' do
+  it 'should respond with success' do
+    get :index, { locale: 'fr' }
+
+    expect(response).to be_success
+  end
+end
+```
 
 ## Contributing
 

data/lib/route_translator.rb

@@ -14,7 +14,20 @@ module RouteTranslator
                              :generate_unnamed_unlocalized_routes, :available_locales,
                              :host_locales, :disable_fallback)
 
-  def self.config(&block)
+  class << self
+    private
+
+    def resolve_host_locale_config_conflicts
+      @config.generate_unlocalized_routes         = false
+      @config.generate_unnamed_unlocalized_routes = false
+      @config.force_locale                        = false
+      @config.hide_locale                         = false
+    end
+  end
+
+  module_function
+
+  def config(&block)
     @config                                     ||= Configuration.new
     @config.force_locale                        ||= false
     @config.hide_locale                         ||= false
@@ -22,23 +35,24 @@ module RouteTranslator
     @config.locale_param_key                    ||= :locale
     @config.generate_unnamed_unlocalized_routes ||= false
     @config.host_locales                        ||= ActiveSupport::OrderedHash.new
-    @config.available_locales                   ||= nil
+    @config.available_locales                   ||= []
     @config.disable_fallback                    ||= false
     yield @config if block
-    resolve_config_conflicts
+    resolve_host_locale_config_conflicts unless @config.host_locales.empty?
     @config
   end
 
-  def self.resolve_config_conflicts
-    if @config.host_locales.present?
-      @config.generate_unlocalized_routes         = false
-      @config.generate_unnamed_unlocalized_routes = false
-      @config.force_locale                        = false
-      @config.hide_locale                         = false
-    end
+  def locale_param_key
+    config.locale_param_key
   end
 
-  def self.locale_param_key
-    config.locale_param_key
+  def available_locales
+    locales = config.available_locales
+
+    if locales.any?
+      locales.map(&:to_sym)
+    else
+      I18n.available_locales.dup
+    end
   end
 end

data/lib/route_translator/host.rb

@@ -1,16 +1,12 @@
 module RouteTranslator
   module Host
-    def self.locale_from_host(host)
-      locales = RouteTranslator.config.host_locales.each_with_object([]) do |(pattern, locale), result|
-        result << locale.to_sym if host =~ regex_for(pattern)
-      end
-      locales &= I18n.available_locales
-      (locales.first || I18n.default_locale).to_sym
-    end
+    class << self
+      private
 
-    def self.regex_for(host_string)
-      escaped = Regexp.escape(host_string).gsub('\*', '.*?').gsub('\.', '\.?')
-      Regexp.new("^#{escaped}$", Regexp::IGNORECASE)
+      def regex_for(host_string)
+        escaped = Regexp.escape(host_string).gsub('\*', '.*?').gsub('\.', '\.?')
+        Regexp.new("^#{escaped}$", Regexp::IGNORECASE)
+      end
     end
 
     def native_locale?(locale)
@@ -20,5 +16,15 @@ module RouteTranslator
     def native_locales
       config.host_locales.values.map { |locale| :"native_#{locale}" }
     end
+
+    module_function
+
+    def locale_from_host(host)
+      locales = RouteTranslator.config.host_locales.each_with_object([]) do |(pattern, locale), result|
+        result << locale.to_sym if host =~ regex_for(pattern)
+      end
+      locales &= I18n.available_locales
+      (locales.first || I18n.default_locale).to_sym
+    end
   end
 end

data/lib/route_translator/translator.rb

@@ -1,157 +1,74 @@
 # frozen_string_literal: true
+
+require File.expand_path('../translator/route_helpers', __FILE__)
+require File.expand_path('../translator/path', __FILE__)
+
 module RouteTranslator
   module Translator
-    # 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 self.add_untranslated_helpers_to_controllers_and_views(old_name, named_route_collection)
-      if named_route_collection.respond_to?(:url_helpers_module)
-        url_helpers_module = named_route_collection.url_helpers_module
-        path_helpers_module = named_route_collection.path_helpers_module
-        url_helpers_list = named_route_collection.helper_names
-        path_helpers_list = named_route_collection.helper_names
-      else
-        url_helpers_module = named_route_collection.module
-        path_helpers_module = named_route_collection.module
-        url_helpers_list = named_route_collection.helpers
-        path_helpers_list = named_route_collection.helpers
+    class << self
+      private
+
+      def available_locales
+        locales = RouteTranslator.available_locales
+        locales.push(*RouteTranslator.native_locales) if RouteTranslator.native_locales.present?
+        # Make sure the default locale is translated in last place to avoid
+        # problems with wildcards when default locale is omitted in paths. The
+        # default routes will catch all paths like wildcard if it is translated first.
+        locales.delete I18n.default_locale
+        locales.push I18n.default_locale
+      end
+
+      def host_locales_option?
+        RouteTranslator.config.host_locales.present?
+      end
+
+      def translate_name(name, locale, named_routes_names)
+        return unless name.present?
+        translated_name = "#{name}_#{locale.to_s.underscore}"
+        if named_routes_names.include?(translated_name.to_sym)
+          nil
+        else
+          translated_name
+        end
       end
 
-      [
-        ['path', path_helpers_module, path_helpers_list],
-        ['url', url_helpers_module, url_helpers_list]
-      ].each do |suffix, helper_container, helper_list|
-        new_helper_name = "#{old_name}_#{suffix}"
+      def translate_conditions(conditions, translated_path)
+        translated_conditions = conditions.dup
 
-        helper_list.push(new_helper_name.to_sym) unless helper_list.include?(new_helper_name.to_sym)
+        translated_conditions[:path_info] = translated_path
+        translated_conditions[:parsed_path_info] = ActionDispatch::Journey::Parser.new.parse(translated_conditions[:path_info]) if conditions[:parsed_path_info]
 
-        helper_container.__send__(:define_method, new_helper_name) do |*args|
-          __send__(Translator.route_name_for(args, old_name, suffix, self), *args)
+        if translated_conditions[:required_defaults] && !translated_conditions[:required_defaults].include?(RouteTranslator.locale_param_key)
+          translated_conditions[:required_defaults] << RouteTranslator.locale_param_key
         end
 
-        add_helpers_to_test_cases(helper_container)
+        translated_conditions
       end
     end
 
-    def self.add_helpers_to_test_cases(helper_container)
-      %w(ActionController ActionMailer ActionView).each do |klass_name|
-        next unless Module.const_defined?(klass_name)
-        klass_name.constantize::TestCase.__send__(:include, helper_container)
-      end
-    end
+    module_function
 
-    def self.translations_for(app, conditions, requirements, defaults, route_name, anchor, route_set, &block)
-      add_untranslated_helpers_to_controllers_and_views(route_name, route_set.named_routes)
+    def translations_for(app, conditions, requirements, defaults, route_name, anchor, route_set)
+      RouteTranslator::Translator::RouteHelpers.add route_name, route_set.named_routes
 
       available_locales.each do |locale|
-        new_conditions = conditions.dup
         begin
-          new_conditions[:path_info] = translate_path(conditions[:path_info], locale)
+          translated_path = RouteTranslator::Translator::Path.translate(conditions[:path_info], locale)
         rescue I18n::MissingTranslationData => e
           raise e unless RouteTranslator.config.disable_fallback
           next
         end
-        new_conditions[:parsed_path_info] = ActionDispatch::Journey::Parser.new.parse(new_conditions[:path_info]) if conditions[:parsed_path_info]
-        if new_conditions[:required_defaults] && !new_conditions[:required_defaults].include?(RouteTranslator.locale_param_key)
-          new_conditions[:required_defaults] << RouteTranslator.locale_param_key
-        end
-        new_defaults = defaults.merge(RouteTranslator.locale_param_key => locale.to_s.gsub('native_', ''))
-        new_requirements = requirements.merge(RouteTranslator.locale_param_key => locale.to_s)
-        new_route_name = translate_name(route_name, locale)
-        new_route_name = nil if new_route_name && route_set.named_routes.routes[new_route_name.to_sym] # TODO: Investigate this :(
-        block.call(app, new_conditions, new_requirements, new_defaults, new_route_name, anchor)
-      end
-    end
-
-    def self.available_locales
-      available_locales = config_locales || I18n.available_locales.dup
-      available_locales.push(*RouteTranslator.native_locales) if RouteTranslator.native_locales.present?
-      # Make sure the default locale is translated in last place to avoid
-      # problems with wildcards when default locale is omitted in paths. The
-      # default routes will catch all paths like wildcard if it is translated first.
-      available_locales.push(available_locales.delete(I18n.default_locale))
-    end
 
-    def self.config_locales
-      if RouteTranslator.config.available_locales
-        RouteTranslator.config.available_locales.map(&:to_sym)
-      end
-    end
-
-    # Translates a path and adds the locale prefix.
-    def self.translate_path(path, locale)
-      new_path = path.dup
-      final_optional_segments = new_path.slice!(%r{(\([^\/]+\))$})
-      translated_segments = new_path.split('/').map do |seg|
-        seg.split('.').map { |phrase| translate_path_segment(phrase, locale) }.join('.')
-      end
-      translated_segments.reject!(&:empty?)
+        new_conditions = translate_conditions(conditions, translated_path)
 
-      if display_locale?(locale) && !locale_param_present?(new_path)
-        translated_segments.unshift(locale.to_s.downcase)
-      end
-
-      joined_segments = translated_segments.join('/')
-
-      "/#{joined_segments}#{final_optional_segments}".gsub(%r{\/\(\/}, '(/')
-    end
-
-    def self.display_locale?(locale)
-      !RouteTranslator.config.hide_locale && !RouteTranslator.native_locale?(locale) &&
-        (!default_locale?(locale) ||
-         RouteTranslator.config.force_locale ||
-         RouteTranslator.config.generate_unlocalized_routes ||
-         RouteTranslator.config.generate_unnamed_unlocalized_routes)
-    end
-
-    def self.translate_name(n, locale)
-      "#{n}_#{locale.to_s.underscore}" if n.present?
-    end
-
-    def self.default_locale?(locale)
-      I18n.default_locale.to_sym == locale.to_sym
-    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, begins with a ":" (param key) or "*" (wildcard),
-    # the segment is returned untouched
-    def self.translate_path_segment(segment, locale)
-      return segment if segment.empty?
-      named_param, hyphenized = segment.split('-'.freeze, 2) if segment.starts_with?(':'.freeze)
-      return "#{named_param}-#{translate_path_segment(hyphenized.dup, locale)}" if hyphenized
-      return segment if segment.starts_with?('('.freeze) || segment.starts_with?('*'.freeze) || segment.include?(':'.freeze)
-
-      appended_part = segment.slice!(/(\()$/)
-      match = TRANSLATABLE_SEGMENT.match(segment)[1] if TRANSLATABLE_SEGMENT.match(segment)
-
-      (translate_string(match, locale) || segment) + appended_part.to_s
-    end
-
-    def self.translate_string(str, locale)
-      locale = locale.to_s.gsub('native_', '')
-      opts = { scope: :routes, locale: locale }
-      if RouteTranslator.config.disable_fallback && locale.to_s != I18n.default_locale.to_s
-        opts[:fallback] = true
-      else
-        opts[:default] = str
+        new_defaults = defaults.merge(RouteTranslator.locale_param_key => locale.to_s.gsub('native_', ''))
+        new_requirements = requirements.merge(RouteTranslator.locale_param_key => locale.to_s)
+        new_route_name = translate_name(route_name, locale, route_set.named_routes.routes)
+        yield app, new_conditions, new_requirements, new_defaults, new_route_name, anchor
       end
-      res = I18n.translate(str, opts)
-      URI.escape(res)
-    end
-
-    def self.locale_param_present?(path)
-      !path.split('/').detect { |segment| segment.to_s == ":#{RouteTranslator.locale_param_key}" }.nil?
-    end
-
-    def self.host_locales_option?
-      RouteTranslator.config.host_locales.present?
     end
 
-    def self.route_name_for(args, old_name, suffix, kaller)
+    def route_name_for(args, old_name, suffix, kaller)
       args_hash           = args.detect { |arg| arg.is_a?(Hash) }
       args_locale         = host_locales_option? && args_hash && args_hash[:locale]
       current_locale_name = I18n.locale.to_s.underscore

data/lib/route_translator/translator/path.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../path/segment', __FILE__)
+
+module RouteTranslator
+  module Translator
+    module Path
+      class << self
+        private
+
+        def display_locale?(locale)
+          !RouteTranslator.config.hide_locale && !RouteTranslator.native_locale?(locale) &&
+            (!default_locale?(locale) || config_requires_locale?)
+        end
+
+        def config_requires_locale?
+          config = RouteTranslator.config
+          (config.force_locale || config.generate_unlocalized_routes || config.generate_unnamed_unlocalized_routes).present?
+        end
+
+        def default_locale?(locale)
+          locale.to_sym == I18n.default_locale.to_sym
+        end
+
+        def locale_param_present?(path)
+          path.split('/').include? ":#{RouteTranslator.locale_param_key}"
+        end
+      end
+
+      module_function
+
+      # Translates a path and adds the locale prefix.
+      def translate(path, locale)
+        new_path = path.dup
+        final_optional_segments = new_path.slice!(%r{(\([^\/]+\))$})
+        translated_segments = new_path.split('/').map do |seg|
+          seg.split('.').map { |phrase| Segment.translate(phrase, locale) }.join('.')
+        end
+        translated_segments.reject!(&:empty?)
+
+        if display_locale?(locale) && !locale_param_present?(new_path)
+          translated_segments.unshift(locale.to_s.downcase)
+        end
+
+        joined_segments = translated_segments.join('/')
+
+        "/#{joined_segments}#{final_optional_segments}".gsub(%r{\/\(\/}, '(/')
+      end
+    end
+  end
+end

data/lib/route_translator/translator/path/segment.rb

@@ -0,0 +1,41 @@
+module RouteTranslator
+  module Translator
+    module Path
+      module Segment
+        class << self
+          def translate_string(str, locale)
+            locale = locale.to_s.gsub('native_', '')
+            opts = { scope: :routes, locale: locale }
+            if RouteTranslator.config.disable_fallback && locale.to_s != I18n.default_locale.to_s
+              opts[:fallback] = true
+            else
+              opts[:default] = str
+            end
+            res = I18n.translate(str, opts)
+            URI.escape(res)
+          end
+        end
+
+        module_function
+
+        # Translates a single path segment.
+        #
+        # If the path segment contains something like an optional format
+        # "people(.:format)", only "people" will be translated.
+        # If there is no translation, the path segment is blank, begins with a
+        # ":" (param key) or "*" (wildcard), the segment is returned untouched.
+        def translate(segment, locale)
+          return segment if segment.empty?
+          named_param, hyphenized = segment.split('-'.freeze, 2) if segment.starts_with?(':'.freeze)
+          return "#{named_param}-#{translate(hyphenized.dup, locale)}" if hyphenized
+          return segment if segment.starts_with?('('.freeze) || segment.starts_with?('*'.freeze) || segment.include?(':'.freeze)
+
+          appended_part = segment.slice!(/(\()$/)
+          match = TRANSLATABLE_SEGMENT.match(segment)[1] if TRANSLATABLE_SEGMENT.match(segment)
+
+          (translate_string(match, locale) || segment) + appended_part.to_s
+        end
+      end
+    end
+  end
+end

data/lib/route_translator/translator/route_helpers.rb

@@ -0,0 +1,52 @@
+module RouteTranslator
+  module Translator
+    module RouteHelpers
+      class << self
+        private
+
+        def add_helpers_to_test_cases(helper_container)
+          %w(ActionController ActionMailer ActionView).each do |klass_name|
+            next unless Module.const_defined?(klass_name)
+            klass_name.constantize::TestCase.__send__(:include, helper_container)
+          end
+        end
+      end
+
+      module_function
+
+      # 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(old_name, named_route_collection)
+        if named_route_collection.respond_to?(:url_helpers_module)
+          url_helpers_module = named_route_collection.url_helpers_module
+          path_helpers_module = named_route_collection.path_helpers_module
+          url_helpers_list = named_route_collection.helper_names
+          path_helpers_list = named_route_collection.helper_names
+        else
+          url_helpers_module = named_route_collection.module
+          path_helpers_module = named_route_collection.module
+          url_helpers_list = named_route_collection.helpers
+          path_helpers_list = named_route_collection.helpers
+        end
+
+        [
+          ['path', path_helpers_module, path_helpers_list],
+          ['url', url_helpers_module, url_helpers_list]
+        ].each do |suffix, helper_container, helper_list|
+          new_helper_name = "#{old_name}_#{suffix}"
+
+          helper_list.push(new_helper_name.to_sym) unless helper_list.include?(new_helper_name.to_sym)
+
+          helper_container.__send__(:define_method, new_helper_name) do |*args|
+            __send__(Translator.route_name_for(args, old_name, suffix, self), *args)
+          end
+
+          add_helpers_to_test_cases(helper_container)
+        end
+      end
+    end
+  end
+end

data/lib/route_translator/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module RouteTranslator
-  VERSION = '4.2.5'.freeze
+  VERSION = '4.3.0'.freeze
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: route_translator
 version: !ruby/object:Gem::Version
-  version: 4.2.5
+  version: 4.3.0
 platform: ruby
 authors:
-- Raul Murciano
+- Geremia Taglialatela
 - Enric Lluelles
+- Raul Murciano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-11 00:00:00.000000000 Z
+date: 2016-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -71,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.10
+        version: 0.8.13
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.10
+        version: 0.8.13
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -149,7 +150,7 @@ dependencies:
         version: 0.11.2
 description: Translates the Rails routes of your application into the languages defined
   in your locale files
-email: enric@lluell.es
+email: tagliala.dev@gmail.com enric@lluell.es
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -164,6 +165,9 @@ files:
 - lib/route_translator/extensions/route_set.rb
 - lib/route_translator/host.rb
 - lib/route_translator/translator.rb
+- lib/route_translator/translator/path.rb
+- lib/route_translator/translator/path/segment.rb
+- lib/route_translator/translator/route_helpers.rb
 - lib/route_translator/version.rb
 homepage: http://github.com/enriclluelles/route_translator
 licenses: