tr8n_core 4.0.1

data/spec/language_context_spec.rb

@@ -0,0 +1,331 @@
+require 'helper'
+
+describe Tr8n::LanguageContext do
+
+  before :all do
+    @app = init_application
+    @english = @app.language('en-US')
+    @russian = @app.language('ru')
+  end
+
+  describe "initialize" do
+    it "sets attributes" do
+      expect(Tr8n::LanguageContext.attributes).to eq([:language, :keyword, :description, :default_key, :token_expression, :variables, :token_mapping, :keys, :rules])
+    end
+  end
+
+  describe "finding context" do
+    it "should return correct context" do
+      #@user = stub_object(:first_name => "Mike", :gender => "male")
+      #@translator = stub_object(:name => "Mike", :user => @user, :gender => "male")
+
+      expect(@russian.context_by_keyword("date").keyword).to eq("date")
+    end
+  end
+
+  describe "matching tokens" do
+    it "should identify the right tokens" do
+      @context = Tr8n::LanguageContext.new(
+          :language           =>     @english,
+          :keyword            =>      "numeric",
+          :token_expression   => '/.*(count|num|age|hours|minutes|years|seconds)(\d)*$/',
+          :variables          => ['@n'],
+          :description        =>   "Numeric language context"
+      )
+
+      expect(@context.token_expression).to eq(/.*(count|num|age|hours|minutes|years|seconds)(\d)*$/)
+      expect(@context.applies_to_token?("num")).to be_true
+      expect(@context.applies_to_token?("num1")).to be_true
+      expect(@context.applies_to_token?("profile_num1")).to be_true
+      expect(@context.applies_to_token?("profile_num21")).to be_true
+      expect(@context.applies_to_token?("profile")).to be_false
+      expect(@context.applies_to_token?("num_years")).to be_true
+      expect(@context.applies_to_token?("count1")).to be_true
+      expect(@context.applies_to_token?("count2")).to be_true
+    end
+  end
+
+  describe "gender rules" do
+    describe "loading variables" do
+      it "should return assigned variables" do
+        context = Tr8n::LanguageContext.new(
+            :language           => @english,
+            :keyword            => "gender",
+            :token_expression   => '/.*(profile|user|actor|target)(\d)*$/',
+            :variables          => ['@gender'],
+            :description        => "Gender language context"
+        )
+
+        obj = double(:gender => "male")
+        Tr8n.config.stub(:context_rules) {
+          {
+              "gender" => {
+                  "variables" => {
+                      "@gender" => "gender",
+                  }
+              }
+          }
+        }
+        expect(context.vars(obj)).to eq({"@gender" => "male"})
+
+        Tr8n.config.stub(:context_rules) {
+          {
+              :gender => {
+                  :variables => {
+                      "@gender" => "gender",
+                  }
+              }
+          }
+        }
+        expect(context.vars(obj)).to eq({"@gender" => "male"})
+        expect(context.vars({:object => obj})).to eq({"@gender" => "male"})
+        expect(context.vars({:gender => "male"})).to eq({"@gender" => "male"})
+        expect(context.vars(:object => {:gender => "male"})).to eq({"@gender" => "male"})
+
+        Tr8n.config.stub(:context_rules) {
+          {
+              "gender" => {
+                  "variables" => {
+                      "@gender" => lambda{|obj| obj.gender},
+                  }
+              }
+          }
+        }
+        expect(context.vars(obj)).to eq({"@gender" => "male"})
+      end
+    end
+
+    describe "evaluate rules" do
+      it "should return matching rule" do
+        context = Tr8n::LanguageContext.new(
+            :language           => @english,
+            :keyword            => "gender",
+            :token_expression   => '/.*(profile|user|actor|target)(\d)*$/',
+            :variables          => ['@gender'],
+            :description        => "Gender language context",
+            :rules              => {
+              :male        => {:language_context => @context, :keyword => "male", :conditions => "(= 'male' @gender)"},
+              :female      => {:language_context => @context, :keyword => "female", :conditions => "(= 'female' @gender)"},
+              :other       => {:language_context => @context, :keyword => "other"}
+            }
+        )
+
+        Tr8n.config.stub(:context_rules) {
+          {
+              "gender" => {
+                  "variables" => {
+                      "@gender" => "gender",
+                  }
+              }
+          }
+        }
+
+        expect(context.fallback_rule.keyword).to eq("other")
+
+        expect(context.find_matching_rule(double(:gender => "male")).keyword).to eq('male')
+        expect(context.find_matching_rule(double(:gender => "female")).keyword).to eq('female')
+        expect(context.find_matching_rule(double(:gender => "unknown")).keyword).to eq('other')
+
+        # unknown goes before other
+        context.rules[:unknown] = Tr8n::LanguageContextRule.new(:language_context => @context, :keyword => "unknown", :conditions => "(&& (!= 'male' @gender) (!= 'female' @gender))")
+        expect(context.find_matching_rule(double(:gender => "unknown")).keyword).to eq('unknown')
+      end
+    end
+  end
+
+  describe "genders rules" do
+    before(:each) do
+      @context = Tr8n::LanguageContext.new(
+          :language             => @english,
+          :keyword              => "genders",
+          :token_expression     => '/.*(profiles|users|actors|targets)(\d)*$/',
+          :variables            => ['@genders', '@count'],
+          :description          =>  "Language context for list of users"
+      )
+
+      Tr8n.config.stub(:context_rules) {
+        {
+            "genders" => {
+                "variables" => {
+                    "@genders" => lambda{|list|
+                      list.collect{|u| u.gender}
+                    },
+                    "@count" => lambda{|list| list.count},
+                }
+            }
+        }
+      }
+    end
+
+    describe "loading variables" do
+      it "should return assigned variables" do
+        obj = [double(:gender => "male"), double(:gender => "female")]
+        expect(@context.vars(obj)).to eq({"@genders" => ["male", "female"], "@count" => 2})
+      end
+    end
+
+    describe "evaluate rules" do
+      it "should return matching rule" do
+        Tr8n.config.stub(:context_rules) {
+          {
+              "genders" => {
+                  "variables" => {
+                      "@genders" => lambda{|list| list.collect{|u| u.gender}},
+                  }
+              }
+          }
+        }
+
+        @context.rules[:one_male]    = Tr8n::LanguageContextRule.new(:conditions => "(&& (= 1 (count @genders)) (all @genders 'male'))")
+        @context.rules[:one_female]  = Tr8n::LanguageContextRule.new(:conditions => "(&& (= 1 (count @genders)) (all @genders 'female'))")
+        @context.rules[:one_unknown] = Tr8n::LanguageContextRule.new(:conditions => "(&& (= 1 (count @genders)) (all @genders 'unknown'))")
+        @context.rules[:other]       = Tr8n::LanguageContextRule.new(:keyword => "other")
+
+        expect(@context.find_matching_rule([double(:gender => "male")])).to eq(@context.rules[:one_male])
+        expect(@context.find_matching_rule([double(:gender => "female")])).to eq(@context.rules[:one_female])
+        expect(@context.find_matching_rule([double(:gender => "unknown")])).to eq(@context.rules[:one_unknown])
+        expect(@context.find_matching_rule([double(:gender => "male"), double(:gender => "male")])).to eq(@context.rules[:other])
+
+        # unknown goes before other
+        @context.rules[:at_least_two] = Tr8n::LanguageContextRule.new(:conditions => "(> (count @genders) 1)")
+        expect(@context.find_matching_rule([double(:gender => "male"), double(:gender => "male")])).to eq(@context.rules[:at_least_two])
+
+        @context.rules.delete(:at_least_two)
+
+        @context.rules[:all_male] = Tr8n::LanguageContextRule.new(:conditions => "(&& (> (count @genders) 1) (all @genders 'male'))")
+        @context.rules[:all_female] = Tr8n::LanguageContextRule.new(:conditions => "(&& (> (count @genders) 1) (all @genders 'female'))")
+
+        expect(@context.find_matching_rule([double(:gender => "male"), double(:gender => "male")])).to eq(@context.rules[:all_male])
+        expect(@context.find_matching_rule([double(:gender => "female"), double(:gender => "female")])).to eq(@context.rules[:all_female])
+        expect(@context.find_matching_rule([double(:gender => "male"), double(:gender => "female")])).to eq(@context.rules[:other])
+      end
+    end
+  end
+
+  describe "list rules" do
+    before(:each) do
+      @context = Tr8n::LanguageContext.new(
+          :language             => @english,
+          :keyword              => "list",
+          :token_expression     => '/.*(list)(\d)*$/',
+          :variables            => ['@count'],
+          :description          =>  "Language context for lists"
+      )
+
+      Tr8n.config.stub(:context_rules) {
+        {
+            "list" => {
+                "variables" => {
+                    "@count" => "count",
+                }
+            }
+        }
+      }
+    end
+
+    describe "loading variables" do
+      it "should return assigned variables" do
+        obj = ["apple", "banana"]
+        expect(@context.vars(obj)).to eq({"@count" => 2})
+      end
+    end
+
+    describe "evaluate rules" do
+      it "should return matching rule" do
+        @context.rules[:one] = Tr8n::LanguageContextRule.new(:conditions => "(= 1 @count)")
+        @context.rules[:two] = Tr8n::LanguageContextRule.new(:conditions => "(= 2 @count)")
+        @context.rules[:other] = Tr8n::LanguageContextRule.new(:keyword => "other")
+
+        expect(@context.find_matching_rule(["apple"])).to eq(@context.rules[:one])
+        expect(@context.find_matching_rule(["apple", "banana"])).to eq(@context.rules[:two])
+        expect(@context.find_matching_rule(["apple", "banana", "grapes"])).to eq(@context.rules[:other])
+      end
+    end
+  end
+
+  describe "numeric rules" do
+    before(:each) do
+      @context = Tr8n::LanguageContext.new(
+          :language             => @english,
+          :keyword              => "numeric",
+          :token_expression     => '/.*(count|num|age|hours|minutes|years|seconds)(\d)*$/',
+          :variables            => ['@n'],
+          :description          =>  "Language context for numbers"
+      )
+
+      Tr8n.config.stub(:context_rules) {
+        {
+          "numeric" => {
+            "token_expression" => '/.*(count|num|age|hours|minutes|years|seconds)(\d)*$/',
+            "variables" => {
+              "@n" => "to_i",
+            }
+          }
+        }
+      }
+    end
+
+    describe "loading variables" do
+      it "should return assigned variables" do
+        obj = double(:to_i => 10)
+        expect(@context.vars(obj)).to eq({"@n" => 10})
+
+        obj = 15
+        expect(@context.vars(obj)).to eq({"@n" => 15})
+      end
+    end
+
+    describe "evaluate rules" do
+      it "should return matching rule" do
+        @context.rules[:one] = Tr8n::LanguageContextRule.new(:conditions => "(&& (= 1 (mod @n 10)) (!= 11 (mod @n 100)))", :description => "{n} mod 10 is 1 and {n} mod 100 is not 11", :examples => "1, 21, 31, 41, 51, 61...")
+        @context.rules[:few] = Tr8n::LanguageContextRule.new(:conditions => "(&& (in '2..4' (mod @n 10)) (not (in '12..14' (mod @n 100))))", :description => "{n} mod 10 in 2..4 and {n} mod 100 not in 12..14", :examples => "2-4, 22-24, 32-34...")
+        @context.rules[:many] = Tr8n::LanguageContextRule.new(:conditions => "(|| (= 0 (mod @n 10)) (in '5..9' (mod @n 10)) (in '11..14' (mod @n 100)))", :description => "{n} mod 10 is 0 or {n} mod 10 in 5..9 or {n} mod 100 in 11..14", :examples => "0, 5-20, 25-30, 35-40...")
+
+        expect(@context.find_matching_rule(1)).to eq(@context.rules[:one])
+        expect(@context.find_matching_rule(2)).to eq(@context.rules[:few])
+        expect(@context.find_matching_rule(0)).to eq(@context.rules[:many])
+      end
+    end
+  end
+
+  describe "date rules" do
+    before(:each) do
+      @context = Tr8n::LanguageContext.new(
+          :language             => @english,
+          :keyword              => "date",
+          :token_expression     => '/.*(date)(\d)*$/',
+          :variables            => ['@date'],
+          :description          =>  "Language context for dates"
+      )
+
+      Tr8n.config.stub(:context_rules) {
+        {
+            "date" => {
+                "variables" => {
+                }
+            }
+        }
+      }
+    end
+
+    describe "loading variables" do
+      it "should return assigned variables" do
+        today = Date.today
+        expect(@context.vars(today)).to eq({"@date" => today})
+      end
+    end
+
+    describe "evaluate rules" do
+      it "should return matching rule" do
+        @context.rules[:present] = Tr8n::LanguageContextRule.new(:conditions => "(= (today) @date)")
+        @context.rules[:past] = Tr8n::LanguageContextRule.new(:conditions => "(> (today) @date)")
+        @context.rules[:future] = Tr8n::LanguageContextRule.new(:conditions => "(< (today) @date)")
+
+        expect(@context.find_matching_rule(Date.today)).to eq(@context.rules[:present])
+        expect(@context.find_matching_rule(Date.today - 24)).to eq(@context.rules[:past])
+        expect(@context.find_matching_rule(Date.today + 24)).to eq(@context.rules[:future])
+      end
+    end
+  end
+
+end

data/spec/language_spec.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require 'helper'
+
+describe Tr8n::Language do
+  describe "#initialize" do
+    it "sets language attributes" do
+      russian = Tr8n::Language.new(load_json('languages/ru.json'))
+      expect(russian.locale).to eq('ru')
+      expect(russian.full_name).to eq("Russian - Русский")
+    end
+  end
+
+
+
+end

data/spec/rules_engine/evaluator_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../helper', File.dirname(__FILE__))
+
+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_true
+
+      expect(e.evaluate(["atom", :a])).to be_true
+      expect(e.evaluate(["atom", "hello"])).to be_true
+      expect(e.evaluate(["atom", 1])).to be_true
+      expect(e.evaluate(["atom", 1.4])).to be_true
+      expect(e.evaluate(["atom", ["eq", 1, 1]])).to be_false
+
+      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_true
+      expect(e.evaluate(["=", "1", "2"])).to be_false
+
+      expect(e.evaluate(["!=", "2", "1"])).to be_true
+      expect(e.evaluate(["!=", "2", "2"])).to be_false
+
+      expect(e.evaluate([">", "2", "1"])).to be_true
+      expect(e.evaluate([">", "1", "2"])).to be_false
+
+      expect(e.evaluate(["<", "2", "3"])).to be_true
+      expect(e.evaluate(["<", "3", "2"])).to be_false
+
+      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_true
+
+      expect(e.evaluate(["&&", ["=", "1", "1"], ["=", 10, ["/", 20, 2]]])).to be_true
+      expect(e.evaluate(["||", ["=", "2", "1"], ["=", 10, ["/", 20, 2]]])).to be_true
+
+      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_true
+
+      e.evaluate(["let", "@n", 11])
+      expect(e.vars).to eq({"@n"=>11})
+      expect(e.evaluate(["=", 11, "@n"])).to be_true
+
+      expect(e.evaluate(["and", ["=", "1", "1"], ["=", 10, ["/", 20, 2]]])).to be_true
+      expect(e.evaluate(["or", ["=", "2", "1"], ["=", 10, ["/", 20, 2]]])).to be_true
+
+      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_true
+      expect(e.evaluate(["match", "hello", "hello world"])).to be_true
+      expect(e.evaluate(["match", "/^h/", "hello world"])).to be_true
+      expect(e.evaluate(["match", "/^e/", "hello world"])).to be_false
+      expect(e.evaluate(["match", "/^h.*d$/", "hello world"])).to be_true
+
+      expect(e.evaluate(["in", "1,2", "1"])).to be_true
+      expect(e.evaluate(["in", "1,2", 1])).to be_true
+      expect(e.evaluate(["in", "a,b,c", "a"])).to be_true
+      expect(e.evaluate(["in", "a..c, d..z", "h"])).to be_true
+
+      expect(e.evaluate(["in", "1..5, 10..22", 21])).to be_true
+      expect(e.evaluate(["in", "1..5, 10..22", 22])).to be_true
+      expect(e.evaluate(["in", "1..5, 10..22", 1])).to be_true
+      expect(e.evaluate(["in", "1..5, 10..22", 23])).to be_false
+      expect(e.evaluate(["in", "1..5, 10..22", "9"])).to be_false
+
+      expect(e.evaluate(["within", "1..3", 2.3])).to be_true
+      expect(e.evaluate(["within", "1..3", 3.3])).to be_false
+
+      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_true
+      expect(e.evaluate(["false"])).to be_false
+
+      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_true
+    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_true
+      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_false
+      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_false
+
+      e.evaluate(["let", "@n", 21])
+      expect(e.evaluate(["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]])).to be_true
+      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_false
+      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_false
+
+      e.evaluate(["let", "@n", 11])
+      expect(e.evaluate(["&&", ["=", 1, ["mod", "@n", 10]], ["!=", 11, ["mod", "@n", 100]]])).to be_false
+      expect(e.evaluate(["&&", ["in", "2..4", ["mod", "@n", 10]], ["not", ["in", "12..14", ["mod", "@n", 100]]]])).to be_false
+      expect(e.evaluate(["||", ["=", 0, ["mod", "@n", 10]], ["in", "5..9", ["mod", "@n", 10]], ["in", "11..14", ["mod", "@n", 100]]])).to be_true
+
+      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_true
+        end
+      end
+
+    end
+
+  end
+end

data/spec/rules_engine/parser_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../helper', File.dirname(__FILE__))
+
+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