isomorfeus-i18n 1.0.0.delta11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 517b69898ba863abe013e1d04288970a6d398137ab4b39b7ef8a8b604ffffeb8
+  data.tar.gz: 7d9afaa9e3ec79ff07e6c76c921024ce79e521b0d947f05f9c5219675e466e60
+SHA512:
+  metadata.gz: 0fad88f98f0c80b712301e0ade3bc72cb8de6496cd7fc0451b1acd715e92fa55f3c07a82ce2c7eb0e6a76645faeac2b2b4fa2f61f5d63bdad39fd83a4bd582ac
+  data.tar.gz: 5bdb60a2804cee36df9ead50fa1081efc2ee709334619ac7a848a6e3bd4f006f29ba310e87a80f7fc26a34c8a05bcc36d08d051ff7f497018eb77a7b822819d1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2019 Jan Biedermann
+
+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/lib/isomorfeus/i18n/config.rb

@@ -0,0 +1,71 @@
+module Isomorfeus
+  # available settings
+  class << self
+    attr_accessor :i18n_type
+
+    if RUBY_ENGINE == 'opal'
+      def available_locales
+        result = Redux.register_and_fetch_by_path(:i18n_state, :available_locales)
+        result ? result : ['en']
+      end
+
+      def i18n_domain
+        result = Redux.register_and_fetch_by_path(:i18n_state, :domain)
+        result ? result : 'app'
+      end
+
+      def i18n_domain=(domain)
+        Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain: domain })
+        domain
+      end
+
+      def locale
+        result = Redux.register_and_fetch_by_path(:i18n_state, :locale)
+        result ? result : available_locales.first
+      end
+
+      def locale=(loc)
+        raise "Locale #{loc} not available!" unless available_locales.include?(loc)
+        Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { locale: locale })
+        loc
+      end
+    else
+      def available_locales
+        @available_locales
+      end
+
+      def available_locales=(locs_arr)
+        FastGettext.available_locales = locs_arr
+        @available_locales = locs_arr
+      end
+
+      def i18n_domain
+        @i18n_domain
+      end
+
+      def i18n_domain=(domain)
+        FastGettext.text_domain = domain
+        @i18n_domain = domain
+      end
+
+      def locale
+        @locale
+      end
+
+      def locale=(loc)
+        raise "Locale #{loc} not available!" unless available_locales.include?(loc)
+        FastGettext.locale = loc
+        @locale = loc
+      end
+
+      def locale_path
+        @locale_path
+      end
+
+      def locale_path=(path)
+        @locale_path = path
+      end
+    end
+
+  end
+end

data/lib/isomorfeus/i18n/handler/locale_handler.rb

@@ -0,0 +1,70 @@
+module Isomorfeus
+  module I18n
+    module Handler
+      class LocaleHandler < LucidHandler::Base
+        include FastGettext::Translation
+        include FastGettext::TranslationMultidomain
+
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+          result = {}
+          # promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, method, [args])
+          if request == 'init'
+            result['data'] = { 'available_locales' => FastGettext.available_locales,
+                               'locale' => FastGettext.locale,
+                               'domain' => FastGettext.text_domain }
+          else
+            request.each_key do |domain|
+              result[domain] = {}
+              begin
+                FastGettext.with_domain(domain) do
+                  request[domain].each_key do |locale|
+                    result[domain][locale] = {}
+                    raise "Locale #{locale} not available!" unless Isomorfeus.available_locales.include?(locale)
+                    FastGettext.with_locale(locale) do
+                      request[domain][locale].each_key do |locale_method|
+                        method_args = request[domain][locale][locale_method]
+                        method_result = case locale_method
+                                        when '_' then _(*method_args)
+                                        when 'n_' then n_(*method_args)
+                                        when 'np_' then np_(*method_args)
+                                        when 'ns_' then ns_(*method_args)
+                                        when 'p_' then p_(*method_args)
+                                        when 's_' then s_(*method_args)
+                                        when 'N_' then N_(*method_args)
+                                        when 'Nn_' then Nn_(*method_args)
+                                        when 'd_' then d_(*method_args)
+                                        when 'dn_' then dn_(*method_args)
+                                        when 'dnp_' then dnp_(*method_args)
+                                        when 'dns_' then dns_(*method_args)
+                                        when 'dp_' then dp_(*method_args)
+                                        when 'ds_' then ds_(*method_args)
+                                        when 'D_' then D_(*method_args)
+                                        when 'Dn_' then Dn_(*method_args)
+                                        when 'Dnp_' then Dnp_(*method_args)
+                                        when 'Dns_' then Dns_(*method_args)
+                                        when 'Dp_' then Dp_(*method_args)
+                                        when 'Ds_' then Ds_(*method_args)
+                                        else
+                                          raise "No such locale method #{locale_method}"
+                                        end
+                        result[domain][locale].deep_merge!(locale_method => { Oj.dump(method_args, mode: :strict) => method_result })
+                      end
+                    end
+                  end
+                end
+              rescue Exception => e
+                result = if Isomorfeus.production?
+                           { error: 'No such thing!' }
+                         else
+                           { error: "Isomorfeus::I18n::Handler::LocaleHandler: #{e.message}" }
+                         end
+              end
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/i18n/init.rb

@@ -0,0 +1,33 @@
+module Isomorfeus
+  module I18n
+    class Init
+      if RUBY_ENGINE == 'opal'
+        def self.init
+          return if @initializing || initialized?
+          @initializing = true
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', :init).then do |response|
+            if response[:agent_response].key?(:error)
+              `console.error(#{response[:agent_response][:error].to_n})`
+              raise response[:agent_response][:error]
+            end
+            @initializing = false
+            Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: response[:agent_response][:data])
+          end
+        end
+
+        def self.initialized?
+          result = Redux.register_and_fetch_by_path(:i18n_state, :available_locales)
+          result ? true : false
+        end
+      else
+        def self.init
+          FastGettext.add_text_domain(Isomorfeus.i18n_domain, path: Isomorfeus.locale_path, type: Isomorfeus.i18n_type)
+          FastGettext.available_locales = Isomorfeus.available_locales
+          FastGettext.text_domain = Isomorfeus.i18n_domain
+          FastGettext.locale = Isomorfeus.locale
+          Thread.current[:isomorfeus_i18n_initialized] = true
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/i18n/reducer.rb

@@ -0,0 +1,31 @@
+module Isomorfeus
+  module I18n
+    module Reducer
+      def self.add_reducer_to_store
+        i18n_reducer = Redux.create_reducer do |prev_state, action|
+          action_type = action[:type]
+          if action_type.JS.startsWith('I18N_')
+            case action_type
+            when 'I18N_STATE'
+              if action.key?(:set_state)
+                action[:set_state]
+              else
+                prev_state
+              end
+            when 'I18N_LOAD'
+              result = prev_state.deep_merge(action[:data])
+              result
+            else
+              prev_state
+            end
+          else
+            prev_state
+          end
+        end
+
+        Redux::Store.preloaded_state_merge!(i18n_state: {})
+        Redux::Store.add_reducer(i18n_state: i18n_reducer)
+      end
+    end
+  end
+end

data/lib/isomorfeus/i18n/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module I18n
+    VERSION = '1.0.0.delta11'
+  end
+end

data/lib/isomorfeus-i18n.rb

@@ -0,0 +1,66 @@
+require 'opal-activesupport'
+require 'isomorfeus-transport'
+
+if RUBY_ENGINE == 'opal'
+  require 'isomorfeus/data/core_ext/hash/deep_merge'
+  require 'isomorfeus/i18n/config'
+  require 'isomorfeus/i18n/reducer'
+  Isomorfeus::I18n::Reducer.add_reducer_to_store
+  require 'lucid_translation/mixin'
+  require 'isomorfeus/i18n/init'
+  Isomorfeus.add_transport_init_class_name('Isomorfeus::I18n::Init')
+else
+  require 'active_support'
+  require 'oj'
+  require 'fast_gettext'
+  require 'isomorfeus/promise'
+  require 'isomorfeus-data'
+  require 'isomorfeus/i18n/config'
+  require 'isomorfeus/i18n/init'
+  require 'lucid_translation/mixin'
+  require 'isomorfeus/i18n/handler/locale_handler'
+
+  Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
+
+  Isomorfeus.locale_path = File.expand_path(File.join('isomorfeus', 'locales'))
+
+  # identify available locales
+  locales = []
+
+  Dir.glob("#{Isomorfeus.locale_path}/**/*.mo").each do |file|
+    locales << File.basename(file, '.mo')
+  end
+  Isomorfeus.i18n_type = :mo unless locales.empty?
+
+  unless Isomorfeus.i18n_type
+    locales = []
+    Dir.glob("#{Isomorfeus.locale_path}/**/*.po").each do |file|
+      locales << File.basename(file, '.po')
+    end
+    Isomorfeus.i18n_type = :po unless locales.empty?
+  end
+
+  unless Isomorfeus.i18n_type
+    locales = []
+    Dir.glob("#{Isomorfeus.locale_path}/**/*.yaml").each do |file|
+      locales << File.basename(file, '.yaml')
+    end
+    Dir.glob("#{Isomorfeus.locale_path}/**/*.yml").each do |file|
+      locales << File.basename(file, '.yml')
+    end
+    Isomorfeus.i18n_type = :yaml unless locales.empty?
+  end
+
+  Isomorfeus.available_locales = locales
+  Isomorfeus.available_locales = ['en'] if Isomorfeus.available_locales.empty?
+
+  if Isomorfeus.available_locales.include?('en')
+    Isomorfeus.locale = 'en'
+  else
+    Isomorfeus.locale = Isomorfeus.available_locales.first
+  end
+
+  Isomorfeus.i18n_domain = 'app'
+
+  Isomorfeus::I18n::Init.init
+end

data/lib/lucid_translation/mixin.rb

@@ -0,0 +1,232 @@
+module LucidTranslation
+  module Mixin
+    CONTEXT_SEPARATOR = "\004"
+    NAMESPACE_SEPARATOR = '|'
+    NIL_BLOCK = -> { nil }
+    TRANSLATION_METHODS = [:_, :n_, :np_, :ns_, :p_, :s_]
+
+    if RUBY_ENGINE != 'opal'
+      class InternalTranslationProxy
+        extend FastGettext::Translation
+        extend FastGettext::TranslationMultidomain
+      end
+    end
+
+    def self.included(base)
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def _(*keys, &block)
+            domain = Isomorfeus.i18n_domain
+            locale = Isomorfeus.locale
+            result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, '_', keys)
+            return result if result
+            if Isomorfeus::I18n::Init.initialized?
+              Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, '_', keys).then do |response|
+                if response[:agent_response].key?(:error)
+                  `console.error(#{response[:agent_response][:error].to_n})`
+                  raise response[:agent_response][:error]
+                end
+                Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+              end
+            end
+            block_given? ? block.call : keys.first
+          end
+
+          def n_(*keys, count, &block)
+            domain = Isomorfeus.i18n_domain
+            locale = Isomorfeus.locale
+            result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, 'n_', keys + [count])
+            return result if result
+            if Isomorfeus::I18n::Init.initialized?
+              Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, 'n_', keys + [count]).then do |response|
+                if response[:agent_response].key?(:error)
+                  `console.error(#{response[:agent_response][:error].to_n})`
+                  raise response[:agent_response][:error]
+                end
+                Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+              end
+            end
+            block_given? ? block.call : keys.last
+          end
+
+          def np_(context, plural_one, *args, separator: nil, &block)
+            nargs = ["#{context}#{separator || CONTEXT_SEPARATOR}#{plural_one}"] + args
+            translation = n_(*nargs, &NIL_BLOCK)
+            return translation if translation
+
+            block_given? ? block.call : n_(plural_one, *args)
+          end
+
+          def ns_(*args, &block)
+            domain = Isomorfeus.i18n_domain
+            locale = Isomorfeus.locale
+            result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, 'ns_', args)
+            return result if result
+            if Isomorfeus::I18n::Init.initialized?
+              Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, 'ns_', args).then do |response|
+                if response[:agent_response].key?(:error)
+                  `console.error(#{response[:agent_response][:error].to_n})`
+                  raise response[:agent_response][:error]
+                end
+                Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+              end
+            end
+            block_given? ? block.call : n_(*args).split(NAMESPACE_SEPARATOR).last
+          end
+
+          def p_(namespace, key, separator = nil, &block)
+            domain = Isomorfeus.i18n_domain
+            locale = Isomorfeus.locale
+            args = separator ? [namespace, key, separator] : [namespace, key]
+            result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, 'p_', args)
+            return result if result
+            if Isomorfeus::I18n::Init.initialized?
+              Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, 'p_', args).then do |response|
+                if response[:agent_response].key?(:error)
+                  `console.error(#{response[:agent_response][:error].to_n})`
+                  raise response[:agent_response][:error]
+                end
+                Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+              end
+            end
+            block_given? ? block.call : key
+          end
+
+          def s_(key, separator = nil, &block)
+            domain = Isomorfeus.i18n_domain
+            locale = Isomorfeus.locale
+            args = separator ? [key, separator] : [key]
+            result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, 's_', args)
+            return result if result
+            if Isomorfeus::I18n::Init.initialized?
+              Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, 's_', args).then do |response|
+                if response[:agent_response].key?(:error)
+                  `console.error(#{response[:agent_response][:error].to_n})`
+                  raise response[:agent_response][:error]
+                end
+                Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+              end
+            end
+            block_given? ? block.call : key.split(separator || NAMESPACE_SEPARATOR).last
+          end
+
+          def N_(translate)
+            translate
+          end
+
+          def Nn_(*keys)
+            keys
+          end
+
+          TRANSLATION_METHODS.each do |method|
+            define_singleton_method("d#{method}") do |domain, *args, &block|
+              old_domain = Isomorfeus.i18n_domain
+              begin
+                Isomorfeus.i18n_domain = domain
+                send(method, *args, &block)
+              ensure
+                Isomorfeus.i18n_domain = old_domain
+              end
+            end
+
+            define_singleton_method("D#{method}") do |*args, &block|
+              domain = Isomorfeus.i18n_domain
+              locale = Isomorfeus.locale
+              result = Redux.register_and_fetch_by_path(:i18n_state, domain, locale, "D#{method}", args)
+              return result if result
+              if Isomorfeus::I18n::Init.initialized?
+                Isomorfeus::Transport.promise_send_path('Isomorfeus::I18n::Handler::LocaleHandler', domain, locale, "D#{method}", args).then do |response|
+                  if response[:agent_response].key?(:error)
+                    `console.error(#{response[:agent_response][:error].to_n})`
+                    raise response[:agent_response][:error]
+                  end
+                  Isomorfeus.store.dispatch(type: 'I18N_LOAD', data: { domain => response[:agent_response][domain] })
+                end
+              end
+              block_given? ? block.call : send(method, *args, &block)
+            end
+          end
+        end
+
+        def _(*args, &block)
+          self.class._(*args, &block)
+        end
+
+        def n_(*args, &block)
+          self.class.n_(*args, &block)
+        end
+
+        def np_(*args, &block)
+          self.class.np_(*args, &block)
+        end
+
+        def ns_(*args, &block)
+          self.class.n_(*args, &block)
+        end
+
+        def p_(*args, &block)
+          self.class.p_(*args, &block)
+        end
+
+        def s(*args, &block)
+          self.class.s_(*args, &block)
+        end
+
+        def N_(translate)
+          translate
+        end
+
+        def Nn_(*keys)
+          keys
+        end
+
+        TRANSLATION_METHODS.each do |method|
+          # translate in given domain
+          define_method("d#{method}") do |domain, *args, &block|
+            self.class.send("d#{method}", domain, *args, &block)
+          end
+
+          define_method("D#{method}") do |*args, &block|
+            self.class.send("D#{method}", *args, &block)
+          end
+        end
+      else
+        base.instance_exec do
+          TRANSLATION_METHODS.each do |method|
+            define_singleton_method(method) do |*args, &block|
+              Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+              InternalTranslationProxy.send(method, *args, &block)
+            end
+
+            define_singleton_method("d#{method}") do |domain, *args, &block|
+              Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+              InternalTranslationProxy.send("d#{method}", domain, *args, &block)
+            end
+
+            define_singleton_method("D#{method}") do |*args, &block|
+              Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+              InternalTranslationProxy.send.send("D#{method}", *args, &block)
+            end
+          end
+        end
+
+        TRANSLATION_METHODS.each do |method|
+          define_method(method) do |domain, *args, &block|
+            Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+            InternalTranslationProxy.send(method, domain, *args, &block)
+          end
+
+          define_method("d#{method}") do |domain, *args, &block|
+            Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+            InternalTranslationProxy.send("d#{method}", domain, *args, &block)
+          end
+
+          define_method("D#{method}") do |*args, &block|
+            Isomorfeus::I18n::Init.init unless Thread.current[:isomorfeus_i18n_initialized] == true
+            InternalTranslationProxy.send("D#{method}", *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: isomorfeus-i18n
+version: !ruby/object:Gem::Version
+  version: 1.0.0.delta11
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: fast_gettext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: opal-activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: opal-autoloader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-react
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 16.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 16.9.2
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+description: I18n for Isomorfeus.
+email: jan@kursator.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/isomorfeus-i18n.rb
+- lib/isomorfeus/i18n/config.rb
+- lib/isomorfeus/i18n/handler/locale_handler.rb
+- lib/isomorfeus/i18n/init.rb
+- lib/isomorfeus/i18n/reducer.rb
+- lib/isomorfeus/i18n/version.rb
+- lib/lucid_translation/mixin.rb
+homepage: http://isomorfeus.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: I18n for Isomorfeus.
+test_files: []