globalize2 0.1.0 → 0.2.0

data/test/data/locale/all.yml

@@ -1,2 +0,0 @@
-en-US:
-  from-all-file: From the "all" file.

data/test/data/locale/de-DE.yml

@@ -1,2 +0,0 @@
-de-DE:
-  from-locale-file: Aus der Locale Datei.

data/test/data/locale/en-US.yml

@@ -1,2 +0,0 @@
-en-US:
-  from-locale-file: From the locale file.

data/test/data/locale/en-US/module.yml

@@ -1,2 +0,0 @@
-en-US:
-  from-locale-dir: From the locale directory.

data/test/data/locale/fi-FI/module.yml

@@ -1,2 +0,0 @@
-fi-FI:
-  from-locale-dir: Locale hakemistosta.

data/test/load_path_test.rb

@@ -1,49 +0,0 @@
-require File.join( File.dirname(__FILE__), 'test_helper' )
-require 'globalize/load_path'
-
-class LoadPathTest < ActiveSupport::TestCase
-  def setup
-    @plugin_dir = "#{File.dirname(__FILE__)}/.."
-    @locale_dir = "#{File.dirname(__FILE__)}/data/locale"
-    @load_path = Globalize::LoadPath.new
-  end
-  
-  test "returns glob patterns for all locales and ruby + yaml files by default" do
-    patterns = %w(locales/all.rb
-                  locales/*.rb 
-                  locales/*/**/*.rb 
-                  locales/all.yml 
-                  locales/*.yml
-                  locales/*/**/*.yml)
-    assert_equal patterns, @load_path.send(:patterns, 'locales')
-  end
-
-  test "returns the glob patterns for registered locales and extensions" do
-    @load_path.locales = [:en, :de]
-    @load_path.extensions = [:sql]
-    patterns = %w(locales/all.sql
-                  locales/en.sql
-                  locales/en/**/*.sql 
-                  locales/de.sql
-                  locales/de/**/*.sql)
-    assert_equal patterns, @load_path.send(:patterns, 'locales')
-  end
-
-  test "expands paths using yml as a default file extension" do
-    @load_path << @locale_dir
-    expected = %w(all.yml de-DE.yml en-US.yml en-US/module.yml fi-FI/module.yml root.yml)
-    assert_equal expected, @load_path.map{|path| path.sub("#{@locale_dir}\/", '')}
-  end
-
-  test "appends new paths to the collection so earlier collected paths preceed later collected ones" do
-    @load_path.locales = [:root]
-    @load_path << "#{@plugin_dir}/lib/locale"
-    @load_path << @locale_dir
-    
-    expected = %W(#{@plugin_dir}/lib/locale/root.yml 
-                  #{@locale_dir}/all.yml
-                  #{@locale_dir}/root.yml)
-    assert_equal expected, @load_path
-  end
-
-end

data/test/locale/fallbacks_test.rb

@@ -1,154 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/locale/fallbacks'
-
-include Globalize::Locale
-I18n.default_locale = :'en-US'    # This has to be set explicitly, no longer default for I18n
-
-class FallbacksTest < ActiveSupport::TestCase
-  def setup
-    I18n.fallbacks = Fallbacks.new
-  end
-
-  def teardown
-    I18n.default_locale = :'en-US'
-  end
-
-  test "#[] caches computed results" do
-    I18n.fallbacks['en']
-    assert_equal( { :en => [:en, :"en-US", :root] }, I18n.fallbacks ) 
-  end
-
-  test "#defaults always reflect the I18n.default_locale if no default has been set manually" do
-    I18n.default_locale = :'en-US'
-    assert_equal( [:'en-US', :en, :root], I18n.fallbacks.defaults ) 
-  end
-
-  test "#defaults always reflect a manually passed default locale if any" do
-    I18n.fallbacks = Fallbacks.new(:'fi-FI')
-    assert_equal( [:'fi-FI', :fi, :root], I18n.fallbacks.defaults ) 
-    I18n.default_locale = :'de-DE'
-    assert_equal( [:'fi-FI', :fi, :root], I18n.fallbacks.defaults ) 
-  end
-
-  test "#defaults allows to set multiple defaults" do
-    I18n.fallbacks = Fallbacks.new(:'fi-FI', :'se-FI')
-    assert_equal( [:'fi-FI', :fi, :'se-FI', :se, :root], I18n.fallbacks.defaults ) 
-  end
-end
-
-class NoMappingFallbacksTest < ActiveSupport::TestCase
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-  end
-
-  test "returns [:es, :en-US, :root] for :es" do
-    assert_equal [:es, :"en-US", :en, :root], @fallbacks[:es] 
-  end
-
-  test "returns [:es-ES, :es, :en-US, :root] for :es-ES" do
-    assert_equal [:"es-ES", :es, :"en-US", :en, :root], @fallbacks[:"es-ES"] 
-  end
-
-  test "returns [:es-MX, :es, :en-US, :root] for :es-MX" do
-    assert_equal [:"es-MX", :es, :"en-US", :en, :root], @fallbacks[:"es-MX"] 
-  end
-
-  test "returns [:es-Latn-ES, :es-Latn, :es, :en-US, :root] for :es-Latn-ES" do
-    assert_equal [:"es-Latn-ES", :"es-Latn", :es, :"en-US", :en, :root], @fallbacks[:'es-Latn-ES'] 
-  end
-
-  test "returns [:en, :en-US, :root] for :en" do
-    assert_equal [:en, :"en-US", :root], @fallbacks[:en] 
-  end
-
-  test "returns [:en-US, :en, :root] for :en-US (special case: locale == default)" do
-    assert_equal [:"en-US", :en, :root], @fallbacks[:"en-US"] 
-  end
-end
-
-class CaMappingFallbacksTest < ActiveSupport::TestCase
-  # Most people who speak Catalan also live in Spain, so test is safe to assume
-  # that they also speak Spanish as spoken in Spain.
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-    @fallbacks.map :ca => :"es-ES"
-  end
-
-  test "returns [:ca, :es-ES, :es, :en-US, :root] for :ca" do
-    assert_equal [:ca, :"es-ES", :es, :"en-US", :en, :root], @fallbacks[:ca] 
-  end
-
-  test "returns [:ca-ES, :ca, :es-ES, :es, :en-US, :root] for :ca-ES" do
-    assert_equal [:"ca-ES", :ca, :"es-ES", :es, :"en-US", :en, :root], @fallbacks[:"ca-ES"] 
-  end
-end
-
-class ArMappingFallbacksTest < ActiveSupport::TestCase
-  # People who speak Arabic as spoken in Palestine often times also speak
-  # Hebrew as spoken in Israel. However test is in no way safe to assume that
-  # everybody who speaks Arabic also speaks Hebrew.
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-    @fallbacks.map :"ar-PS" => :"he-IL"
-  end
-
-  test "returns [:ar, :en-US, :root] for :ar" do
-    assert_equal [:ar, :"en-US", :en, :root], @fallbacks[:ar] 
-  end
-
-  test "returns [:ar-EG, :ar, :en-US, :root] for :ar-EG" do
-    assert_equal [:"ar-EG", :ar, :"en-US", :en, :root], @fallbacks[:"ar-EG"] 
-  end
-
-  test "returns [:ar-PS, :ar, :he-IL, :he, :en-US, :root] for :ar-PS" do
-    assert_equal [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en, :root], @fallbacks[:"ar-PS"] 
-  end
-end
-
-class SmsMappingFallbacksTest < ActiveSupport::TestCase
-  # Sami people live in several scandinavian countries. In Finnland many people
-  # know Swedish and Finnish. Thus, test can be assumed that Sami living in
-  # Finnland also speak Swedish and Finnish.
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-    @fallbacks.map :sms => [:"se-FI", :"fi-FI"]
-  end
-
-  test "returns [:sms-FI, :sms, :se-FI, :se, :fi-FI, :fi, :en-US, :root] for :sms-FI" do
-    assert_equal [:"sms-FI", :sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en, :root], @fallbacks[:"sms-FI"] 
-  end
-end
-
-class DeAtMappingFallbacksTest < ActiveSupport::TestCase
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-    @fallbacks.map :"de-AT" => :"de-DE"
-  end
-
-  test "returns [:de, :en-US, :root] for de" do
-    assert_equal [:de, :"en-US", :en, :root], @fallbacks[:"de"] 
-  end
-
-  test "returns [:de-DE, :de, :en-US, :root] for de-DE" do
-    assert_equal [:"de-DE", :de, :"en-US", :en, :root], @fallbacks[:"de-DE"] 
-  end
-
-  test "returns [:de-AT, :de, :de-DE, :en-US, :root] for de-AT" do
-    assert_equal [:"de-AT", :de, :"de-DE", :"en-US", :en, :root], @fallbacks[:"de-AT"] 
-  end
-end
-
-class DeMappingFallbacksTest < ActiveSupport::TestCase
-  def setup
-    @fallbacks = Fallbacks.new(:'en-US')
-    @fallbacks.map :de => :en, :he => :en
-  end
-  
-  test "returns [:de, :en, :root] for :de" do
-    assert_equal [:de, :en, :"en-US", :root], @fallbacks[:de] 
-  end
-  
-  test "returns [:he, :en, :root] for :de" do
-    assert_equal [:he, :en, :"en-US", :root], @fallbacks[:he] 
-  end
-end

data/test/locale/language_tag_test.rb

@@ -1,130 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/locale/language_tag'
-
-include Globalize::Locale
-
-class LanguageTagTest < ActiveSupport::TestCase
-  test "given a valid tag 'de' returns an LanguageTag from #tag" do
-    assert_instance_of LanguageTag, LanguageTag.tag('de')
-  end
-
-  test "given a valid tag 'de' returns an array of subtags" do
-    assert_equal ['de', nil, nil, nil, nil, nil, nil], LanguageTag::SimpleParser.match('de') 
-  end
-  
-  test "given a valid tag 'de-DE' returns an array of subtags" do
-    assert_equal ['de', nil, 'DE', nil, nil, nil, nil], LanguageTag::SimpleParser.match('de-DE') 
-  end
-  
-  test "given a valid lowercase tag 'de-latn-de-variant-x-phonebk' returns an array of subtags" do
-    assert_equal ['de', 'latn', 'de', 'variant', nil, 'x-phonebk', nil], 
-      LanguageTag::SimpleParser.match('de-latn-de-variant-x-phonebk') 
-  end
-  
-  test "given a valid uppercase tag 'DE-LATN-DE-VARIANT-X-PHONEBK' returns an array of subtags" do
-    assert_equal ['DE', 'LATN', 'DE', 'VARIANT', nil, 'X-PHONEBK', nil], 
-      LanguageTag::SimpleParser.match('DE-LATN-DE-VARIANT-X-PHONEBK') 
-  end
-  
-  test "given an invalid tag 'a-DE' test returns false" do
-    assert !LanguageTag::SimpleParser.match('a-DE')
-  end
-  
-  test "given an invalid tag 'de-419-DE' test returns false" do
-    assert !LanguageTag::SimpleParser.match('de-419-DE')
-  end
-end
-
-class DeLatnLanguageTagTest < ActiveSupport::TestCase
-  def setup
-    subtags = %w(de Latn DE variant a-ext x-phonebk i-klingon)
-    @tag = LanguageTag.new *subtags
-  end
-
-  test "returns 'de' as the language subtag in lowercase" do
-    assert_equal 'de', @tag.language
-  end
-
-  test "returns 'Latn' as the script subtag in titlecase" do
-    assert_equal 'Latn', @tag.script 
-  end
-
-  test "returns 'DE' as the region subtag in uppercase" do
-    assert_equal 'DE', @tag.region
-  end
-
-  test "returns 'variant' as the variant subtag in lowercase" do
-    assert_equal 'variant', @tag.variant 
-  end
-
-  test "returns 'a-ext' as the extension subtag" do
-    assert_equal 'a-ext', @tag.extension 
-  end
-
-  test "returns 'x-phonebk' as the privateuse subtag" do
-    assert_equal 'x-phonebk', @tag.privateuse 
-  end
-
-  test "returns 'i-klingon' as the grandfathered subtag" do
-    assert_equal 'i-klingon', @tag.grandfathered 
-  end
-  
-  test "returns a formatted tag string from #to_s" do
-    assert_equal 'de-Latn-DE-variant-a-ext-x-phonebk-i-klingon', @tag.to_s 
-  end
-  
-  test "returns an array containing the formatted subtags from #to_a" do
-    assert_equal %w(de Latn DE variant a-ext x-phonebk i-klingon), @tag.to_a 
-  end
-end
-
-class InheritanceLanguageTagTest < ActiveSupport::TestCase
-  test "returns 'de-Latn-DE-variant-a-ext-x-phonebk' as the parent of 'de-Latn-DE-variant-a-ext-x-phonebk-i-klingon'" do
-    tag = LanguageTag.new *%w(de Latn DE variant a-ext x-phonebk i-klingon)
-    assert_equal 'de-Latn-DE-variant-a-ext-x-phonebk', tag.parent.to_s 
-  end
-
-  test "returns 'de-Latn-DE-variant-a-ext' as the parent of 'de-Latn-DE-variant-a-ext-x-phonebk'" do
-    tag = LanguageTag.new *%w(de Latn DE variant a-ext x-phonebk)
-    assert_equal 'de-Latn-DE-variant-a-ext', tag.parent.to_s 
-  end
-
-  test "returns 'de-Latn-DE-variant' as the parent of 'de-Latn-DE-variant-a-ext'" do
-    tag = LanguageTag.new *%w(de Latn DE variant a-ext)
-    assert_equal 'de-Latn-DE-variant', tag.parent.to_s 
-  end
-
-  test "returns 'de-Latn-DE' as the parent of 'de-Latn-DE-variant'" do
-    tag = LanguageTag.new *%w(de Latn DE variant)
-    assert_equal 'de-Latn-DE', tag.parent.to_s 
-  end
-
-  test "returns 'de-Latn' as the parent of 'de-Latn-DE'" do
-    tag = LanguageTag.new *%w(de Latn DE)
-    assert_equal 'de-Latn', tag.parent.to_s 
-  end
-
-  test "returns 'de' as the parent of 'de-Latn'" do
-    tag = LanguageTag.new *%w(de Latn)
-    assert_equal 'de', tag.parent.to_s 
-  end
-  
-  # TODO RFC4647 says: "If no language tag matches the request, the "default" value is returned."
-  # where should we set the default language?
-  # test "returns '' as the parent of 'de'" do
-  #   tag = LanguageTag.new *%w(de)
-  #   assert_equal '', tag.parent.to_s
-  # end
-
-  test "returns an array of 5 parents for 'de-Latn-DE-variant-a-ext-x-phonebk-i-klingon'" do
-    parents = %w(de-Latn-DE-variant-a-ext-x-phonebk-i-klingon 
-                 de-Latn-DE-variant-a-ext-x-phonebk 
-                 de-Latn-DE-variant-a-ext 
-                 de-Latn-DE-variant 
-                 de-Latn-DE 
-                 de-Latn 
-                 de) 
-    tag = LanguageTag.new *%w(de Latn DE variant a-ext x-phonebk i-klingon)
-    assert_equal parents, tag.parents.map{|tag| tag.to_s} 
-  end  
-end

data/test/model/active_record/translated_test.rb

@@ -1,487 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', '..', 'test_helper' )
-require 'active_record'
-require 'globalize/model/active_record'
-
-# Hook up model translation
-ActiveRecord::Base.send(:include, Globalize::Model::ActiveRecord::Translated)
-
-# Load Post model
-require File.join( File.dirname(__FILE__), '..', '..', 'data', 'models' )
-
-class TranslatedTest < ActiveSupport::TestCase
-  def setup
-    I18n.locale = :'en-US'
-    I18n.fallbacks.clear
-    reset_db! File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'schema.rb'))
-    ActiveRecord::Base.locale = nil
-  end
-
-  def teardown
-    I18n.fallbacks.clear
-  end
-
-  test "modifiying translated fields" do
-    post = Post.create :subject => 'foo'
-    assert_equal 'foo', post.subject
-    post.subject = 'bar'
-    assert_equal 'bar', post.subject
-  end
-
-  test "modifiying translated fields while switching locales" do
-    post = Post.create :subject => 'foo'
-    assert_equal 'foo', post.subject
-    I18n.locale = :'de-DE'
-    post.subject = 'bar'
-    assert_equal 'bar', post.subject
-    I18n.locale = :'en-US'
-    assert_equal 'foo', post.subject
-    I18n.locale = :'de-DE'
-    post.subject = 'bar'
-  end
-
-  test "has post_translations" do
-    post = Post.create
-    assert_nothing_raised { post.globalize_translations }
-  end
-
-  test "has German post_translations" do
-    I18n.locale = :de
-    post = Post.create :subject => 'foo'
-    assert_equal 1, post.globalize_translations.size
-    I18n.locale = :en
-    assert_equal 1, post.globalize_translations.size
-  end
-
-  test "returns the value passed to :subject" do
-    post = Post.new
-    assert_equal 'foo', (post.subject = 'foo')
-  end
-
-  test "translates subject and content into en-US" do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-    assert post.save
-    post.reload
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-  end
-
-  test "finds a German post" do
-    post = Post.create :subject => 'foo (en)', :content => 'bar'
-    I18n.locale = 'de-DE'
-    post = Post.first
-    post.subject = 'baz (de)'
-    post.save
-    assert_equal 'baz (de)', Post.first.subject
-    I18n.locale = :'en-US'
-    assert_equal 'foo (en)', Post.first.subject
-  end
-
-  test "saves an English post and loads test correctly" do
-    assert_nil Post.first
-    post = Post.create :subject => 'foo', :content => 'bar'
-    assert post.save
-    post = Post.first
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-  end
-
-  test "updates an attribute" do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    post.update_attribute :subject, 'baz'
-    assert_equal 'baz', Post.first.subject
-  end
-
-  test "update_attributes failure" do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    assert !post.update_attributes( { :subject => '' } )
-    assert_nil post.reload.attributes['subject']
-    assert_equal 'foo', post.subject
-  end
-
-  test "validates presence of :subject" do
-    post = Post.new
-    assert !post.save
-
-    post = Post.new :subject => 'foo'
-    assert post.save
-  end
-
-  test "returns the value for the correct locale, after locale switching" do
-    post = Post.create :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post.subject = 'bar'
-    post.save
-    I18n.locale = 'en-US'
-    post = Post.first
-    assert_equal 'foo', post.subject
-    I18n.locale = 'de-DE'
-    assert_equal 'bar', post.subject
-  end
-
-  test "keeping one field in new locale when other field is changed" do
-    I18n.fallbacks.map 'de-DE' => [ 'en-US' ]
-    post = Post.create :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post.content = 'bar'
-    assert_equal 'foo', post.subject
-  end
-
-  test "modifying non-required field in a new locale" do
-    I18n.fallbacks.map 'de-DE' => [ 'en-US' ]
-    post = Post.create :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post.content = 'bar'
-    assert post.save
-  end
-
-  test "returns the value for the correct locale, after locale switching, without saving" do
-    post = Post.create :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post.subject = 'bar'
-    I18n.locale = 'en-US'
-    assert_equal 'foo', post.subject
-    I18n.locale = 'de-DE'
-    assert_equal 'bar', post.subject
-  end
-
-  test "saves all locales, even after locale switching" do
-    post = Post.new :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post.subject = 'bar'
-    I18n.locale = 'he-IL'
-    post.subject = 'baz'
-    post.save
-    I18n.locale = 'en-US'
-    post = Post.first
-    assert_equal 'foo', post.subject
-    I18n.locale = 'de-DE'
-    assert_equal 'bar', post.subject
-    I18n.locale = 'he-IL'
-    assert_equal 'baz', post.subject
-  end
-
-  test "resolves a simple fallback" do
-    I18n.locale = 'de-DE'
-    post = Post.create :subject => 'foo'
-    I18n.locale = 'de'
-    post.subject = 'baz'
-    post.content = 'bar'
-    post.save
-    I18n.locale = 'de-DE'
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-  end
-
-  test "resolves a simple fallback without reloading" do
-    I18n.locale = 'de-DE'
-    post = Post.new :subject => 'foo'
-    I18n.locale = 'de'
-    post.subject = 'baz'
-    post.content = 'bar'
-    I18n.locale = 'de-DE'
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-  end
-
-  test "resolves a complex fallback without reloading" do
-    I18n.fallbacks.map 'de' => %w(en he)
-    I18n.locale = 'de'
-    post = Post.new
-    I18n.locale = 'en'
-    post.subject = 'foo'
-    I18n.locale = 'he'
-    post.subject = 'baz'
-    post.content = 'bar'
-    I18n.locale = 'de'
-    assert_equal 'foo', post.subject
-    assert_equal 'bar', post.content
-  end
-
-  test "returns nil if no translations are found" do
-    post = Post.new :subject => 'foo'
-    assert_equal 'foo', post.subject
-    assert_nil post.content
-  end
-
-  test "returns nil if no translations are found; reloaded" do
-    post = Post.create :subject => 'foo'
-    post = Post.first
-    assert_equal 'foo', post.subject
-    assert_nil post.content
-  end
-
-  test "works with associations" do
-    blog = Blog.create
-    post1 = blog.posts.create :subject => 'foo'
-    I18n.locale = 'de-DE'
-    post2 = blog.posts.create :subject => 'bar'
-    assert_equal 2, blog.posts.size
-    I18n.locale = 'en-US'
-    assert_equal 'foo', blog.posts.first.subject
-    assert_nil blog.posts.last.subject
-    I18n.locale = 'de-DE'
-    assert_equal 'bar', blog.posts.last.subject
-  end
-
-  test "works with simple dynamic finders" do
-    foo = Post.create :subject => 'foo'
-    Post.create :subject => 'bar'
-    post = Post.find_by_subject('foo')
-    assert_equal foo, post
-  end
-
-  test 'change attribute on globalized model' do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    assert_equal [], post.changed
-    post.subject = 'baz'
-    assert_equal [ 'subject' ], post.changed
-    post.content = 'quux'
-    assert_member 'subject', post.changed
-    assert_member 'content', post.changed
-  end
-
-  test 'change attribute on globalized model after locale switching' do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    assert_equal [], post.changed
-    post.subject = 'baz'
-    I18n.locale = :de
-    assert_equal [ 'subject' ], post.changed
-  end
-
-  test 'fallbacks with lots of locale switching' do
-    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
-    post = Post.create :subject => 'foo'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'foo', post.subject
-
-    I18n.locale = :'en-US'
-    post.update_attribute :subject, 'bar'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'bar', post.subject
-  end
-
-  test 'reload' do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    post.subject = 'baz'
-    assert_equal 'foo', post.reload.subject
-  end
-
-  test 'complex writing and stashing' do
-    post = Post.create :subject => 'foo', :content => 'bar'
-    post.subject = nil
-    assert_nil post.subject
-    assert !post.valid?
-  end
-
-  test 'translated class locale setting' do
-    assert ActiveRecord::Base.respond_to?(:locale)
-    assert_equal :'en-US', I18n.locale
-    assert_equal :'en-US', ActiveRecord::Base.locale
-    I18n.locale = :de
-    assert_equal :de, I18n.locale
-    assert_equal :de, ActiveRecord::Base.locale
-    ActiveRecord::Base.locale = :es
-    assert_equal :de, I18n.locale
-    assert_equal :es, ActiveRecord::Base.locale
-    I18n.locale = :fr
-    assert_equal :fr, I18n.locale
-    assert_equal :es, ActiveRecord::Base.locale
-  end
-
-  test "untranslated class responds to locale" do
-    assert Blog.respond_to?(:locale)
-  end
-
-  test "to ensure locales in different classes are the same" do
-    ActiveRecord::Base.locale = :de
-    assert_equal :de, ActiveRecord::Base.locale
-    assert_equal :de, Parent.locale
-    Parent.locale = :es
-    assert_equal :es, ActiveRecord::Base.locale
-    assert_equal :es, Parent.locale
-  end
-
-  test "attribute saving goes by content locale and not global locale" do
-    ActiveRecord::Base.locale = :de
-    assert_equal :'en-US', I18n.locale
-    Post.create :subject => 'foo'
-    assert_equal :de, Post.first.globalize_translations.first.locale
-  end
-
-  test "attribute loading goes by content locale and not global locale" do
-    post = Post.create :subject => 'foo'
-    assert_equal :'en-US', ActiveRecord::Base.locale
-    ActiveRecord::Base.locale = :de
-    assert_equal :'en-US', I18n.locale
-    post.update_attribute :subject, 'foo [de]'
-    assert_equal 'foo [de]', Post.first.subject
-    ActiveRecord::Base.locale = :'en-US'
-    assert_equal 'foo', Post.first.subject
-  end
-
-  test "access content locale before setting" do
-    Globalize::Model::ActiveRecord::Translated::ActMethods.class_eval "remove_class_variable(:@@locale)"
-    assert_nothing_raised { ActiveRecord::Base.locale }
-  end
-
-  test "translated_locales" do
-    Post.locale = :de
-    post = Post.create :subject => 'foo'
-    Post.locale = :es
-    post.update_attribute :subject, 'bar'
-    Post.locale = :fr
-    post.update_attribute :subject, 'baz'
-    assert_equal [ :de, :es, :fr ], post.translated_locales
-    assert_equal [ :de, :es, :fr ], Post.first.translated_locales
-  end
-  
-  test "saving record correctly after post-save reload" do
-    reloader = Reloader.create :content => 'foo'
-    assert_equal 'foo', reloader.content
-  end
-
-  test "including globalize_translations" do
-    I18n.locale = :de
-    Post.create :subject => "Foo1", :content => "Bar1"
-    Post.create :subject => "Foo2", :content => "Bar2"
-
-    class << Post
-      def tranlsations_included
-        self.all(:include => :globalize_translations)
-      end
-    end
-
-    default       = Post.all.map {|x| [x.subject, x.content]}
-    with_include  = Post.tranlsations_included.map {|x| [x.subject, x.content]}
-    assert_equal default, with_include
-  end
-
-  test "setting multiple translations at once with options hash" do
-    Post.locale = :de
-    post = Post.create :subject => "foo1", :content => "foo1"
-    Post.locale = :en
-    post.update_attributes( :subject => "bar1", :content => "bar1" )
-
-    options = { :de => {:subject => "foo2", :content => "foo2"},
-                :en => {:subject => "bar2", :content => "bar2"} }
-    post.set_translations options
-    post.reload
-
-    assert ["bar2", "bar2"], [post.subject, post.content]
-    Post.locale = :de
-    assert ["foo2", "foo2"], [post.subject, post.content]
-  end
-
-  test "setting only one translation with set_translations" do
-    Post.locale = :de
-    post = Post.create :subject => "foo1", :content => "foo1"
-    Post.locale = :en
-    post.update_attributes( :subject => "bar1", :content => "bar1" )
-
-    options = { :en => {:subject => "bar2", :content => "bar2"} }
-    post.set_translations options
-    post.reload
-
-    assert ["bar2", "bar2"], [post.subject, post.content]
-    Post.locale = :de
-    assert ["foo1", "foo1"], [post.subject, post.content]
-  end
-
-  test "setting only selected attributes with set_translations" do
-    Post.locale = :de
-    post = Post.create :subject => "foo1", :content => "foo1"
-    Post.locale = :en
-    post.update_attributes( :subject => "bar1", :content => "bar1" )
-
-    options = { :de => {:content => "foo2"}, :en => {:subject => "bar2"} }
-    post.set_translations options
-    post.reload
-
-    assert ["bar2", "bar1"], [post.subject, post.content]
-    Post.locale = :de
-    assert ["foo1", "foo2"], [post.subject, post.content]
-  end
-
-  test "setting invalid attributes raises ArgumentError" do
-    Post.locale = :de
-    post = Post.create :subject => "foo1", :content => "foo1"
-    Post.locale = :en
-    post.update_attributes( :subject => "bar1", :content => "bar1" )
-
-    options = { :de => {:fake => "foo2"} }
-    exception = assert_raise(ActiveRecord::UnknownAttributeError) do
-      post.set_translations options
-    end
-    assert_equal "unknown attribute: fake", exception.message
-  end
-
-  test "reload accepting find options" do
-    p = Post.create :subject => "Foo", :content => "Bar"
-    assert p.reload(:readonly => true, :lock => true)
-    assert_raise(ArgumentError) { p.reload(:foo => :bar) }
-  end
-
-  test "dependent destroy of translation" do
-    p = Post.create :subject => "Foo", :content => "Bar"
-    assert_equal 1, PostTranslation.count
-    p.destroy
-    assert_equal 0, PostTranslation.count
-  end
-
-  test "translating subclass of untranslated comment model" do
-    translated_comment = TranslatedComment.create(:post => @post)
-    assert_nothing_raised { translated_comment.globalize_translations }
-  end
-
-  test "modifiying translated comments works as expected" do
-    I18n.locale = :en
-    translated_comment = TranslatedComment.create(:post => @post, :content => 'foo')
-    assert_equal 'foo', translated_comment.content
-
-    I18n.locale = :de
-    translated_comment.content = 'bar'
-    assert translated_comment.save
-    assert_equal 'bar', translated_comment.content
-
-    I18n.locale = :en
-    assert_equal 'foo', translated_comment.content
-
-    assert_equal 2, translated_comment.globalize_translations.size
-  end
-  
-  test "can create a proxy class for a namespaced model" do
-    module Foo
-      module Bar
-        class Baz < ActiveRecord::Base
-          translates :bumm
-        end
-      end
-    end
-  end
-  
-  test "attribute translated before type cast" do
-    Post.locale = :en
-    post = Post.create :subject => 'foo', :content => 'bar'
-    Post.locale = :de
-    post.update_attribute :subject, "German foo"
-    assert_equal 'German foo', post.subject_before_type_cast
-    Post.locale = :en
-    assert_equal 'foo', post.subject_before_type_cast
-  end
-  
-  test "don't override existing translation model" do
-    assert PostTranslation.new.respond_to?(:existing_method)
-  end
-end
-
-# TODO should validate_presence_of take fallbacks into account? maybe we need
-#   an extra validation call, or more options for validate_presence_of.
-# TODO error checking for fields that exist in main table, don't exist in
-# proxy table, aren't strings or text
-#
-# TODO allow finding by translated attributes in conditions?
-# TODO generate advanced dynamic finders?