t_t 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b73436334b6c70340cf56c69878f5645ddecbd12
-  data.tar.gz: 6f9f3913be2190fc19abce30109a1816621562b8
+  metadata.gz: 5e2d2727092a795c91c2ed55be7121285f17fe67
+  data.tar.gz: c60c9c93024393bc55c3ab325d8bc5c5137dab9a
 SHA512:
-  metadata.gz: a9c423a3ab34a17a0f4f858a773d7c0d60250e32f18679e469e136de30b22b68b5fe5af7e30820c83fbedbcd47d097a65807050989ec875422daa0ba577946ad
-  data.tar.gz: 42c316f2a5355a2b8379724847f8088582c3f46782811fff42595f6e49f7795ac711dfefe090d41f225db956c08507d02d4cb7a598bdfcbf900d9d393d787ab7
+  metadata.gz: ecb7f85dc79c4ad72f4351f6956b37cb5731af57191c11b6fe7a93fc41053466e9006f8adf183c0dfb025bedb8ec53f06eb83cd6b49ffb7437daef752a72d02c
+  data.tar.gz: c50045f1db29052474c838ebdcf7ffa0fdb551d4b3922e198f28361d569dfc98eec32863003985b6251c394addba1a07b9cfff492c5591c52c6d59f529e8b713

data/.travis.yml

@@ -1,13 +1,13 @@
+language: ruby
+cache: bundler
 rvm:
   - 1.9.3
-  - rbx-2
   - jruby
   - 2.0.0
   - 2.1
   - 2.2
   - ruby-head
 gemfile:
-  - gemfiles/Gemfile.actionpack-3.1.x
   - gemfiles/Gemfile.actionpack-3.2.x
   - gemfiles/Gemfile.actionpack-4.0.x
   - gemfiles/Gemfile.actionpack-4.1.x

data/cheatsheet.md

@@ -124,8 +124,8 @@ For other `active_model` based orms please specify configuration in an initializ
 #   attributes:
 #     user: "Email"
 
-# app/config/tt.rb
-TT.config(prefix: :mongoid)
+# app/config/t_t.rb
+TT::Rails.config(prefix: :mongoid)
 ```
 
 ## Resources
@@ -302,8 +302,8 @@ For example, words related to a user tips is good to place into `tips`, words re
 the gem provides a configuration block:
 
 ```ruby
-# app/config/tt.rb
-TT.config do
+# app/config/t_t.rb
+TT::Rails.config do
   lookup_key_method :tip, :tips
   lookup_key_method :f, :forms
 end
@@ -317,13 +317,13 @@ all it's not a problem. Let's look at a possible cases:
 
 ### You don't have ActionPack or want to use Dos-T outside the views
 
-`tt` is an instance of `TT::Translator`. To create a variable you need `namespace` & `section` (optional) keys. In the rails
+`tt` is an instance of `TT::Base`. To create a variable you need `namespace` & `section` (optional) keys. In the rails
 environment it's `controller_path` and `action_name`.
 
 ```ruby
 class EmailApp < Sinatra::Base
   before do
-    @tt = TT::Translator.new('emails')
+    @tt = TT::Base.new('emails')
   end
 
   post '/' do
@@ -336,7 +336,7 @@ class EmailSender
   attr_reader :tt
 
   def initialize
-    @tt = TT::Translator.new('services/email_sender')
+    @tt = TT::Base.new('services/email_sender')
   end
 
   def work
@@ -352,6 +352,8 @@ end
 
 Just specify an orm i18n scope:
 ```ruby
-# app/config/tt.rb
-TT.config(prefix: :mongoid)
+# app/config/t_t.rb
+
+# activerecord and mongoid is supported out of the box
+TT::Rails.config(prefix: :mongoid)
 ```

data/docs/action_factory.md

@@ -1,10 +1,9 @@
 # Overview
 
-Dos-T provides a factory (not required by default) to generate 'action'-translations in a few lines.
+Dos-T provides the factory to generate 'action'-translations in a few lines.
 
 ```ruby
 # config/locales/actions.rb
-require 't_t/action_factory'
 
 TT.define_actions(:en, :de) do |f|
   f.add :see_all, en: "See all %{rs}", de: "Siehe alle %{RS}"
@@ -17,6 +16,7 @@ texts. The most popular case is an English "a/an" rule. For example, an applicat
 
 ```ruby
 # config/locales/actions.en.yml
+
 en:
   actions:
     base:
@@ -38,14 +38,13 @@ can teach DSL some grammar and it will generates all translation for you:
 
 ```ruby
 # config/locales/actions.rb
-require 't_t/action_factory'
 
 TT.define_actions(:en) do |f|
   f.for(:en) do |l|
     # defines `a/an` rule for English where:
     # base   - a base action translation or a result of the previous rule processing
-    # a_meta - a action-related metadata (could be specified on adding an action)
-    # r_meta - a resource-related metadata (could be specified on marking a resource to use a rule)
+    # a_meta - a action-related metadata (specified on adding an action)
+    # r_meta - a resource-related metadata (specified on marking a resource to use a rule)
     l.rule(:an) { |base, a_meta, r_meta| a_meta }
 
     # registers a resources which should use the rule
@@ -62,7 +61,6 @@ end
 Here an another example with a more complex grammar rules:
 
 ```ruby
-require 't_t/action_factory'
 # de:
 #   models:
 #     article:

data/docs/synchronisation.md

@@ -0,0 +1,39 @@
+# Synchronisation of a translation files
+
+When you work on a multi-language application it's easy to add a key for one language and forget to add for another.
+With Dos-T you have a file watcher which watches on the main locale files (`:en` translations by default). Like the asset
+pipeline in development environment, you can enable the file synchronisation and on each page reload the gem will check
+if an English translation was changed and apply changes for other languages. To enable it add the next in
+`config/environments/development.rb`:
+
+```ruby
+# config/environments/development.rb
+
+Rails.application.configure do
+  # other configuration
+  config.tt.sync = true
+end
+```
+
+If your default translation is not English or the translation files located not in `config/locales` use the next
+configuration:
+
+```ruby
+# config/environments/development.rb
+
+Rails.application.configure do
+  # a custom default locale
+  config.tt.sync = :de
+  # a custom default glob
+  config.tt.sync = { locale: :fr, glob: 'other/locale/folder/**/*.yml' }
+end
+```
+
+Also you can synchronise files without a page reload. Add the next line at the bottom `%rails_root%/Rakefile`:
+
+```ruby
+require 't_t/tasks'
+```
+
+You will have two additional rake tasks - `tt:s` (synchronises the translation files) and `tt:m` (prints the missing
+translations for all languages)

data/lib/t_t.rb

@@ -1,226 +1,41 @@
-require "active_support/inflector"
-require "active_support/lazy_load_hooks"
-require "active_support/multibyte/chars"
-require "i18n"
+require 't_t/base'
 
 module TT
-  module Utils
-    extend self
-
-    DOWNCASE = lambda { |str, locale| (locale == :en) ? str.downcase : str.mb_chars.downcase.to_s }
-
-    def lookup(prefix, base_suffix)
-      prefix ? prefix_lookup(prefix, base_suffix) : simple_lookup(base_suffix)
-    end
-
-    def to_parts(str)
-      str.to_s.underscore.split(/\.|\//)
-    end
-
-    private
-
-    def simple_lookup(base_suffix)
-      lambda do |ns, type|
-        parts = to_parts(ns)
-        model_path = parts.join('.')
-
-        root = "#{ type }.#{ model_path }"
-
-        defaults = []
-        defaults << :"#{ type }.#{ parts.last }" if parts.length > 1
-        if base_suffix
-          defaults << :"#{ type }.#{ base_suffix }"
-        else
-          defaults << type
-        end
-
-        [root, defaults]
-      end
-    end
-
-    def prefix_lookup(prefix, base_suffix)
-      lambda do |ns, type|
-        parts = to_parts(ns)
-        model_path = parts.join('.')
-
-        root = "#{ prefix }.#{ type }.#{ model_path }"
-        defaults = [:"#{ type }.#{ model_path }"]
-
-        if parts.length > 1
-          pure_model = parts.last
-          defaults << :"#{ prefix }.#{ type }.#{ pure_model }"
-          defaults << :"#{ type }.#{ pure_model }"
-        end
-
-        if base_suffix
-          defaults << :"#{ prefix }.#{ type }.#{ base_suffix }"
-          defaults << :"#{ type }.#{ base_suffix }"
-        else
-          defaults << :"#{ prefix }.#{ type }"
-          defaults << type
-        end
-
-        [root, defaults]
-      end
-    end
+  def self.fork(*args, &block)
+    klass = Class.new(Base)
+    klass.config(*args, &block)
+    klass
   end
 
-  class Translator
-    class << self
-      def lookup_key_method(meth_name, path)
-        class_eval <<-RUBY
-          def #{ meth_name }(key, options = {})
-            I18n.t "\#{ _config.fetch(:ns) }.#{ path }.\#{ key }",
-              { default: [:"#{ path }.\#{ key }"] }.merge(options)
-          end
-        RUBY
-      end
-
-      def settings(custom = nil)
-        @settings ||= {}
-
-        if custom
-          unknown = custom.keys.detect { |key| ![:downcase, :prefix].include?(key) }
-          if unknown
-            raise ArgumentError, "TT doesn't know `#{ unknown }` option in the configuration"
-          else
-            @settings.merge!(custom)
-          end
-        end
-
-        @settings
-      end
-    end
-
-    lookup_key_method :c, :common
-
-    def initialize(ns, section = nil)
-      @lookup   = Utils.lookup(self.class.settings[:prefix], nil)
-      @b_lookup = Utils.lookup(self.class.settings[:prefix], :base)
-      @e_lookup = Utils.lookup(self.class.settings[:prefix], :messages)
-
-      ns = Utils.to_parts(ns).join('.')
-      @config = { ns: ns, root: (section ? "#{ ns }.#{ section }" : ns) }
-      default_model = ns.to_s.singularize
-
-      @config[:attributes] = @lookup.call(default_model, :attributes)
-      @config[:models]     = @lookup.call(default_model, :models)
-      @config[:actions]    = @b_lookup.call(default_model, :actions)
-      @config[:enums]      = @b_lookup.call(default_model, :enums)
-      @config[:errors]     = @e_lookup.call(default_model, :errors)
-
-      @downcase = self.class.settings.fetch(:downcase, Utils::DOWNCASE)
-    end
-
-    def a(name, model_name = nil, custom = {})
-      path, defaults = _resolve(@b_lookup, model_name, :actions, name)
-
-      resource = r(model_name)
-      resources = rs(model_name)
-      I18n.t path, {
-        default: defaults, r: @downcase.call(resource, I18n.locale), R: resource,
-        rs: @downcase.call(resources, I18n.locale), RS: resources
-      }.merge!(custom)
-    end
-
-    def attr(name, model_name = nil)
-      path, defaults = _resolve(@lookup, model_name, :attributes, name)
-      I18n.t path, default: defaults
-    end
-
-    def enum(name, kind, model_name = nil)
-      path, defaults = _resolve(@b_lookup, model_name, :enums, "#{ name }.#{ kind }")
-      I18n.t path, default: defaults
-    end
-
-    def e(attr_name, error_name, *args)
-      custom = args.last.is_a?(Hash) ? args.pop : {}
-      model_name = args.first
-      path, defaults = _resolve_errors(model_name, attr_name, error_name)
-      I18n.t path, { default: defaults }.merge!(custom)
-    end
-
-    def r(model_name = nil)
-      rs(model_name, 1)
-    end
-
-    def rs(model_name = nil, count = 10)
-      path, defaults = _resolve(@lookup, model_name, :models, nil)
-      # cut from defaults :"#{ orm }.models", :models
-      I18n.t path, default: defaults[0...-2], count: count
-    end
-
-    def t(key, custom = {})
-      defaults = [:"#{ _config.fetch(:ns) }.common.#{ key }"].concat(Array(custom[:default]))
-      I18n.t "#{ _config.fetch(:root) }.#{ key  }", custom.merge(default: defaults)
-    end
-
-    private
-
-    def _config
-      @config
-    end
-
-    def _resolve_errors(model_name, attr_name, error_name)
-      if attr_name == :base
-        _resolve(@e_lookup, model_name, :errors, error_name)
-      else
-        path, _defaults = _resolve(@lookup, model_name, :errors, "#{ attr_name }.#{ error_name }")
-        defaults = _defaults + ["errors.messages.#{ error_name }".to_sym]
-        return path, defaults
-      end
-    end
-
-    def _resolve(lookup, model_name, type, key)
-      paths = model_name ? lookup.call(model_name, type) : _config.fetch(type)
-      if key
-        return "#{ paths.first }.#{ key }", paths.last.map { |i| :"#{ i }.#{ key }" }
-      else
-        return *paths
-      end
-    end
-
-    ActiveSupport.run_load_hooks(:tt, self)
+  def self.config(*args, &block)
+    base.config(*args, &block)
   end
 
-  def self.fork(&block)
-    Class.new(Translator, &block)
+  def self.base(value = nil)
+    @base || Base
   end
 
-  def self.config(options = {}, &block)
-    Translator.settings(options)
-    Translator.instance_exec(&block) if block_given?
+  def self.base=(value)
+    @base = value
   end
-end
-
-if defined?(ActionPack) || defined?(ActionMailer)
-  module TT::Helper
-    extend ::ActiveSupport::Concern
 
-    included do
-      helper_method :tt
-
-      prepend_before_filter { instance_variable_set(:@tt, ::TT::Translator.new(controller_path, action_name)) }
-    end
-
-    private
-
-    def tt(*args)
-      args.empty? ? @tt : @tt.t(*args)
-    end
+  def self.raise_error(base)
+    raise ArgumentError, "t_t: #{ base }"
   end
 
-  ActiveSupport.on_load(:action_controller) do
-    include ::TT::Helper
+  def self.define_actions(*args)
+    require "t_t/action_factory"
+    f = ActionFactory.new(*args)
+    yield f
+    f.as_hash
   end
 
-  ActiveSupport.on_load(:action_mailer) do
-    include ::TT::Helper
+  def self.const_missing(name)
+    super unless name.to_s == 'Translator'
+    puts ""
+    puts "t_t: TT::Translator is deprecated. Please, use #{ base } instead"
+    base
   end
 end
 
-if defined?(ActiveRecord)
-  ActiveSupport.on_load(:active_record) do
-    TT.config(prefix: :activerecord)
-  end
-end
+require 't_t/rails' if defined?(Rails)

data/lib/t_t/action_factory.rb

@@ -1,5 +1,3 @@
-require 't_t/builtin_rules'
-
 module TT
   class ActionFactory
     Action = Struct.new(:base, :rules)
@@ -57,17 +55,18 @@ module TT
     end
 
     def for(key, &block)
-      yield @locales.fetch(key) { raise_error "`#{ key }` is unknown" }
+      yield @locales.fetch(key) { TT.raise_error "`#{ key }` is unknown" }
     end
 
     def activate_rules(*list)
+      require 't_t/builtin_rules'
       list.each { |rkey| BuiltinRules.send(rkey, self) }
     end
 
     def add(akey, list)
       @locales.each do |lkey, locale|
         unless action = list[lkey]
-          raise_error "action `#{ akey }` is missing for `#{ lkey }` locale"
+          TT.raise_error "action `#{ akey }` is missing for `#{ lkey }` locale"
         end
 
         action = Action.new(action, []) if action.is_a?(String)
@@ -75,10 +74,10 @@ module TT
         if action.is_a?(Action)
           action.rules.each do |rule|
             next if locale.knows_rule?(rule.key)
-            raise_error "`#{ rule.key }` is an unknown rule for `#{ lkey }` locale"
+            TT.raise_error "`#{ rule.key }` is an unknown rule for `#{ lkey }` locale"
           end
         else
-          raise_error "the value of `#{ akey }` action for `#{ lkey }` locale has a wrong type"
+          TT.raise_error "the value of `#{ akey }` action for `#{ lkey }` locale has a wrong type"
         end
 
         @actions[lkey][akey] = action
@@ -91,11 +90,11 @@ module TT
 
     def add_exception(mkey, schema)
       schema.each do |lkey, list|
-        raise_error("`#{ lkey }` is an unknown locale") unless @locales.has_key?(lkey)
+        TT.raise_error("`#{ lkey }` is an unknown locale") unless @locales.has_key?(lkey)
 
         list.each do |akey, str|
           unless @actions[lkey].has_key?(akey)
-            raise_error "`#{ akey }` action is not specified. Do it before add an exception"
+            TT.raise_error "`#{ akey }` action is not specified. Do it before add an exception"
           end
 
           @exceptions[lkey][akey] ||= {}
@@ -121,17 +120,5 @@ module TT
         hash.merge!(lkey => { actions: actions })
       end
     end
-
-    private
-
-    def raise_error(base)
-      raise ArgumentError, "t_t: #{ base }"
-    end
-  end
-
-  def self.define_actions(*args)
-    f = ActionFactory.new(*args)
-    yield f
-    f.as_hash
   end
 end

data/lib/t_t/base.rb

@@ -0,0 +1,185 @@
+require "active_support/inflector"
+require "active_support/lazy_load_hooks"
+require "active_support/multibyte/chars"
+require "i18n"
+
+module TT
+  module Utils
+    extend self
+
+    DOWNCASE = lambda { |str, locale| (locale == :en) ? str.downcase : str.mb_chars.downcase.to_s }
+
+    def lookup(prefix, base_suffix)
+      prefix ? prefix_lookup(prefix, base_suffix) : simple_lookup(base_suffix)
+    end
+
+    def to_parts(str)
+      str.to_s.underscore.split(/\.|\//)
+    end
+
+    private
+
+    def simple_lookup(base_suffix)
+      lambda do |ns, type|
+        parts = to_parts(ns)
+        model_path = parts.join('.')
+
+        root = "#{ type }.#{ model_path }"
+
+        defaults = []
+        defaults << :"#{ type }.#{ parts.last }" if parts.length > 1
+        if base_suffix
+          defaults << :"#{ type }.#{ base_suffix }"
+        else
+          defaults << type
+        end
+
+        [root, defaults]
+      end
+    end
+
+    def prefix_lookup(prefix, base_suffix)
+      lambda do |ns, type|
+        parts = to_parts(ns)
+        model_path = parts.join('.')
+
+        root = "#{ prefix }.#{ type }.#{ model_path }"
+        defaults = [:"#{ type }.#{ model_path }"]
+
+        if parts.length > 1
+          pure_model = parts.last
+          defaults << :"#{ prefix }.#{ type }.#{ pure_model }"
+          defaults << :"#{ type }.#{ pure_model }"
+        end
+
+        if base_suffix
+          defaults << :"#{ prefix }.#{ type }.#{ base_suffix }"
+          defaults << :"#{ type }.#{ base_suffix }"
+        else
+          defaults << :"#{ prefix }.#{ type }"
+          defaults << type
+        end
+
+        [root, defaults]
+      end
+    end
+  end
+
+  class Base
+    def self.lookup_key_method(meth_name, path)
+      class_eval <<-RUBY
+        def #{ meth_name }(key, options = {})
+          I18n.t "\#{ _config.fetch(:ns) }.#{ path }.\#{ key }",
+            { default: [:"#{ path }.\#{ key }"] }.merge(options)
+        end
+      RUBY
+    end
+
+    def self.config(custom = nil, &block)
+      @settings ||= {}
+
+      if custom
+        unknown = custom.keys.detect { |key| ![:downcase, :prefix].include?(key) }
+        if unknown
+          TT.raise_error "`#{ unknown }` is a wrong key in the configuration"
+        else
+          @settings.merge!(custom)
+        end
+      end
+
+      instance_exec(&block) if block_given?
+
+      @settings
+    end
+
+    lookup_key_method :c, :common
+
+    def initialize(ns, section = nil)
+      @lookup   = Utils.lookup(self.class.config[:prefix], nil)
+      @b_lookup = Utils.lookup(self.class.config[:prefix], :base)
+      @e_lookup = Utils.lookup(self.class.config[:prefix], :messages)
+
+      ns = Utils.to_parts(ns).join('.')
+      @config = { ns: ns, root: (section ? "#{ ns }.#{ section }" : ns) }
+      default_model = ns.to_s.singularize
+
+      @config[:attributes] = @lookup.call(default_model, :attributes)
+      @config[:models]     = @lookup.call(default_model, :models)
+      @config[:actions]    = @b_lookup.call(default_model, :actions)
+      @config[:enums]      = @b_lookup.call(default_model, :enums)
+      @config[:errors]     = @e_lookup.call(default_model, :errors)
+
+      @downcase = self.class.config.fetch(:downcase, Utils::DOWNCASE)
+    end
+
+    def a(name, model_name = nil, custom = {})
+      path, defaults = _resolve(@b_lookup, model_name, :actions, name)
+
+      resource = r(model_name)
+      resources = rs(model_name)
+      I18n.t path, {
+        default: defaults, r: @downcase.call(resource, I18n.locale), R: resource,
+        rs: @downcase.call(resources, I18n.locale), RS: resources
+      }.merge!(custom)
+    end
+
+    def attr(name, model_name = nil)
+      path, defaults = _resolve(@lookup, model_name, :attributes, name)
+      I18n.t path, default: defaults
+    end
+
+    def enum(name, kind, model_name = nil)
+      path, defaults = _resolve(@b_lookup, model_name, :enums, "#{ name }.#{ kind }")
+      I18n.t path, default: defaults
+    end
+
+    def e(attr_name, error_name, *args)
+      custom = args.last.is_a?(Hash) ? args.pop : {}
+      model_name = args.first
+      path, defaults = _resolve_errors(model_name, attr_name, error_name)
+      I18n.t path, { default: defaults }.merge!(custom)
+    end
+
+    def r(model_name = nil)
+      rs(model_name, 1)
+    end
+
+    def rs(model_name = nil, count = 10)
+      path, defaults = _resolve(@lookup, model_name, :models, nil)
+      # cut from defaults :"#{ orm }.models", :models
+      I18n.t path, default: defaults[0...-2], count: count
+    end
+
+    def t(key, custom = {})
+      defaults = [:"#{ _config.fetch(:ns) }.common.#{ key }"].concat(Array(custom[:default]))
+      I18n.t "#{ _config.fetch(:root) }.#{ key  }", custom.merge(default: defaults)
+    end
+
+    private
+
+    def _config
+      @config
+    end
+
+    def _resolve_errors(model_name, attr_name, error_name)
+      if attr_name == :base
+        _resolve(@e_lookup, model_name, :errors, error_name)
+      else
+        path, _defaults = _resolve(@lookup, model_name, :errors, "#{ attr_name }.#{ error_name }")
+        defaults = _defaults + ["errors.messages.#{ error_name }".to_sym]
+        return path, defaults
+      end
+    end
+
+    def _resolve(lookup, model_name, type, key)
+      paths = model_name ? lookup.call(model_name, type) : _config.fetch(type)
+      if key
+        return "#{ paths.first }.#{ key }", paths.last.map { |i| :"#{ i }.#{ key }" }
+      else
+        return *paths
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:tt, self)
+  end
+end

data/lib/t_t/i18n_sync.rb

@@ -0,0 +1,138 @@
+require 'active_support/file_update_checker'
+require 'yaml'
+
+module TT
+  class I18nSync
+    MARK = ":t_t: "
+
+    module Utils
+      extend self
+
+      def flat_hash(value, key = nil)
+        case value
+        when Hash
+          value.inject({}) { |r, (k, v)| r.merge! flat_hash(v, [key, k].compact.join('/')) }
+        else
+          { key => value }
+        end
+      end
+
+      def flat_file(*args)
+        flat_hash(load_file(*args))
+      end
+
+      def load_file(path, locale, &block)
+        content = YAML.load_file(path)
+        yield content if block_given?
+        content.fetch(locale.to_s) do
+          TT.raise_error "expected #{ path } should contain `#{ locale }` translations"
+        end
+      end
+
+      def sync_file(path, locale, standard)
+        old_review = {}
+        source = load_file(path, locale) { |content| old_review.merge!(content.fetch('review', {})) }
+        new_review = {}
+        content = { locale => sync_level(standard, source, new_review) }
+        review = old_review.merge(flat_hash(new_review))
+        content['review'] = review unless review.empty?
+        write_file(path, content)
+      end
+
+      def write_file(path, content)
+        File.open("#{ path }", "wb") { |stream| YAML.dump(content, stream, line_width: 1000) }
+      end
+
+      private
+
+      def sync_level(st_level, source, review)
+        level = st_level.inject({}) do |r, (key, st_node)|
+          node = source[key]
+
+          r[key] = case st_node
+          when Hash
+            sub_review = {}
+            sub_level = sync_level(st_node, (node.is_a?(Hash) ? node : {}), sub_review)
+            review[key] = sub_review unless sub_review.empty?
+            sub_level
+          when Array then node.is_a?(Array) ? node : st_node.map { |v| "#{ MARK }#{ v }" }
+          else
+            node.nil? ? "#{ MARK }#{ st_node }" : node
+          end
+          r
+        end
+
+        (source.keys - st_level.keys).each { |key| review[key] = source[key] }
+
+        level
+      end
+    end
+
+    class FileGroup
+      attr_reader :st_locale, :standard, :list
+
+      def initialize(st_locale, standard, list)
+        @st_locale = st_locale
+        @standard = standard
+        @list = list
+      end
+
+      def execute
+        file_updated_at = File.mtime(standard)
+        return if file_updated_at == @prev_updated_at
+
+        st_source = Utils.load_file(standard, st_locale)
+        list.each { |l, path| Utils.sync_file(path, l, st_source) }
+
+        @prev_updated_at = file_updated_at
+      end
+
+      def missed
+        flat_list = list.inject({}) { |r, (l, path)| r.merge!(l => Utils.flat_file(path, l)) }
+
+        Utils.flat_file(standard, st_locale).inject([]) do |list, (k, st_v)|
+          item = flat_list.inject({ st_locale => st_v }) { |r, (l, h)| r.merge!(l => h[k]) }
+          list << item if item.any? { |l, v| v.nil? }
+          list
+        end
+      end
+    end
+
+    attr_reader :checker, :groups
+
+    def initialize(st_locale, files)
+      @groups = []
+
+      files.inject({}) do |r, file|
+        parts = file.split('.')
+        k = parts[0...-2].join('.')
+        l = File.basename(parts[-2])
+        r[k] ||= {}
+        r[k][l] = file
+        r
+      end.each_value do |group|
+        locales = group.keys
+        next unless locales.include?(st_locale) && locales.size > 1
+        list = group.reject { |l, v| l == st_locale }
+        groups << FileGroup.new(st_locale, group[st_locale], list)
+      end
+
+      @checker = ActiveSupport::FileUpdateChecker.new(groups.map(&:standard)) { execute }
+    end
+
+    def execute
+      groups.each(&:execute)
+    end
+
+    def missed
+      groups.inject({}) do |r, group|
+        unless (list = group.missed).empty?
+          base_path = group.standard.split(group.st_locale)[0]
+          key = "#{ base_path }(*).yml"
+          r[key] = list
+        end
+        r
+      end
+    end
+  end
+end

data/lib/t_t/rails.rb

@@ -0,0 +1,63 @@
+options = {}
+if defined?(Mongoid)
+  options[:prefix] = :mongoid
+elsif defined?(ActiveRecord)
+  options[:prefix] = :activerecord
+end
+
+TT.base = TT::Rails = TT.fork(options) do
+  def self.sync(value = nil)
+    @sync = value unless value.nil?
+    @sync
+  end
+end
+
+module TT
+  module Helper
+    extend ::ActiveSupport::Concern
+
+    included do
+      helper_method :tt
+
+      prepend_before_filter { instance_variable_set(:@tt, ::TT::Rails.new(controller_path, action_name)) }
+    end
+
+    private
+
+    def tt(*args)
+      args.empty? ? @tt : @tt.t(*args)
+    end
+  end
+
+  class Railtie < ::Rails::Railtie
+    config.tt = ActiveSupport::OrderedOptions.new
+
+    config.after_initialize do |app|
+      if options = app.config.tt.sync
+        require 't_t/i18n_sync'
+
+        locale = :en
+        glob = 'config/locales/**/*.yml'
+        if options.is_a?(Symbol) || options.is_a?(String)
+          locale = options
+        elsif options.is_a?(Hash)
+          locale = options[:locale] if options.has_key?(:locale)
+          glob = options[:glob] if options.has_key?(:glob)
+        end
+
+        file_sync = ::TT::I18nSync.new(locale.to_s, Dir.glob(glob))
+        TT::Rails.sync(file_sync)
+        ::Rails.application.reloaders << file_sync.checker
+        ActionDispatch::Reloader.to_prepare { file_sync.checker.execute_if_updated }
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_controller) do
+  include ::TT::Helper
+end
+
+ActiveSupport.on_load(:action_mailer) do
+  include ::TT::Helper
+end

data/lib/t_t/tasks.rb

@@ -0,0 +1,23 @@
+namespace :tt do
+  desc "Synchronises the translation file groups"
+  task :s => :environment do
+    if sync = TT::Rails.sync
+      sync.execute
+    else
+      puts "t_t: Please, setup the synchronisation first"
+    end
+  end
+
+  desc "Shows a missed keys in the translation file groups"
+  task :m => [:s] do
+    if sync = TT::Rails.sync
+      sync.missed.each do |group, list|
+        puts "# #{ group }"
+        puts line.inject("") { |r, (k, v)| r + "#{ k.upcase }: #{ v.to_s.encode('utf-8') }\n" }
+        puts '---'
+      end
+    else
+      puts "t_t: Please, setup the synchronisation first"
+    end
+  end
+end

data/readme.md

@@ -87,16 +87,24 @@ The result will be the next:
 = link_to 'Add a new user', new_user_path
 ```
 
+## Additional features
+
+#### [The action factory](./docs/action_factory.md)
+
+#### [Synchronisation of a translation files](./docs/synchronisation.md)
+
 ## Setup
 
 Just add `gem "t_t"` into your Gemfile and run `bundle`.
 
 ## Requirements
 
-Dos-T is tested against Ruby 1.9.3+. If your application uses Ruby on Rails the framework version should be 3.2+
+Dos-T is tested against Ruby 1.9.3+ & JRuby(1.9+ compatible). If your application uses Ruby on Rails the framework version should be 3.2+
 
 ## Changelog
-
+- 1.2.0
+  - Deprecate TT::Translator in favour of TT::Base & TT::Rails
+  - Introduce a real-time watcher for [translation file synchronisation](./docs/synchronisation.md)
 - 1.1.0:
   - Added [the action factory](./docs/action_factory.md)
   - Improve #attr, #r, #rs methods to make them more compatible with ActiveModel methods

data/t_t.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "t_t"
-  spec.version       = "1.1.0"
+  spec.version       = "1.2.0"
   spec.authors       = ["Sergey Pchelintsev"]
   spec.email         = ["mail@sergeyp.me"]
   spec.summary       = %q{An opinioned I18n helper}
@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "i18n", ">= 0.6.0"
   spec.add_dependency "activesupport", ">= 3.0.0"
 
-  spec.add_development_dependency "actionpack", ">= 3.0.0"
+  spec.add_development_dependency "rails", ">= 3.0.0"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "minitest", ">= 4.7"
   spec.add_development_dependency "rack-test"

data/tests/lib/action_pack_test.rb

@@ -11,7 +11,7 @@ describe "ActionPack integration" do
   end
 
   it 'returns tt instance if the method was called without args' do
-    assert_equal @controller.tt.class, TT::Translator
+    assert_equal @controller.tt.class, TT::Rails
   end
 
   it 'calls #t if args were passed' do

data/tests/lib/i18n_sync_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+describe 'I18n synchronisation' do
+  it 'add a missing keys' do
+    store = {
+      'en' => { 'a' => 'a', 'b' => 'b', 'c' => { 'd' => 'd' }, 'e' => { 'f' => ['k', 'l'] } },
+      'de' => { 'b' => 'de-b' }
+    }
+
+    YAML.stub :load_file, store do
+      group = TT::I18nSync::FileGroup.new('en', __FILE__, { 'de' => 'de.yml' })
+      expectation = lambda do |path, content|
+        assert_equal path, 'de.yml'
+        assert_equal content, {
+          'de' => {
+            'a' => ':t_t: a', 'b' => 'de-b',
+            'c' => { 'd' => ':t_t: d' },
+            'e' => { 'f' => [':t_t: k', ':t_t: l'] }
+          }
+        }
+      end
+
+      utils = TT::I18nSync::Utils
+      utils.stub(:write_file, expectation) { group.execute }
+
+      should_not_call_twice = proc { assert false, "should not call twice" }
+      utils.stub(:write_file, should_not_call_twice) { group.execute }
+    end
+  end
+
+  it 'saves the previous review and adds a new' do
+    store = {
+      'review' => { 'c/d' => 'c', 'r' => 'r' },
+      'en' => { 'a' => 'a', 'b' => 'b', 'c' => { 'd' => 'd' } },
+      'de' => { 'b' => 'de-b' }
+    }
+    YAML.stub :load_file, store do
+      group = TT::I18nSync::FileGroup.new('de', __FILE__, { 'en' => 'en.yml' })
+      expectation = lambda do |path, content|
+        assert_equal path, 'en.yml'
+        assert_equal content['en'], { 'b' => 'b' }
+        assert_equal content['review'].sort, [['a', 'a'], ['c/d', 'd'], ['r', 'r']]
+      end
+
+      utils = TT::I18nSync::Utils
+      utils.stub(:write_file, expectation) { group.execute }
+    end
+  end
+
+  it 'combines files into a full groups' do
+    groupMock = Struct.new(:locale, :standard, :list) do
+      def execute
+      end
+    end
+
+    TT::I18nSync::FileGroup.stub(:new, proc { |*args| groupMock.new(*args) }) do
+      sync = TT::I18nSync.new('de', [
+        'config/locales/fr.yml', 'config/locales/views.bg.yml', 'config/locales/models/orm.nl.yml',
+        'config/locales/de.yml', 'config/locales/views.de.yml', 'config/locales/models/orm.en-US.yml',
+        'config/locales/es.yml', 'config/locales/views.en-US.yml', 'config/locales/models/orm.de.yml',
+        'config/locales/en-US.yml', 'config/locales/views.es.yml', 'config/locales/models/orm.es.yml',
+        'config/locales/fix.en-US.yml', 'config/locales/skip.de.yml'
+      ])
+
+      assert_equal 3, sync.groups.length
+
+      sync.groups[0].tap do |group|
+        assert_equal 'config/locales/de.yml', group.standard
+        assert_equal [
+          ['en-US', 'config/locales/en-US.yml'],
+          ['es', 'config/locales/es.yml'],
+          ['fr', 'config/locales/fr.yml']
+        ], group.list.sort
+      end
+    end
+  end
+
+  it 'shows all missed translations' do
+    store = {
+      'en' => { 'a' => 'a', 'b' => 'b', 'c' => { 'd' => 'd' } },
+      'de' => { 'b' => 'de-b' }
+    }
+    YAML.stub :load_file, store do
+      sync = TT::I18nSync.new('en', ['en.yml', 'de.yml'])
+      result = sync.missed
+
+      assert_equal 1, result.size
+      assert_equal '(*).yml', result.keys.first
+
+      result['(*).yml'].tap do |list|
+        assert_equal 2, list.size
+        assert_equal({ 'en' => 'a', 'de' => nil }, list.first)
+        assert_equal({ 'en' => 'd', 'de' => nil }, list.last)
+      end
+    end
+  end
+end

data/tests/lib/model_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe 'Methods related to models' do
   before do
-    @tt = TT::Translator.new("admin/users", "spec")
+    @tt = TT::Rails.new("admin/users", "spec")
   end
 
   describe 'actions' do
@@ -134,7 +134,7 @@ describe 'Methods related to models' do
 
   describe 'resource names' do
     before do
-      @tt = TT::Translator.new('public/people')
+      @tt = TT::Rails.new('public/people')
       load_i18n({
         models: { person: { one: "whatever", other: "whatever" }, user: { one: "User", other: "Users" } },
         activerecord: { models: {

data/tests/test_helper.rb

@@ -1,14 +1,11 @@
-# emulate activerecord presence
-ActiveRecord = nil
-
 require "minitest/autorun"
 require "minitest/mock"
 require "rack/test"
-require "action_controller"
+require "action_controller/railtie"
+require "active_record/railtie"
 require "t_t"
-require "t_t/action_factory"
+require "t_t/i18n_sync"
 
-ActiveSupport.run_load_hooks(:active_record, self)
 ViewTranslator = TT.fork do
   lookup_key_method :f, :form
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: t_t
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Sergey Pchelintsev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-25 00:00:00.000000000 Z
+date: 2016-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
-  name: actionpack
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -121,20 +121,25 @@ files:
 - Rakefile
 - cheatsheet.md
 - docs/action_factory.md
+- docs/synchronisation.md
 - examples/simple_app.yml
-- gemfiles/Gemfile.actionpack-3.1.x
 - gemfiles/Gemfile.actionpack-3.2.x
 - gemfiles/Gemfile.actionpack-4.0.x
 - gemfiles/Gemfile.actionpack-4.1.x
 - gemfiles/Gemfile.actionpack-4.2.x
 - lib/t_t.rb
 - lib/t_t/action_factory.rb
+- lib/t_t/base.rb
 - lib/t_t/builtin_rules.rb
+- lib/t_t/i18n_sync.rb
+- lib/t_t/rails.rb
+- lib/t_t/tasks.rb
 - readme.md
 - t_t.gemspec
 - tests/lib/action_factory_test.rb
 - tests/lib/action_pack_test.rb
 - tests/lib/builtin_rules_test.rb
+- tests/lib/i18n_sync_test.rb
 - tests/lib/model_test.rb
 - tests/lib/view_test.rb
 - tests/test_helper.rb

data/gemfiles/Gemfile.actionpack-3.1.x

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '../'
-gem 'activesupport', '~> 3.1.0'