t_t 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc0178a11cfb6485afd79658204c099a1669b9e2
-  data.tar.gz: 5b2fe90809f3c1ecc26dfa80c31b7ae54d104c50
+  metadata.gz: d836d08bfcb2cd0c0ddc4cf71c7ff13bc8d95aba
+  data.tar.gz: 46616d020eef370af7a34e6dd672262be6dcf477
 SHA512:
-  metadata.gz: 2bf34f3f4efb00014850798c385233ce27c9956a9867080d9c4cdc0141052d3ec3d6bbbbe66922e4be2f933a52fc758566e8e912adb6c9306b6e740ed221c5eb
-  data.tar.gz: 157cedeec1cbcab34a82d77a5d70844aea77193bde81d2d5f9272f304f68c580a49c879a4fde8169eada2a8307eb58f90fce50a9d01e6d4f9aa2b66b657fda7f
+  metadata.gz: 8b0904544cbcce8598217fae39dacc61a7c2940298f9f096a1e24ff36828b06a756fdceef79f01aeafccbc20580ebd49018ee6f72e7a8d52ee0af9db18b4bb91
+  data.tar.gz: d16e1835b588593536162b9dd9aa5541dcf9ea8bdc672d7de552f172fefdcc8231e354c9435adf85a893f386b3a1f5475bc62e5eeb70a937c4f47db753d958dd

data/.travis.yml

@@ -0,0 +1,15 @@
+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
+  - gemfiles/Gemfile.actionpack-4.2.x
+  - Gemfile

data/cheatsheet.md

@@ -0,0 +1,307 @@
+# Dos-T cheatsheet
+
+## Commons
+The **widely used words** across the application such as "Back", "Cancel", "Save" are the prime candidates to put in **common**:
+
+```ruby
+# en:
+#   common:
+#     back: "Back"
+
+tt.c :back # => "Back"
+```
+
+Time to time there is a need to **override commons** for a section (controller in rails environment). To do so, just **add 'common' sub-key** in the section translations:
+
+```ruby
+# en:
+#   common:
+#     copy: "Copy"
+#   users:
+#     common:
+#       copy: "Duplicate"
+
+# app/views/documents/index.haml
+= tt.c :copy # => "Copy"
+
+# app/views/users/index.haml
+= tt.c :copy # => "Duplicate"
+```
+
+## Attributes
+
+You probably know that `active_model` based classes have handy method **#human_attribute_name**. The main problems with it are the long method name and `humanization` on translation missing. The gem provides an **almost compatible equivalent #attr**.
+
+```ruby
+# en:
+#   attributes:
+#     base:
+#       email: "Email"
+#     user:
+#       email: "Login / Email"
+
+# app/views/subscriptions/index.haml
+# a base translation
+tt.attr :email, :subscription # => "Email"
+
+# app/views/users/index.haml
+# a specific translation
+tt.attr :email, :user # => "Login / Email"
+
+# with 'current model reflection' (preferred): UsersController => :user
+tt.attr :email # => "Login / Email"
+```
+
+`#attr` also looks into orm translations paths. If you place translations according to `active_record`:
+
+```ruby
+# en:
+#   activerecord:
+#     attributes:
+#       user:
+#         email: "Login / Email"
+#   attributes:
+#     user: "Email"
+
+tt.c :email, :user # => "Login / Email"
+```
+For other `active_model` based orms please specify configuration in an initializator:
+
+```ruby
+# en:
+#   mongoid:
+#     attributes:
+#       user:
+#         email: "Login / Email"
+#   attributes:
+#     user: "Email"
+
+# app/config/tt.rb
+TT.config(prefix: :mongoid)
+```
+## Resources
+
+There is another translation hard-to-use feature which are present in `active_model` - **.model_name.human**. It
+returns a translated human name of a model. To get a plural version you should also provide the `count: 10` parameter.
+With Dos-T you get two short methods which do the job - **#r** & **#rs** (human resource and resources):
+
+```ruby
+# en:
+#   models:
+#     user:
+#       one: "User"
+#       other: "Users"
+#       zero: "Userz"
+
+tt.r :user      # => "User"
+tt.rs :user, 20 # => "Users"
+tt.rs :user, 0  # => "Userz"
+
+# app/views/users/show.haml
+#  with 'current model reflection' and the default value (10)
+tt.rs           # => "Users"
+```
+
+## Enums
+
+Quite often a developer needs to provide a **human translation for the variants** of an enum attribute. Dos-T provides
+a handy method **#enum**:
+
+```ruby
+# en:
+#   enums:
+#     base:
+#       role:
+#         a: "Admin"
+#         u: "User"
+#     subscription:
+#       role:
+#         c: "Subscriber"
+
+# app/views/subscriptions/index.haml
+tt.enum :role, :a, :user         # => "Admin"
+tt.enum :role, :c, :subscription # => "Subscriber"
+
+# with 'current model reflection'
+tt.enum :role, :u                # => "User"
+```
+You can put enum translations inside orm translation namespace as with `#attr` method.
+
+## Errors
+
+Errors are an essential part of any application. Within `active_model` orms you have **errors.full_messages**
+& **errors.full_messages_for** which are fine only for a few use-cases. To make it easier the gem has an
+**almost compatible equivalent #e**:
+
+```ruby
+# en:
+#   errors:
+#     base:
+#       blank: "is blank"
+#       greater_than: "must be greater than %{count}"
+#       password:
+#         blank: "is empty"
+#     user:
+#       password:
+#         blank: "is invalid"
+
+# app/views/users/index.haml
+tt.e(:password, :blank, :user)                  # => "is invalid"
+tt.e(:password, :greater_than, :user, count: 4) # => "must be greater than 4"
+
+# with 'current model reflection'
+tt.e(:password, :blank)                         # => "is invalid"
+tt.e(:password, :greater_than, count: 4)        # => "must be greater than 4"
+
+tt.e(:password, :blank, :client)                # => "is empty"
+tt.e(:name, :blank, :client)                    # => "is blank"
+```
+
+## Actions
+
+The unique feature of the gem which helps to reduce amount of duplications in flash messages, warnings and other messages
+related to notification about some action on resources. To get the idea let's look into a typical rails controller:
+
+```ruby
+def create
+  if user.save
+    flash[:notice] = "The user has been created"
+  end
+  # other code
+end
+
+def update
+  if user.save
+    flash[:notice] = "The user has been updated"
+  end
+  # other code
+end
+
+def destroy
+  user.destroy
+  flash[:notice] = "The user has been deleted"
+  # other code
+end
+```
+
+For one controller the situation looks fine, but a typical application has at least 10 to 15 controllers. As the result
+these translations creates a long translation files with many duplications. To solve the problem method **#a**
+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"
+#   models:
+#     user:
+#       one: "User"
+#       other: "Users"
+
+def create
+  if user.save
+    flash[:notice] = tt.a(:create, :user) # => "The user has been created"
+  end
+  # other code
+end
+
+def update
+  if user.save
+    flash[:notice] = tt.a(:update, :user) # => "The user has been updated"
+  end
+  # other code
+end
+
+def destroy
+  user.destroy
+  # with 'current model reflection'
+  flash[:notice] = tt.a(:delete)         # => "The user has been deleted"
+  # other code
+end
+```
+
+As you can see in translation you define a base translation for an action which expected at least the next variables:
+- RS  - `tt.rs`
+- R   - `tt.r`
+- rs  - `tt.rs.downcase`
+- r   - `tt.r.downcase`
+
+If for some action one of the models should have a custom translation (a business logic, a grammar rule of a language)
+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"
+
+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.
+
+## Custom shortcuts
+
+As an application grows `common` grows too. To avoid a long list of common words it's good to group them by group.
+For example, words related to a user tips is good to place into `tips`, words related to forms into `forms`. To do it
+the gem provides a configuration block:
+
+```ruby
+# app/config/tt.rb
+TT.config do
+  lookup_key_method :tip, :tips
+  lookup_key_method :f, :forms
+end
+```
+As the result your `tt` variable will have `#tip` & `#f` methods which behave like `#c`.
+
+## Advanced usage & configuration
+
+Dos-T was designed to be easy-as-possible for the default rails stack, but if you don't have it or don't have rails at
+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
+environment it's `controller_path` and `action_name`.
+
+```ruby
+class EmailApp < Sinatra::Base
+  before do
+    @tt = TT::Translator.new('emails')
+  end
+
+  post '/' do
+    # processing
+    { status: tt.t(:handled) }.to_json # { status: I18n.t('emails.handled') }.to_json
+  end
+end
+
+class EmailSender
+  attr_reader :tt
+
+  def initialize
+    @tt = TT::Translator.new('services/email_sender')
+  end
+
+  def work
+    each_letter do |letter|
+      send_mail(subject: tt.a(:confirm, :email, user: letter.user_name))
+      # ...
+    end
+  end
+end
+```
+
+### You use different to ActiveRecord orm
+
+Just specify an orm i18n scope:
+```ruby
+# app/config/tt.rb
+TT.config(prefix: :mongoid)
+```

data/gemfiles/Gemfile.actionpack-3.1.x

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

data/gemfiles/Gemfile.actionpack-3.2.x

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

data/gemfiles/Gemfile.actionpack-4.0.x

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

data/gemfiles/Gemfile.actionpack-4.1.x

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

data/gemfiles/Gemfile.actionpack-4.2.x

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

data/lib/t_t.rb

@@ -1,65 +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 = :base)
+      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
+        defaults << :"#{ type }.#{ base_suffix }"
+
+        [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
+        defaults << :"#{ prefix }.#{ type }.#{ base_suffix }"
+        defaults << :"#{ type }.#{ base_suffix }"
+
+        [root, defaults]
+      end
+    end
+  end
+
   class Translator
-    def self.shortcut(meth_name, section)
-      class_eval <<-RUBY
-        def #{ meth_name }(key, options = {})
-          I18n.t "\#{ ns }.#{ section }.\#{ key }",
-            { default: :"#{ section }.\#{ key }" }.merge(options)
+    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
-      RUBY
+
+        @settings
+      end
     end
 
-    def initialize(ns, section)
-      @ns = ns
-      @section = section
+    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)
+
+      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)
+
+      @downcase = self.class.settings.fetch(:downcase, Utils::DOWNCASE)
     end
 
-    def t(key, options = {})
-      I18n.t "#{ ns }.#{ section }.#{ key  }",
-        { default: :"#{ ns }.common.#{ key  }" }.merge(options)
+    def a(name, model_name = nil, custom = {})
+      path, defaults = _resolve(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
 
-    shortcut :c, :common
-    shortcut :f, :form
+    def attr(name, model_name = nil)
+      path, defaults = _resolve(model_name, :attributes, name)
+      I18n.t path, default: defaults
+    end
 
-    def attr(name, klass = context_klass)
-      klass.human_attribute_name(name)
+    def enum(name, kind, model_name = nil)
+      path, defaults = _resolve(model_name, :enums, "#{ name }.#{ kind }")
+      I18n.t path, default: defaults
     end
 
-    def enum(name, kind, klass = context_klass)
-      klass.human_attribute_name("#{ name }_#{ kind }")
+    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 resource(klass = context_klass)
-      klass.model_name.human(count: 1)
+    def r(model_name = nil)
+      rs(model_name, 1)
     end
-    alias_method :record, :resource
 
-    def resources(klass = context_klass)
-      klass.model_name.human(count: 10)
+    def rs(model_name = nil, count = 10)
+      path, defaults = _resolve(model_name, :models)
+      I18n.t path, default: defaults, count: count
     end
-    alias_method :records, :resources
 
-    def no_resources(klass = context_klass)
-      klass.model_name.human(count: 0)
+    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
-    alias_method :no_records, :no_resources
 
     private
 
-    attr_reader :ns, :section
+    def _config
+      @config
+    end
 
-    def context_klass
-      return @context_klass if @context_klass
+    def _resolve(model_name, type, key = nil)
+      _resolve_with_lookup(@lookup, model_name, type, key)
+    end
 
-      @context_klass = ns.split('.').map(&:classify).join('::').singularize.constantize
+    def _resolve_errors(model_name, attr_name, error_name)
+      if attr_name == :base
+        _resolve_with_lookup(@err_lookup, model_name, :errors, error_name)
+      else
+        path, _defaults = _resolve(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)
+      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
+
+  def self.fork(&block)
+    Class.new(Translator, &block)
+  end
+
+  def self.config(&block)
+    Translator.instance_exec(&block)
+  end
 end
 
 if defined?(ActionPack) || defined?(ActionMailer)
@@ -68,12 +188,13 @@ if defined?(ActionPack) || defined?(ActionMailer)
 
     included do
       helper_method :tt
+
+      prepend_before_filter { instance_variable_set(:@tt, ::TT::Translator.new(controller_path, action_name)) }
     end
 
     private
 
     def tt(*args)
-      @tt ||= ::TT::Translator.new(controller_path.gsub('/', '.'), action_name)
       args.empty? ? @tt : @tt.t(*args)
     end
   end
@@ -86,3 +207,9 @@ if defined?(ActionPack) || defined?(ActionMailer)
     include ::TT::Helper
   end
 end
+
+if defined?(ActiveRecord)
+  ActiveSupport.on_load(:active_record) do
+    TT.config(prefix: :activerecord)
+  end
+end

data/readme.md

@@ -0,0 +1,96 @@
+# Dos-T
+
+[![Build Status](https://travis-ci.org/jalkoby/tt.svg?branch=master)](https://travis-ci.org/jalkoby/tt)
+[![Gem Version](https://badge.fury.io/rb/t_t.svg)](https://badge.fury.io/rb/t_t)
+
+Dos-T introduces a translation convention for a ruby web application (with a focus on the rails flow). The library is based on the next ideas:
+- focus on a every day issues
+- reduce amount of duplications inside translation files
+- easy to use from day one & minimum to write (nobody likes to write a long and obvious method names)
+- have a clear defaults
+
+## Usage
+
+Dos-T adds an extra helper method `tt` into your controllers, mailers & views. The best way to explain all features
+is to look at [Cheatsheet](./cheatsheet.md). The below is shown a brief overview:
+
+```Haml
+# en:
+#   actions:
+#     add:
+#       base: "Add a new %{r}"
+#   attributes:
+#     user:
+#       name: "Name"
+#       email: "Email"
+#       role: "Role"
+#   common:
+#     actions: "Actions"
+#     confirm: "Are you sure?"
+#     edit: "Edit"
+#     delete: "Delete"
+#   enums:
+#     user:
+#       role:
+#         a: "Admin"
+#         g: "Guest"
+#         m: "Manager"
+#   models:
+#     user:
+#       one: "User"
+#       other: "Users"
+
+# app/views/users/index.haml
+%h2= tt.rs :user
+
+%table
+  %thead
+    %th= tt.attr :name
+    %th= tt.attr :email
+    %th= tt.attr :role
+    %th= tt.c :actions
+
+  %tbody
+    - @users.each do |user|
+      %tr
+        %td= user.name
+        %td= user.email
+        %td= tt.enum :role, user.role
+        %td
+          = link_to tt.c(:edit), edit_user_path(user)
+          = link_to tt.c(:delete), user_path(user), method: :delete, confirm: tt.c(:confirm)
+
+= link_to tt.a(:add), new_user_path
+```
+
+The result will be the next:
+```Haml
+%h2 Users
+
+%table
+  %thead
+    %th Name
+    %th Email
+    %th Role
+    %th Actions
+
+  %tbody
+    - @users.each do |user|
+      %tr
+        %td= user.name
+        %td= user.email
+        %td= { 'a' => 'Admin', 'g' => 'Guest', 'm' => 'Manager' }[user.role]
+        %td
+          = link_to 'Edit', edit_user_path(user)
+          = link_to 'Delete', user_path(user), method: :delete, confirm: 'Are you sure?'
+
+= link_to 'Add a new user', new_user_path
+```
+
+## 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+

data/t_t.gemspec

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

data/tests/lib/action_pack_test.rb

@@ -7,6 +7,7 @@ end
 describe "ActionPack integration" do
   before do
     @controller = TTController.new
+    @controller.run_callbacks(:process_action)
   end
 
   it 'returns tt instance if the method was called without args' do
@@ -14,6 +15,7 @@ describe "ActionPack integration" do
   end
 
   it 'calls #t if args were passed' do
+    load_i18n(common: { tar: 'global_tar' })
     assert_equal @controller.tt.c(:tar), 'global_tar'
   end
 end

data/tests/lib/model_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+describe 'Methods related to models' do
+  before do
+    @tt = ARTranslator.new("admin/users", "spec")
+  end
+
+  describe 'actions' do
+    before do
+      load_i18n({
+        actions: {
+          base:  { do: 'Do', make: 'Do', execute: 'Do' },
+          user:  {
+            make: 'Make', execute: 'Make',
+            subscribe: 'The %{r} will be subscribed with other %{rs} of this day. %{RS} get 10% off with the subscription.'
+          },
+          admin: { user: { execute: 'Execute' } }
+        },
+        models: { admin: { user: { one: "Admin", other: "Admins" } } }
+      })
+    end
+
+    it 'returns a specific action' do
+      assert_equal @tt.a(:execute), 'Execute'
+    end
+
+    it 'returns a pure model action' do
+      assert_equal @tt.a(:make), 'Make'
+    end
+
+    it 'returns a base action' do
+      assert_equal @tt.a(:do), 'Do'
+    end
+
+    it 'allows to specify a custom model' do
+      assert_equal @tt.a(:execute, :user), 'Make'
+    end
+
+    it 'passes translations of a model' do
+      assert_equal @tt.a(:subscribe), 'The admin will be subscribed with other admins of this day. Admins get 10% off with the subscription.'
+    end
+  end
+
+  describe 'attributes' do
+    before do
+      load_i18n(attributes: {
+        base:  { name: 'Name', phone: 'Phone', email: 'Email' },
+        user:  { name: 'Nick', phone: 'Notification phone' },
+        admin: { user: { name: 'Contact admin name' } }
+      })
+    end
+
+    it 'returns a specific attribute' do
+      assert_equal @tt.attr(:name), 'Contact admin name'
+    end
+
+    it 'returns a pure model attribute' do
+      assert_equal @tt.attr(:phone), 'Notification phone'
+    end
+
+    it 'returns a base attribute' do
+      assert_equal @tt.attr(:email), 'Email'
+    end
+
+    it 'allows to specify a custom model' do
+      assert_equal @tt.attr(:name, :user), 'Nick'
+    end
+  end
+
+  describe 'enums' do
+    before do
+      load_i18n(enums: {
+        base: { gender: { f: 'Female', m: 'Male', o: 'Other' } },
+        user: { gender: { f: 'Woman', m: 'Man' } },
+        admin: { user: { gender: { f: 'Admin' } } }
+      })
+    end
+
+    it 'returns a specific enum' do
+      assert_equal @tt.enum(:gender, :f), 'Admin'
+    end
+
+    it 'returns a pure model enum' do
+      assert_equal @tt.enum(:gender, :m), 'Man'
+    end
+
+    it 'returns a base enum' do
+      assert_equal @tt.enum(:gender, :o), 'Other'
+    end
+
+    it 'allows to specify a custom model' do
+      assert_equal @tt.enum(:gender, :f, :user), 'Woman'
+    end
+  end
+
+  describe 'errors' do
+    before do
+      load_i18n(errors: {
+        messages: { name: { blank: "should be filled" }, fields_missed: "not all required fields are filled" },
+        user: { password: { weak: "Your password is weak" }, limit: 'The limit has been reached', duplicated: "The site has an account with the inputed information" },
+        admin: { user: { email: { empty: "The admin email should be filled" }, limit: "The system has reached the admin limit" } }
+      })
+    end
+
+    it 'returns a specific error' do
+      assert_equal @tt.e(:email, :empty), 'The admin email should be filled'
+    end
+
+    it 'returns a specific base error' do
+      assert_equal @tt.e(:base, :limit), 'The system has reached the admin limit'
+    end
+
+    it 'returns a pure model error' do
+      assert_equal @tt.e(:password, :weak), 'Your password is weak'
+    end
+
+    it 'returns a base pure model error' do
+      assert_equal @tt.e(:base, :duplicated), 'The site has an account with the inputed information'
+    end
+
+    it 'returns a base attribute error' do
+      assert_equal @tt.e(:name, :blank), 'should be filled'
+    end
+
+    it 'returns a base error' do
+      assert_equal @tt.e(:base, :fields_missed), 'not all required fields are filled'
+      assert_equal @tt.e(:roo, :fields_missed), 'not all required fields are filled'
+    end
+
+    it 'allows to specify a custom model' do
+      assert_equal @tt.e(:base, :limit, :user), 'The limit has been reached'
+    end
+  end
+
+  describe 'resource names' do
+    before do
+      @tt = ARTranslator.new('public/people')
+      load_i18n({
+        models: { person: { one: "whatever", other: "whatever" }, user: { one: "User", other: "Users" } },
+        activerecord: { models: {
+          public: { person: { one: "Celebrity", other: "Celebrities" } },
+          person: { one: "Person", other: "People" }
+        } }
+      })
+    end
+
+    it 'handles namespaces' do
+      assert_equal @tt.r, 'Celebrity'
+      assert_equal @tt.rs, 'Celebrities'
+    end
+
+    it 'looks inside orm namespace' do
+      assert_equal @tt.r(:person), 'Person'
+      assert_equal @tt.rs(:person), 'People'
+    end
+
+    it "fallbacks into base if orm namespace doesn't have a key" do
+      assert_equal @tt.r(:user), 'User'
+      assert_equal @tt.rs(:user), 'Users'
+    end
+  end
+end

data/tests/lib/view_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+describe 'methods related to views' do
+  before do
+    @tt = ViewTranslator.new("tt", "spec")
+  end
+
+  describe '#t' do
+    before do
+      load_i18n(tt: {
+        common: { too: "namespace_too" },
+        spec: { foo: "spec_foo" }
+      })
+    end
+
+    it "looks for a section translation first" do
+      assert_equal @tt.t(:foo), "spec_foo"
+    end
+
+    it "looks into the section commons" do
+      assert_equal @tt.t(:too), "namespace_too"
+    end
+
+    it "allows a custom options" do
+      assert_equal @tt.t(:tar, default: "default_tar"), "default_tar"
+    end
+  end
+
+  describe '#c' do
+    before do
+      load_i18n(
+        common: { tar: 'global_tar' },
+        tt: { common: { foo: "namespace_foo" }, }
+      )
+    end
+
+    it "looks for a namespace translation first" do
+      assert_equal @tt.c(:foo), "namespace_foo"
+    end
+
+    it "falls back to a global translation" do
+      assert_equal @tt.c(:tar), "global_tar"
+    end
+
+    it "allows a custom options" do
+      assert_equal @tt.c(:car, default: "default_car"), 'default_car'
+    end
+  end
+
+  describe '#f' do
+    before do
+      load_i18n(
+        form: { edit: "global_edit", save: "global_save" },
+        tt: { form: { edit: "namespace_edit" } }
+      )
+    end
+
+    it "looks for a namespace translation first" do
+      assert_equal @tt.f(:edit), "namespace_edit"
+    end
+
+    it "falls back to a global translation" do
+      assert_equal @tt.f(:save), "global_save"
+    end
+
+    it "allows a custom options" do
+      assert_equal @tt.f(:commit, default: "default_commit"), "default_commit"
+    end
+  end
+end

data/tests/test_helper.rb

@@ -4,39 +4,22 @@ require "rack/test"
 require "action_controller"
 require "t_t"
 
+ViewTranslator = TT.fork do
+  lookup_key_method :f, :form
+end
+
+ARTranslator = TT.fork do
+  settings prefix: :activerecord
+end
+
 I18n.backend = I18n::Backend::Simple.new
-I18n.backend.store_translations(:en, {
-  common: {
-    tar: 'global_tar'
-  },
-  crumbs: {
-    index: 'global_index',
-    new: 'global_new'
-  },
-  form: {
-    edit: "global_edit",
-    save: "global_save"
-  },
-  tooltip: {
-    info: "global_info",
-    notice: "global_notice"
-  },
-  tt: {
-    common: {
-      foo: "namespace_foo",
-      bar: "namespace_bar"
-    },
-    crumbs: {
-      new: 'namespace_new'
-    },
-    form: {
-      edit: "namespace_edit"
-    },
-    spec: {
-      foo: "spec_foo"
-    },
-    tooltip: {
-      info: "namespace_info"
-    }
-  }
-})
+
+class Minitest::Spec
+  after :each do
+    I18n.backend.reload!
+  end
+
+  def load_i18n(data)
+    I18n.backend.store_translations(:en, data)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: t_t
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Sergey Pchelintsev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-31 00:00:00.000000000 Z
+date: 2016-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -116,14 +116,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
-- LICENSE.txt
-- README.md
 - Rakefile
+- cheatsheet.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
+- readme.md
 - t_t.gemspec
 - tests/lib/action_pack_test.rb
-- tests/lib/t_t_test.rb
+- tests/lib/model_test.rb
+- tests/lib/view_test.rb
 - tests/test_helper.rb
 homepage: ''
 licenses:
@@ -145,8 +153,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: An opinioned I18n helper
 test_files: []
+has_rdoc: 

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2015 Sergey Pchelintsev
-
-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

@@ -1,91 +0,0 @@
-## About
-
-The main goal of Dos-T is reducing time on supporting a multi-language web application by providing a few conventions and a short method names. We believe that it's a primary reason which slows down development. Cause it's boring to write a long path like `t('namespace.controller_name.action_name.section.key')`. Let's better spend time on something more interesting.
-
-So what's makes Dos-T such a good tool(on our opinion):
-
-### Example of page
-
-```haml
-/ users#index
-= link_to tt.c(:new_resource, model: tt.resource), new_user_path, "data-tooltip" => tt(:new_user_tip)
-
-%table
-  %tr
-    %th= tt.attr :name
-    %th= tt.attr :email
-    %th= tt.attr :phone
-    %th= tt.attr :role
-    %th= tt.c :actions
-  - @users.each do |user|
-    %tr
-      %td= user.name
-      %td= user.email
-      %td= user.phone
-      %td= tt.enum :role, user.role
-      %td
-        = link_to tt.f(:edit), edit_user_path(user)
-        = link_to tt.f(:delete), user_path(user), method: :delete, confirm: tt.c(:confirm)
-
-/ tt.c looks in 'users.common', 'common'
-/ tt.f looks in 'users.form', 'form'
-/ tt looks in 'users.index', 'users.common'
-/ tt.attr - calls human_attribute_name on User
-/ tt.enum - calls human_attribute_name on User with role_%value%
-/ tt.resource - User.model_name.human(count: 1)
-```
-
-### Global commons
-
-`tt.c` - in every application there are some elements which are present in every page. For example, if a page has "delete some resource" button/link, it's good to have a confirmation message which tells a user "Are you sure?". At this point you add a key for this page, for example, in "admin.users.index.confirm" path and on page call `t('.confirm')`. Rails is smart enough to prepend a full path to ".confirm" key. But then you need to add confirmation on `admin/users#show` and you, probably, will not duplicate it for "show" page and move it into a common section. After that the translation helper can't help us and we need to provide a full path – `t('common.confirm')`. We reduce a duplication of translation keys, but have to write a long methods. Well, as always, programming is a compromise. But not this time, with Dos-T you can have both – just call `tt.c(:confirm)`. At first it will look into a section's common node(description of a section see below). If Dos-T doesn't find a translation there it will look into the global *common* >>> *common.confirm*. You, probably, are interested what's a section. By a section Dos-T means I18n path of the current controller(mailer). Let's review the previous example. If our current controller is `Admin::UsersController`, the section is *admin.users*. That's why if we want for deleting users a special confirmation we just add "admin.users.common.confirmation" key and it's done.
-
-`tt.f` - the global `common` section could fast become a huge and you will add some namespaces into it. We prefer a facts over a supposes, but there is a 100% assumption that you will have this subsection - `common.form` with `save`, `edit`, `delete` and etc. Cause we don't know any application which doesn't have that. That's why Dos-T has another method `tt.f` which like `tt.c` -  first looks into the current section(*controller_path.form*) and fallbacks into the global("form").
-
-And finally, Dos-T allows you to define a new "common-used" sections. For example, for breadcrumbs. Just place "tt.rb" file in config/initializations that:
-
-```ruby
-ActiveSupport.on_load(:tt) do
-  shortcut(:crumbs, :breadcrumbs) # => tt.crumbs(:index) which looks into `breadcrumbs` sections
-  shortcut(:tip, :tooltips) # => tt.tip(:readonly) which looks into `tooltips` sections
-end
-```
-
-### Section's commons
-
-`tt` - let's back to our example with user management pages. Our clients decided to add a gravatar support. To make this feature more clear to admins we should put a tooltip with a description on index and show page, next to label "Gravatar". It brings a problem where to put a translation. If we put it into 'admin.users.index' we can use `t('.gravatar')` on index page, but have to use `t('admin.users.index.gravatar')` on show page and vice versa. And there Dos-T helps us. Just put `tt(:gravatar)` and put the tip into 'admin.users.common'. First it will act like a `t('.gravatar')` and fallbacks into section's common. And yes, `tt(:key)` is one symbol shorter than t('.key') – you can't avoid `t` in a favour to `tt`.
-
-### Resource translations
-
-`tt.attr` - we think every developer enjoys how `form_for` easily translates column's label - `f.label :column_name` - and Rails will magically translate it. But then we have to use an ugly way(`User.human_attribute_name(:column_name)`) to reuse these translations on index and show pages. It's become boring to type again and again this `human_attribute_name`. Dos-T provides a shortcut `tt.attr :column_name, User`. But it could be a shorter, cause if you call it in `UsersController` in 9/10 you closely work with User model. That's why, a second argument in `#attr` method is an optional and default value is a context class. A context class is computed on a controller name. If it's `users_controller`, Dos-T expects for a User model presence. If it's `Admin::UsersController` a context class is still User model.
-
-### Other useful methods
-
-* `tt.record([context_class])` – returns the singular human name of a model class(alias - resource)
-* `tt.records([context_class])` – returns the plural human name of a model class(alias – resources)
-* `tt.no_records([context_class])` – returns the zero form human name of a model class(alias – no_resources)
-* `tt.enum(attr_name, variant, [context_class])` – returns a human variant name of an attribute. It looks for human  attribute name of "%attr_name%_%variant%"
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 't_t'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install t_t
-
-
-## Contributing
-
-1. Fork it ( https://github.com/jalkoby/t_t/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request

data/tests/lib/t_t_test.rb

@@ -1,146 +0,0 @@
-require 'test_helper'
-
-describe TT::Translator do
-  before do
-    @tt = TT::Translator.new("tt", "spec")
-  end
-
-  describe '#t' do
-    it "looks for a section translation first" do
-      assert_equal @tt.t(:foo), "spec_foo"
-    end
-
-    it "falls back to common namespace translations" do
-      assert_equal @tt.t(:bar), "namespace_bar"
-    end
-
-    it "allows a custom options" do
-      assert_equal @tt.t(:tar, default: "default_tar"), "default_tar"
-    end
-  end
-
-  describe '#c' do
-    it "looks for a namespace translation first" do
-      assert_equal @tt.c(:foo), "namespace_foo"
-    end
-
-    it "falls back to a global translation" do
-      assert_equal @tt.c(:tar), "global_tar"
-    end
-
-    it "allows a custom options" do
-      assert_equal @tt.c(:car, default: "default_car"), 'default_car'
-    end
-  end
-
-  describe '#f' do
-    it "looks for a namespace translation first" do
-      assert_equal @tt.f(:edit), "namespace_edit"
-    end
-
-    it "falls back to a global translation" do
-      assert_equal @tt.f(:save), "global_save"
-    end
-
-    it "allows a custom options" do
-      assert_equal @tt.f(:commit, default: "default_commit"), "default_commit"
-    end
-  end
-
-  describe 'a model related methods' do
-    before do
-      @klass = Minitest::Mock.new
-    end
-
-    describe '#attr' do
-      it 'uses the provided class' do
-        @klass.expect(:human_attribute_name, 'Nombre', [:name])
-        assert_equal @tt.attr(:name, @klass), 'Nombre'
-      end
-
-      it 'uses a context class by default' do
-        @klass.expect(:human_attribute_name, 'Nombre', [:name])
-        @tt.stub(:context_klass, @klass) do
-          assert_equal @tt.attr(:name), 'Nombre'
-        end
-      end
-    end
-
-    describe '#enum' do
-      it 'uses the provided class' do
-        @klass.expect(:human_attribute_name, 'Melody', ['type_melody'])
-        assert_equal @tt.enum(:type, :melody, @klass), 'Melody'
-      end
-
-      it 'uses a context class by default' do
-        @klass.expect(:human_attribute_name, 'Sound', ['type_sound'])
-        @tt.stub(:context_klass, @klass) do
-          assert_equal @tt.enum(:type, :sound), 'Sound'
-        end
-      end
-    end
-
-    describe 'a model name' do
-      before do
-        @model_name = Minitest::Mock.new
-        @klass.expect(:model_name, @model_name)
-      end
-
-      describe '#resource' do
-        before do
-          @model_name.expect(:human, 'Coche', [{ count: 1 }])
-        end
-
-        it 'uses the provided class' do
-          assert_equal @tt.resource(@klass), 'Coche'
-        end
-
-        it 'uses a context class by default' do
-          @tt.stub(:context_klass, @klass) do
-            assert_equal @tt.resource, 'Coche'
-          end
-        end
-      end
-
-      describe '#resources' do
-        before do
-          @model_name.expect(:human, 'Coches', [{ count: 10 }])
-        end
-
-        it 'uses the provided class' do
-          assert_equal @tt.resources(@klass), 'Coches'
-        end
-
-        it 'uses a context class by default' do
-          @tt.stub(:context_klass, @klass) do
-            assert_equal @tt.resources, 'Coches'
-          end
-        end
-      end
-
-      describe '#no_resources' do
-        before do
-          @model_name.expect(:human, 'Coches', [{ count: 0 }])
-        end
-
-        it 'uses the provided class' do
-          assert_equal @tt.no_resources(@klass), 'Coches'
-        end
-
-        it 'uses a context class by default' do
-          @tt.stub(:context_klass, @klass) do
-            assert_equal @tt.no_resources, 'Coches'
-          end
-        end
-      end
-
-      after do
-        assert @model_name.verify
-      end
-    end
-
-    after do
-      assert @klass.verify
-    end
-  end
-end