t_t 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93be7cafdab979b4837cf9be239ecdec38ed2d04
-  data.tar.gz: a3bc394c6c54755306a3108e133e4f1f1b5cb24a
+  metadata.gz: b73436334b6c70340cf56c69878f5645ddecbd12
+  data.tar.gz: 6f9f3913be2190fc19abce30109a1816621562b8
 SHA512:
-  metadata.gz: b680bb07574bac2214318dd97059757e21a4e7bfae91d6ed32602c828c79cbac1b1ba98e8301e63f35ece020d6a7e5a334dde3da560960df9bb15911dc054355
-  data.tar.gz: 789a592362b858ac87dd2e564c8cc33e83e6eeae6a926b5617bad58bc7b75e70386620e9c2b6029a7179ec207a43651a418906a3e0af85d330b775db2629e3f1
+  metadata.gz: a9c423a3ab34a17a0f4f858a773d7c0d60250e32f18679e469e136de30b22b68b5fe5af7e30820c83fbedbcd47d097a65807050989ec875422daa0ba577946ad
+  data.tar.gz: 42c316f2a5355a2b8379724847f8088582c3f46782811fff42595f6e49f7795ac711dfefe090d41f225db956c08507d02d4cb7a598bdfcbf900d9d393d787ab7

data/Rakefile

@@ -7,4 +7,10 @@ Rake::TestTask.new(:test) do |t|
   t.pattern = 'tests/**/*_test.rb'
 end
 
+Rake::TestTask.new(:run) do |t|
+  t.libs << "lib"
+  t.libs << "tests"
+  t.pattern = ARGV[1]
+end
+
 task default: :test

data/cheatsheet.md

@@ -84,8 +84,7 @@ You probably know that `active_model` based classes have handy method **#human_a
 ```ruby
 # en:
 #   attributes:
-#     base:
-#       email: "Email"
+#     email: "Email"
 #     user:
 #       email: "Login / Email"
 
@@ -241,12 +240,10 @@ comes on the scene:
 ```ruby
 # en:
 #   actions:
-#     create:
-#       base: "The %{r} has been created"
-#     update:
-#       base: "The %{r} has been updated"
-#     delete:
-#       base: "The %{r} has been deleted"
+#     base:
+#       create: "The %{r} has been created"
+#       update: "The %{r} has been updated"
+#       delete: "The %{r} has been deleted"
 #   models:
 #     user:
 #       one: "User"
@@ -286,14 +283,17 @@ just add a model name key in a action translations:
 ```ruby
 # en:
 #   actions:
-#     create:
-#       base: "The %{r} has been created"
-#       photo: "The %{r} has been uploaded"
+#     base:
+#       create: "The %{r} has been created"
+#     photo:
+#       create: "The %{r} has been uploaded"
 
 tt.a(:create, :user)  # => "The user has been created"
 tt.a(:create, :photo) # => "The photo has been uploaded"
 ```
-Take a look at [examples folder](./examples/) for a more examples.
+
+To simplify generation of translations Dos-T provides [the action factory](./docs/action_factory.md).
+For more examples take a look [here](./examples/).
 
 ## Custom shortcuts
 

data/docs/action_factory.md

@@ -0,0 +1,179 @@
+# Overview
+
+Dos-T provides a factory (not required by default) 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}"
+end
+```
+
+From the example above you've understood the basic DSL's api, but started wondering what's a point of it due to fill
+a yml file will be faster and easier. The reason comes when you will face a grammar rule which requires a different
+texts. The most popular case is an English "a/an" rule. For example, an application has the next translation:
+
+```ruby
+# config/locales/actions.en.yml
+en:
+  actions:
+    base:
+      choose: "Please, choose a %{r}"
+    agent:
+      choose: "Please, choose an %{r}"
+    article:
+      choose: "Please, choose an %{r}"
+    occupation:
+      choose: "Please, choose an %{r}"
+      #...
+```
+
+This grammar rule forces us to create n * m keys where:
+- n is a count of actions with the rule
+- m is a count of models which uses "an"
+A plain translation file becomes large what makes the its maintenance hard. With Dos-T it's easy due to you
+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)
+    l.rule(:an) { |base, a_meta, r_meta| a_meta }
+
+    # registers a resources which should use the rule
+    l.use_rule_for(:an, :agent, :article, occupation: "a useless resource (`occupation`) metadata for the `an` rule")
+  end
+
+  # "Please, choose an %{r}" is an action metadata for the rule
+  f.add :choose, en: f.with_rules("Please, choose a %{r}", an: "Please, choose an %{r}")
+  f.add :create, en: f.with_rules("Create a %{r}", an: "Create an %{r}")
+  f.add :delete_all, en: "Do you want to delete all %{rs}"
+end
+```
+
+Here an another example with a more complex grammar rules:
+
+```ruby
+require 't_t/action_factory'
+# de:
+#   models:
+#     article:
+#       one: "Artikel"
+#       other: "Artikel"
+#     child:
+#       one: "Kind"
+#       other: "Kinder"
+#     comment:
+#       one: "Komment"
+#       other: "Komments"
+#     list:
+#       one: "Liste"
+#       other: "Listen"
+#     log:
+#       one: "Protokoll"
+#       other: "Protokolle"
+#     person:
+#       one: "Person"
+#       other: "Personen"
+# ru:
+#   models:
+#     article:
+#       one: "Статья"
+#       other: "Статьи"
+#     child:
+#       one: "Ребенок"
+#       other: "Дети"
+#     comment:
+#       one: "Комментарий"
+#       other: "Комментарии"
+#     list:
+#       one: "Список"
+#       other: "Списки"
+#     log:
+#       one: "Запись"
+#       other: "Записи"
+#     person:
+#       one: "Персона"
+#       other: "Персоны"
+
+TT.define_actions(:de, :ru) do |f|
+  f.for(:de) do |l|
+    # German articles are sensitive to gender
+    l.rule(:feminine) { |_, a_meta, _| a_meta }
+    l.rule(:neuter)   { |_, a_meta, _| a_meta }
+
+    l.use_rule_for(:feminine, :list, :person)
+    l.use_rule_for(:neuter, :child, :log)
+  end
+
+  f.for(:ru) do |l|
+    # Russian language has 6 noun cases(падежи)
+    # for passive voice Accuse case(Винительный падеж - кого? что?) is used
+    l.rule(:accuse) { |base, _, r_meta| r_meta.inject(base) { |str, (k, v)| str.gsub("%{#{ k }}", v) } }
+    l.use_rule_for :accuse,
+      article: { r: "статью", R: "Статью" }, # the plural version is not changing
+      child: { r: "ребенка", rs: "детей", R: "Ребенка", RS: "Детей" },
+      person: { r: "персону", rs: "персон", R: "Персону", RS: "Персон" }
+  end
+
+  f.add :add,
+    de: f.with_rules("Neuen %{R} hinzufügen", feminine: "Neue %{R} hinzufügen", neuter: "Neues %{R} hinzufügen"),
+    ru: f.with_rules("Добавить %{r}", :accuse)
+
+  f.add :edit,
+    de: f.with_rules("Den %{R} bearbeiten", feminine: "Die %{R} bearbeiten", neuter: "Das %{R} bearbeiten"),
+    ru: f.with_rules("Изменить %{r}", :accuse)
+
+  f.add :delete_all,
+    de: "Alle %{RS} löschen"
+    ru: f.with_rules("Удалить %{rs}", :accuse)
+end
+```
+
+The generated list of actions is present in the following table:
+
+||add-de|edit-de|delete-de|add-ru|edit-ru|delete-ru|
+|---|---|---|---|---|---|---|
+|article|Neuen Artikel hinzufügen|Den Artikel bearbeiten|Alle Artikel löschen|Добавить статью|Изменить статью|Удалить статьи|
+|child|Neues Kind hinzufügen|Das Kind bearbeiten|Alle Kinder löschen|Добавить ребенка|Изменить ребенка|Удалить детей|
+|comment|Neuen Komment hinzufügen|Den Komment bearbeiten|Alle Komments löschen|Добавить комментарий|Изменить комментарий|Удалить комментарии|
+|list|Neue Liste hinzufügen|Die Liste bearbeiten|Alle Listen löschen|Добавить список|Изменить список|Удалить списки|
+|log|Neues Protokoll hinzufügen|Das Protokoll bearbeiten|Alle Protokolle löschen|Добавить запись|Изменить запись|Удалить записи|
+|person|Neue Person hinzufügen|Die Person bearbeiten|Alle Personen löschen|Добавить персону|Изменить персону|Удалить персон|
+
+With the factory you get a flexibility in resource renaming - just change of a few lines. A possibility to make a typo
+in a similar translations down to zero. All shown rules a included in the factory, but not activated.
+To do it, do the next:
+
+```ruby
+TT.define_actions(:en, :de, :ru) do |f|
+  # the naming convention is similar to BEM
+  f.activate_rules(:en__an, :de__gender, :ru__accuse)
+end
+```
+
+If you would like to add another grammar rule feel free to make a pull request.
+
+## Adding an exceptions
+
+Dos-T was built to maximize the usage of patterns in translations. It helps to avoid typos and long files, but texts
+become more technical. In the previous section, you probably noticed that translations like "Das Kind bearbeiten"
+(change the child) or "Изменить персону"(change the person) better to replace by more human oriented
+"Das Kind-Profile bearbeiten" (change the child's profile) and "Изменить биографию персоны" (change the person's bio).
+For those situations the library allows to specify an exceptions:
+
+```ruby
+TT.define_actions(:de, :ru) do |f|
+  # declaration of rules and actions
+
+  f.add_exception(:child, ru: { edit: "Das Kind-Profile bearbeiten" }, de: { edit: "Изменить профиль ребенка" })
+end
+```

data/examples/simple_app.yml

@@ -101,11 +101,11 @@ en:
         blank: Select at least one task list
   # action related
   actions:
-    choose_few:
-      base: Choose one or more %{rs}
-    create:
-      base: "The %{r} has been created"
-      task: "The %{r} hass been added"
-    select_before:
-      base: "Please choose a %{r} before"
-      icon: "Please choose an %{r} before"
+    base:
+      choose_few: "Choose one or more %{rs}"
+      create: "The %{r} has been created"
+      select_before: "Please choose a %{r} before"
+    task:
+      create: "The %{r} hass been added"
+    icon:
+      select_before: "Please choose an %{r} before"

data/lib/t_t/action_factory.rb

@@ -0,0 +1,137 @@
+require 't_t/builtin_rules'
+
+module TT
+  class ActionFactory
+    Action = Struct.new(:base, :rules)
+    Option = Struct.new(:key, :meta) do
+      def self.parse(list)
+        list.flat_map do |item|
+          item.respond_to?(:map) ? item.map { |key, meta| new(key, meta) } : new(item)
+        end
+      end
+    end
+
+    class Locale
+      def initialize
+        @rules = {}
+        @list  = {}
+      end
+
+      def rule(key, &block)
+        @rules[key] = block
+        @list[key]  = []
+      end
+
+      def use_rule_for(key, *list)
+        @list[key].concat(Option.parse(list))
+      end
+
+      def knows_rule?(key)
+        @rules.has_key?(key)
+      end
+
+      def compile(action)
+        action.rules.inject(base: action.base) do |result, a_option|
+          rule = @rules.fetch(a_option.key)
+
+          @list.fetch(a_option.key).each do |r_option|
+            base = result.fetch(r_option.key, action.base)
+            result[r_option.key] = rule.call(base, a_option.meta, r_option.meta)
+          end
+
+          result
+        end
+      end
+    end
+
+    def initialize(*locales)
+      @actions = {}
+      @locales = {}
+      @exceptions = {}
+
+      locales.each do |lkey|
+        @actions[lkey]    = {}
+        @exceptions[lkey] = {}
+        @locales[lkey]    = Locale.new
+      end
+    end
+
+    def for(key, &block)
+      yield @locales.fetch(key) { raise_error "`#{ key }` is unknown" }
+    end
+
+    def activate_rules(*list)
+      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"
+        end
+
+        action = Action.new(action, []) if action.is_a?(String)
+
+        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"
+          end
+        else
+          raise_error "the value of `#{ akey }` action for `#{ lkey }` locale has a wrong type"
+        end
+
+        @actions[lkey][akey] = action
+      end
+    end
+
+    def with_rules(base, *list)
+      Action.new(base, Option.parse(list))
+    end
+
+    def add_exception(mkey, schema)
+      schema.each do |lkey, list|
+        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"
+          end
+
+          @exceptions[lkey][akey] ||= {}
+          @exceptions[lkey][akey][mkey] = str
+        end
+      end
+    end
+
+    def as_hash
+      @actions.inject({}) do |hash, (lkey, list)|
+        locale = @locales.fetch(lkey)
+
+        actions = list.inject({}) do |result, (akey, action)|
+          keys = locale.compile(action).merge!(@exceptions[lkey].fetch(akey, {}))
+          keys.each do |mkey, str|
+            result[mkey] = {} unless result.has_key?(mkey)
+            result[mkey][akey] = str
+          end
+
+          result
+        end
+
+        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/builtin_rules.rb

@@ -0,0 +1,45 @@
+module TT
+  module BuiltinRules
+    extend self
+
+    # The indefinite article a (before a consonant sound) or an (before a vowel sound)
+    # is used only with singular, countable nouns.
+    def en__an(f)
+      f.for(:en) do |l|
+        l.rule(:an) { |_, a_meta, _| a_meta }
+      end
+    end
+
+    # The articles in German
+    # | masculine | feminine | neuter | plural |
+    # | neuen     | neue     | neues  | neue   |
+    # | keinen    | keine    | kein   | keine  |
+    # | der       | die      | das    | die    |
+
+    # this lambda generate default translation for masculine form
+    # & add exceptions for feminine & neuter genders
+    # ie
+    #   new:
+    #     base: "Neuen %{r} hinzufügen"    -> "Neuen Benutzer anlegen"
+    #     company: "Neues %{r} hinzufügen" -> "Neues Unternehmen anlegen"
+    #     role: "Neue %{r} hinzufügen"     -> "Neue Rolle hinzufügen"
+    def de__gender(f)
+      f.for(:de) do |l|
+        l.rule(:feminine) { |_, a_meta, _| a_meta }
+        l.rule(:neuter)   { |_, a_meta, _| a_meta }
+      end
+    end
+
+    # To get a correct translation in Russian
+    # you need to set the proper ending for object by using `Винительный падеж - Кого? Что?`
+    # "Создать Компанию(кого?) & Cоздать Сектор(что?)"
+    # for `что?` we can use the resource name, for `кого?` - need to provide a separated key
+    def ru__accuse(f)
+      f.for(:ru) do |l|
+        l.rule(:accuse) do |base, _, r_meta|
+          r_meta.inject(base) { |str, (k, t)| str.gsub("%{#{k}}", t) }
+        end
+      end
+    end
+  end
+end

data/lib/t_t.rb

@@ -9,7 +9,7 @@ module TT
 
     DOWNCASE = lambda { |str, locale| (locale == :en) ? str.downcase : str.mb_chars.downcase.to_s }
 
-    def lookup(prefix, base_suffix = :base)
+    def lookup(prefix, base_suffix)
       prefix ? prefix_lookup(prefix, base_suffix) : simple_lookup(base_suffix)
     end
 
@@ -28,7 +28,11 @@ module TT
 
         defaults = []
         defaults << :"#{ type }.#{ parts.last }" if parts.length > 1
-        defaults << :"#{ type }.#{ base_suffix }"
+        if base_suffix
+          defaults << :"#{ type }.#{ base_suffix }"
+        else
+          defaults << type
+        end
 
         [root, defaults]
       end
@@ -47,8 +51,14 @@ module TT
           defaults << :"#{ prefix }.#{ type }.#{ pure_model }"
           defaults << :"#{ type }.#{ pure_model }"
         end
-        defaults << :"#{ prefix }.#{ type }.#{ base_suffix }"
-        defaults << :"#{ type }.#{ base_suffix }"
+
+        if base_suffix
+          defaults << :"#{ prefix }.#{ type }.#{ base_suffix }"
+          defaults << :"#{ type }.#{ base_suffix }"
+        else
+          defaults << :"#{ prefix }.#{ type }"
+          defaults << type
+        end
 
         [root, defaults]
       end
@@ -85,22 +95,25 @@ module TT
     lookup_key_method :c, :common
 
     def initialize(ns, section = nil)
-      @lookup = Utils.lookup(self.class.settings[:prefix])
-      @err_lookup = Utils.lookup(self.class.settings[:prefix], :messages)
+      @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
-      [:actions, :attributes, :enums, :models].each do |i|
-        @config[i] = @lookup.call(default_model, i)
-      end
-      @config[:errors] = @err_lookup.call(default_model, :errors)
+
+      @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(model_name, :actions, name)
+      path, defaults = _resolve(@b_lookup, model_name, :actions, name)
 
       resource = r(model_name)
       resources = rs(model_name)
@@ -111,12 +124,12 @@ module TT
     end
 
     def attr(name, model_name = nil)
-      path, defaults = _resolve(model_name, :attributes, name)
+      path, defaults = _resolve(@lookup, model_name, :attributes, name)
       I18n.t path, default: defaults
     end
 
     def enum(name, kind, model_name = nil)
-      path, defaults = _resolve(model_name, :enums, "#{ name }.#{ kind }")
+      path, defaults = _resolve(@b_lookup, model_name, :enums, "#{ name }.#{ kind }")
       I18n.t path, default: defaults
     end
 
@@ -132,8 +145,9 @@ module TT
     end
 
     def rs(model_name = nil, count = 10)
-      path, defaults = _resolve(model_name, :models)
-      I18n.t path, default: defaults, count: count
+      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 = {})
@@ -147,21 +161,17 @@ module TT
       @config
     end
 
-    def _resolve(model_name, type, key = nil)
-      _resolve_with_lookup(@lookup, model_name, type, key)
-    end
-
     def _resolve_errors(model_name, attr_name, error_name)
       if attr_name == :base
-        _resolve_with_lookup(@err_lookup, model_name, :errors, error_name)
+        _resolve(@e_lookup, model_name, :errors, error_name)
       else
-        path, _defaults = _resolve(model_name, :errors, "#{ attr_name }.#{ error_name }")
+        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_with_lookup(lookup, model_name, type, key)
+    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 }" }

data/readme.md

@@ -17,8 +17,8 @@ is to look at [Cheatsheet](./cheatsheet.md). The below is shown a brief overview
 ```Haml
 # en:
 #   actions:
-#     add:
-#       base: "Add a new %{r}"
+#     base:
+#       add: "Add a new %{r}"
 #   attributes:
 #     user:
 #       name: "Name"
@@ -94,3 +94,12 @@ 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+
+
+## Changelog
+
+- 1.1.0:
+  - Added [the action factory](./docs/action_factory.md)
+  - Improve #attr, #r, #rs methods to make them more compatible with ActiveModel methods
+  - Fix a documentation mismatching
+- 1.0.1
+  - fix the activerecord integration

data/t_t.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "t_t"
-  spec.version       = "1.0.1"
+  spec.version       = "1.1.0"
   spec.authors       = ["Sergey Pchelintsev"]
   spec.email         = ["mail@sergeyp.me"]
   spec.summary       = %q{An opinioned I18n helper}

data/tests/lib/action_factory_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+describe "Action factory" do
+  describe "adding an actions" do
+    it 'adds an action' do
+      result = factory(:es) { |f| f.add :sing, es: 'cantar' }
+      assert_equal result, { es: { actions: { base: { sing: 'cantar' } } } }
+    end
+
+    it 'checks a locale action presence' do
+      assert_raises(ArgumentError, 't_t: action `run` is missing for `fr` locale') do
+        factory(:fr) { |f| f.add :run, en: 'Run' }
+      end
+    end
+
+    it 'checks a locale rule presence' do
+      assert_raises(ArgumentError, 't_t: `feminine` is an unknown rule for `es` locale') do
+        factory(:es) { |f| f.add :swim, es: f.with_rules('El nada', feminine: 'Ella nada') }
+      end
+    end
+
+    it 'checks a valid action type' do
+      assert_raises(ArgumentError, 't_t: the value of `count` action for `fr` locale has a wrong type') do
+        factory(:fr) { |f| f.add :count, fr: 34 }
+      end
+    end
+  end
+
+  describe "adding an exceptions" do
+    it 'adds an exception' do
+      result = factory(:en) do |f|
+        f.add :add, en: 'Add a new'
+        f.add_exception :user, en: { add: 'Register a new' }
+      end
+
+      assert_equal result, { en: { actions: { base: { add: 'Add a new' }, user: { add: 'Register a new' } } } }
+    end
+
+    it 'checks a locale presence' do
+      assert_raises(ArgumentError, 't_t: `ru` is an unknown locale') do
+        factory(:en) do |f|
+          f.add :add, en: 'Add a new'
+          f.add_exception :user, ru: { add: 'Register a new' }
+        end
+      end
+    end
+
+    it 'checks an action presence' do
+      assert_raises(ArgumentError, 't_t: `listen` action is not specified. Do it before add an exception') do
+        factory(:en) { |f| f.add_exception :visitor, en: { listen: "listen to a band" } }
+      end
+    end
+  end
+
+  private
+
+  def factory(*args, &block)
+    TT.define_actions(*args, &block)
+  end
+end

data/tests/lib/builtin_rules_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+describe 'Built-in rules' do
+  it '#en__an' do
+    result = with_factory(:en, :an) do |f|
+      f.for(:en) { |l| l.use_rule_for(:an, :alarm) }
+
+      f.add :add, en: f.with_rules('A', an: 'An')
+    end
+
+    assert_equal result[:base][:add], 'A'
+    assert_equal result[:alarm][:add], 'An'
+  end
+
+  it '#de__gender' do
+    list = with_factory(:de, :gender) do |f|
+      f.for(:de) do |l|
+        l.use_rule_for(:feminine, :role)
+        l.use_rule_for(:neuter, :company)
+      end
+
+      f.add :choose_gender, de: f.with_rules('M', feminine: 'F', neuter: 'N')
+    end
+
+    assert_equal list[:base][:choose_gender], 'M'
+    assert_equal list[:role][:choose_gender], 'F'
+    assert_equal list[:company][:choose_gender], 'N'
+  end
+
+  it '#ru__accuse' do
+    list = with_factory(:ru, :accuse) do |f|
+      f.for(:ru) do |l|
+        l.use_rule_for(:accuse, man: { r: 'man', R: 'Man' }, woman: { RS: 'Women', rs: 'women' })
+      end
+
+      f.add :accuse, ru: f.with_rules("%{r} %{rs} %{R} %{RS}", :accuse)
+    end
+
+    assert_equal list[:base][:accuse], "%{r} %{rs} %{R} %{RS}"
+    assert_equal list[:man][:accuse], "man %{rs} Man %{RS}"
+    assert_equal list[:woman][:accuse], "%{r} women %{R} Women"
+  end
+
+  private
+
+  def with_factory(lang, macro)
+    TT.define_actions(lang) do |f|
+      f.activate_rules("#{ lang }__#{ macro }")
+      yield f
+    end[lang][:actions]
+  end
+end

data/tests/lib/model_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe 'Methods related to models' do
   before do
-    @tt = ARTranslator.new("admin/users", "spec")
+    @tt = TT::Translator.new("admin/users", "spec")
   end
 
   describe 'actions' do
@@ -44,7 +44,7 @@ describe 'Methods related to models' do
   describe 'attributes' do
     before do
       load_i18n(attributes: {
-        base:  { name: 'Name', phone: 'Phone', email: 'Email' },
+        name: 'Name', phone: 'Phone', email: 'Email',
         user:  { name: 'Nick', phone: 'Notification phone' },
         admin: { user: { name: 'Contact admin name' } }
       })
@@ -134,7 +134,7 @@ describe 'Methods related to models' do
 
   describe 'resource names' do
     before do
-      @tt = ARTranslator.new('public/people')
+      @tt = TT::Translator.new('public/people')
       load_i18n({
         models: { person: { one: "whatever", other: "whatever" }, user: { one: "User", other: "Users" } },
         activerecord: { models: {

data/tests/test_helper.rb

@@ -1,19 +1,18 @@
+# emulate activerecord presence
+ActiveRecord = nil
+
 require "minitest/autorun"
 require "minitest/mock"
 require "rack/test"
 require "action_controller"
 require "t_t"
 require "t_t/action_factory"
-require "t_t/action_macros"
 
+ActiveSupport.run_load_hooks(:active_record, self)
 ViewTranslator = TT.fork do
   lookup_key_method :f, :form
 end
 
-ARTranslator = TT.fork do
-  settings prefix: :activerecord
-end
-
 I18n.backend = I18n::Backend::Simple.new
 
 class Minitest::Spec
@@ -25,3 +24,12 @@ class Minitest::Spec
     I18n.backend.store_translations(:en, data)
   end
 end
+
+class << Minitest::Spec
+  alias :focus :it
+
+  if ENV.has_key?('FOCUS')
+    def it(*args, &block)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: t_t
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Sergey Pchelintsev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-19 00:00:00.000000000 Z
+date: 2016-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -120,6 +120,7 @@ files:
 - Gemfile
 - Rakefile
 - cheatsheet.md
+- docs/action_factory.md
 - examples/simple_app.yml
 - gemfiles/Gemfile.actionpack-3.1.x
 - gemfiles/Gemfile.actionpack-3.2.x
@@ -127,9 +128,13 @@ files:
 - 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/builtin_rules.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/model_test.rb
 - tests/lib/view_test.rb
 - tests/test_helper.rb