tr8n_core 4.0.7 → 4.0.9

data/spec/rules_engine/evaluator_spec.rb

@@ -1,150 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe Tr8n::RulesEngine::Evaluator do
-  describe "#evaluator" do
-    it "evaluates standard expressions" do
-      e = Tr8n::RulesEngine::Evaluator.new
-      e.evaluate(["label", "greeting", "hello world"])
-      expect(e.vars).to eq({"greeting"=>"hello world"})
-
-      expect(e.evaluate(["quote", [1,2,3]])).to eq([1,2,3])
-      expect(e.evaluate(["quote", ["a","b","c"]])).to eq(["a","b","c"])
-
-      expect(e.evaluate(["car", ["+", 1, 2]])).to eq(1)
-      expect(e.evaluate(["cdr", ["+", 1, 2]])).to eq([1, 2])
-      expect(e.evaluate(["cons", 1, ["quote", [2, 3]]])).to eq([1, 2, 3])
-
-      expect(e.evaluate(["eq", 1, 1])).to be_truthy
-
-      expect(e.evaluate(["atom", :a])).to be_truthy
-      expect(e.evaluate(["atom", "hello"])).to be_truthy
-      expect(e.evaluate(["atom", 1])).to be_truthy
-      expect(e.evaluate(["atom", 1.4])).to be_truthy
-      expect(e.evaluate(["atom", ["eq", 1, 1]])).to be_falsey
-
-      expect(e.evaluate(["cond", ["eq", 1, 1], 1, 0])).to eq(1)
-      expect(e.evaluate(["cond", ["eq", 1, 2], 1, 0])).to eq(0)
-    end
-
-    it "evaluates rules" do
-      e = Tr8n::RulesEngine::Evaluator.new
-      expect(e.evaluate(["=", "1", "1"])).to be_truthy
-      expect(e.evaluate(["=", "1", "2"])).to be_falsey
-
-      expect(e.evaluate(["!=", "2", "1"])).to be_truthy
-      expect(e.evaluate(["!=", "2", "2"])).to be_falsey
-
-      expect(e.evaluate([">", "2", "1"])).to be_truthy
-      expect(e.evaluate([">", "1", "2"])).to be_falsey
-
-      expect(e.evaluate(["<", "2", "3"])).to be_truthy
-      expect(e.evaluate(["<", "3", "2"])).to be_falsey
-
-      expect(e.evaluate(["+", 1, 2])).to eq(3)
-      expect(e.evaluate(["+", -1, 2])).to eq(1)
-
-      expect(e.evaluate(["-", 2, 1])).to eq(1)
-      expect(e.evaluate(["*", 2, 10])).to eq(20)
-      expect(e.evaluate(["/", 20, 10])).to eq(2)
-
-      expect(e.evaluate(["!", ["=", "1", "2"]])).to be_truthy
-
-      expect(e.evaluate(["&&", ["=", "1", "1"], ["=", 10, ["/", 20, 2]]])).to be_truthy
-      expect(e.evaluate(["||", ["=", "2", "1"], ["=", 10, ["/", 20, 2]]])).to be_truthy
-
-      expect(e.evaluate(["if", ["=", 1, 2], 1, 0])).to eq(0)
-
-      e.evaluate(["let", "@n", 1])
-      expect(e.vars).to eq({"@n"=>1})
-      expect(e.evaluate(["=", 1, "@n"])).to be_truthy
-
-      e.evaluate(["let", "@n", 11])
-      expect(e.vars).to eq({"@n"=>11})
-      expect(e.evaluate(["=", 11, "@n"])).to be_truthy
-
-      expect(e.evaluate(["and", ["=", "1", "1"], ["=", 10, ["/", 20, 2]]])).to be_truthy
-      expect(e.evaluate(["or", ["=", "2", "1"], ["=", 10, ["/", 20, 2]]])).to be_truthy
-
-      expect(e.evaluate(["mod", 23, 10])).to eq(3)
-      expect(e.evaluate(["mod", 2.3, 10])).to eq(2.3)
-
-      expect(e.evaluate(["match", "/hello/", "hello world"])).to be_truthy
-      expect(e.evaluate(["match", "hello", "hello world"])).to be_truthy
-      expect(e.evaluate(["match", "/^h/", "hello world"])).to be_truthy
-      expect(e.evaluate(["match", "/^e/", "hello world"])).to be_falsey
-      expect(e.evaluate(["match", "/^h.*d$/", "hello world"])).to be_truthy
-
-      expect(e.evaluate(["in", "1,2", "1"])).to be_truthy
-      expect(e.evaluate(["in", "1,2", 1])).to be_truthy
-      expect(e.evaluate(["in", "a,b,c", "a"])).to be_truthy
-      expect(e.evaluate(["in", "a..c, d..z", "h"])).to be_truthy
-
-      expect(e.evaluate(["in", "1..5, 10..22", 21])).to be_truthy
-      expect(e.evaluate(["in", "1..5, 10..22", 22])).to be_truthy
-      expect(e.evaluate(["in", "1..5, 10..22", 1])).to be_truthy
-      expect(e.evaluate(["in", "1..5, 10..22", 23])).to be_falsey
-      expect(e.evaluate(["in", "1..5, 10..22", "9"])).to be_falsey
-
-      expect(e.evaluate(["within", "1..3", 2.3])).to be_truthy
-      expect(e.evaluate(["within", "1..3", 3.3])).to be_falsey
-
-      expect(e.evaluate(["replace", "/^hello/", "hi", "hello world"])).to eq("hi world")
-      expect(e.evaluate(["replace", "world", "hi", "hello world"])).to eq("hello hi")
-      expect(e.evaluate(["replace", "o", "a", "hello world"])).to eq("hella warld")
-      expect(e.evaluate(["replace", "/world$/", "moon", "hello moon"])).to eq("hello moon")
-
-      expect(e.evaluate(["append", "world", "hello "])).to eq("hello world")
-      expect(e.evaluate(["prepend", "hello ", "world"])).to eq("hello world")
-
-      expect(e.evaluate(["true"])).to be_truthy
-      expect(e.evaluate(["false"])).to be_falsey
-
-      expect(e.evaluate(["date", "2011-01-01"])).to eq(Date.new(2011, 1, 1))
-      expect(e.evaluate(["today"])).to eq(Date.today)
-
-      expect(e.evaluate(["time", "2011-01-01 10:9:8"])).to eq(Time.new(2011, 1, 1, 10, 9, 8))
-
-      expect(e.evaluate([">", ["date", "3014-01-01"], ["today"]])).to be_truthy
-    end
-
-    it "evaluates expressions" do
-      e = Tr8n::RulesEngine::Evaluator.new
-
-      e.evaluate(["let", "@n", 1])
-      expect(e.evaluate(["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]])).to be_truthy
-      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_falsey
-      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_falsey
-
-      e.evaluate(["let", "@n", 21])
-      expect(e.evaluate(["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]])).to be_truthy
-      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_falsey
-      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_falsey
-
-      e.evaluate(["let", "@n", 11])
-      expect(e.evaluate(["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]])).to be_falsey
-      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_falsey
-      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_truthy
-
-      rules = {
-          "one" => ["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]],
-          "few" => ["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]],
-          "many" => ["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]]
-      }
-
-      {
-          "one" => [1, 21, 31, 41, 51, 61],
-          "few" => [2,3,4, 22,23,24, 32,33,34],
-          "many" => [0, 5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20, 25,26,27,28,29,30, 35,36,37,38,39,40]
-      }.each do |key, values|
-        values.each do |value|
-          e.evaluate(["let", "@n", value])
-          expect(e.evaluate(rules[key])).to be_truthy
-        end
-      end
-
-    end
-
-  end
-end

data/spec/rules_engine/parser_spec.rb

@@ -1,31 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe Tr8n::RulesEngine::Parser do
-  describe "#parser" do
-    it "parses expressions" do
-      expect(Tr8n::RulesEngine::Parser.new("(= 1 (mod n 10))").tokens).to eq(
-          ["(", "=", "1", "(", "mod", "n", "10", ")", ")"]
-      )
-
-      expect(Tr8n::RulesEngine::Parser.new("(&& (= 1 (mod @n 10)) (!= 11 (mod @n 100)))").tokens).to eq(
-          ["(", "&&", "(", "=", "1", "(", "mod", "@n", "10", ")", ")", "(", "!=", "11", "(", "mod", "@n", "100", ")", ")", ")"]
-      )
-
-      {
-          "(= 1 1)" => ["=", 1, 1],
-          "(+ 1 1)" => ["+", 1, 1],
-          "(= 1 (mod n 10))" => ["=", 1, ["mod", "n", 10]],
-          "(&& 1 1)" => ["&&", 1, 1],
-          "(mod @n 10)" => ["mod", "@n", 10],
-          "(&& (= 1 (mod @n 10)) (!= 11 (mod @n 100)))" => ["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]],
-          "(&& (in '2..4' (mod @n 10)) (not (in '12..14' (mod @n 100))))" => ["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]],
-          "(|| (= 0 (mod @n 10)) (in '5..9' (mod @n 10)) (in '11..14' (mod @n 100)))" => ["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]]
-      }.each do |source, target|
-        expect(Tr8n::RulesEngine::Parser.new(source).parse).to eq(target)
-      end
-
-    end
-  end
-end

data/spec/source_spec.rb

@@ -1,13 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe Tr8n::Source do
-  describe "#initialize" do
-    it "helper methods" do
-      expect(Tr8n::Source.normalize("https://travis-ci.org/tr8n/tr8n_ruby_core")).to eq("/tr8n/tr8n_ruby_core")
-      expect(Tr8n::Source.normalize("https://www.google.com/search?q=test&source=lnms")).to eq("/search")
-      expect(Tr8n::Source.cache_prefix).to eq('s@')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,101 +0,0 @@
-# encoding: UTF-8
-
-require 'rspec'
-require 'json'
-
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start
-
-require 'tr8n_core'
-
-RSpec.configure do |config|
-  config.raise_errors_for_deprecations!
-  config.mock_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
-end
-
-Tr8n.configure do |config|
-  config.format = :text
-end
-
-def fixtures_root
-  File.join(File.dirname(__FILE__), 'fixtures')
-end
-
-def load_json(file_path)
-  JSON.parse(File.read("#{fixtures_root}/#{file_path}"))
-end
-
-def load_translation_key_from_hash(app, hash)
-  app.cache_translation_key(Tr8n::TranslationKey.new(hash.merge(:application => app)))
-end
-
-def load_translation_key_from_array(app, arr)
-  arr.each do |tkey|
-    load_translation_key_from_hash(app, tkey)
-  end
-end
-
-def load_translation_keys_from_file(app, path)
-  load_translation_key_from_array(app, load_json(path))
-end
-
-def stub_object(attrs)
-  user = double()
-  attrs.each do |key, value|
-    user.stub(key) { value }
-  end
-  user
-end
-
-def init_application(locales = [], path = 'application.json')
-  locales = ['en-US', 'ru', 'es'] if locales.size == 0
-  app = Tr8n::Application.new(load_json(path))
-  locales.each do |locale|
-    app.add_language(Tr8n::Language.new(load_json("languages/#{locale}.json")))
-  end
-  Tr8n.session.application = app
-  Tr8n.session.current_language = app.language('en-US')
-  app
-end
-
-RSpec.configure do |config|
-  config.before do
-    ARGV.replace []
-  end
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  def capture(stream)
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      yield
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
-    end
-
-    result
-  end
-
-  def source_root
-    fixtures_root
-  end
-  
-  def destination_root
-    File.join(File.dirname(__FILE__), 'sandbox')
-  end
-
-  alias :silence :capture
-end
-

data/spec/tokens/data_spec.rb

@@ -1,114 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_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, current_user.name]}}
-      expect(@token.token_value([user, user.first_name], @english)).to eq(user.first_name)
-
-      # tr("Hello {user}", "", {:user => [current_user, :name]}}
-      expect(@token.token_value([user, :first_name], @english)).to eq(user.first_name)
-
-      # 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, user.first_name]},                                                     "Hello Tom",
-        {:user => [user, :first_name]},                                                         "Hello Tom",
-        {: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.session.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, {
-            :description => "List joiner",
-            :limit => 4,
-            :separator => ", ",
-            :joiner => 'and',
-            :less => '{laquo} less',
-            :expandable => false,
-            :collapsable => true
-        }], @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, {
-            :description => "List joiner",
-            :limit => 10,
-            :separator => ", ",
-            :joiner => 'and',
-            :less => '{laquo} less',
-            :expandable => false,
-            :collapsable => true
-        }], @english)).to eq("First name 1, First name 2, First name 3, First name 4, First name 5 and First name 6")
-
-        expect(token.token_value([users, :first_name, {
-            :joiner => 'or',
-            :expandable => false,
-        }], @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, {
-            :limit => 2,
-            :joiner => 'or',
-            :expandable => false,
-        }], @english)).to eq("First name 1, First name 2 or 4 others")
-
-      end
-    end
-  end
-
-end

data/spec/tokens/data_tokenizer_spec.rb

@@ -1,29 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_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

@@ -1,81 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_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

@@ -1,24 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_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_falsey
-    end
-  end
-end

data/spec/tokens/method_spec.rb

@@ -1,84 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_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_truthy
-  #    expect(token.has_case_key?).to be_falsey
-  #    expect(token.caseless_name).to eq("user.first_name")
-  #
-  #    expect(token.types).to be_nil
-  #    expect(token.has_types?).to be_falsey
-  #    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_falsey
-  #  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