mova-i18n 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f5ffd7156c6938db949bd1356541156f14cd25f
+  data.tar.gz: c9b80e1787bfa36cad7e9184b8ead9f4a0bd498b
+SHA512:
+  metadata.gz: 25d4e0d8c815e7dd6580a72b82d5f1887d466f06e569dd60820cd03e4a9d3dd4128f808c0f9c20ea456ec135d913033d14f73cc930a354719f13160e6fe67de4
+  data.tar.gz: efb39f365dd204519860140b414d38d4cff408d6611c41da1057b065a948b3be382aaec838ba039a1d7c656e64e685162739d2df443b35493108066448de3492

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/CONTRIBUTING.md

@@ -0,0 +1,47 @@
+# Contributing
+
+## Adding a feature
+
+1. Open an issue and explain what you're planning to do. It is better to discuss new idea first,
+   rather when diving into code.
+2. Add some tests.
+3. Write the code.
+4. Make sure all tests pass.
+5. Commit with detailed explanation what you've done in a message.
+6. Open pull request.
+
+## Breaking/removing a feature
+
+1. Add deprecation warning and fallback to old behaivour if possible.
+2. Explain how to migrate to the new code in CHANGELOG.
+3. Update/remove tests.
+4. Update the code.
+5. Make sure all tests pass.
+6. Commit with detailed explanation what you've done in a message.
+7. Open pull request.
+
+## Fixing a bug
+
+1. Add failing test.
+2. Fix the bug.
+3. Make sure all tests pass.
+4. Commit with detailed explanation what you've done in a message.
+5. Open pull request.
+
+## Fixing a typo
+
+1. Commit with a message that include "[ci skip]" remark.
+2. Open pull request.
+
+## Running the tests
+
+```
+rake bundle
+rake test
+```
+
+## Working with documentation
+
+```
+yard server -dr
+open http://localhost:8808

data/Gemfile

@@ -0,0 +1,26 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "rspec-mocks", "~> 3.0"
+gem "yard", "~> 0.8"
+gem "pry"
+
+case ENV["RAILS"]
+when "3.2"
+  version = "~> 3.2.19"
+  gem "actionpack", version
+  gem "railties", version
+  gem "tzinfo", "~> 0.3.29"
+  gem "minitest", "~> 4.2"
+when "4.0"
+  version = '~> 4.0.0'
+  gem 'actionpack', version
+  gem 'railties', version
+  gem "minitest", "~> 4.2"
+when nil, "4.1"
+  version = '~> 4.1.0'
+  gem 'actionpack', version
+  gem 'railties', version
+  gem "minitest", "~> 5.4"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrii Malyshko
+
+MIT License
+
+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,93 @@
+# Mova-I18n
+
+**Mova-I18n** overwrites `translate/t` method of [I18n][i18n] in a way that delegates it to
+[Mova][mova] internals without major breaking of I18n API. This speeds up translation
+lookups while staying compatible with libraries that rely on I18n.
+
+## Status
+
+Not tested in production.
+
+## Installation
+
+Add this line to your application's Gemfile and run `bundle`:
+
+```ruby
+gem 'mova-i18n'
+```
+
+## Configuration
+
+No configuration is needed if you have in-memory `I18n::Backend::Simple` backend (used in Rails
+apps by default). Mova-I18n will use I18n setup (including locale fallbacks) and automatically
+load translations stored in local files.
+
+When using other persistent key-value storage, you probably need chain configuration like this:
+
+```ruby
+require "mova/storage/chain"
+require "mova/storage/readonly"
+require "mova/storage/memory"
+redis = ActiveSupport::Cache::RedisStore.new("localhost:6379/0")
+chain = Mova::Storage::Chain.new(Mova::Storage::Readonly.new(redis), Mova::Storage::Memory.new)
+I18n.mova.translator = Mova::I18nTranslator.new(storage: chain)
+```
+
+Note, that you must pass your storage wrapped in `Readonly`, otherwise `I18n.reload!` will clear
+all translations stored there when Rails boots up. It will also protect your storage from having 
+incompatible data written to it, such as hashes or procs (those are partially supported and can be 
+handled normally only with in-memory storage). Such configuration allows to override Rails default
+translations in your backend, since first storage takes precedence over next one.
+
+## Compatibility
+
+### Supported
+
+* the following `I18n.translate` calls:
+
+```ruby
+I18n.t(:key)
+I18n.t("key")
+I18n.t(:key, locale: :fr)
+I18n.t(:key, raise: true)
+I18n.t(:key, throw: true)
+I18n.t(:key, fallback: true) # i.e. disabled locale fallback
+I18n.t(:key, default: :default_key_lookup)
+I18n.t(:key, default: "default translation")
+I18n.t(:key, default: [:default_key_lookup1, :default_key_lookup2])
+I18n.t(:key, default: [:default_key_lookup1, "default translation"])
+I18n.t(:key, scope: :key_scope)
+I18n.t(:key, scope: [:key_scope_part1, :key_scope_part2])
+I18n.t(:key, interpolation1: "value1", interpolation2: "value2")
+I18n.t(:key, count: 3)
+```
+
+Any combination of `locale`, `raise/throw`, `default`, `scope`, `count`, `fallback` options
+is also supported.
+
+* `I18n.localize` and `I18n.transliterate`
+
+* locale fallbacks
+
+### Partially supported
+
+*  storing values other than String or nil is possible only with in-memory storage or with chain
+including in-memory storage (see "Configuration"). Although it violates one of the Mova design principles,
+Mova-I18n tries to be compatible with Rails localization helpers that require hashes to be
+returned from `I18n.t`, so it writes to and retrieves a couple of hashes from a storage.
+
+### Not supported
+
+*  translations as procs, using procs in defaults. Actually, you can store them (see "Partially
+supported"), but they'll never be called. The only exception are the pluralization and transliteration
+rules (for compatibility with [Rails-I18n][rails-i18n] project).
+
+   This means that **`default` option in Rails 4.x views won't work**, because Rails wraps it in a proc
+call. Although using `default` in a template is a bad practice anyway.
+
+*  bulk translation via `I18n.t([:first_key, :second_key])`. Use map instead.
+*  cascade lookup
+
+[mova]: https://github.com/mova-rb/mova
+[i18n]: https://github.com/svenfuchs/i18n
+[rails-i18n]: https://github.com/svenfuchs/rails-i18n

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+
+rails_versions = %w(3.2 4.0 4.1)
+
+task :default => :test
+
+task :bundle do
+  rails_versions.each do |version|
+    sh "RAILS=#{version} bundle"
+  end
+end
+
+task :test do
+  $LOAD_PATH.unshift("test")
+  Dir.glob("./test/**/*_test.rb").each { |file| require file}
+
+  rails_versions.each do |version|
+    sh "RAILS=#{version} rake test:rails"
+  end
+end
+
+task "test:rails" do
+  Dir.glob("./test_rails/**/*_test.rb").each { |file| require file}
+end

data/lib/mova-i18n.rb

@@ -0,0 +1,77 @@
+require "i18n"
+require "mova"
+require "mova/interpolation/sprintf"
+require "mova-i18n/config"
+require "mova-i18n/bridge"
+
+module I18n
+  def self.mova
+    Mova::I18nConfig
+  end
+
+  # make sure we can safely call `I18n.fallbacks` even
+  # if `I18n::Backend::Fallbacks` was not required
+  unless respond_to?(:fallbacks)
+    def self.fallbacks
+      @fallbacks ||= Hash.new { |h,k| h[k] = [k] }
+    end
+  end
+
+  class << self
+    def translate(key, options = nil)
+      options = options && options.dup || {}
+
+      locale = options[:locale] || config.locale
+      locale_with_fallbacks =
+        if options[:fallback]
+          # suppress locale fallbacks (inverted due to I18n fallbacks implementation)
+          [locale]
+        else
+          fallbacks[locale]
+        end
+
+      if (default = options[:default]) && !default.is_a?(Hash)
+        defaults = Array(default)
+        options[:default] = defaults.last.is_a?(String) ? defaults.pop : nil
+        key = Array(key).concat(defaults)
+      end
+
+      if (count = options[:count])
+        zero_plural_key = :zero if count == 0
+        plural_key = mova.pluralizer(locale).call(count)
+        key = Array(key).each_with_object([]) do |key, memo|
+          memo << Mova::Scope.join(key, zero_plural_key) if zero_plural_key
+          memo << Mova::Scope.join(key, plural_key)
+          memo << key
+        end
+      end
+
+      if (scope = options[:scope])
+        scope = Array(scope)
+        key = Array(key).map do |key|
+          Mova::Scope.join(scope + [key])
+        end
+      end
+
+      result = mova.translator.get(key, locale_with_fallbacks, options)
+
+      if result.is_a?(String) && !(interpolation_keys = options.keys - RESERVED_KEYS).empty?
+        mova.interpolator.call(result, options)
+      else
+        result
+      end
+    end
+    alias_method :t, :translate
+
+    def exists?(key, locale = config.locale)
+      locale_with_fallbacks = fallbacks[locale]
+      result = mova.translator.get([key], locale_with_fallbacks, default: "")
+      Mova.presence(result)
+    end
+
+    def reload!
+      super
+      mova.transfer_translations!
+    end
+  end
+end

data/lib/mova-i18n/bridge.rb

@@ -0,0 +1,69 @@
+module Mova
+  # `I18nBridge` name to explicitly avoid collision with root namespace, so we
+  # don't need to type `::I18n`.
+  module I18nBridge
+    module Translator
+      def default(locales, keys, options)
+        origin_locale = locales.first
+        origin_key = keys.first
+
+        if options[:raise]
+          raise I18n::MissingTranslationData.new(origin_locale, origin_key, options)
+        end
+
+        if options[:throw]
+          throw :exception, I18n::MissingTranslation.new(origin_locale, origin_key, options)
+        end
+
+        key_with_locale = Mova::Scope.join(origin_locale, origin_key)
+        "missing translation: #{key_with_locale}"
+      end
+
+      def put(translations)
+        super
+        put_exact_translation(translations, "i18n.transliterate.rule")
+        put_exact_translation(translations, "number.format")
+        put_exact_translation(translations, "number.currency.format")
+        put_exact_translation(translations, "number.human.format")
+        put_exact_translation(translations, "number.human.decimal_units.units")
+        put_exact_translation(translations, "number.percentage.format")
+        put_exact_translation(translations, "number.precision.format")
+      end
+
+      # Stores exact value because {Mova::Translator#put} flattens hashes before writing
+      # to the storage, while `I18n.transliterate` and Rails localization helpers rely on
+      # ability of storing hashes as is.
+      def put_exact_translation(translations, key)
+        scope_path = Mova::Scope.split(key).map &:to_sym
+        locales = translations.keys
+
+        locales.each do |locale|
+          full_path = [locale] + scope_path
+
+          translation = full_path.inject(translations) do |memo, scope|
+            memo[scope] || {}
+          end
+
+          unless translation == {}
+            key_with_locale = Mova::Scope.join(full_path)
+            storage.write(key_with_locale, translation)
+          end
+        end
+      end
+    end
+
+    module Sprintf
+      def missing_placeholder(placeholder, values, string)
+        raise I18n::MissingInterpolationArgument.new(placeholder, values, string)
+      end
+    end
+  end
+
+  class I18nTranslator < Translator
+    include I18nBridge::Translator
+  end
+
+  class I18nInterpolator < Interpolation::Sprintf
+    include I18nBridge::Sprintf
+  end
+end

data/lib/mova-i18n/config.rb

@@ -0,0 +1,36 @@
+module Mova
+  module I18nConfig
+    class << self
+      attr_writer :translator, :interpolator
+
+      # Transfer translations from `I18n::Backend::Simple`, since we can have enumerate all keys
+      # here. Other key-value storages should be passed to `I18n.mova.translator` directly.
+      #
+      # @note Clears all current translations in `I18n.mova.translator.storage`. Use
+      #   {Mova::Storage::Readonly} to protect certain storages if you have a chain of them.
+      def transfer_translations!
+        # calling protected methods
+        I18n.backend.send(:init_translations) if I18n.backend.respond_to?(:init_translations, true)
+        if I18n.backend.respond_to?(:translations, true)
+          translations = I18n.backend.send(:translations)
+          translator.storage.clear
+          translator.put(translations)
+        end
+      end
+
+      def translator
+        @translator ||= I18nTranslator.new
+      end
+
+      def interpolator
+        @interpolator ||= I18nInterpolator.new
+      end
+
+      def pluralizer(locale)
+        @pluralizers ||= {}
+        @pluralizers[locale] ||= translator.storage.read("#{locale}.i18n.plural.rule") ||
+                                 ->(count){ count == 1 ? :one : :other }
+      end
+    end
+  end
+end

data/mova-i18n.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  spec.name          = "mova-i18n"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Andrii Malyshko"]
+  spec.email         = ["mail@nashbridges.me"]
+  spec.summary       = "Seamless migration from I18n to Mova"
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/mova-rb/mova-i18n"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "i18n"
+  spec.add_dependency "mova", "~> 0.1"
+end