tr8n 3.1.8 → 3.2.0

data/spec/models/tr8n/daily_language_metric_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::DailyLanguageMetric do
+	
+end

data/spec/models/tr8n/date_rule_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::DateRule do
+	
+end

data/spec/models/tr8n/gender_list_rule_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::GenderListRule do
+	
+end

data/spec/models/tr8n/gender_rule_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::GenderRule do
+	before :all do 
+		@lang = Tr8n::Language.create(:locale => "elb", :english_name => "Elbonian")
+	end
+
+	after :all do 
+		@lang.destroy
+	end
+
+	describe 'class methods'	do
+		it 'should respec configuration settings' do
+			Tr8n::Config.stub!(:rules_engine).and_return({
+				:gender_rule => {
+														token_suffixes: ["user", "actor", "target"],
+      											object_method:   "gender",
+      											method_values:  {
+        											female:        "f",
+        											male:          "m",
+        											neutral:       "n",
+        											unknown:       "u"	      								 
+        										} 
+      									}
+			})
+
+			Tr8n::GenderRule.dependency.should eq("gender")
+			Tr8n::GenderRule.suffixes.should eq(["user", "actor", "target"])
+
+			Tr8n::GenderRule.gender_object_value_for(:female).should eq("f")
+			Tr8n::GenderRule.gender_object_value_for(:male).should eq("m")
+			Tr8n::GenderRule.gender_object_value_for(:neutral).should eq("n")
+			Tr8n::GenderRule.gender_object_value_for(:unknown).should eq("u")
+
+			obj = mock("object_with_gender")
+			obj.should_receive(:gender).and_return("m")
+			Tr8n::GenderRule.gender_token_value(obj).should eq("m")
+		end
+
+		describe 'default transform without token value' do
+			it 'should always use a musculine form' do
+				Tr8n::GenderRule.default_transform("he").should eq("he")
+				Tr8n::GenderRule.default_transform("he", "she").should eq("he")
+				Tr8n::GenderRule.default_transform("his", "her").should eq("his")
+			end
+		end
+
+		describe 'transform with a token value' do
+			it 'should return the form based on the token value' do
+				male = mock("male")
+				male.stub!(:gender).and_return("male")
+				female = mock("male")
+				female.stub!(:gender).and_return("female")
+				unknwon = mock("unknwon")
+				unknwon.stub!(:gender).and_return("unknwon")
+
+				Tr8n::GenderRule.transform(male, "registered on").should eq("registered on")
+				Tr8n::GenderRule.transform(male, "he", "she").should eq("he")
+				Tr8n::GenderRule.transform(male, "his", "her").should eq("his")
+				Tr8n::GenderRule.transform(male, "he", "she", "he/she").should eq("he")
+
+				Tr8n::GenderRule.transform(female, "registered on").should eq("registered on")
+				Tr8n::GenderRule.transform(female, "he", "she").should eq("she")
+				Tr8n::GenderRule.transform(female, "his", "her").should eq("her")
+				Tr8n::GenderRule.transform(female, "he", "she", "he/she").should eq("she")
+
+				Tr8n::GenderRule.transform(unknwon, "registered on").should eq("registered on")
+				Tr8n::GenderRule.transform(unknwon, "he", "she").should eq("he/she")
+				Tr8n::GenderRule.transform(unknwon, "his", "her").should eq("his/her")
+				Tr8n::GenderRule.transform(unknwon, "he", "she", "he/she").should eq("he/she")
+			end
+		end
+	end	
+
+	describe 'instance methods'	do
+		describe 'evaluate rule' do
+			it 'should return results based on gender' do
+				male = mock("male")
+				male.stub!(:gender).and_return("male")
+				female = mock("male")
+				female.stub!(:gender).and_return("female")
+				unknwon = mock("unknwon")
+				unknwon.stub!(:gender).and_return("unknwon")
+
+				definition = {operator: "is", value: "male"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(male).should be_true
+				rule.evaluate(female).should be_false
+				rule.evaluate(unknwon).should be_false
+
+				definition = {operator: "is_not", value: "male"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(male).should be_false
+				rule.evaluate(female).should be_true
+				rule.evaluate(unknwon).should be_true
+
+				definition = {operator: "is", value: "female"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(male).should be_false
+				rule.evaluate(female).should be_true
+				rule.evaluate(unknwon).should be_false
+
+				definition = {operator: "is_not", value: "female"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(male).should be_true
+				rule.evaluate(female).should be_false
+				rule.evaluate(unknwon).should be_true
+			end
+		end
+
+		describe 'hashing a rule' do
+			it 'should produce a correct hash' do 
+				definition = {operator: "is", value: "male"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.to_hash.should eq({:type=>"gender", :operator=>"is", :value=>"male"})
+			end
+		end	
+
+		describe 'describing a rule' do
+			it 'should produce a correct description' do 
+				definition = {operator: "is", value: "male"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("is a male")
+
+				definition = {operator: "is", value: "unknown"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("has an unknown gender")
+
+				definition = {operator: "is_not", value: "female"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("is not a female")
+
+				definition = {operator: "is_not", value: "unknown"}
+				rule = Tr8n::GenderRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("does not have an unknown gender")
+			end
+		end
+
+	end	
+
+end

data/spec/models/tr8n/glossary_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::Glossary do
+	
+end

data/spec/models/tr8n/ip_location_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::IpLocation do
+	
+end

data/spec/models/tr8n/language_case_rule_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageCaseRule do
+	
+end

data/spec/models/tr8n/language_case_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageCase do
+	
+end

data/spec/models/tr8n/language_case_value_map_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageCaseValueMap do
+	
+end

data/spec/models/tr8n/language_forum_abuse_report_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageForumAbuseReport do
+	
+end

data/spec/models/tr8n/language_forum_message_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageForumMessage do
+	
+end

data/spec/models/tr8n/language_forum_topic_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageForumTopic do
+	
+end

data/spec/models/tr8n/language_metric_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageMetric do
+	
+end

data/spec/models/tr8n/language_rule_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageRule do
+	
+end

data/spec/models/tr8n/language_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::Language do
+  describe 'cache key' do
+    it 'shold use locale' do
+      lang = Tr8n::Language.find_or_create('test', 'Test Language')
+      lang.cache_key.should eq("language_test")
+    end
+  end
+
+  describe 'finding or creating a new language' do
+    context 'none existing language' do
+      it 'should not be found' do
+        lang = Tr8n::Language.for('test')
+        lang.should be_nil
+      end
+
+      it 'should be created' do
+        lang = Tr8n::Language.for('test')
+        lang.should be_nil
+        
+        lang = Tr8n::Language.find_or_create('test', 'Test Language')
+        lang.locale.should eql('test')
+        lang.english_name.should eql('Test Language')
+
+        lang = Tr8n::Language.for('test')
+        lang.should be_a(Tr8n::Language)
+        lang.english_name.should eql('Test Language')
+      end
+    end
+
+    context 'existing language' do
+      it 'should be found' do
+        Tr8n::Language.create(:locale => 'test123', :english_name => 'Test Language 123')
+        lang = Tr8n::Language.for('test123')
+        lang.should be_a(Tr8n::Language)
+        lang.english_name.should eql('Test Language 123')
+      end
+    end
+  end  
+
+  describe 'current language' do
+    before :all do 
+      @lang = Tr8n::Language.find_or_create('test', 'Test Language')
+      Tr8n::Config.init(@lang.locale)
+    end
+
+    after :all do 
+      @lang.destroy
+    end
+
+    it 'must be set' do
+      lang = Tr8n::Language.for('test')
+      lang.should be_a(Tr8n::Language)
+      lang.current?.should be_true
+    end
+  end
+
+  describe 'default language' do
+    before :all do 
+      @lang = Tr8n::Language.find_or_create('test', 'Test Language')
+      Tr8n::Config.init(@lang.locale)
+    end
+
+    after :all do 
+      @lang.destroy
+    end
+
+    it 'must be set' do
+      Tr8n::Config.stub(:default_locale).and_return(@lang.locale)
+      lang = Tr8n::Language.for('test')
+      lang.should be_a(Tr8n::Language)
+      lang.default?.should be_true
+    end
+  end
+
+
+
+end    

data/spec/models/tr8n/language_user_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::LanguageUser do
+	
+end

data/spec/models/tr8n/list_rule_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::ListRule do
+	
+end

data/spec/models/tr8n/monthly_language_metric_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::MonthlyLanguageMetric do
+	
+end

data/spec/models/tr8n/numeric_rule_spec.rb

@@ -0,0 +1,162 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe Tr8n::NumericRule do
+	before :all do 
+		@lang = Tr8n::Language.create(:locale => "elb", :english_name => "Elbonian")
+	end
+
+	after :all do 
+		@lang.destroy
+	end
+
+	describe 'class methods'	do
+		it 'should respec configuration settings' do
+			Tr8n::Config.stub!(:rules_engine).and_return({
+				:numeric_rule => {
+													token_suffixes: ["count", "num"],
+	      									object_method:   "to_i"
+	      								 } 
+			})
+
+			Tr8n::NumericRule.dependency.should eq("number")
+			Tr8n::NumericRule.suffixes.should eq(["count", "num"])
+			Tr8n::NumericRule.number_token_value(5).should eq(5)
+
+			obj = mock("numeric_object")
+			obj.should_receive(:to_i).and_return(42)
+			Tr8n::NumericRule.number_token_value(obj).should eq(42)
+		end
+
+		describe 'default transform without token value' do
+			it 'should return the pluralized form of the noun' do
+				Tr8n::NumericRule.default_transform("car", "cars").should eq("cars")
+				Tr8n::NumericRule.default_transform("car").should eq("cars")
+			end
+		end
+
+		describe 'transform with a token value' do
+			it 'should return the form based on the token value' do
+				Tr8n::NumericRule.transform(1, "person", "people").should eq("person")
+				Tr8n::NumericRule.transform(2, "person", "people").should eq("people")
+				Tr8n::NumericRule.transform(2, "car").should eq("cars")
+			end
+		end
+
+		describe 'sanitize values' do
+			it 'should strip values' do
+				Tr8n::NumericRule.sanitize_values("1,  2, 3 ,  4 ").should eq(["1","2","3","4"])
+				Tr8n::NumericRule.sanitize_values("1,2,3,4").should eq(["1","2","3","4"])
+			end
+		end
+
+		describe 'humanize values' do
+			it 'should strip values' do
+				Tr8n::NumericRule.humanize_values("1,  2, 3 ,  4 ").should eq("1, 2, 3, 4")
+				Tr8n::NumericRule.humanize_values("1,2,3,4").should eq("1, 2, 3, 4")
+			end
+		end
+
+		describe 'evaluating a rule fragment' do
+			it 'should return correct results' do 
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is, [5]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is, [2,3,5]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is, [4]).should be_false
+
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is_not, [4]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is_not, [4,2,3]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:is_not, [5]).should be_false
+
+				Tr8n::NumericRule.evaluate_rule_fragment(5,  	:ends_in, [5]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(25, 	:ends_in, [5]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(25, 	:ends_in, [2,3,4,5]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:ends_in, [2]).should be_false
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:ends_in, [2,3,4]).should be_false
+
+				Tr8n::NumericRule.evaluate_rule_fragment(5, 	:does_not_end_in, [2,3,4]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(25, 	:does_not_end_in, [2,4]).should be_true
+				Tr8n::NumericRule.evaluate_rule_fragment(25, 	:does_not_end_in, [2,5]).should be_false
+				Tr8n::NumericRule.evaluate_rule_fragment(25, 	:does_not_end_in, [5]).should be_false
+			end
+		end
+	end
+
+	describe 'instance methods' do
+		describe 'creating a rule' do
+			it 'should create a rule object' do 
+				definition = {multipart: false, part1: "is", value1: "1"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.should be_a(Tr8n::NumericRule)
+			end
+		end
+
+		describe 'evaluating a simple rule' do
+			it 'should return correct results' do 
+				definition = {multipart: false, part1: "is", value1: "1,2,3,4"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(5).should be_false
+				rule.evaluate(1).should be_true
+
+				definition = {multipart: false, part1: "is_not", value1: "2,3,4,5"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(5).should be_false
+				rule.evaluate(1).should be_true
+
+				definition = {multipart: false, part1: "ends_in", value1: "2,3,4,5"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(25).should be_true
+				rule.evaluate(1).should be_false
+
+				definition = {multipart: false, part1: "does_not_end_in", value1: "2,3,4,5"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(25).should be_false
+				rule.evaluate(1).should be_true
+			end
+		end
+
+		describe 'evaluating multipart rule' do
+			it 'should return correct results' do 
+				definition = {multipart: true, part1: "ends_in", value1: "1", operator: "and", part2: "does_not_end_in", value2: "11"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(1).should be_true
+				rule.evaluate(21).should be_true
+				rule.evaluate(231).should be_true
+				rule.evaluate(1021).should be_true
+				rule.evaluate(2).should be_false
+				rule.evaluate(11).should be_false
+				rule.evaluate(211).should be_false
+				rule.evaluate(1011).should be_false
+
+				definition = {multipart: true, part1: "ends_in", value1: "2,3,4", operator: "and", part2: "does_not_end_in", value2: "12,13,14"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.evaluate(2).should be_true
+				rule.evaluate(1023).should be_true
+				rule.evaluate(34).should be_true
+				rule.evaluate(1013).should be_false
+				rule.evaluate(14).should be_false
+			end
+		end
+
+		describe 'hashing a rule' do
+			it 'should produce a correct hash' do 
+				definition = {multipart: true, part1: "ends_in", value1: "2,3,4", operator: "and", part2: "does_not_end_in", value2: "12,13,14"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.to_hash.should eq({:type=>"number", :multipart=>true, :operator=>"and", :part1=>"ends_in",
+																:value1=>"2,3,4", :part2=>"does_not_end_in", :value2=>"12,13,14"})
+			end
+		end	
+
+		describe 'describing a rule' do
+			it 'should produce a correct description' do 
+				definition = {multipart: true, part1: "ends_in", value1: "2,3,4", operator: "and", part2: "does_not_end_in", value2: "12,13,14"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("ends in 2, 3, 4, but not in 12, 13, 14")
+
+				definition = {multipart: false, part1: "does_not_end_in", value1: "2,3,4,5"}
+				rule = Tr8n::NumericRule.create(:language => @lang, :definition => definition)
+				rule.description.should eq("does not end in 2, 3, 4, 5")
+			end
+		end
+
+	end
+
+end