tr8n_core 4.0.1

data/spec/tokens/data_spec.rb

@@ -0,0 +1,160 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::Data do
+  before do
+    @app = init_application
+    @english = @app.language('en-US')
+    @tkey = Tr8n::TranslationKey.new({
+      :label => "Hello {user}",
+      :application => @app,
+      :locale => 'en-US'
+    })
+    @token = @tkey.data_tokens.first
+  end
+
+  describe "initialize" do
+    it "should parse data token" do
+      expect(@token.class.name).to eq("Tr8n::Tokens::Data")
+      expect(@token.context_keys).to eq([])
+    end
+  end
+
+  describe "substitute" do
+    it "should substitute values" do
+      user = stub_object({:first_name => "Tom", :last_name => "Anderson", :gender => "Male", :to_s => "Tom Anderson"})
+      user.stub(:last_name_with_prefix) {|prefix| "#{prefix} #{user.last_name}"}
+
+      # tr("Hello {user}", "", {:user => current_user}}
+      expect(@token.token_value(user, {}, @english)).to eq(user.to_s)
+
+      # tr("Hello {user}", "", {:user => [current_user]}}
+      expect(@token.token_value([user], {}, @english)).to eq(user.to_s)
+
+      # tr("Hello {user}", "", {:user => [current_user, current_user.name]}}
+      expect(@token.token_value([user, user.first_name], {}, @english)).to eq(user.first_name)
+
+      # tr("Hello {user}", "", {:user => [current_user, "{$0} {$1}", "param1"]}}
+      expect(@token.token_value([user, "{$0} {$1}", "param1"], {}, @english)).to eq(user.to_s + " param1")
+      expect(@token.token_value([user, "{$0} {$1} {$2}", "param1", "param2"], {}, @english)).to eq(user.to_s + " param1 param2")
+
+      # tr("Hello {user}", "", {:user => [current_user, :name]}}
+      expect(@token.token_value([user, :first_name], {}, @english)).to eq(user.first_name)
+
+      # tr("Hello {user}", "", {:user => [current_user, :method_name, "param1"]}}
+      expect(@token.token_value([user, :last_name_with_prefix, 'Mr.'], {}, @english)).to eq("Mr. Anderson")
+
+      # tr("Hello {user}", "", {:user => [current_user, lambda{|user| user.name}]}}
+      expect(@token.token_value([user, lambda{|user| user.to_s}], {}, @english)).to eq(user.to_s)
+
+      # tr("Hello {user}", "", {:user => [current_user, lambda{|user, param1| user.name}, "param1"]}}
+      expect(@token.token_value([user, lambda{|user, param1| user.to_s + " " + param1}, "extra_param1"], {}, @english)).to eq(user.to_s + " extra_param1")
+
+      # tr("Hello {user}", "", {:user => {:object => current_user, :value => current_user.name}]}}
+      expect(@token.token_value({:object => user, :value => user.to_s}, {}, @english)).to eq(user.to_s)
+
+      # tr("Hello {user}", "", {:user => {:object => current_user, :attribute => :first_name}]}}
+      expect(@token.token_value({:object => user, :attribute => :first_name}, {}, @english)).to eq(user.first_name)
+      expect(@token.token_value({:object => {:first_name => "Michael"}, :attribute => :first_name}, {}, @english)).to eq("Michael")
+    end
+
+    it "should perform complete substitution" do
+      user = stub_object({:first_name => "Tom", :last_name => "Anderson", :gender => "Male", :to_s => "Tom Anderson"})
+      user.stub(:last_name_with_prefix) {|prefix| "#{prefix} #{user.last_name}"}
+
+      [
+        {:user => user},                                                                        "Hello Tom Anderson",
+        {:user => [user]},                                                                      "Hello Tom Anderson",
+        {:user => [user, user.first_name]},                                                     "Hello Tom",
+        {:user => [user, "{$0} {$1}", "param1"]},                                               "Hello Tom Anderson param1",
+        {:user => [user, "{$0} {$1} {$2}", "param1", "param2"]},                                "Hello Tom Anderson param1 param2",
+        {:user => [user, :first_name]},                                                         "Hello Tom",
+        {:user => [user, :last_name_with_prefix, 'Mr.']},                                       "Hello Mr. Anderson",
+        {:user => [user, lambda{|user| user.to_s}]},                                            "Hello Tom Anderson",
+        {:user => [user, lambda{|user, param1| user.to_s + " " + param1}, "extra_param1"]},     "Hello Tom Anderson extra_param1",
+        {:user => {:object => user, :value => user.to_s}},                                      "Hello Tom Anderson",
+        {:user => {:object => user, :attribute => :first_name}},                                "Hello Tom",
+        {:user => {:object => {:first_name => "Michael"}, :attribute => :first_name}},          "Hello Michael"
+      ].each_slice(2).to_a.each do |pair|
+        expect(@token.substitute(@tkey.label, pair.first, @english)).to eq(pair.last)
+      end
+
+    end
+
+    it "should substitute token with array values" do
+      tkey = Tr8n::TranslationKey.new({
+        :label => "Hello {users}",
+        :application => @app,
+        :locale => 'en-US'
+      })
+      token = tkey.data_tokens.first
+
+      users = []
+      1.upto(6) do |i|
+        users << stub_object({:first_name => "First name #{i}", :last_name => "Last name #{i}", :gender => "Male"})
+      end
+
+      Tr8n.config.with_block_options(:dry => true) do
+        expect(token.token_value([users, :first_name], {}, @english)).to match("2 others")
+
+        expect(token.token_value([users, [:first_name], {
+          :translate_items => false,
+          :expandable => false,
+          :minimizable => true,
+          :to_sentence => true,
+          :limit => 4,
+          :separator => ", ",
+          :description => nil,
+          :andor => 'and'
+        }], {}, @english)).to eq("First name 1, First name 2, First name 3, First name 4 and 2 others")
+
+        expect(token.token_value([users, [:first_name], {
+          :translate_items => false,
+          :expandable => false,
+          :minimizable => true,
+          :to_sentence => false,
+          :limit => 4,
+          :separator => ", ",
+          :description => nil,
+          :andor => 'and'
+        }], {}, @english)).to eq("First name 1, First name 2, First name 3, First name 4, First name 5, First name 6")
+
+        expect(token.token_value([users, [:first_name], {
+          :translate_items => false,
+          :expandable => false,
+          :minimizable => true,
+          :to_sentence => true,
+          :limit => 4,
+          :separator => ", ",
+          :description => nil,
+          :andor => 'or'
+        }], {}, @english)).to eq("First name 1, First name 2, First name 3, First name 4 or 2 others")
+
+        expect(token.token_value([users, [:first_name], {
+          :translate_items => false,
+          :expandable => false,
+          :minimizable => true,
+          :to_sentence => true,
+          :limit => 2,
+          :separator => ", ",
+          :description => nil,
+          :andor => 'or'
+        }], {}, @english)).to eq("First name 1, First name 2 or 4 others")
+
+        expect(token.token_value([users, [:first_name], {
+          :translate_items => false,
+          :expandable => false,
+          :minimizable => true,
+          :to_sentence => true,
+          :limit => 2,
+          :separator => " & ",
+          :description => nil,
+          :andor => 'or'
+        }], {}, @english)).to eq("First name 1 & First name 2 or 4 others")
+
+      end
+    end
+  end
+
+end

data/spec/tokens/data_tokenizer_spec.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::DataTokenizer do
+  before do
+
+  end
+
+  describe "initialize" do
+    it "should parse the text correctly" do
+      dt = Tr8n::Tokens::DataTokenizer.new("Hello World")
+      expect(dt.tokens).to be_empty
+
+      dt = Tr8n::Tokens::DataTokenizer.new("Hello {world}")
+      expect(dt.tokens.count).to equal(1)
+      expect(dt.tokens.first.name).to eq("world")
+      expect(dt.tokens.first.name(:parens => true)).to eq("{world}")
+
+      dt = Tr8n::Tokens::DataTokenizer.new("Dear {user:gender}")
+      expect(dt.tokens.count).to equal(1)
+      expect(dt.tokens.first.name).to eq("user")
+      expect(dt.tokens.first.name(:parens => true)).to eq("{user}")
+      expect(dt.tokens.first.context_keys).to eq(['gender'])
+      expect(dt.tokens.first.name(:parens => true, :context_keys => true)).to eq("{user:gender}")
+    end
+  end
+end
+

data/spec/tokens/decoration_tokenizer_spec.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::DecorationTokenizer do
+
+  describe "parse" do
+    it "should correctly parse tokens" do
+      dt = Tr8n::Tokens::DecorationTokenizer.new("Hello World")
+      expect(dt.fragments).to eq(["[tr8n]", "Hello World", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", "Hello World"])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello World]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello World", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello World"]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello World")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello World", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello World"]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello [strong: World]]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello ", "[strong:", " World", "]", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello ", ["strong", "World"]]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello [strong: World]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello ", "[strong:", " World", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello ", ["strong", "World"]]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold1: Hello [strong22: World]]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold1:", " Hello ", "[strong22:", " World", "]", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold1", "Hello ", ["strong22", "World"]]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello, [strong: how] [weak: are] you?]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello, ", "[strong:", " how", "]", " ", "[weak:", " are", "]", " you?", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello, ", ["strong", "how"], " ", ["weak", "are"], " you?"]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello, [strong: how [weak: are] you?]")
+      expect(dt.fragments).to eq(["[tr8n]", "[bold:", " Hello, ", "[strong:", " how ", "[weak:", " are", "]", " you?", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["bold", "Hello, ", ["strong", "how ", ["weak", "are"], " you?"]]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[link: you have [italic: [bold: {count}] messages] [light: in your mailbox]]")
+      expect(dt.fragments).to eq(["[tr8n]", "[link:", " you have ", "[italic:", " ", "[bold:", " {count}", "]", " messages", "]", " ", "[light:", " in your mailbox", "]", "]", "[/tr8n]"])
+      expect(dt.parse).to eq(["tr8n", ["link", "you have ", ["italic", "", ["bold", "{count}"], " messages"], " ", ["light", "in your mailbox"]]])
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[link] you have [italic: [bold: {count}] messages] [light: in your mailbox] [/link]")
+      expect(dt.fragments).to eq(["[tr8n]", "[link]", " you have ", "[italic:", " ", "[bold:", " {count}", "]", " messages", "]", " ", "[light:", " in your mailbox", "]", " ", "[/link]", "[/tr8n]"])
+      expect(dt.parse).to eq( ["tr8n", ["link", " you have ", ["italic", "", ["bold", "{count}"], " messages"], " ", ["light", "in your mailbox"], " "]])
+    end
+  end
+
+  describe "substitute" do
+    it "should correctly substitute tokens" do
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold: Hello World]")
+      expect(dt.substitute).to eq("<strong>Hello World</strong>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold]Hello World[/bold]")
+      expect(dt.substitute).to eq("<strong>Hello World</strong>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[bold] Hello World [/bold]")
+      expect(dt.substitute).to eq("<strong> Hello World </strong>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[p: Hello World]", :p => '<p>{$0}</p>')
+      expect(dt.substitute).to eq("<p>Hello World</p>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[p: Hello World]", :p => lambda{|text| "<p>#{text}</p>"})
+      expect(dt.substitute).to eq("<p>Hello World</p>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[p]Hello World[/p]", :p => lambda{|text| "<p>#{text}</p>"})
+      expect(dt.substitute).to eq("<p>Hello World</p>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[link: you have 5 messages]", "link" => '<a href="http://mail.google.com">{$0}</a>')
+      expect(dt.substitute).to eq("<a href=\"http://mail.google.com\">you have 5 messages</a>")
+
+      dt = Tr8n::Tokens::DecorationTokenizer.new("[link: you have {clount} messages]", "link" => '<a href="http://mail.google.com">{$0}</a>')
+      expect(dt.substitute).to eq("<a href=\"http://mail.google.com\">you have {clount} messages</a>")
+
+    end
+  end
+
+end
+

data/spec/tokens/hidden_spec.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::Hidden do
+  before do
+    @app = init_application
+    @english = @app.language('en-US')
+    @tkey = Tr8n::TranslationKey.new({
+                                         :label => "{_he_she}",
+                                         :application => @app,
+                                         :locale => 'en-US'
+                                     })
+    @token = @tkey.data_tokens.first
+  end
+
+  describe "initialize" do
+    it "should parse data token" do
+      expect(@token.class.name).to eq("Tr8n::Tokens::Hidden")
+      expect(@token.context_keys).to eq([])
+      expect(@token.allowed_in_translation?).to be_false
+    end
+  end
+end

data/spec/tokens/method_spec.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::Method do
+  #before do
+  #  @app = init_application
+  #  @english = @app.language('en-US')
+  #  @tkey = Tr8n::TranslationKey.new({
+  #    :label => "Hello {user.first_name}",
+  #    :application => @app,
+  #    :locale => 'en-US'
+  #  })
+  #  @tlabel = @tkey.tokenized_label
+  #end
+  #
+  #describe "initialize" do
+  #  it "should parse token info" do
+  #    token = @tlabel.tokens.first
+  #    expect(token.class.name).to eq("Tr8n::Tokens::Method")
+  #    expect(token.original_label).to eq(@tlabel.label)
+  #    expect(token.full_name).to eq("{user.first_name}")
+  #    expect(token.declared_name).to eq("user.first_name")
+  #    expect(token.name).to eq("user.first_name")
+  #    expect(token.sanitized_name).to eq("{user.first_name}")
+  #    expect(token.name_key).to eq(:"user.first_name")
+  #    expect(token.pipeless_name).to eq("user.first_name")
+  #    expect(token.case_key).to be_nil
+  #    expect(token.supports_cases?).to be_true
+  #    expect(token.has_case_key?).to be_false
+  #    expect(token.caseless_name).to eq("user.first_name")
+  #
+  #    expect(token.types).to be_nil
+  #    expect(token.has_types?).to be_false
+  #    expect(token.associated_rule_types).to eq([:value])
+  #    expect(token.language_rule_classes).to eq([Tr8n::Rules::Value])
+  #    expect(token.transformable_language_rule_classes).to eq([])
+  #    expect(token.decoration?).to be_false
+  #  end
+  #end
+  #
+  #describe "substitute" do
+  #  it "should substitute values" do
+  #    token = @tlabel.tokens.first
+  #
+  #    user = stub_object({:first_name => "Tom", :last_name => "Anderson", :gender => "Male", :to_s => "Tom Anderson"})
+  #
+  #    # tr("Hello {user}", "", {:user => current_user}}
+  #    expect(token.token_value(user, {}, @english)).to eq(user.to_s)
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user]}}
+  #    expect(token.token_value([user], {}, @english)).to eq(user.to_s)
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, current_user.name]}}
+  #    expect(token.token_value([user, user.first_name], {}, @english)).to eq(user.first_name)
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, "{$0} {$1}", "param1"]}}
+  #    expect(token.token_value([user, "{$0} {$1}", "param1"], {}, @english)).to eq(user.to_s + " param1")
+  #    expect(token.token_value([user, "{$0} {$1} {$2}", "param1", "param2"], {}, @english)).to eq(user.to_s + " param1 param2")
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, :name]}}
+  #    expect(token.token_value([user, :first_name], {}, @english)).to eq(user.first_name)
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, :method_name, "param1"]}}
+  #    user.stub(:last_name_with_prefix) {|prefix| "#{prefix} #{user.last_name}"}
+  #    expect(token.token_value([user, :last_name_with_prefix, 'Mr.'], {}, @english)).to eq("Mr. Anderson")
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, lambda{|user| user.name}]}}
+  #    expect(token.token_value([user, lambda{|user| user.to_s}], {}, @english)).to eq(user.to_s)
+  #
+  #    # tr("Hello {user}", "", {:user => [current_user, lambda{|user, param1| user.name}, "param1"]}}
+  #    expect(token.token_value([user, lambda{|user, param1| user.to_s + " " + param1}, "extra_param1"], {}, @english)).to eq(user.to_s + " extra_param1")
+  #
+  #    # tr("Hello {user}", "", {:user => {:object => current_user, :value => current_user.name}]}}
+  #    expect(token.token_value({:object => user, :value => user.to_s}, {}, @english)).to eq(user.to_s)
+  #
+  #    # tr("Hello {user}", "", {:user => {:object => current_user, :attribute => :first_name}]}}
+  #    expect(token.token_value({:object => user, :attribute => :first_name}, {}, @english)).to eq(user.first_name)
+  #    expect(token.token_value({:object => {:first_name => "Michael"}, :attribute => :first_name}, {}, @english)).to eq("Michael")
+  #  end
+  #end
+
+
+end

data/spec/tokens/transform_spec.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Tokens::Transform do
+  #before do
+  #  @app = init_application
+  #  @english = @app.language('en-US')
+  #  @tkey = Tr8n::TranslationKey.new({
+  #    :label => "You have {count||message}",
+  #    :application => @app,
+  #    :locale => 'en-US'
+  #  })
+  #  @tlabel = @tkey.tokenized_label
+  #end
+  #
+  #describe "initialize" do
+  #  it "should parse token info" do
+  #    token = @tlabel.tokens.first
+  #    expect(token.class.name).to eq("Tr8n::Tokens::Transform")
+  #    expect(token.original_label).to eq(@tlabel.label)
+  #    expect(token.full_name).to eq("{count||message}")
+  #    expect(token.declared_name).to eq("count||message")
+  #    expect(token.name).to eq("count")
+  #    expect(token.sanitized_name).to eq("{count}")
+  #    expect(token.name_key).to eq(:count)
+  #    expect(token.pipeless_name).to eq("count")
+  #    expect(token.case_key).to be_nil
+  #    expect(token.supports_cases?).to be_true
+  #    expect(token.has_case_key?).to be_false
+  #    expect(token.caseless_name).to eq("count")
+  #
+  #    expect(token.types).to be_nil
+  #    expect(token.has_types?).to be_false
+  #    expect(token.associated_rule_types).to eq([:number, :value])
+  #    expect(token.language_rule_classes).to eq([Tr8n::Rules::Number, Tr8n::Rules::Value])
+  #    expect(token.transformable_language_rule_classes).to eq([Tr8n::Rules::Number])
+  #    expect(token.decoration?).to be_false
+  #  end
+  #end
+  #
+  #describe "substitute" do
+  #  it "should substitute values" do
+  #    token = @tlabel.tokens.first
+  #
+  #  end
+  #end
+
+
+end

data/spec/translation_key_spec.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::TranslationKey do
+  describe "#initialize" do
+    before do
+      @app = init_application
+      @english = @app.language('en-US')
+      @russian = @app.language('ru')
+    end
+
+    it "sets attributes" do
+      expect(Tr8n::TranslationKey.attributes).to eq([:application, :language, :id, :key, :label, :description, :locale, :level, :locked, :translations])
+
+      tkey = Tr8n::TranslationKey.new({
+          :label => "Hello World",
+          :application => @app
+      })
+      expect(tkey.locale).to eq("en-US")
+      expect(tkey.language.locale).to eq("en-US")
+
+      tkey = Tr8n::TranslationKey.new({
+        :label => "Hello World",
+        :application => @app,
+        :locale => 'en-US'
+      })
+
+      expect(tkey.id).to be_nil
+      expect(tkey.label).to eq("Hello World")
+      expect(tkey.description).to be_nil
+      expect(tkey.key).to eq("d541c79af1be6a05b1f16fca8b5730de")
+      expect(tkey.locale).to eq("en-US")
+      expect(tkey.language.locale).to eq("en-US")
+      expect(tkey.has_translations_for_language?(@russian)).to be_false
+      expect(tkey.translations_for_language(@russian)).to eq([])
+    end
+
+    it "translates labels correctly into default language" do
+      tkey = Tr8n::TranslationKey.new(:label => "Hello World", :application => @app)
+      expect(tkey.substitute_tokens("Hello World", {}, @english)).to eq("Hello World")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user1}", {:user => "Michael"}, @english)).to eq("Hello {user1}")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user}", {:user => "Michael"}, @english)).to eq("Hello Michael")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user1} and {user2}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user1} and {user2}", {:user1 => "Michael" , :user2 => "Tom"}, @english)).to eq("Hello Michael and Tom")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user}", {:user => {:object => {:name => "Michael"}, :value => "Michael"}}, @english)).to eq("Hello Michael")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user}", {:user => {:object => {:name => "Michael"}, :attribute => "name"}}, @english)).to eq("Hello Michael")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user}", {:user => {:object => double(:name => "Michael"), :attribute => "name"}}, @english)).to eq("Hello Michael")
+
+      tkey = Tr8n::TranslationKey.new(:label => "Hello {user1} [bold: and] {user2}", :application => @app)
+      expect(tkey.substitute_tokens("Hello {user1} [bold: and] {user2}", {:user1 => "Michael" , :user2 => "Tom"}, @english)).to eq("Hello Michael <strong>and</strong> Tom")
+
+      tkey = Tr8n::TranslationKey.new(:label => "You have [link: [bold: {count}] messages]", :application => @app)
+      expect(tkey.substitute_tokens("You have [link: [bold: {count}] messages]", {:count => 5, :link => {:href => "www.google.com"}}, @english)).to eq("You have <a href='www.google.com'><strong>5</strong> messages</a>")
+
+      tkey = Tr8n::TranslationKey.new(:label => "You have [link][bold: {count}] messages[/link]", :application => @app)
+      expect(tkey.substitute_tokens("You have [link][bold: {count}] messages[/link]", {:count => 5, :link => {:href => "www.google.com"}}, @english)).to eq("You have <a href='www.google.com'><strong>5</strong> messages</a>")
+    end
+
+    context "labels with numeric rules" do
+      it "should return correct translations" do
+        key = Tr8n::TranslationKey.new(:label => "You have {count||message}.", :application => @app)
+        key.set_language_translations(@russian, [
+            Tr8n::Translation.new(:label => "U vas est {count} soobshenie.", :context => {"count" => {"number" => "one"}}),
+            Tr8n::Translation.new(:label => "U vas est {count} soobsheniya.", :context => {"count" => {"number" => "few"}}),
+            Tr8n::Translation.new(:label => "U vas est {count} soobshenii.", :context => {"count" => {"number" => "many"}}),
+        ])
+
+        expect(key.translate(@russian, {:count => 1})).to eq("U vas est 1 soobshenie.")
+        expect(key.translate(@russian, {:count => 101})).to eq("U vas est 101 soobshenie.")
+        expect(key.translate(@russian, {:count => 11})).to eq("U vas est 11 soobshenii.")
+        expect(key.translate(@russian, {:count => 111})).to eq("U vas est 111 soobshenii.")
+
+        expect(key.translate(@russian, {:count => 5})).to eq("U vas est 5 soobshenii.")
+        expect(key.translate(@russian, {:count => 26})).to eq("U vas est 26 soobshenii.")
+        expect(key.translate(@russian, {:count => 106})).to eq("U vas est 106 soobshenii.")
+
+        expect(key.translate(@russian, {:count => 3})).to eq("U vas est 3 soobsheniya.")
+        expect(key.translate(@russian, {:count => 13})).to eq("U vas est 13 soobshenii.")
+        expect(key.translate(@russian, {:count => 23})).to eq("U vas est 23 soobsheniya.")
+        expect(key.translate(@russian, {:count => 103})).to eq("U vas est 103 soobsheniya.")
+      end
+    end
+  end
+end

data/spec/translation_spec.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Translation do
+  describe "initialize" do
+    before do
+      @app = init_application
+      @english = @app.language('en-US')
+      @russian = @app.language('ru')
+    end
+
+    it "sets attributes" do
+      expect(Tr8n::Translation.attributes).to eq([:translation_key, :language, :locale, :label, :context, :precedence])
+
+      t = Tr8n::Translation.new(:label => "You have {count||message}", :context => {"count" => {"number" => "one"}}, :language => @russian)
+
+      [1, 101, 1001].each do |count|
+        expect(t.matches_rules?(:count => count)).to be_true
+      end
+
+    end
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Utils do
+  describe "helper methods" do
+    it "should return correct values" do
+      #expect(Tr8n::Utils.root).to eq(File.expand_path("#{__dir__}/../"))
+      expect(Tr8n::Utils.load_yaml("#{Tr8n.config.root}/config/tokens/data.yml").class).to eq(Hash)
+
+      expect(
+        Tr8n::Utils.normalize_tr_params("Hello {user}", "Sample label", {:user => "Michael"}, {})
+      ).to eq(
+        {:label=>"Hello {user}", :description=>"Sample label", :tokens=>{:user=>"Michael"}, :options=>{}}
+      )
+
+      expect(
+        Tr8n::Utils.normalize_tr_params("Hello {user}", {:user => "Michael"}, nil, nil)
+      ).to eq(
+        {:label=>"Hello {user}", :description=>nil, :tokens=>{:user=>"Michael"}, :options=>nil}
+      )
+
+      expect(
+        Tr8n::Utils.normalize_tr_params("Hello {user}", {:user => "Michael"}, {:skip_decoration => true}, nil)
+      ).to eq(
+        {:label=>"Hello {user}", :description=>nil, :tokens=>{:user=>"Michael"}, :options=>{:skip_decoration=>true}}
+      )
+
+      expect(
+        Tr8n::Utils.normalize_tr_params({:label=>"Hello {user}", :description=>"Sample label", :tokens=>{:user=>"Michael"}, :options=>{}}, nil, nil, nil)
+      ).to eq(
+        {:label=>"Hello {user}", :description=>"Sample label", :tokens=>{:user=>"Michael"}, :options=>{}}
+      )
+
+      expect(Tr8n::Utils.guid.class).to be(String)
+    end
+
+    it "should correctly split by sentence" do
+
+      expect(
+          Tr8n::Utils.split_by_sentence("Hello World")
+      ).to eq(
+          ["Hello World"]
+      )
+
+      expect(
+          Tr8n::Utils.split_by_sentence("This is the first sentence. Followed by the second one.")
+      ).to eq(
+           ["This is the first sentence.", "Followed by the second one."]
+       )
+
+    end
+
+    it "should correctly sign and verify signature" do
+      data = {"name" => "Michael"}
+      key = "abc"
+
+      request =  Tr8n::Utils.sign_and_encode_params(data, key)
+      result = Tr8n::Utils.decode_and_verify_params(request, key)
+      expect(result["name"]).to eq(data["name"])
+    end
+
+  end
+end