tr8n 3.2.0 → 3.2.1

data/lib/tr8n/version.rb

@@ -23,5 +23,5 @@
 
 
 module Tr8n
-  VERSION = "3.2.0"
+  VERSION = "3.2.1"
 end

data/spec/models/tr8n/gender_rule_spec.rb

@@ -51,8 +51,8 @@ describe Tr8n::GenderRule do
 				male.stub!(:gender).and_return("male")
 				female = mock("male")
 				female.stub!(:gender).and_return("female")
-				unknwon = mock("unknwon")
-				unknwon.stub!(:gender).and_return("unknwon")
+				unknown = mock("unknown")
+				unknown.stub!(:gender).and_return("unknown")
 
 				Tr8n::GenderRule.transform(male, "registered on").should eq("registered on")
 				Tr8n::GenderRule.transform(male, "he", "she").should eq("he")
@@ -64,10 +64,10 @@ describe Tr8n::GenderRule do
 				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")
+				Tr8n::GenderRule.transform(unknown, "registered on").should eq("registered on")
+				Tr8n::GenderRule.transform(unknown, "he", "she").should eq("he/she")
+				Tr8n::GenderRule.transform(unknown, "his", "her").should eq("his/her")
+				Tr8n::GenderRule.transform(unknown, "he", "she", "he/she").should eq("he/she")
 			end
 		end
 	end	

data/spec/models/tr8n/language_case_rule_spec.rb

@@ -1,5 +1,223 @@
 require File.expand_path('../../spec_helper', File.dirname(__FILE__))
 
 describe Tr8n::LanguageCaseRule do
-	
+  describe "language case rule creation" do
+    before :all do
+      @user = User.create(:first_name => "Mike", :gender => "male")
+      @translator = Tr8n::Translator.create(:name => "Mike", :user => @user, :gender => "male")
+      @english = Tr8n::Language.create(:locale => "en-US", :english_name => "English")
+      @russian = Tr8n::Language.create(:locale => "ru", :english_name => "Russian")
+
+	    @lcase_en = Tr8n::LanguageCase.create(
+	      language:     @english,
+	      keyword:      "pos",
+	      latin_name:   "Possessive",
+	      native_name:  "Possessive", 
+	      description:  "Used to indicate possession (i.e., ownership). It is usually created by adding 's to the word", 
+	      application:  "phrase")
+
+	    @lcase_ru = Tr8n::LanguageCase.create(
+	      language:     @russian,
+	      keyword:      "pos",
+	      latin_name:   "Possessive",
+	      native_name:  "Possessive", 
+	      description:  "Used to indicate possession (i.e., ownership).", 
+	      application:  "words")
+    end
+
+    after :all do
+      [@user, @translator, @english, @russian, 
+      	@lcase_en, @lcase_ru].each do |obj|
+        obj.destroy
+       end       
+    end
+
+    describe "evaluating simple rules without genders" do
+      it "should result in correct substitution" do
+        lcrule = Tr8n::LanguageCaseRule.create(
+        		:language => @english,
+        		:language_case => @lcase_en,
+        		:definition => {
+        			part1: "ends_in", 
+        			value1: "s", 
+        			operation: "append", 
+        			operation_value: "'"
+        })
+
+        lcrule.should be_a(Tr8n::LanguageCaseRule)
+
+        lcrule.definition[:part1].should eq("ends_in")
+        lcrule.definition["part1"].should eq("ends_in")
+
+        lcrule.evaluate_part("Michael", 1).should be_false
+        lcrule.evaluate(nil, "Michael").should be_false
+
+        lcrule.evaluate_part("Anna", 1).should be_false
+        lcrule.evaluate(nil, "Anna").should be_false
+
+        lcrule.evaluate_part("friends", 1).should be_true
+        lcrule.evaluate(nil, "friends").should be_true
+        lcrule.apply("friends").should eq("friends'")
+
+
+        lcrule = Tr8n::LanguageCaseRule.create(
+        		:language => @english,
+        		:language_case => @lcase_en,
+        		:definition => {
+        			part1: "does_not_end_in", 
+        			value1: "s", operation: "append", 
+        			operation_value: "'s"
+        })
+
+        lcrule.evaluate(nil, "Michael").should be_true
+        lcrule.apply("Michael").should eq("Michael's")
+
+        lcrule.evaluate(nil, "Anna").should be_true
+        lcrule.apply("Anna").should eq("Anna's")
+
+        lcrule.evaluate(nil, "friends").should be_false
+
+        lcrule = Tr8n::LanguageCaseRule.create(
+        		:language => @english,
+        		:language_case => @lcase_en,
+        		:definition => {
+			        part1: "is",
+			        value1: "1",
+			        operation: "replace",
+			        operation_value: "first",
+        })
+
+        lcrule.evaluate(nil, "2").should be_false
+        lcrule.evaluate(nil, "1").should be_true
+        lcrule.apply("1").should eq("first")
+
+        lcrule = Tr8n::LanguageCaseRule.create(
+        		:language => @english,
+        		:language_case => @lcase_en,
+        		:definition => {
+			        part1: "ends_in",
+			        value1: "0,4,5,6,7,8,9,11,12,13",
+			        operation: "append",
+			        operation_value: "th",
+        })
+
+        lcrule.evaluate(nil, "4").should be_true
+        lcrule.apply("4").should eq("4th")
+
+        lcrule.evaluate(nil, "7").should be_true
+        lcrule.apply("7").should eq("7th")
+
+      end
+    end
+
+    describe "evaluating simple rules with genders" do
+      it "should result in correct substitution" do
+        lcrule1 = Tr8n::LanguageCaseRule.create(
+        		:language => @russian,
+        		:language_case => @lcase_ru,
+        		:definition => {
+        			gender: "female", 
+			        part1: "is",
+			        value1: "1",
+			        operation: "replace",
+			        operation_value: "pervaya",
+        })
+
+        lcrule2 = Tr8n::LanguageCaseRule.create(
+        		:language => @russian,
+        		:language_case => @lcase_ru,
+        		:definition => {
+        			gender: "male", 
+			        part1: "is",
+			        value1: "1",
+			        operation: "replace",
+			        operation_value: "pervii",
+        })
+
+        anna = mock("female")
+        anna.stub!(:to_s).and_return("Anna")
+        anna.stub!(:gender).and_return("female")
+
+        michael = mock("male")
+        michael.stub!(:to_s).and_return("Michael")
+        michael.stub!(:gender).and_return("male")
+
+        lcrule1.evaluate(michael, "1").should be_false
+        lcrule1.evaluate(anna, "1").should be_true
+        lcrule1.apply("1").should eq("pervaya")
+
+        lcrule2.evaluate(anna, "1").should be_false
+        lcrule2.evaluate(michael, "1").should be_true
+        lcrule2.apply("1").should eq("pervii")
+			end
+		end   
+
+    describe "applying rules" do
+    	describe "when using replace" do
+     	 	it "it should correctly replace values" do
+	        lcrule = Tr8n::LanguageCaseRule.create(
+	        		:language => @english,
+	        		:language_case => @lcase_ru,
+	        		:definition => {
+				        part1: "is",
+				        value1: "1",
+				        operation: "replace",
+				        operation_value: "1st",
+	        })
+
+	        lcrule.evaluate(nil, "1").should be_true
+        	lcrule.apply("1").should eq("1st")
+     	 	end
+      end
+
+    	describe "when using append" do
+     	 	it "it should correctly append values" do
+	        lcrule = Tr8n::LanguageCaseRule.create(
+	        		:language => @english,
+	        		:language_case => @lcase_ru,
+	        		:definition => {
+				        part1: "is",
+				        value1: "1",
+				        operation: "append",
+				        operation_value: "st",
+	        })
+
+	        lcrule.evaluate(nil, "1").should be_true
+	        lcrule.apply("1").should eq("1st")
+     	 	end
+      end
+
+    	describe "when using prepand" do
+     	 	it "it should correctly prepand values" do
+	        lcrule = Tr8n::LanguageCaseRule.create(
+	        		:language => @english,
+	        		:language_case => @lcase_ru,
+	        		:definition => {
+				        part1: "starts_with",
+				        value1: "q,w,r,t,p,s,d,f,g,j,k,h,l,z,x,c,v,b,n,m",
+				        operation: "prepand",
+				        operation_value: "a ",
+	        })
+
+	        lcrule.evaluate(nil, "car").should be_true
+	        lcrule.apply("car").should eq("a car")
+
+	        lcrule = Tr8n::LanguageCaseRule.create(
+	        		:language => @english,
+	        		:language_case => @lcase_ru,
+	        		:definition => {
+				        part1: "starts_with",
+				        value1: "e,u,i,o,a",
+				        operation: "prepand",
+				        operation_value: "an ",
+	        })
+
+	        lcrule.evaluate(nil, "apple").should be_true
+	        lcrule.apply("apple").should eq("an apple")
+     	 	end
+      end
+
+		end
+
+	end
 end

data/spec/models/tr8n/language_case_spec.rb

@@ -1,5 +1,55 @@
 require File.expand_path('../../spec_helper', File.dirname(__FILE__))
 
 describe Tr8n::LanguageCase do
-	
+  describe "language case creation" do
+    before :all do
+      @user = User.create(:first_name => "Mike", :gender => "male")
+      @translator = Tr8n::Translator.create!(:name => "Mike", :user => @user, :gender => "male")
+      @english = Tr8n::Language.create!(:locale => "en-US", :english_name => "English")
+      @russian = Tr8n::Language.create!(:locale => "ru", :english_name => "Russian")
+    end
+
+    after :all do
+      [@user, @translator, @english, @russian].each do |obj|
+        obj.destroy
+       end       
+    end
+
+    describe "registering cache key" do
+      it "should contain language and keyword" do
+        lcase = Tr8n::LanguageCase.create(
+          language:     @english,
+          keyword:      "pos",
+          latin_name:   "Possessive",
+          native_name:  "Possessive", 
+          description:  "Used to indicate possession (i.e., ownership). It is usually created by adding 's to the word", 
+          application:  "phrase")
+        
+        lcase.cache_key.should eq("language_case_en-US_pos")
+
+        Tr8n::LanguageCase.by_keyword("pos", @english).should eq(lcase)
+      end
+    end
+
+    describe "apply" do
+      it "should substitute the tokens with appropriate case" do
+        lcase = Tr8n::LanguageCase.create(
+          language:     @english,
+          keyword:      "pos",
+          latin_name:   "Possessive",
+          native_name:  "Possessive", 
+          description:  "Used to indicate possession (i.e., ownership). It is usually created by adding 's to the word", 
+          application:  "phrase")
+        
+        lcase.add_rule({multipart: false, gender: "none", part1: "ends_in", value1: "s", operation: "append", operation_value: "'"})
+        lcase.add_rule({multipart: false, gender: "none", part1: "does_not_end_in", value1: "s", operation: "append", operation_value: "'s"})
+
+        michael = mock("male")
+        michael.stub!(:to_s).and_return("Michael")
+        michael.stub!(:gender).and_return("male")
+
+        lcase.apply(michael, "Michael", {}).should eq("Michael's")
+      end
+    end
+  end
 end

data/spec/models/tr8n/translation_key_spec.rb

@@ -17,6 +17,13 @@ describe Tr8n::TranslationKey do
       Tr8n::Config.init(@english.locale, @translator)
     end
     
+    after :all do
+      [@user, @translator, @user2, @translator2, 
+       @english, @russian, @spanish].each do |obj|
+        obj.destroy
+       end       
+    end
+
     context "creating new translation key" do
       it "should create a unique hash" do
         key = Tr8n::TranslationKey.find_or_create("Hello World", "We must start with this sentence!")
@@ -62,6 +69,29 @@ describe Tr8n::TranslationKey do
         key.translate(@english, {:user => @user2}).should == "Anna updated her profile"
       end
     end
+  end
+
+  context "translations" do
+    before :all do 
+      @user = User.create(:first_name => "Mike", :gender => "male")
+      @translator = Tr8n::Translator.create!(:name => "Mike", :user => @user, :gender => "male")
+
+      @user2 = User.create(:first_name => "Anna", :gender => "female")
+      @translator2 = Tr8n::Translator.create!(:name => "Anna", :user => @user2, :gender => "female")
+
+      @english = Tr8n::Language.create!(:locale => "en-US", :english_name => "English")
+      @russian = Tr8n::Language.create!(:locale => "ru", :english_name => "Russian")
+      @spanish = Tr8n::Language.create!(:locale => "es", :english_name => "Spanish")      
+      
+      Tr8n::Config.init(@english.locale, @translator)
+    end
+    
+    after :all do
+      [@user, @translator, @user2, @translator2, 
+       @english, @russian, @spanish].each do |obj|
+        obj.destroy
+       end       
+    end
 
     describe "translating labels into a foreign language" do
       context "labels with no rules" do
@@ -112,6 +142,232 @@ describe Tr8n::TranslationKey do
           key.translate(@russian, {:count => 103}).should eq("U vas est 103 soobsheniya.")
         end
       end
+
+
+      context "labels with gender rules" do
+        it "should return correct translations" do
+
+          definition = {operator: "is", value: "male"}
+          rule1 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+
+          definition = {operator: "is", value: "female"}
+          rule2 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+
+          definition = {operator: "is", value: "unknown"}
+          rule3 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+
+          key = Tr8n::TranslationKey.find_or_create("{user| Born on:}")
+          key.add_translation("Rodilsya:", [{:token=>"user", :rule_id=>[rule1.id]}], @russian, @translator)
+          key.add_translation("Rodilas':", [{:token=>"user", :rule_id=>[rule2.id]}], @russian, @translator)
+          key.add_translation("Rodilsya/Rodilas':", [{:token=>"user", :rule_id=>[rule3.id]}], @russian, @translator)
+
+          male = mock("male")
+          male.stub!(:to_s).and_return("Michael")
+          male.stub!(:gender).and_return("male")
+          female = mock("female")
+          female.stub!(:to_s).and_return("Anna")
+          female.stub!(:gender).and_return("female")
+          unknown = mock("unknown")
+          unknown.stub!(:to_s).and_return("Alex")
+          unknown.stub!(:gender).and_return("unknown")
+
+          key.translate(@english, {:user => male}).should eq("Born on:")
+          key.translate(@english, {:user => female}).should eq("Born on:")
+
+          key.translate(@russian, {:user => male}).should eq("Rodilsya:")
+          key.translate(@russian, {:user => female}).should eq("Rodilas':")
+          key.translate(@russian, {:user => unknown}).should eq("Rodilsya/Rodilas':")
+
+          key = Tr8n::TranslationKey.find_or_create("{user} updated {user|his, her} profile.")
+          key.add_translation("{user} obnovil svoi profil'.", [{:token=>"user", :rule_id=>[rule1.id]}], @russian, @translator)
+          key.add_translation("{user} obnovila svoi profil'.", [{:token=>"user", :rule_id=>[rule2.id]}], @russian, @translator)
+          key.add_translation("{user} obnovil/obnovila svoi profil'.", [{:token=>"user", :rule_id=>[rule3.id]}], @russian, @translator)
+
+          key.translate(@english, {:user => male}).should eq("Michael updated his profile.")
+          key.translate(@english, {:user => female}).should eq("Anna updated her profile.")
+
+          key.translate(@russian, {:user => male}).should eq("Michael obnovil svoi profil'.")
+          key.translate(@russian, {:user => female}).should eq("Anna obnovila svoi profil'.")
+          key.translate(@russian, {:user => unknown}).should eq("Alex obnovil/obnovila svoi profil'.")
+        end
+      end      
+
+      context "labels with mixed rules and tokens" do
+        it "should return correct translations" do
+          definition = {operator: "is", value: "male"}
+          grule1 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+          definition = {operator: "is", value: "female"}
+          grule2 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+          definition = {operator: "is", value: "unknown"}
+          grule3 = Tr8n::GenderRule.create(:language => @russian, :definition => definition)
+
+          definition = {multipart: true, part1: "ends_in", value1: "1", operator: "and", part2: "does_not_end_in", value2: "11"}
+          nrule1 = Tr8n::NumericRule.create(:language => @russian, :definition => definition)
+          definition = {multipart: true, part1: "ends_in", value1: "2,3,4", operator: "and", part2: "does_not_end_in", value2: "12,13,14"}
+          nrule2 = Tr8n::NumericRule.create(:language => @russian, :definition => definition)
+          definition = {multipart: false, part1: "ends_in", value1: "0,5,6,7,8,9,11,12,13,14"}
+          nrule3 = Tr8n::NumericRule.create(:language => @russian, :definition => definition)
+
+          male = mock("male")
+          male.stub!(:to_s).and_return("Michael")
+          male.stub!(:gender).and_return("male")
+          female = mock("female")
+          female.stub!(:to_s).and_return("Anna")
+          female.stub!(:gender).and_return("female")
+          unknown = mock("unknown")
+          unknown.stub!(:to_s).and_return("Alex")
+          unknown.stub!(:gender).and_return("unknown")
+
+          key = Tr8n::TranslationKey.find_or_create("Dear {user}, you have [bold: {count||message}].")
+          key.add_translation("Dorogoi {user}, u vas est' [bold: {count} soobshenie].", [
+                {:token=>"user", :rule_id=>[grule1.id]}, {:token=>"count", :rule_id=>[nrule1.id]}
+          ], @russian, @translator)
+          key.add_translation("Dorogoi {user}, u vas est' [bold: {count} soobsheniya].", [
+                {:token=>"user", :rule_id=>[grule1.id]}, {:token=>"count", :rule_id=>[nrule2.id]}
+          ], @russian, @translator)
+          key.add_translation("Dorogoi {user}, u vas est' [bold: {count} soobshenii].", [
+                {:token=>"user", :rule_id=>[grule1.id]}, {:token=>"count", :rule_id=>[nrule3.id]}
+          ], @russian, @translator)
+          key.add_translation("Dorogaya {user}, u vas est' [bold: {count} soobshenie].", [
+                {:token=>"user", :rule_id=>[grule2.id]}, {:token=>"count", :rule_id=>[nrule1.id]}
+          ], @russian, @translator)
+          key.add_translation("Dorogaya {user}, u vas est' [bold: {count} soobsheniya].", [
+                {:token=>"user", :rule_id=>[grule2.id]}, {:token=>"count", :rule_id=>[nrule2.id]}
+          ], @russian, @translator)
+          key.add_translation("Dorogaya {user}, u vas est' [bold: {count} soobshenii].", [
+                {:token=>"user", :rule_id=>[grule2.id]}, {:token=>"count", :rule_id=>[nrule3.id]}
+          ], @russian, @translator)
+
+          key.translate(@english, {:user => male, :count => 1, :bold => "<b>{$0}</b>"}).should eq("Dear Michael, you have <b>1 message</b>.")
+          key.translate(@english, {:user => female, :count => 1, :bold => "<b>{$0}</b>"}).should eq("Dear Anna, you have <b>1 message</b>.")
+
+          key.translate(@english, {:user => male, :count => 5, :bold => "<b>{$0}</b>"}).should eq("Dear Michael, you have <b>5 messages</b>.")
+          key.translate(@english, {:user => female, :count => 5, :bold => "<b>{$0}</b>"}).should eq("Dear Anna, you have <b>5 messages</b>.")
+
+          key.translate(@russian, {:user => male, :count => 1, :bold => "<b>{$0}</b>"}).should eq("Dorogoi Michael, u vas est' <b>1 soobshenie</b>.")
+          key.translate(@russian, {:user => female, :count => 1, :bold => "<b>{$0}</b>"}).should eq("Dorogaya Anna, u vas est' <b>1 soobshenie</b>.")
+
+          key.translate(@russian, {:user => male, :count => 2, :bold => "<b>{$0}</b>"}).should eq("Dorogoi Michael, u vas est' <b>2 soobsheniya</b>.")
+          key.translate(@russian, {:user => female, :count => 2, :bold => "<b>{$0}</b>"}).should eq("Dorogaya Anna, u vas est' <b>2 soobsheniya</b>.")
+
+          key.translate(@russian, {:user => male, :count => 5, :bold => "<b>{$0}</b>"}).should eq("Dorogoi Michael, u vas est' <b>5 soobshenii</b>.")
+          key.translate(@russian, {:user => female, :count => 5, :bold => "<b>{$0}</b>"}).should eq("Dorogaya Anna, u vas est' <b>5 soobshenii</b>.")
+        end      
+      end
+
+      context "labels with languages cases" do
+        describe "when using a possesive case in English" do
+          it "should add s or ' at the end of the phrase" do
+            michael = mock("male")
+            michael.stub!(:to_s).and_return("Michael")
+            michael.stub!(:gender).and_return("male")
+            anna = mock("female")
+            anna.stub!(:to_s).and_return("Anna")
+            anna.stub!(:gender).and_return("female")
+
+            language_case = Tr8n::LanguageCase.create(:language => @english, 
+                          :translator => @translator, :keyword => "pos", 
+                          :latin_name => "Possessive", :application => "phrase")
+
+            language_case.add_rule({
+                                    part1: "ends_in", value1: "s", 
+                                    operation: "append", 
+                                    operation_value: "'"
+                                   }, :translator => @translator)
+            language_case.add_rule({
+                                    part1: "does_not_end_in", 
+                                    value1: "s", 
+                                    operation: "append", 
+                                    operation_value: "'s"
+                                    }, :translator => @translator)
+
+            key = Tr8n::TranslationKey.find_or_create("{actor} updated {target::pos} profile.")
+            key.translate(@english, {:actor => michael, :target => anna}).should eq("Michael updated Anna's profile.")
+          end
+        end
+
+        describe "when using a full ordinal case in English" do
+          it "should use first, second, or add th to the end of numbers" do
+            lcase = Tr8n::LanguageCase.create(
+                :language => @english, 
+                :translator => @translator, 
+                :keyword => "ord", 
+                :description => "The adjective form of the cardinal numbers",
+                :latin_name => "Ordinal", 
+                :application => "phrase"
+            )
+            lcase.add_rule({
+                part1:                "is",
+                value1:               "1",
+                operation:            "replace",
+                operation_value:      "first"
+            }, :translator => @translator)
+            lcase.add_rule({
+                part1:                "is",
+                value1:               "2",
+                operation:            "replace",
+                operation_value:      "second"
+            }, :translator => @translator)
+            lcase.add_rule({
+                part1:                "is",
+                value1:               "3",
+                operation:            "replace",
+                operation_value:      "third"
+            }, :translator => @translator)
+            lcase.add_rule({
+                multipart:            "true",
+                part1:                "ends_in",
+                value1:               "1",
+                operator:             "and",
+                part2:                "does_not_end_in",
+                value2:               "11",
+                operation:            "append",
+                operation_value:      "st"
+            }, :translator => @translator)
+            lcase.add_rule({
+                multipart:            "true",
+                part1:                "ends_in",
+                value1:               "2",
+                operator:             "and",
+                part2:                "does_not_end_in",
+                value2:               "12",
+                operation:            "append",
+                operation_value:      "nd"
+            }, :translator => @translator)
+            lcase.add_rule({
+                multipart:            "true",
+                part1:                "ends_in",
+                value1:               "3",
+                operator:             "and",
+                part2:                "does_not_end_in",
+                value2:               "13",
+                operation:            "append",
+                operation_value:      "rd"
+            }, :translator => @translator)
+            lcase.add_rule({
+                part1:                "ends_in",
+                value1:               "0,4,5,6,7,8,9,11,12,13",
+                operation:            "append",
+                operation_value:      "th"
+            }, :translator => @translator)
+
+            @english = Tr8n::Language.find(@english.id)
+
+            key = Tr8n::TranslationKey.find_or_create("This is your {count::ord} notice!")
+            key.translate(@english, {:count => 1}).should eq("This is your first notice!")
+            key.translate(@english, {:count => 2}).should eq("This is your second notice!")
+            key.translate(@english, {:count => 3}).should eq("This is your third notice!")
+            key.translate(@english, {:count => 4}).should eq("This is your 4th notice!")
+            key.translate(@english, {:count => 5}).should eq("This is your 5th notice!")
+            key.translate(@english, {:count => 12}).should eq("This is your 12th notice!")
+            key.translate(@english, {:count => 42}).should eq("This is your 42nd notice!")
+            key.translate(@english, {:count => 13}).should eq("This is your 13th notice!")
+            key.translate(@english, {:count => 23}).should eq("This is your 23rd notice!")
+          end
+         end 
+
+      end
+
     end
 
   end