i18n_backend_database_rails3 0.2.0

data/spec/i18n_ext_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe I18n do
+
+  describe "with default locale en" do
+    before(:each) do
+      I18n.default_locale = "en"
+    end
+
+    describe "and locale en" do
+      before(:each) do
+        I18n.locale = "en"
+      end
+
+      it "should return empty local segment" do
+        I18n.locale_segment.should == ''
+      end
+
+      it "should return empty local segment using alias" do
+        I18n.ls.should == ''
+      end
+    end
+
+    describe "and locale es" do
+      before(:each) do
+        I18n.locale = "es"
+      end
+
+      it "should return es local segment" do
+        I18n.locale_segment.should == '/es'
+      end
+
+      it "should return es local segment using alias" do
+        I18n.ls.should == '/es'
+      end
+    end
+
+  end
+
+end

data/spec/localize_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe I18n::Backend::Database do
+  before(:each) do
+    @backend = I18n::Backend::Database.new
+  end
+
+  after(:each) do
+    @backend.cache_store.clear
+  end
+
+  describe "with default locale en" do
+    before(:each) do
+      I18n.default_locale = "en"
+      if File.exists?('vendor/rails/activesupport/lib/active_support/locale/en.yml')
+        I18nUtil.load_from_yml 'vendor/rails/activesupport/lib/active_support/locale/en.yml'
+      else
+        activesupport_gem = Gem.cache.find_name('activesupport').sort_by { |g| g.version.version }.last
+        I18nUtil.load_from_yml "#{activesupport_gem.full_gem_path}/lib/active_support/locale/en.yml"
+      end
+    end
+
+    describe "and locale en" do
+      before(:each) do
+        I18n.locale = "en"
+      end
+
+      it "should localize dates in different formats" do
+        dates = {
+          Date.new(2009,1,1)   => {:default => "2009-01-01", :short => "Jan 01", :long => "January 01, 2009"},
+          Date.new(2009,1,31)  => {:default => "2009-01-31", :short => "Jan 31", :long => "January 31, 2009"},
+          Date.new(2009,2,2)   => {:default => "2009-02-02", :short => "Feb 02", :long => "February 02, 2009"},
+          Date.new(2009,2,28)  => {:default => "2009-02-28", :short => "Feb 28", :long => "February 28, 2009"},
+          Date.new(2008,2,29)  => {:default => "2008-02-29", :short => "Feb 29", :long => "February 29, 2008"},
+          Date.new(2009,3,11)  => {:default => "2009-03-11", :short => "Mar 11", :long => "March 11, 2009"},
+          Date.new(2010,4,30)  => {:default => "2010-04-30", :short => "Apr 30", :long => "April 30, 2010"},
+          Date.new(2020,12,31) => {:default => "2020-12-31", :short => "Dec 31", :long => "December 31, 2020"}
+        }
+
+        dates.each do |date, formats|
+          formats.each do |format, expected_value|
+            @backend.localize("en", date, format).should == expected_value
+          end
+        end
+      end
+
+      it "should localize times in different formats" do
+        time = DateTime.new(y=2008,m=3,d=22,h=16,min=30,s=12)
+
+        @backend.localize("en", time, :default).should == "Sat, 22 Mar 2008 16:30:12 +0000"
+        @backend.localize("en", time, :short).should == "22 Mar 16:30"
+        @backend.localize("en", time, :long).should == "March 22, 2008 16:30"
+        @backend.localize("en", time, '%B %d, %Y %H:%M %p').should == "March 22, 2008 16:30 pm"
+      end
+
+    end
+
+    describe "and locale es" do
+      before(:each) do
+        I18n.locale = "es"
+        @spanish_locale = Locale.create!(:code => 'es')
+      end
+
+    end
+  end
+end

data/spec/localize_text_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe I18n::Backend::Database do
+  before(:each) do
+    @backend = I18n::Backend::Database.new
+  end
+
+  after(:each) do
+    @backend.cache_store.clear
+  end
+
+  describe "with default locale en" do
+    before(:each) do
+      I18n.default_locale = "en"
+      @english_locale = Locale.create!(:code => "en")
+    end
+
+    describe "and locale en" do
+      before(:each) do
+        I18n.locale = "en"
+      end
+
+      it "should localize tagged text" do
+        @backend.localize_text("en", "shane ^^is now friends with^^ dylan").should == "shane is now friends with dylan"
+      end
+
+      it "should localize text tagged more than once" do
+        @backend.localize_text("en", "dylan ^^is now friends with^^ shane ^^and is happy, ^^dylan ^^claps his hands!^^").should == "dylan is now friends with shane and is happy, dylan claps his hands!"
+      end
+
+      it "should localize tagged text using class method" do
+        I18n.localize_text("shane ^^is now friends with^^ dylan").should == "shane is now friends with dylan"
+      end
+
+      it "should localize tagged text using class method alias" do
+        I18n.lt("shane ^^is now friends with^^ dylan").should == "shane is now friends with dylan"
+      end
+
+      it "should add localize text tags" do
+        I18n.tag_localized_text("is now friends with").should == "^^is now friends with^^"
+      end
+
+      it "should add localize text tags using alias" do
+        I18n.tlt("is now friends with").should == "^^is now friends with^^"
+      end
+
+      it "should just return text with no localize text tags" do
+        @backend.localize_text("en", "shane is now friends with dylan").should == "shane is now friends with dylan"
+      end
+
+      it "should localize tagged text using custom localize text tag" do
+        @backend.localize_text_tag = "##"
+        @backend.localize_text("en", "shane ##is now friends with## dylan").should == "shane is now friends with dylan"
+      end
+
+      it "should localize tagged text using another custom localize text tag" do
+        @backend.localize_text_tag = "LOCALIZED_TEXT_TAG"
+        @backend.localize_text("en", "shane LOCALIZED_TEXT_TAGis now friends withLOCALIZED_TEXT_TAG dylan").should == "shane is now friends with dylan"
+      end
+
+    end
+
+    describe "and locale es" do
+      before(:each) do
+        I18n.locale = "es"
+        @spanish_locale = Locale.create!(:code => 'es')
+      end
+
+      it "should localize tagged text" do
+        @spanish_locale.translations.create!(:key => 'is now friends with', :value => 'ahora es con amigos')
+        @backend.localize_text("es", "shane ^^is now friends with^^ dylan").should == "shane ahora es con amigos dylan"
+      end
+
+    end
+  end
+end

data/spec/models/locale_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Locale do
+  before(:each) do
+    @valid_attributes = {
+      :code => "en",
+      :name => "English"
+    }
+  end
+
+  it "should create a new instance given valid attributes" do
+    Locale.create!(@valid_attributes)
+  end
+
+  it "should return code as to_param" do
+    Locale.new(@valid_attributes).to_param.should == 'en'
+  end
+
+  it "should be invalid with no code" do
+    Locale.create!(:code => "en")
+    locale = Locale.new
+    locale.should_not be_valid
+  end
+end
+
+
+describe "English and Spanish Locales with I18n default locale set to English" do
+  before(:each) do
+    I18n.default_locale = "en"
+    @english_locale = Locale.create!(:code => "en")
+    @spanish_locale = Locale.create!(:code => "es")
+  end
+
+  it "should create a translated translation using english locale" do
+    translation = @english_locale.create_translation('Hello World', 'Hello World')
+    translation.key.should == Translation.hk('Hello World')
+    translation.value.should == 'Hello World'
+  end
+
+  it "should create an untranslated translation using spanish locale" do
+    translation = @spanish_locale.create_translation('Hello World', 'Hello World')
+    translation.key.should == Translation.hk('Hello World')
+    translation.value.should be_nil
+  end
+
+  it "should return default locale of English" do
+    Locale.default_locale.should == @english_locale
+  end
+
+  it "should return list of non-default locales" do
+    @geek_locale = Locale.create!(:code => "gk")
+    Locale.non_defaults.should include(@spanish_locale)
+    Locale.non_defaults.should include(@geek_locale)
+    Locale.non_defaults.should_not include(@english_locale)
+  end
+
+  it "should know that the english_locale is the default" do
+    @english_locale.should be_default_locale
+  end
+
+  it "should know if it has a translation record" do
+    translation = @english_locale.create_translation('key', 'Hello World')
+    @english_locale.should have_translation('key')
+  end
+
+  it "should have 0 translations" do
+    @spanish_locale.should have(0).translations
+  end
+
+  it "should have 0 untranslated" do
+    @spanish_locale.translations.untranslated.should have(0).records
+  end
+
+  it "should have 0 translated" do
+    @spanish_locale.translations.translated.should have(0).records
+  end
+
+  it "should have 100% translated" do
+    @spanish_locale.percentage_translated.should == 100
+  end
+
+end
+
+describe "Locale with translations" do
+  before(:each) do
+    I18n.default_locale = "en"
+    @english_locale = Locale.create!(:code => "en")
+    @spanish_locale = Locale.create!(:code => "es")
+
+    @spanish_locale.translations.create!(:key => 'key1', :value => 'translated1')
+    @spanish_locale.translations.create!(:key => 'key2', :value => 'translated2')
+    @spanish_locale.translations.create!(:key => 'key3', :value =>  nil) # 1 untranslated record
+  end
+
+  it "should have 3 translations" do
+    @spanish_locale.should have(3).translations
+  end
+
+  it "should have 1 untranslated" do
+    @spanish_locale.translations.untranslated.should have(1).records
+  end
+
+  it "should have 2 translated" do
+    @spanish_locale.translations.translated.should have(2).records
+  end
+
+  it "should have 67% translated" do
+    @spanish_locale.percentage_translated.should == 67
+  end
+
+end

data/spec/models/translation_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Translation do
+  before(:each) do
+    @valid_attributes = {
+      :key   => "Hello World",
+      :value => "Hello World"
+    }
+  end
+
+  it "should create a new instance given valid attributes" do
+    Translation.create!(@valid_attributes)
+  end
+end
+
+describe "English and Spanish Locales with I18n default locale set to English" do
+  before(:each) do
+    I18n.default_locale = "en"
+    @english_locale = Locale.create!(:code => "en")
+    @spanish_locale = Locale.create!(:code => "es")
+  end
+
+  describe "with no English translation" do
+    it "should have return 'No default locale value' for a new Spanish translation with same key" do
+      @spanish_translation = @spanish_locale.translations.create(:key => 'Hello World')
+      @spanish_translation.default_locale_value.should == 'No default locale value' 
+    end
+  end
+
+  describe "with one English translation" do
+    before(:each) do
+      @english_translation = @english_locale.translations.create(:key => 'Hello World', :value => 'Hello World')
+    end
+
+    it "should have a default locale value" do
+      @english_translation.default_locale_value.should == 'Hello World'  
+    end
+
+    it "should have a default locale value of the English for a new Spanish translation with same key" do
+      @spanish_translation = @spanish_locale.translations.create(:key => 'Hello World')
+      @spanish_translation.default_locale_value.should == 'Hello World'  
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+ENV["RAILS_ENV"] = "test"
+require File.join(File.dirname(__FILE__), "/../../../../config/environment")
+require 'spec/rails'
+require 'i18n_backend_database'
+
+Spec::Runner.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+
+  config.after(:each) do
+    Locale.reset_default_locale
+    I18n.locale = "en"
+    I18n.default_locale = "en"
+    I18n.backend.cache_store.clear
+  end
+end

data/spec/translate_asset_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe I18n do
+
+  describe "with default locale en" do
+    before(:each) do
+      I18n.default_locale = "en"
+      ActionView::Helpers::AssetTagHelper.send(:remove_const, :ASSETS_DIR)
+      ActionView::Helpers::AssetTagHelper::ASSETS_DIR = "#{RAILS_ROOT}/vendor/plugins/i18n_backend_database/spec/assets/public"
+      I18n.send(:remove_const, :APP_DIRECTORY)
+      I18n::APP_DIRECTORY = "./vendor/plugins/i18n_backend_database/spec/assets"
+    end
+
+    it "should find my test views" do
+      I18n.asset_translations.should == ["promo/sfc08_140x400_3.gif", "image1.gif", "image2.gif", "icons/icon1.gif", "icons/icon2.gif", 
+                                         "/favicons/favicon1.gif", "/favicons/favicon2.gif"] 
+    end
+
+    it "should return no untranslated assets" do
+      I18n.untranslated_assets(:en).should be_empty
+    end
+
+    it "should return untranslated assets" do
+      I18n.untranslated_assets(:es).should == ["promo/sfc08_140x400_3.gif", "image2.gif", "icons/icon2.gif", "/favicons/favicon2.gif"]
+    end
+
+    describe "and locale en" do
+      before(:each) do
+        I18n.locale = "en"
+      end
+
+      it "should return default asset path" do
+        I18n.ta("image.gif").should == 'image.gif'
+      end
+
+      it "should return translated asset path for locale passed" do
+       I18n.ta("image1.gif", :locale => :es).should == '/es/images/image1.gif'
+      end
+    end
+
+    describe "and locale es" do
+      before(:each) do
+        I18n.locale = "es"
+      end
+
+      it "should return default asset path if no translated asset exists" do
+       I18n.ta("image2.gif").should == 'image2.gif'
+      end
+
+      it "should return translated asset path if translatied asset exists" do
+       I18n.ta("image1.gif").should == '/es/images/image1.gif'
+      end
+    end
+
+  end
+
+end

data/spec/translate_spec.rb

@@ -0,0 +1,546 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class MemoryStoreProxy < ActiveSupport::Cache::MemoryStore
+  attr_accessor :write_count
+
+  def initialize
+    @write_count = 0
+    super
+  end
+
+  def write(key, value, options = nil)
+    super(key, value, options)
+    @write_count += 1
+  end
+end
+
+describe I18n::Backend::Database do
+  before(:each) do
+    @backend = I18n::Backend::Database.new
+  end
+
+  after(:each) do
+    @backend.cache_store.clear
+  end
+
+  describe "returning hashes for non-leaves" do
+    before do
+      #Set up a translation hierarchy
+      @locale = Locale.create!(:code => "en")
+      I18n.default_locale = "en"
+    end
+
+    it "should return a hash when asked for a non-leaf node" do
+      format_hash = {:separator => ".", :precision => 3, :delimiter => ","}
+      @locale.translations.create!(:key => "number.format.separator", :value => format_hash[:separator])
+      @locale.translations.create!(:key => "number.format.precision", :value => format_hash[:precision])
+      @locale.translations.create!(:key => "number.format.delimiter", :value => format_hash[:delimiter])
+      @backend.translate("en", "number.format").should == format_hash
+    end
+
+    it "should return a nested hash" do
+      nested_hash = {:a => "b", :c => {:d => "e", :f => "g"}}
+      @locale.translations.create!(:key => "nested.a", :value => "b")
+      @locale.translations.create!(:key => "nested.c.d", :value => "e")
+      @locale.translations.create!(:key => "nested.c.f", :value => "g")
+      @backend.translate("en", "nested").should == nested_hash
+    end
+
+    it "should not be fooled by SQL injection" do
+      #for bad_string in ["number.format%", "number.format\%", "number.format\\"] do
+      for bad_string in ["number.format\\"] do
+        @backend.translate("en", bad_string).should == bad_string
+      end
+    end
+
+    it "should not be fooled by keys ending in a delimiter" do
+      @locale.translations.create!(:key => "number.format.", :value => 'this should be a normal leaf')
+      @backend.translate('en', 'number.format.').should == 'this should be a normal leaf'
+    end
+
+  end
+
+  describe "with default locale en" do
+    before(:each) do
+      I18n.default_locale = "en"
+      @english_locale = Locale.create!(:code => "en")
+    end
+
+    describe "and locale en" do
+      before(:each) do
+        I18n.locale = "en"
+      end
+
+      it "should create a record with the key as the value when the key is a string" do
+        @backend.translate("en", "String").should == "String"
+        @english_locale.should have(1).translation
+        @english_locale.translations.first.key.should == Translation.hk("String")
+        @english_locale.translations.first.raw_key.should == "String"
+        @english_locale.translations.first.value.should == "String"
+      end
+
+      it "should not write to the cache if the key already exists in the cache" do
+        @backend.cache_store = MemoryStoreProxy.new
+        @english_locale.translations.create!(:key => 'String', :value => 'Value')
+
+        @backend.translate("en", "String").should == "Value"
+        @backend.cache_store.write_count.should == 1
+
+        @backend.translate("en", "String").should == "Value"
+        @backend.cache_store.write_count.should == 1
+      end
+
+      it "should create a record with the key as the value when the key is a string and cache that record" do
+        @backend.translate("en", "status").should == "status"
+        @english_locale.should have(1).translation
+
+        # once cached
+        @backend.translate("en", "status").should == "status"
+        @english_locale.should have(1).translation
+      end
+
+      it "should find a record with the key as the value when the key is a string" do
+        @english_locale.translations.create!(:key => 'String', :value => 'Value')
+        @backend.translate("en", "String").should == "Value"
+        @english_locale.should have(1).translation
+      end
+
+      it "should support having a record with a nil value" do
+        @english_locale.translations.create!(:key => 'date.order')
+        @backend.translate("en", :'date.order').should be_nil
+        @english_locale.should have(1).translation
+      end
+
+      it "should create a record with a nil value when key is a symbol" do
+        @backend.translate("en", :'date.order').should be_nil
+        @english_locale.should have(1).translation
+        @english_locale.translations.first.key.should == Translation.hk('date.order')
+        @english_locale.translations.first.raw_key.should == "date.order"
+        @english_locale.translations.first.value.should be_nil
+
+        # once cached
+        @backend.translate("en", :'date.order').should be_nil
+        @english_locale.reload.should have(1).translation
+      end
+
+      it "should support storing values as YAML symbols" do
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :year\n",  :pluralization_index => 0)
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :month\n", :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :day\n",   :pluralization_index => 2)
+
+        @backend.translate("en", :'date.order').should == [:year, :month, :day]
+        @english_locale.should have(3).translations
+      end
+
+      it "should find a cached record from a cache key if it exists in the cache" do
+        hash_key = Translation.hk("blah")
+        @backend.cache_store.write("en:#{hash_key}", 'woot')
+        @backend.translate("en", "blah").should == "woot"
+      end
+
+      it "should find a cached record with a nil value from a cache key if it exists in the cache" do
+        hash_key = Translation.hk(".date.order")
+        @backend.cache_store.write("en:#{hash_key}", nil)
+        @backend.translate("en", :'date.order').should be_nil
+      end
+
+      it "should write a cache record to the cache for a newly created translation record" do
+        hash_key = Translation.hk("blah")
+        @backend.translate("en", "blah")
+        @backend.cache_store.read("en:#{hash_key}").should == "blah"
+      end
+
+      it "should write a cache record to the cache for translation record with nil value" do
+        @english_locale.translations.create!(:key => '.date.order')
+        @backend.translate("en", :'date.order').should be_nil
+
+        hash_key = Translation.hk(".date.order")
+        @backend.cache_store.read("en:#{hash_key}").should be_nil
+      end
+
+      it "should handle active record helper defaults, where default is the object name" do
+        options = {:count=>1, :scope=>[:activerecord, :models], :default=>"post"}
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.blank', :value => 'post')
+        @backend.translate("en", :"models.blank", options).should == 'post'
+      end
+
+      it "should handle translating defaults used by active record attributes" do
+        options = {:scope=>[:activerecord, :attributes], :count=>1, :default=>["Content"]}
+        @backend.translate("en", :"post.content", options).should == 'Content'
+
+        # and when cached
+        options = {:scope=>[:activerecord, :attributes], :count=>1, :default=>["Content"]}
+        @backend.translate("en", :"post.content", options).should == 'Content'
+        @english_locale.should have(1).translation
+      end
+
+      it "should handle translating defaults used by active record attributes when the default is blank" do
+        options = { :count=>1, :default=> " "}
+        @backend.translate("en", "key", options).should == " "
+
+        # and when cached
+        options = { :count=>1, :default=> " "}
+        @backend.translate("en", "key", options).should ==  " "
+        @english_locale.should have(1).translation
+      end
+
+      it "should be able to handle interpolated values" do
+        options = {:some_value => 'INTERPOLATED'}
+        @english_locale.translations.create!(:key => 'Fred', :value => 'Fred has been {{some_value}}!!')
+        @backend.translate("en", 'Fred', options).should == 'Fred has been INTERPOLATED!!'
+      end
+
+      it "should be able to handle interpolated values with 'Fred {{some_value}}' also as the key" do
+        options = {:some_value => 'INTERPOLATED'}
+        @english_locale.translations.create!(:key => 'Fred {{some_value}}', :value => 'Fred {{some_value}}!!')
+        @backend.translate("en", 'Fred {{some_value}}', options).should == 'Fred INTERPOLATED!!'
+      end
+
+      it "should be able to handle interpolated count values" do
+        options = {:count=>1, :model => ["Cheese"], :scope=>[:activerecord, :errors], :default=>["Locale"]}
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => '{{count}} errors prohibited this {{model}} from being saved')
+        @backend.translate("en", :"messages.blank", options).should == '1 errors prohibited this Cheese from being saved'
+      end
+
+      it "should be able to handle the case of scope being passed in as something other than an array" do
+        options = {:count=>1, :model => ["Cheese"], :scope=> :activerecord, :default=>["Locale"]}
+        @english_locale.translations.create!(:key => 'activerecord.messages.blank', :value => 'dude')
+        @backend.translate("en", :"messages.blank", options).should == 'dude'
+      end
+
+      it "should be able to handle pluralization" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.template.header', :value => '1 error prohibited this {{model}} from being saved', :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'activerecord.errors.template.header', :value => '{{count}} errors prohibited this {{model}} from being saved', :pluralization_index => 0)
+
+        options = {:count=>1, :model=>"translation", :scope=>[:activerecord, :errors, :template]}
+        @backend.translate("en", :"header", options).should == "1 error prohibited this translation from being saved"
+        @english_locale.should have(2).translations
+
+        options = {:count=>2, :model=>"translation", :scope=>[:activerecord, :errors, :template]}
+        @backend.translate("en", :"header", options).should == "2 errors prohibited this translation from being saved"
+        @english_locale.should have(2).translations
+      end
+
+      it "should find lowest level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "is blank moron!"
+      end
+
+      it "should find higher level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.blank', :value => 'translation blank')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "translation blank"
+      end
+
+      it "should find highest level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.blank', :value => 'translation blank')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.attributes.locale.blank', :value => 'translation locale blank')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "translation locale blank"
+      end
+
+      it "should create the translation for custom message" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", "This is a custom message!", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "This is a custom message!"
+        @english_locale.should have(2).translations
+        @english_locale.translations.find_by_key(Translation.hk("This is a custom message!")).value.should == 'This is a custom message!'
+      end
+
+      it "should find the translation for custom message" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'This is a custom message!', :value => 'This is a custom message!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", "This is a custom message!", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "This is a custom message!"
+      end
+
+      it "should NOT find the translation for custom message" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'This is a custom message!', :value => 'This is a custom message!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("en", :"models.translation.attributes.locale.blank", options).should == "is blank moron!"
+      end
+
+      it "should return an array" do
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'January',  :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'February', :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'March',    :pluralization_index => 3)
+        @backend.translate("en", :"date.month_names").should == [nil, 'January', 'February', 'March']
+
+        # once cached
+        @backend.translate("en", :"date.month_names").should == [nil, 'January', 'February', 'March']
+        @english_locale.reload.should have(3).translation
+      end
+
+      it "should return an unfrozen array" do
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'January',  :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'February', :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'March',    :pluralization_index => 3)
+        @backend.translate("en", :"date.month_names").should_not be_frozen
+
+        # once cached
+        @backend.translate("en", :"date.month_names").should_not be_frozen
+      end
+
+      it "should return an array of days" do
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Sunday',    :pluralization_index => 0)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Monday',    :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Tuesday',   :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Wednesday', :pluralization_index => 3)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Thursday',  :pluralization_index => 4)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Friday',    :pluralization_index => 5)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Saturday',  :pluralization_index => 6)
+
+        # once cached
+        @backend.translate("en", :"date.day_names").should == ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+        @english_locale.reload.should have(7).translation
+      end
+
+    end
+
+    describe "and locale es" do
+      before(:each) do
+        I18n.locale = "es"
+        @spanish_locale = Locale.create!(:code => 'es')
+      end
+
+      it "should create a record with a nil value when the key is a string" do
+        @backend.translate("es", "String").should == "String"
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("String")
+        @spanish_locale.translations.first.value.should be_nil
+      end
+
+      it "should not write to the cache if the key already exists in the cache" do
+        @backend.cache_store = MemoryStoreProxy.new
+        @english_locale.translations.create!(:key => 'Message Center', :value => 'Message Center')
+        @spanish_locale.translations.create!(:key => 'Message Center', :value => nil)
+
+        @backend.translate("es", "Message Center").should == "Message Center"
+        @backend.cache_store.write_count.should == 1
+
+        @backend.translate("es", "Message Center").should == "Message Center"
+        @backend.cache_store.write_count.should == 1
+      end
+
+      it "should handle basic workflow" do
+        @english_locale.translations.create!(:key => 'Message Center', :value => 'Message Center')
+        @spanish_locale.translations.create!(:key => 'Message Center', :value => nil)
+
+        @backend.translate("en", "Message Center").should == "Message Center"
+
+        @english_locale.should have(1).translation
+        @english_locale.translations.first.key.should == Translation.hk("Message Center")
+        @english_locale.translations.first.raw_key.should == "Message Center"
+        @english_locale.translations.first.value.should == "Message Center"
+
+        @backend.translate("es", "Message Center").should == "Message Center"
+
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("Message Center")
+        @spanish_locale.translations.first.value.should be_nil
+        
+        @backend.translate("es", "Message Center").should == "Message Center"
+        @spanish_locale.should have(1).translation
+      end
+
+      it "should return default locale (en) value and create the spanish record" do
+        @english_locale.translations.create!(:key => 'String', :value => 'English String')
+        @backend.translate("es", "String").should == "English String"
+        @spanish_locale.should have(1).translation
+      end
+
+      it "should return just the passed in value when no translated record and no default translation" do
+        @backend.translate("es", "String").should == "String" 
+        @spanish_locale.should have(1).translation
+      end
+
+      it "should support having a default locale record with a nil value" do
+        @english_locale.translations.create!(:key => 'date.order')
+        @backend.translate("es", :'date.order').should be_nil
+
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk('date.order')
+        @spanish_locale.translations.first.value.should be_nil
+      end
+
+      it "should be able to handle interpolated values" do
+        options = {:some_value => 'INTERPOLATED'}
+        @english_locale.translations.create!(:key => 'Fred', :value => 'Fred has been {{some_value}}!!')
+        @spanish_locale.translations.create!(:key => 'Fred', :value => 'Fred ha sido {{some_value}}!!')
+        @backend.translate("es", 'Fred', options).should == 'Fred ha sido INTERPOLATED!!'
+      end
+
+      it "should be able to handle interpolated count values" do
+        options = {:count=>1, :model => ["Cheese"], :scope=>[:activerecord, :errors], :default=>["Locale"]}
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => '{{count}} error prohibited this {{model}} from being saved')
+        @backend.translate("es", :"messages.blank", options).should == '1 error prohibited this Cheese from being saved'
+      end
+
+      it "should be able to handle pluralization" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.template.header', :value => '1 error prohibited this {{model}} from being saved', :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'activerecord.errors.template.header', :value => '{{count}} errors prohibited this {{model}} from being saved', :pluralization_index => 0)
+        options = {:count=>1, :model=>"translation", :scope=>[:activerecord, :errors, :template]}
+        @backend.translate("es", :"header", options).should == "1 error prohibited this translation from being saved"
+        @spanish_locale.should have(2).translations
+
+        options = {:count=>2, :model=>"translation", :scope=>[:activerecord, :errors, :template]}
+        @backend.translate("es", :"header", options).should == "2 errors prohibited this translation from being saved"
+        @spanish_locale.reload.should have(2).translations
+      end
+
+      it "should find lowest level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("es", :"models.translation.attributes.locale.blank", options).should == "is blank moron!"
+
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("activerecord.errors.messages.blank")
+        @spanish_locale.translations.first.value.should be_nil
+      end
+
+      it "should find higher level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.blank', :value => 'translation blank')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("es", :"models.translation.attributes.locale.blank", options).should == "translation blank"
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("activerecord.errors.models.translation.blank")
+        @spanish_locale.translations.first.value.should be_nil
+        @backend.cache_store.read("es:activerecord.errors.models.translation.blank", "translation blank")
+      end
+
+      it "should find highest level translation" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.blank', :value => 'translation blank')
+        @english_locale.translations.create!(:key => 'activerecord.errors.models.translation.attributes.locale.blank', :value => 'translation locale blank')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("es", :"models.translation.attributes.locale.blank", options).should == "translation locale blank"
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("activerecord.errors.models.translation.attributes.locale.blank")
+        @spanish_locale.translations.first.value.should be_nil
+      end
+
+      it "should find the translation for custom message" do
+        @english_locale.translations.create!(:key => 'activerecord.errors.messages.blank', :value => 'is blank moron!')
+        @english_locale.translations.create!(:key => 'This is a custom message!', :value => 'This is a custom message!')
+
+        options = {:attribute=>"Locale", :value=>nil, 
+          :scope=>[:activerecord, :errors], :default=>[:"models.translation.blank", "This is a custom message!", :"messages.blank"], :model=>"Translation"}
+
+        @backend.translate("es", :"models.translation.attributes.locale.blank", options).should == "This is a custom message!"
+        @spanish_locale.should have(1).translation
+        @spanish_locale.translations.first.key.should == Translation.hk("This is a custom message!")
+        @spanish_locale.translations.first.value.should be_nil
+      end
+
+      it "should return an array from spanish locale" do
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'January',  :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'February', :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'March',    :pluralization_index => 3)
+        @spanish_locale.translations.create!(:key => 'date.month_names', :value => 'Enero',    :pluralization_index => 1)
+        @spanish_locale.translations.create!(:key => 'date.month_names', :value => 'Febrero',  :pluralization_index => 2)
+        @spanish_locale.translations.create!(:key => 'date.month_names', :value => 'Marzo',    :pluralization_index => 3)
+
+        @backend.translate("es", :"date.month_names").should == [nil, 'Enero', 'Febrero', 'Marzo']
+
+        # once cached
+        @backend.translate("es", :"date.month_names").should == [nil, 'Enero', 'Febrero', 'Marzo']
+        @english_locale.reload.should have(3).translation
+        @spanish_locale.reload.should have(3).translation
+      end
+
+      it "should return an array from default locale" do
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'January',  :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'February', :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.month_names', :value => 'March',    :pluralization_index => 3)
+        @backend.translate("es", :"date.month_names").should == [nil, 'January', 'February', 'March']
+
+        # once cached
+        @backend.translate("es", :"date.month_names").should == [nil, 'January', 'February', 'March']
+        @english_locale.reload.should have(3).translation
+        @spanish_locale.reload.should have(3).translation
+      end
+
+      it "should return an array of days" do
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Sunday',    :pluralization_index => 0)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Monday',    :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Tuesday',   :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Wednesday', :pluralization_index => 3)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Thursday',  :pluralization_index => 4)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Friday',    :pluralization_index => 5)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Saturday',  :pluralization_index => 6)
+        @backend.translate("es", :"date.day_names").should == ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+
+        # once cached
+        @backend.translate("es", :"date.day_names").should == ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+        @english_locale.reload.should have(7).translation
+        @spanish_locale.reload.should have(7).translation
+      end
+
+      it "should return an array of days" do
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Sunday',    :pluralization_index => 0)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Monday',    :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Tuesday',   :pluralization_index => 2)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Wednesday', :pluralization_index => 3)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Thursday',  :pluralization_index => 4)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Friday',    :pluralization_index => 5)
+        @english_locale.translations.create!(:key => 'date.day_names', :value => 'Saturday',  :pluralization_index => 6)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 0)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 1)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 2)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 3)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 4)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 5)
+        @spanish_locale.translations.create!(:key => 'date.day_names', :value => nil,         :pluralization_index => 6)
+        @backend.translate("es", :"date.day_names").should == ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+
+        # once cached
+        @backend.translate("es", :"date.day_names").should == ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+        @english_locale.reload.should have(7).translation
+        @spanish_locale.reload.should have(7).translation
+      end
+
+      it "should support storing values as YAML symbols" do
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :year\n",  :pluralization_index => 0)
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :month\n", :pluralization_index => 1)
+        @english_locale.translations.create!(:key => 'date.order', :value => "--- :day\n",   :pluralization_index => 2)
+
+        @backend.translate("es", :'date.order').should == [:year, :month, :day]
+        @english_locale.should have(3).translations
+        @spanish_locale.should have(3).translations
+      end
+
+    end
+  end
+end