Updated globalize2 to latest version. Modified existing code accoringly

53 files changed, 1351 insertions, 2373 deletions

diff --git a/app/models/node.rb b/app/models/node.rb
index 4f67dcb..db44b71 100644
--- a/app/models/node.rb
+++ b/app/models/node.rb
@@ -25,7 +25,7 @@ class Node < ActiveRecord::Base
   
   # Index for Fulltext Search
   define_index do
-    indexes head.globalize_translations.title
+    indexes head.translations.title
     indexes slug
     indexes unique_name
   end
diff --git a/app/models/page.rb b/app/models/page.rb
index 37b221e..a993e31 100644
--- a/app/models/page.rb
+++ b/app/models/page.rb
@@ -10,14 +10,14 @@ class Page < ActiveRecord::Base
   named_scope( 
     :drafts, 
     :joins => :node,
-    :include => [:globalize_translations],
+    :include => [:translations],
     :conditions => ["nodes.draft_id = pages.id"]
   )
   
   named_scope(
     :heads,
     :joins => :node,
-    :include => [:globalize_translations],
+    :include => [:translations],
     :conditions => ["nodes.head_id = pages.id"]
   )
   
@@ -89,7 +89,7 @@ class Page < ActiveRecord::Base
   # outdated_translations? for more information.
   # Takes :locale => <locale> and :delta_time => 12.hours as options
   def self.find_with_outdated_translations options = {}
-    Page.all(:include => :globalize_translations).select do |page|
+    Page.all(:include => :translations).select do |page|
       page.outdated_translations? options
     end
   end
@@ -132,11 +132,11 @@ class Page < ActiveRecord::Base
     self.published_at     = page.published_at
     
     # Getting rid of the auto-generated empty translations
-    self.globalize_translations.delete_all
+    self.translations.delete_all
     
     # Clone translated attributes
-    page.globalize_translations.each do |translation|
-      self.globalize_translations.create!(translation.attributes)
+    page.translations.each do |translation|
+      self.translations.create!(translation.attributes)
     end
     
     # Clone asset references
@@ -163,7 +163,7 @@ class Page < ActiveRecord::Base
     
     options = default_options.merge options
     
-    translations = self.globalize_translations
+    translations = self.translations
     
     default = *(translations.select {|x| x.locale == I18n.default_locale})
     custom  = *(translations.select {|x| x.locale == options[:locale]})
diff --git a/test/unit/page_test.rb b/test/unit/page_test.rb
index bb82da0..099b79d 100644
--- a/test/unit/page_test.rb
+++ b/test/unit/page_test.rb
@@ -108,20 +108,20 @@ class PageTest < ActiveSupport::TestCase
     
     assert_not_nil page = Page.create!( :title => "Hallo" )
     page.reload
-    assert_equal 2, page.globalize_translations.size
+    assert_equal 1, page.translations.size
     assert_equal [], Page.find_with_outdated_translations
     
     I18n.locale = :en
     page.title = "Hello"
     page.save
     
-    assert_equal 3, page.globalize_translations.size
+    assert_equal 2, page.translations.size
     assert_equal 0, Page.find_with_outdated_translations.size
     
-    english = *page.globalize_translations.select {|x| x.locale == :en}
-    PageTranslation.record_timestamps = false
+    english = *page.translations.select {|x| x.locale == :en}
+    Page::Translation.record_timestamps = false
     english.update_attributes(:updated_at => (Time.now+25.hours))    
-    PageTranslation.record_timestamps = true
+    Page::Translation.record_timestamps = true
     assert_equal 1, Page.find_with_outdated_translations.count
     
     I18n.locale = :de
diff --git a/vendor/plugins/globalize2/README.textile b/vendor/plugins/globalize2/README.textile
index dbd7288..7155a7c 100644
--- a/vendor/plugins/globalize2/README.textile
+++ b/vendor/plugins/globalize2/README.textile
@@ -1,16 +1,17 @@
 h1. Globalize2
 
-Globalize2 is the successor of Globalize for Rails. 
+Globalize2 is the successor of Globalize for Rails.
 
-It is compatible with and builds on the new "I18n api in Ruby on Rails":http://rails-i18n.org. and adds model translations as well as a bunch of other useful features, such as Locale fallbacks (RFC4647 compliant) and automatic loading of Locale data from defined directory/file locations.
+It is compatible with and builds on the new "I18n api in Ruby on Rails":http://guides.rubyonrails.org/i18n.html. and adds model translations to ActiveRecord.
 
-Globalize2 is much more lightweight and modular than its predecessor was. Content translations in Globalize2 use default ActiveRecord features and do not limit any functionality any more. 
-
-All features and tools in Globalize2 are implemented in the most unobstrusive and loosely-coupled way possible, so you can pick whatever features or tools you need for your application and combine them with other tools from other libraries or plugins.
+Globalize2 is much more lightweight and compatible than its predecessor was. Model translations in Globalize2 use default ActiveRecord features and do not limit any ActiveRecord functionality any more.
 
 h2. Requirements
 
-Rails 2.2 (currently Rails edge)
+ActiveRecord
+I18n
+
+(or Rails > 2.2)
 
 h2. Installation
 
@@ -20,19 +21,9 @@ To install Globalize2 with its default setup just use:
 script/plugin install git://github.com/joshmh/globalize2.git
 </code></pre>
 
-This will:
-
-* activate model translations
-* set I18n.load_path to an instance of Globalize::LoadPath
-* set I18n.backend to an instance of Globalize::Backend::Static
-
-h2. Configuration
-
-You might want to add additional configuration to an initializer, e.g. config/initializers/globalize.rb
-
 h2. Model translations
 
-Model translations (or content translations) allow you to translate your models' attribute values. E.g.
+Model translations allow you to translate your models' attribute values. E.g.
 
 <pre><code>
 class Post < ActiveRecord::Base
@@ -44,10 +35,10 @@ Allows you to values for the attributes :title and :text per locale:
 
 <pre><code>
 I18n.locale = :en
-post.title # Globalize2 rocks!
+post.title # => Globalize2 rocks!
 
 I18n.locale = :he
-post.title # גלובאלייז2 שולט!
+post.title # => גלובאלייז2 שולט!
 </code></pre>
 
 In order to make this work, you'll need to add the appropriate translation tables. Globalize2 comes with a handy helper method to help you do this. It's called @create_translation_table!@. Here's an example:
@@ -69,134 +60,6 @@ end
 
 Note that the ActiveRecord model @Post@ must already exist and have a @translates@ directive listing the translated fields.
 
-h2. Globalize::Backend::Static
-
-Globalize2 ships with a Static backend that builds on the Simple backend from the I18n library (which is shipped with Rails) and adds the following features:
-
-* It uses locale fallbacks when looking up translation data.
-* It returns an instance of Globalize::Translation::Static instead of a plain Ruby String as a translation.
-* It allows to hook in custom pluralization logic as lambdas.
-
-h2. Custom pluralization logic
-
-The Simple backend has its pluralization algorithm baked in hardcoded. This algorithm is only suitable for English and other languages that have the same pluralization rules. It is not suitable for, e.g., Czech though.
-
-To add custom pluralization logic to Globalize' Static backend you can do something like this:
-
-<pre><code>
-@backend.add_pluralizer :cz, lambda{|c| 
-  c == 1 ? :one : (2..4).include?(c) ? :few : :other 
-}
-</code></pre>
-
-h2. Locale Fallbacks
-
-Globalize2 ships with a Locale fallback tool which extends the I18n module to hold a fallbacks instance which is set to an instance of Globalize::Locale::Fallbacks by default but can be swapped with a different implementation. 
-
-Globalize2 fallbacks will compute a number of other locales for a given locale. For example:
-
-<pre><code>
-I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :"en-US", :en]
-</code></pre>
-
-Globalize2 fallbacks always fall back to 
-
-* all parents of a given locale (e.g. :es for :"es-MX"), 
-* then to the fallbacks' default locales and all of their parents and 
-* finally to the :root locale. 
-
-The default locales are set to [:"en-US"] by default but can be set to something else. The root locale is a concept borrowed from "CLDR":http://unicode.org and makes sense for storing common locale data which works as a last default fallback (e.g. "ltr" for bidi directions).
-
-One can additionally add any number of additional fallback locales manually. These will be added before the default locales to the fallback chain. For example:
-
-<pre><code>
-fb = I18n.fallbacks
-
-fb.map :ca => :"es-ES"
-fb[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
-
-fb.map :"ar-PS" => :"he-IL"
-fb[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
-fb[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
-
-fb.map :sms => [:"se-FI", :"fi-FI"]
-fb[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
-</code></pre>
-
-h2. Globalize::LoadPath
-
-Globalize2 replaces the plain Ruby array that is set to I18n.load_path by default through an instance of Globalize::LoadPath.
-
-This object can be populated with both paths to files and directories. If a path to a directory is added to it it will look up all locale data files present in that directory enforcing the following convention:
-
-<pre><code>
-I18n.load_path << "#{RAILS_ROOT}/lib/locales"
-
-# will load all the following files if present:
-lib/locales/all.yml
-lib/locales/fr.yml
-lib/locales/fr/*.yaml
-lib/locales/ru.yml
-lib/locales/ru/*.yaml
-...
-</code></pre>
-
-One can also specify which locales are used. By default this is set to "*" meaning that files for all locales are added. To define that only files for the locale :es are added one can specify:
-
-<pre><code>
-I18n.load_path.locales = [:es]
-</code></pre>
-
-One can also specify which file extensions are used. By default this is set to ['rb', 'yml'] so plain Ruby and YAML files are added if found. To define that only *.sql files are added one can specify:
-
-<pre><code>
-I18n.load_path.extensions = ['sql']
-</code></pre>
-
-Note that Globalize::LoadPath "expands" a directory to its contained file paths immediately when you add it to the load_path. Thus, if you change the locales or extensions settings in the middle of your application the change won't be applied to already added file paths.
-
-
-h2. Globalize::Translation classes
-
-Globalize2's Static backend as well as Globalize2 model translations return instances of Globalize::Translation classes (instead of plain Ruby Strings). These are simple and lightweight value objects that carry some additional meta data about the translation and how it was looked up.
-
-Model translations return instances of Globalize::Translation::Attribute, the Static backend returns instances of Globalize::Translation::Static.
-
-For example:
-
-<pre><code>
-I18n.locale = :de
-
-# Translation::Attribute
-title = Post.first.title  # assuming that no translation can be found:
-title.locale              # => :en
-title.requested_locale    # => :de 
-title.fallback?           # => true
-
-# Translation::Static
-rails = I18n.t :rails     # assuming that no translation can be found:
-rails.locale              # => :en
-rails.requested_locale    # => :de 
-rails.fallback?           # => true
-rails.options             # returns the options passed to #t
-rails.plural_key          # returns the plural_key (e.g. :one, :other)
-rails.original            # returns the original translation with no values 
-                          # interpolated to it (e.g. "Hi {{name}}!")
-</code></pre>
-
-h2. Missing Translations Log Handler
-
-A simple exception handler that behaves like the default exception handler but additionally logs missing translations to a given log.
-
-Useful for identifying missing translations during testing.
-
-E.g. 
-
-  require 'globalize/i18n/missing_translations_log_handler
-  I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
-  I18n.exception_handler = :missing_translations_log_handler
-
-To set up a different log file:
+h2. Migration from Globalize
 
-  logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
-  I18n.missing_translations_logger = logger
+See this script by Tomasz Stachewicz: http://gist.github.com/120867
diff --git a/vendor/plugins/globalize2/Rakefile b/vendor/plugins/globalize2/Rakefile
index bca49a1..ee80713 100644
--- a/vendor/plugins/globalize2/Rakefile
+++ b/vendor/plugins/globalize2/Rakefile
@@ -20,3 +20,20 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "globalize2"
+    s.summary = "Rails I18n: de-facto standard library for ActiveRecord data translation"
+    s.description = "Rails I18n: de-facto standard library for ActiveRecord data translation"
+    s.email = "joshmh@gmail.com"
+    s.homepage = "http://github.com/joshmh/globalize2"
+    # s.rubyforge_project = ''
+    s.authors = ["Sven Fuchs, Joshua Harvey, Clemens Kofler"]
+    # s.add_development_dependency ''
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
diff --git a/vendor/plugins/globalize2/VERSION b/vendor/plugins/globalize2/VERSION
new file mode 100644
index 0000000..0ea3a94
--- /dev/null
+++ b/vendor/plugins/globalize2/VERSION
@@ -0,0 +1 @@
+0.2.0
diff --git a/vendor/plugins/globalize2/generators/templates/db_backend_migration.rb b/vendor/plugins/globalize2/generators/templates/db_backend_migration.rb
index d4513a5..0f02611 100644
--- a/vendor/plugins/globalize2/generators/templates/db_backend_migration.rb
+++ b/vendor/plugins/globalize2/generators/templates/db_backend_migration.rb
@@ -8,16 +8,16 @@ class ActsAsTaggableMigration < ActiveRecord::Migration
     end
 
 # TODO: FINISH DOING MIGRATION -- stopped in the middle
-    
+
     create_table :globalize_translations_map do |t|
       t.string  :key, :null => false
       t.integer :translation_id, :null => false
     end
-    
+
     add_index :taggings, :tag_id
     add_index :taggings, [:taggable_id, :taggable_type]
   end
-  
+
   def self.down
     drop_table :globalize_translations
     drop_table :tags
diff --git a/vendor/plugins/globalize2/globalize2.gemspec b/vendor/plugins/globalize2/globalize2.gemspec
new file mode 100644
index 0000000..6ad93d3
--- /dev/null
+++ b/vendor/plugins/globalize2/globalize2.gemspec
@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{globalize2}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sven Fuchs, Joshua Harvey, Clemens Kofler"]
+  s.date = %q{2009-12-25}
+  s.description = %q{Rails I18n: de-facto standard library for ActiveRecord data translation}
+  s.email = %q{joshmh@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "generators/db_backend.rb",
+     "generators/templates/db_backend_migration.rb",
+     "globalize2.gemspec",
+     "init.rb",
+     "lib/globalize.rb",
+     "lib/globalize/active_record.rb",
+     "lib/globalize/active_record/adapter.rb",
+     "lib/globalize/active_record/attributes.rb",
+     "lib/globalize/active_record/migration.rb",
+     "lib/i18n/missing_translations_log_handler.rb",
+     "lib/i18n/missing_translations_raise_handler.rb",
+     "notes.textile",
+     "test/active_record/fallbacks_test.rb",
+     "test/active_record/migration_test.rb",
+     "test/active_record/sti_translated_test.rb",
+     "test/active_record/translates_test.rb",
+     "test/active_record/translation_class_test.rb",
+     "test/active_record/validation_tests.rb",
+     "test/active_record_test.rb",
+     "test/all.rb",
+     "test/data/models.rb",
+     "test/data/no_globalize_schema.rb",
+     "test/data/schema.rb",
+     "test/i18n/missing_translations_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/joshmh/globalize2}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Rails I18n: de-facto standard library for ActiveRecord data translation}
+  s.test_files = [
+    "test/active_record/fallbacks_test.rb",
+     "test/active_record/migration_test.rb",
+     "test/active_record/sti_translated_test.rb",
+     "test/active_record/translates_test.rb",
+     "test/active_record/translation_class_test.rb",
+     "test/active_record/validation_tests.rb",
+     "test/active_record_test.rb",
+     "test/all.rb",
+     "test/data/models.rb",
+     "test/data/no_globalize_schema.rb",
+     "test/data/schema.rb",
+     "test/i18n/missing_translations_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+
diff --git a/vendor/plugins/globalize2/init.rb b/vendor/plugins/globalize2/init.rb
index 7b5428e..a408925 100644
--- a/vendor/plugins/globalize2/init.rb
+++ b/vendor/plugins/globalize2/init.rb
@@ -1,10 +1 @@
-require 'rails_edge_load_path_patch.rb' unless I18n.respond_to?(:load_path)
-
-ActiveRecord::Base.send :include, Globalize::Model::ActiveRecord::Translated
-
-I18n.backend = Globalize::Backend::Static.new
-
-I18n.load_path = Globalize::LoadPath.new I18n.load_path
-I18n.load_path << "#{File.dirname(__FILE__)}/lib/locale"
-I18n.load_path << "#{RAILS_ROOT}/lib/locale"
-
+require 'globalize'
diff --git a/vendor/plugins/globalize2/lib/globalize.rb b/vendor/plugins/globalize2/lib/globalize.rb
new file mode 100644
index 0000000..67c1878
--- /dev/null
+++ b/vendor/plugins/globalize2/lib/globalize.rb
@@ -0,0 +1,15 @@
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+
+  class << self
+    def fallbacks?
+      I18n.respond_to?(:fallbacks)
+    end
+
+    def fallbacks(locale)
+      fallbacks? ? I18n.fallbacks[locale] : [locale.to_sym]
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Globalize::ActiveRecord)
diff --git a/vendor/plugins/globalize2/lib/globalize/active_record.rb b/vendor/plugins/globalize2/lib/globalize/active_record.rb
new file mode 100644
index 0000000..d2a843f
--- /dev/null
+++ b/vendor/plugins/globalize2/lib/globalize/active_record.rb
@@ -0,0 +1,194 @@
+module Globalize
+  class MigrationError < StandardError; end
+  class MigrationMissingTranslatedField < MigrationError; end
+  class BadMigrationFieldType < MigrationError; end
+
+  module ActiveRecord
+    autoload :Adapter,      'globalize/active_record/adapter'
+    autoload :Attributes,   'globalize/active_record/attributes'
+    autoload :Migration,    'globalize/active_record/migration'
+
+    def self.included(base)
+      base.extend ActMacro
+    end
+
+    class << self
+      def build_translation_class(target, options)
+        options[:table_name] ||= "#{target.table_name.singularize}_translations"
+
+        klass = target.const_defined?(:Translation) ?
+          target.const_get(:Translation) :
+          target.const_set(:Translation, Class.new(::ActiveRecord::Base))
+
+        klass.class_eval do
+          set_table_name(options[:table_name])
+          belongs_to target.name.underscore.gsub('/', '_')
+          def locale; read_attribute(:locale).to_sym; end
+          def locale=(locale); write_attribute(:locale, locale.to_s); end
+        end
+
+        klass
+      end
+    end
+
+    module ActMacro
+      def locale
+        (defined?(@@locale) && @@locale)
+      end
+
+      def locale=(locale)
+        @@locale = locale
+      end
+
+      def translates(*attr_names)
+        return if translates?
+        options = attr_names.extract_options!
+
+        class_inheritable_accessor :translation_class, :translated_attribute_names
+        self.translation_class = ActiveRecord.build_translation_class(self, options)
+        self.translated_attribute_names = attr_names.map(&:to_sym)
+
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
+        after_save :save_translations!
+        has_many :translations, :class_name  => translation_class.name,
+                                :foreign_key => class_name.foreign_key,
+                                :dependent   => :delete_all,
+                                :extend      => HasManyExtensions
+
+        named_scope :with_translations, lambda { |locale|
+          conditions = required_attributes.map do |attribute|
+            "#{quoted_translation_table_name}.#{attribute} IS NOT NULL"
+          end
+          conditions << "#{quoted_translation_table_name}.locale = ?"
+          { :include => :translations, :conditions => [conditions.join(' AND '), locale] }
+        }
+
+        attr_names.each { |attr_name| translated_attr_accessor(attr_name) }
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+    end
+
+    module HasManyExtensions
+      def by_locale(locale)
+        first(:conditions => { :locale => locale.to_s })
+      end
+
+      def by_locales(locales)
+        all(:conditions => { :locale => locales.map(&:to_s) })
+      end
+    end
+
+    module ClassMethods
+      delegate :set_translation_table_name, :to => :translation_class
+
+      def with_locale(locale)
+        previous_locale, self.locale = self.locale, locale
+        result = yield
+        self.locale = previous_locale
+        result
+      end
+
+      def translation_table_name
+        translation_class.table_name
+      end
+
+      def quoted_translation_table_name
+        translation_class.quoted_table_name
+      end
+
+      def required_attributes
+        validations = reflect_on_all_validations.select do |validation|
+          validation.macro == :validates_presence_of
+        end.map(&:name)
+      end
+
+      def respond_to?(method, *args, &block)
+        method.to_s =~ /^find_by_(\w+)$/ && translated_attribute_names.include?($1.to_sym) || super
+      end
+
+      def method_missing(method, *args)
+        if method.to_s =~ /^find_by_(\w+)$/ && translated_attribute_names.include?($1.to_sym)
+          find_first_by_translated_attr_and_locales($1, args.first)
+        else
+          super
+        end
+      end
+
+      protected
+
+        def find_first_by_translated_attr_and_locales(name, value)
+          query = "#{translated_attr_name(name)} = ? AND #{translated_attr_name('locale')} IN (?)"
+          locales = Globalize.fallbacks(locale || I18n.locale).map(&:to_s)
+          find(:first, :joins => :translations, :conditions => [query, value, locales])
+        end
+
+        def translated_attr_accessor(name)
+          define_method "#{name}=", lambda { |value|
+            globalize.write(self.class.locale || I18n.locale, name, value)
+            self[name] = value
+          }
+          define_method name, lambda { |*args|
+            globalize.fetch(args.first || self.class.locale || I18n.locale, name)
+          }
+          alias_method "#{name}_before_type_cast", name
+        end
+
+        def translated_attr_name(name)
+          "#{translation_class.table_name}.#{name}"
+        end
+    end
+
+    module InstanceMethods
+      def globalize
+        @globalize ||= Adapter.new self
+      end
+
+      def attributes=(attributes, *args)
+        if attributes.respond_to?(:delete) && locale = attributes.delete(:locale)
+          self.class.with_locale(locale) { super }
+        else
+          super
+        end
+      end
+
+      def available_locales
+        translations.scoped(:select => 'DISTINCT locale').map(&:locale)
+      end
+
+      def translated_locales
+        translations.map(&:locale)
+      end
+
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name => send(name))
+        end
+      end
+
+      def set_translations(options)
+        options.keys.each do |locale|
+          translation = translations.find_by_locale(locale.to_s) ||
+            translations.build(:locale => locale.to_s)
+          translation.update_attributes!(options[locale])
+        end
+      end
+
+      def reload(options = nil)
+        translated_attribute_names.each { |name| @attributes.delete(name.to_s) }
+        globalize.reset
+        super(options)
+      end
+
+      protected
+
+        def save_translations!
+          globalize.save_translations!
+        end
+    end
+  end
+end
diff --git a/vendor/plugins/globalize2/lib/globalize/active_record/adapter.rb b/vendor/plugins/globalize2/lib/globalize/active_record/adapter.rb
new file mode 100644
index 0000000..12f89ec
--- /dev/null
+++ b/vendor/plugins/globalize2/lib/globalize/active_record/adapter.rb
@@ -0,0 +1,80 @@
+module Globalize
+  module ActiveRecord
+    class Adapter
+      # The cache caches attributes that already were looked up for read access.
+      # The stash keeps track of new or changed values that need to be saved.
+      attr_reader :record, :cache, :stash
+
+      def initialize(record)
+        @record = record
+        @cache = Attributes.new
+        @stash = Attributes.new
+      end
+
+      def fetch(locale, attr_name)
+        cache.contains?(locale, attr_name) ?
+          cache.read(locale, attr_name) :
+          cache.write(locale, attr_name, fetch_attribute(locale, attr_name))
+      end
+
+      def write(locale, attr_name, value)
+        stash.write(locale, attr_name, value)
+        cache.write(locale, attr_name, value)
+      end
+
+      def save_translations!
+        stash.each do |locale, attrs|
+          translation = record.translations.find_or_initialize_by_locale(locale.to_s)
+          attrs.each { |attr_name, value| translation[attr_name] = value }
+          translation.save!
+        end
+        stash.clear
+      end
+
+      def reset
+        cache.clear
+        # stash.clear
+      end
+
+      protected
+
+        def fetch_translation(locale)
+          locale = locale.to_sym
+          record.translations.loaded? ? record.translations.detect { |t| t.locale == locale } :
+            record.translations.by_locale(locale)
+        end
+
+        def fetch_translations(locale)
+          # only query if not already included with :include => translations
+          record.translations.loaded? ? record.translations :
+            record.translations.by_locales(Globalize.fallbacks(locale))
+        end
+
+        def fetch_attribute(locale, attr_name)
+          translations = fetch_translations(locale)
+          value, requested_locale = nil, locale
+
+          Globalize.fallbacks(locale).each do |fallback|
+            translation = translations.detect { |t| t.locale == fallback }
+            value  = translation && translation.send(attr_name)
+            locale = fallback && break if value
+          end
+
+          set_metadata(value, :locale => locale, :requested_locale => requested_locale)
+          value
+        end
+
+        def set_metadata(object, metadata)
+          if object.respond_to?(:translation_metadata)
+            object.translation_metadata.merge!(meta_data)
+          end
+        end
+
+        def translation_metadata_accessor(object)
+          return if obj.respond_to?(:translation_metadata)
+          class << object; attr_accessor :translation_metadata end
+          object.translation_metadata ||= {}
+        end
+    end
+  end
+end
diff --git a/vendor/plugins/globalize2/lib/globalize/active_record/attributes.rb b/vendor/plugins/globalize2/lib/globalize/active_record/attributes.rb
new file mode 100644
index 0000000..7bd923c
--- /dev/null
+++ b/vendor/plugins/globalize2/lib/globalize/active_record/attributes.rb
@@ -0,0 +1,25 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+module Globalize
+  module ActiveRecord
+    class Attributes < Hash
+      def [](locale)
+        locale = locale.to_sym
+        self[locale] = {} unless has_key?(locale)
+        self.fetch(locale)
+      end
+
+      def contains?(locale, attr_name)
+        self[locale].has_key?(attr_name)
+      end
+
+      def read(locale, attr_name)
+        self[locale][attr_name]
+      end
+
+      def write(locale, attr_name, value)
+        self[locale][attr_name] = value
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/globalize2/lib/globalize/active_record/migration.rb b/vendor/plugins/globalize2/lib/globalize/active_record/migration.rb
new file mode 100644
index 0000000..ebff3b6
--- /dev/null
+++ b/vendor/plugins/globalize2/lib/globalize/active_record/migration.rb
@@ -0,0 +1,40 @@
+module Globalize
+  module ActiveRecord
+    module Migration
+      def create_translation_table!(fields)
+        translated_attribute_names.each do |f|
+          raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
+        end
+
+        fields.each do |name, type|
+          if translated_attribute_names.include?(name) && ![:string, :text].include?(type)
+            raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
+          end
+        end
+
+        self.connection.create_table(translation_table_name) do |t|
+          t.references self.table_name.singularize
+          t.string :locale
+          fields.each do |name, type|
+            t.column name, type
+          end
+          t.timestamps
+        end
+
+        self.connection.add_index(translation_table_name, "#{self.table_name.singularize}_id", :name => translation_index_name)
+      end
+
+      def translation_index_name
+        require 'digest/sha1'
+        # FIXME what's the max size of an index name?
+        index_name = "index_#{translation_table_name}_on_#{self.table_name.singularize}_id"
+        index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
+      end
+
+      def drop_translation_table!
+        self.connection.remove_index(translation_table_name, :name => translation_index_name) rescue nil
+        self.connection.drop_table(translation_table_name)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/globalize2/lib/globalize/backend/chain.rb b/vendor/plugins/globalize2/lib/globalize/backend/chain.rb
deleted file mode 100644
index bb8679e..0000000
--- a/vendor/plugins/globalize2/lib/globalize/backend/chain.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-module I18n
-  class << self
-    def chain_backends(*args)
-      self.backend = Globalize::Backend::Chain.new(*args)
-    end
-  end
-end
-  
-module Globalize  
-  module Backend
-    class Chain      
-      def initialize(*args)
-        add(*args) unless args.empty?
-      end
-      
-      # Change this to a) accept any number of backends and b) accept classes.
-      # When classes are passed instantiate them and add the instances as backends.
-      # Return the added backends from #add.
-      #
-      # Add an initialize method that accepts the same arguments and passes them
-      # to #add, so we could:
-      #   I18n.backend = Globalize::Backend::Chain.new(Globalize::Backend::Foo, Globalize::Backend::Bar)
-      #   Globalize::Backend::Chain.new(:foo, :bar)
-      #   Globalize.chain_backends :foo, :bar
-      def add(*backends)
-        backends.each do |backend|
-          backend = Globalize::Backend.const_get(backend.to_s.capitalize) if backend.is_a? Symbol
-          backend = backend.new if backend.is_a? Class
-          self.backends << backend
-        end
-      end
-      
-      def load_translations(*args)
-        backends.each{|backend| backend.load_translations(*args) }
-      end
-    
-      # For defaults:
-      # Never pass any default option to the backends but instead implement our own default
-      # mechanism (e.g. symbols as defaults would need to be passed to the whole chain to
-      # be translated).
-      #
-      # For namespace lookup: 
-      # Only return if the result is not a hash OR count is not present, otherwise merge them.
-      # So in effect the count variable would control whether we have a namespace lookup or a 
-      # pluralization going on.
-      #
-      # Exceptions:
-      # Make sure that we catch MissingTranslationData exceptions and raise
-      # one in the end when no translation was found at all.
-      #
-      # For bulk translation:
-      # If the key is an array we need to call #translate for each of the
-      # keys and collect the results.
-      
-      def translate(locale, key, options = {})
-        raise I18n::InvalidLocale.new(locale) if locale.nil?
-        return key.map{|k| translate locale, k, options } if key.is_a? Array
-        
-        default = options.delete(:default)
-        result = backends.inject({}) do |namespace, backend|
-          begin
-            translation = backend.translate(locale.to_sym, key, options) 
-            if namespace_lookup?(translation, options)
-              namespace.merge! translation
-            elsif translation
-              return translation 
-            end
-          rescue I18n::MissingTranslationData
-          end
-        end
-        result || default(locale, default, options) || raise(I18n::MissingTranslationData.new(locale, key, options))
-      end
-      
-      def localize(locale, object, format = :default)
-        backends.each do |backend|
-          result = backend.localize(locale, object, format) and return result
-        end
-      end
-    
-      protected
-        def backends
-          @backends ||= []
-        end
-        
-        def default(locale, default, options = {})
-          case default
-            when String then default
-            when Symbol then translate locale, default, options
-            when Array  then default.each do |obj| 
-              result = default(locale, obj, options.dup) and return result
-            end and nil
-          end
-        rescue I18n::MissingTranslationData
-          nil
-        end
-        
-        def namespace_lookup?(result, options)
-          result.is_a?(Hash) and not options.has_key?(:count)
-        end
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/backend/pluralizing.rb b/vendor/plugins/globalize2/lib/globalize/backend/pluralizing.rb
deleted file mode 100644
index 80016f2..0000000
--- a/vendor/plugins/globalize2/lib/globalize/backend/pluralizing.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-require 'i18n/backend/simple'
-
-module Globalize
-  module Backend
-    class Pluralizing < I18n::Backend::Simple
-      def pluralize(locale, entry, count)
-        return entry unless entry.is_a?(Hash) and count
-        key = :zero if count == 0 && entry.has_key?(:zero)
-        key ||= pluralizer(locale).call(count)
-        raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
-        translation entry[key], :plural_key => key
-      end
-
-      def add_pluralizer(locale, pluralizer)
-        pluralizers[locale.to_sym] = pluralizer
-      end
-
-      def pluralizer(locale)
-        pluralizers[locale.to_sym] || default_pluralizer
-      end
-
-      protected
-        def default_pluralizer
-          pluralizers[:en]
-        end
-
-        def pluralizers
-          @pluralizers ||= { :en => lambda{|n| n == 1 ? :one : :other } }
-        end
-
-        # Overwrite this method to return something other than a String
-        def translation(string, attributes)
-          string
-        end
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/backend/static.rb b/vendor/plugins/globalize2/lib/globalize/backend/static.rb
deleted file mode 100644
index fb9e1fe..0000000
--- a/vendor/plugins/globalize2/lib/globalize/backend/static.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-require 'globalize/backend/pluralizing'
-require 'globalize/locale/fallbacks'
-require 'globalize/translation'
-
-module Globalize
-  module Backend
-    class Static < Pluralizing
-      def initialize(*args)
-        add(*args) unless args.empty?
-      end
-
-      def translate(locale, key, options = {})
-        result, default, fallback = nil, options.delete(:default), nil
-        I18n.fallbacks[locale].each do |fallback|
-          begin
-            result = super(fallback, key, options) and break
-          rescue I18n::MissingTranslationData
-          end
-        end
-        result ||= default locale, default, options
-
-        attrs = {:requested_locale => locale, :locale => fallback, :key => key, :options => options}
-        translation(result, attrs) || raise(I18n::MissingTranslationData.new(locale, key, options))
-      end
-
-      protected
-
-        alias :orig_interpolate :interpolate unless method_defined? :orig_interpolate
-        def interpolate(locale, string, values = {})
-          result = orig_interpolate(locale, string, values)
-          translation = translation(string)
-          translation.nil? ? result : translation.replace(result)
-        end
-
-        def translation(result, meta = nil)
-          return unless result
-
-          case result
-          when Numeric
-            result
-          when String
-            result = Translation::Static.new(result) unless result.is_a? Translation::Static
-            result.set_meta meta
-            result
-          when Hash
-            Hash[*result.map do |key, value|
-              [key, translation(value, meta)]
-            end.flatten]
-          when Array
-            result.map do |value|
-              translation(value, meta)
-            end
-          else
-            result
-            # raise "unexpected translation type: #{result.inspect}"
-          end
-        end
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/load_path.rb b/vendor/plugins/globalize2/lib/globalize/load_path.rb
deleted file mode 100644
index a49825b..0000000
--- a/vendor/plugins/globalize2/lib/globalize/load_path.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# Locale load_path and Locale loading support.
-#
-# To use this include the Globalize::LoadPath::I18n module to I18n like this:
-#
-#   I18n.send :include, Globalize::LoadPath::I18n
-#
-# Clients can add load_paths using:
-#
-#   I18n.load_path.add load_path, 'rb', 'yml'   # pass any number of extensions like this
-#   I18n.load_path << 'path/to/dir'             # usage without an extension, defaults to 'yml'
-#
-# And load locale data using either of:
-#
-#   I18n.load_locales 'en-US', 'de-DE'
-#   I18n.load_locale 'en-US'
-# 
-# This will lookup all files named like:
-#
-#   'path/to/dir/all.yml'
-#   'path/to/dir/en-US.yml'
-#   'path/to/dir/en-US/*.yml'
-#
-# The filenames will be passed to I18n.load_translations which delegates to 
-# the backend. So the actual behaviour depends on the implementation of the
-# backend. I18n::Backend::Simple will be able to read YAML and plain Ruby 
-# files. See the documentation for I18n.load_translations for details.
-
-module Globalize
-  class LoadPath < Array
-    def extensions
-      @extensions ||= ['rb', 'yml']
-    end
-    attr_writer :extensions
-  
-    def locales
-      @locales ||= ['*']
-    end
-    attr_writer :locales
-  
-    def <<(path)
-      push path
-    end
-  
-    def push(*paths)
-      super(*paths.map{|path| filenames(path) }.flatten.uniq.sort)
-    end
-  
-    protected
-  
-      def filenames(path)
-        return [path] if File.file? path
-        patterns(path).map{|pattern| Dir[pattern] }
-      end
-  
-      def patterns(path)
-        locales.map do |locale|
-          extensions.map do |extension|
-            %W(#{path}/all.#{extension} #{path}/#{locale}.#{extension} #{path}/#{locale}/**/*.#{extension})
-          end
-        end.flatten.uniq
-      end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/locale/fallbacks.rb b/vendor/plugins/globalize2/lib/globalize/locale/fallbacks.rb
deleted file mode 100644
index c4acd57..0000000
--- a/vendor/plugins/globalize2/lib/globalize/locale/fallbacks.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-require 'globalize/locale/language_tag'
-
-module I18n
-  @@fallbacks = nil
-    
-  class << self
-    # Returns the current fallbacks. Defaults to +Globalize::Locale::Fallbacks+.
-    def fallbacks
-      @@fallbacks ||= Globalize::Locale::Fallbacks.new
-    end
-    
-    # Sets the current fallbacks. Used to set a custom fallbacks instance.
-    def fallbacks=(fallbacks) 
-      @@fallbacks = fallbacks
-    end
-  end
-end
-
-module Globalize
-  module Locale
-    class Fallbacks < Hash
-      def initialize(*defaults)
-        @map = {}
-        map defaults.pop if defaults.last.is_a?(Hash)
-        
-        defaults = [I18n.default_locale.to_sym] if defaults.empty?
-        self.defaults = defaults 
-      end
-      
-      def defaults=(defaults)
-        @defaults = defaults.map{|default| compute(default, false) }.flatten << :root
-      end
-      attr_reader :defaults
-      
-      def [](tag)
-        tag = tag.to_sym
-        has_key?(tag) ? fetch(tag) : store(tag, compute(tag))
-      end
-    
-      def map(mappings)
-        mappings.each do |from, to|
-          from, to = from.to_sym, Array(to)
-          to.each do |to|
-            @map[from] ||= []
-            @map[from] << to.to_sym
-          end
-        end
-      end
-      
-      protected
-    
-      def compute(tags, include_defaults = true)
-        result = Array(tags).collect do |tag|
-          tags = LanguageTag::tag(tag.to_sym).parents(true).map! {|t| t.to_sym }
-          tags.each{|tag| tags += compute(@map[tag]) if @map[tag] }
-          tags
-        end.flatten
-        result.push *defaults if include_defaults
-        result.uniq
-      end
-    end
-  end
-end
diff --git a/vendor/plugins/globalize2/lib/globalize/locale/language_tag.rb b/vendor/plugins/globalize2/lib/globalize/locale/language_tag.rb
deleted file mode 100644
index d9aae54..0000000
--- a/vendor/plugins/globalize2/lib/globalize/locale/language_tag.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# for specifications see http://en.wikipedia.org/wiki/IETF_language_tag
-#
-# SimpleParser does not implement advanced usages such as grandfathered tags
-
-module Globalize
-  module Locale
-    module Rfc4646
-      SUBTAGS = [:language, :script, :region, :variant, :extension, :privateuse, :grandfathered]
-      FORMATS = {:language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase}
-    end
-    
-    class LanguageTag < Struct.new(*Rfc4646::SUBTAGS)
-      class << self
-        def parser
-          @@parser ||= SimpleParser
-        end
-    
-        def parser=(parser)
-          @@parser = parser
-        end
-    
-        def tag(tag)
-          matches = parser.match(tag)
-          new *matches if matches
-        end
-      end
-  
-      Rfc4646::FORMATS.each do |name, format|
-        define_method(name) { self[name].send(format) unless self[name].nil? }
-      end
-      
-      def to_sym
-        to_s.to_sym
-      end
-      
-      def to_s
-        @tag ||= to_a.compact.join("-")
-      end
-  
-      def to_a
-        members.collect {|attr| self.send(attr) }
-      end
-  
-      def parent
-        segs = to_a.compact
-        segs.length < 2 ? nil : LanguageTag.tag(segs[0..(segs.length-2)].join('-'))
-      end
-      
-      def parents(include_self = true)
-        result, parent = [], self.dup
-        result << parent if include_self
-        while parent = parent.parent
-          result << parent
-        end
-        result
-      end
-  
-      module SimpleParser
-        PATTERN = %r{\A(?:
-          ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
-          (?:-([a-z]{4}))?                                        # script
-          (?:-([a-z]{2}|\d{3}))?                                  # region
-          (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
-          (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
-          (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
-          (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
-          /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
-          )\z}xi 
-
-        class << self
-          def match(tag)
-            c = PATTERN.match(tag.to_s).captures
-            c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
-          rescue
-            false
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/vendor/plugins/globalize2/lib/globalize/model/active_record.rb b/vendor/plugins/globalize2/lib/globalize/model/active_record.rb
deleted file mode 100644
index 9218054..0000000
--- a/vendor/plugins/globalize2/lib/globalize/model/active_record.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-require 'globalize/translation'
-require 'globalize/locale/fallbacks'
-require 'globalize/model/active_record/adapter'
-require 'globalize/model/active_record/translated'
-
-module Globalize
-  module Model
-    module ActiveRecord
-      class << self
-        def create_proxy_class(klass)
-          module_names = klass.name.split('::')
-          klass_name   = module_names.pop
-          target       = module_names.empty? ? Object : module_names.join('::').constantize
-
-          target.const_set "#{klass_name}Translation", Class.new(::ActiveRecord::Base) {
-            belongs_to "#{klass.name.underscore.gsub('/', '_')}".intern
-
-            def locale
-              read_attribute(:locale).to_sym
-            end
-
-            def locale=(locale)
-              write_attribute(:locale, locale.to_s)
-            end
-          }
-        end
-
-        def define_accessors(klass, attr_names)
-          attr_names.each do |attr_name|
-            klass.send :define_method, attr_name, lambda {
-              globalize.fetch self.class.locale, attr_name
-            }
-            klass.send :define_method, "#{attr_name}_before_type_cast", lambda {
-              globalize.fetch self.class.locale, attr_name
-            }
-            klass.send :define_method, "#{attr_name}=", lambda {|val|
-              globalize.stash self.class.locale, attr_name, val
-              self[attr_name] = val
-            }
-          end
-        end
-      end
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/model/active_record/adapter.rb b/vendor/plugins/globalize2/lib/globalize/model/active_record/adapter.rb
deleted file mode 100644
index 93355b8..0000000
--- a/vendor/plugins/globalize2/lib/globalize/model/active_record/adapter.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-module Globalize
-  module Model
-    class AttributeStash < Hash
-      def contains?(locale, attr_name)
-        locale = locale.to_sym
-        self[locale] ||= {}
-        self[locale].has_key? attr_name        
-      end
-      
-      def read(locale, attr_name)
-        locale = locale.to_sym
-        self[locale] ||= {}
-        self[locale][attr_name]
-      end
-      
-      def write(locale, attr_name, value)
-        locale = locale.to_sym
-        self[locale] ||= {}
-        self[locale][attr_name] = value
-      end
-    end
-    
-    class Adapter
-      def initialize(record)
-        @record = record
-        
-        # TODO what exactly are the roles of cache and stash
-        @cache = AttributeStash.new
-        @stash = AttributeStash.new
-      end
-      
-      def fetch(locale, attr_name)
-        # locale = I18n.locale
-        is_cached = @cache.contains?(locale, attr_name)
-        is_cached ? @cache.read(locale, attr_name) : begin
-          value = fetch_attribute locale, attr_name
-          @cache.write locale, attr_name, value if value && value.locale == locale
-          value
-        end
-      end
-      
-      def stash(locale, attr_name, value)
-        @stash.write locale, attr_name, value
-        @cache.write locale, attr_name, value
-      end
-      
-      def update_translations!
-        @stash.each do |locale, attrs|
-          translation = @record.globalize_translations.find_or_initialize_by_locale(locale.to_s)
-          attrs.each{|attr_name, value| translation[attr_name] = value }
-          translation.save!
-        end
-        @stash.clear
-      end
-      
-      # Clears the cache
-      def clear
-        @cache.clear
-        @stash.clear
-      end
-      
-      private
-      
-      def fetch_attribute(locale, attr_name)
-        fallbacks = I18n.fallbacks[locale].map{|tag| tag.to_s}.map(&:to_sym)
-        
-        # If the translations were included with 
-        # :include => globalize_translations
-        # there is no need to query them again.
-        unless @record.globalize_translations.loaded?
-          translations = @record.globalize_translations.by_locales(fallbacks) 
-        else
-          translations = @record.globalize_translations
-        end
-        result, requested_locale = nil, locale
-
-        # Walk through the fallbacks, starting with the current locale itself, and moving
-        # to the next best choice, until we find a match.
-        # Check the @globalize_set_translations cache first to see if we've just changed the 
-        # attribute and not saved yet.
-        fallbacks.each do |fallback|
-          # TODO should we be checking stash or just cache?
-          result = @stash.read(fallback, attr_name) || begin
-            translation = translations.detect {|tr| tr.locale == fallback }
-            translation && translation.send(attr_name)
-          end
-          if result
-            locale = fallback
-            break
-          end
-        end
-        result && Translation::Attribute.new(result, :locale => locale, :requested_locale => requested_locale)
-      end
-    end
-  end
-end
diff --git a/vendor/plugins/globalize2/lib/globalize/model/active_record/translated.rb b/vendor/plugins/globalize2/lib/globalize/model/active_record/translated.rb
deleted file mode 100644
index 4f75c8a..0000000
--- a/vendor/plugins/globalize2/lib/globalize/model/active_record/translated.rb
+++ /dev/null
@@ -1,164 +0,0 @@
-require 'digest/sha1'
-
-module Globalize
-  module Model
-    class MigrationError < StandardError; end
-    class MigrationMissingTranslatedField < MigrationError; end
-    class BadMigrationFieldType < MigrationError; end
-
-    module ActiveRecord
-      module Translated
-        def self.included(base)
-          base.extend ActMethods
-        end
-
-        module ActMethods
-          def translates(*attr_names)
-            options = attr_names.extract_options!
-            options[:translated_attributes] = attr_names
-
-            # Only set up once per class
-            unless included_modules.include? InstanceMethods
-              class_inheritable_accessor :globalize_options, :globalize_proxy
-
-              include InstanceMethods
-              extend  ClassMethods
-
-              self.globalize_proxy = Globalize::Model::ActiveRecord.create_proxy_class(self)
-              has_many(
-                :globalize_translations,
-                :class_name   => globalize_proxy.name,
-                :extend       => Extensions,
-                :dependent    => :delete_all,
-                :foreign_key  => class_name.foreign_key
-              )
-
-              after_save :update_globalize_record
-            end
-
-            self.globalize_options = options
-            Globalize::Model::ActiveRecord.define_accessors(self, attr_names)
-
-            # Import any callbacks that have been defined by extensions to Globalize2
-            # and run them.
-            extend Callbacks
-            Callbacks.instance_methods.each { |callback| send(callback) }
-          end
-
-          def locale=(locale)
-            @@locale = locale
-          end
-
-          def locale
-            (defined?(@@locale) && @@locale) || I18n.locale
-          end
-        end
-
-        # Dummy Callbacks module. Extensions to Globalize2 can insert methods into here
-        # and they'll be called at the end of the translates class method.
-        module Callbacks
-        end
-
-        # Extension to the has_many :globalize_translations association
-        module Extensions
-          def by_locales(locales)
-            find :all, :conditions => { :locale => locales.map(&:to_s) }
-          end
-        end
-
-        module ClassMethods
-          def method_missing(method, *args)
-            if method.to_s =~ /^find_by_(\w+)$/ && globalize_options[:translated_attributes].include?($1.to_sym)
-              find(:first, :joins => :globalize_translations,
-                   :conditions => [ "#{i18n_attr($1)} = ? AND #{i18n_attr('locale')} IN (?)",
-                                   args.first,I18n.fallbacks[I18n.locale].map{|tag| tag.to_s}])
-            else
-              super
-            end
-          end
-
-          def create_translation_table!(fields)
-            translated_fields = self.globalize_options[:translated_attributes]
-            translated_fields.each do |f|
-              raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
-            end
-
-            fields.each do |name, type|
-              if translated_fields.include?(name) && ![:string, :text].include?(type)
-                raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
-              end
-            end
-
-            self.connection.create_table(translation_table_name) do |t|
-              t.references self.table_name.singularize
-              t.string :locale
-              fields.each do |name, type|
-                t.column name, type
-              end
-              t.timestamps
-            end
-
-            self.connection.add_index(translation_table_name, "#{self.table_name.singularize}_id", :name => translation_index_name)
-          end
-
-          def translation_table_name
-            self.name.underscore.gsub('/', '_') + '_translations'
-          end
-
-          def translation_index_name
-            # FIXME what's the max size of an index name?
-            index_name = "index_#{translation_table_name}_on_#{self.table_name.singularize}_id"
-            index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
-          end
-
-          def drop_translation_table!
-            self.connection.remove_index(translation_table_name, :name => translation_index_name)
-            self.connection.drop_table translation_table_name
-          end
-
-          private
-
-          def i18n_attr(attribute_name)
-            self.base_class.name.underscore.gsub('/', '_') + "_translations.#{attribute_name}"
-          end
-        end
-
-        module InstanceMethods
-          def reload(options = nil)
-            globalize.clear
-
-            # clear all globalized attributes
-            # TODO what's the best way to handle this?
-            self.class.globalize_options[:translated_attributes].each do |attr|
-              @attributes.delete(attr.to_s)
-            end
-
-            super(options)
-          end
-
-          def globalize
-            @globalize ||= Adapter.new self
-          end
-
-          def update_globalize_record
-            globalize.update_translations!
-          end
-
-          def translated_locales
-            globalize_translations.scoped(:select => 'DISTINCT locale').map do |translation|
-              translation.locale.to_sym
-            end
-          end
-
-          def set_translations options
-            options.keys.each do |key|
-              translation = globalize_translations.find_by_locale(key.to_s) ||
-                globalize_translations.build(:locale => key.to_s)
-              translation.update_attributes!(options[key])
-            end
-          end
-        end
-      end
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/translation.rb b/vendor/plugins/globalize2/lib/globalize/translation.rb
deleted file mode 100644
index a80afcd..0000000
--- a/vendor/plugins/globalize2/lib/globalize/translation.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-module Globalize
-  # Translations are simple value objects that carry some context information
-  # alongside the actual translation string.
-
-  class Translation < String
-    class Attribute < Translation
-      attr_accessor :requested_locale, :locale, :key
-    end
-    
-    class Static < Translation
-      attr_accessor :requested_locale, :locale, :key, :options, :plural_key, :original
-      
-      def initialize(string, meta = nil)
-        self.original = string
-        super
-      end
-    end
-    
-    def initialize(string, meta = nil)
-      set_meta meta
-      super string
-    end
-  
-    def fallback?
-      locale.to_sym != requested_locale.to_sym
-    end
-    
-    def set_meta(meta)
-      meta.each {|name, value| send :"#{name}=", value } if meta
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/globalize/i18n/missing_translations_log_handler.rb b/vendor/plugins/globalize2/lib/i18n/missing_translations_log_handler.rb
index 3f06ac2..24c1089 100644
--- a/vendor/plugins/globalize2/lib/globalize/i18n/missing_translations_log_handler.rb
+++ b/vendor/plugins/globalize2/lib/i18n/missing_translations_log_handler.rb
@@ -2,10 +2,10 @@
 # but additionally logs missing translations to a given log.
 #
 # Useful for identifying missing translations during testing.
-# 
-# E.g. 
 #
-#   require 'globalize/i18n/missing_translations_log_handler
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_log_handler'
 #   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
 #   I18n.exception_handler = :missing_translations_log_handler
 #
@@ -16,7 +16,7 @@
 
 module I18n
   @@missing_translations_logger = nil
-  
+
   class << self
     def missing_translations_logger
       @@missing_translations_logger ||= begin
@@ -24,18 +24,18 @@ module I18n
         Logger.new(STDOUT)
       end
     end
-  
+
     def missing_translations_logger=(logger)
       @@missing_translations_logger = logger
     end
-  
+
     def missing_translations_log_handler(exception, locale, key, options)
       if MissingTranslationData === exception
         missing_translations_logger.warn(exception.message)
-        return exception.message 
+        return exception.message
       else
         raise exception
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/vendor/plugins/globalize2/lib/globalize/i18n/missing_translations_raise_handler.rb b/vendor/plugins/globalize2/lib/i18n/missing_translations_raise_handler.rb
index e32be28..18237b1 100644
--- a/vendor/plugins/globalize2/lib/globalize/i18n/missing_translations_raise_handler.rb
+++ b/vendor/plugins/globalize2/lib/i18n/missing_translations_raise_handler.rb
@@ -2,10 +2,10 @@
 # but also raises on missing translations.
 #
 # Useful for identifying missing translations during testing.
-# 
-# E.g. 
 #
-#   require 'globalize/i18n/missing_translations_raise_handler
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_raise_handler'
 #   I18n.exception_handler = :missing_translations_raise_handler
 module I18n
   class << self
@@ -13,8 +13,6 @@ module I18n
       raise exception
     end
   end
-  
-#  self.exception_handler = :missing_translations_raise_handler
 end
 
 I18n.exception_handler = :missing_translations_raise_handler
diff --git a/vendor/plugins/globalize2/lib/locale/root.yml b/vendor/plugins/globalize2/lib/locale/root.yml
deleted file mode 100644
index 2ec2b3b..0000000
--- a/vendor/plugins/globalize2/lib/locale/root.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-root:
-  bidi:
-    direction: left-to-right
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/lib/rails_edge_load_path_patch.rb b/vendor/plugins/globalize2/lib/rails_edge_load_path_patch.rb
deleted file mode 100644
index e6f90d8..0000000
--- a/vendor/plugins/globalize2/lib/rails_edge_load_path_patch.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-module I18n
-  @@load_path = nil
-  @@default_locale = :'en-US'
-  
-  class << self
-    def load_path
-      @@load_path ||= []
-    end
-    
-    def load_path=(load_path)
-      @@load_path = load_path
-    end
-  end
-end
-
-I18n::Backend::Simple.module_eval do
-  def initialized?
-    @initialized ||= false
-  end
-  
-  protected
-
-    def init_translations
-      load_translations(*I18n.load_path)
-      @initialized = true
-    end
-    
-    def lookup(locale, key, scope = [])
-      return unless key
-      init_translations unless initialized?
-      keys = I18n.send :normalize_translation_keys, locale, key, scope
-      keys.inject(translations){|result, k| result[k.to_sym] or return nil }
-    end
-end
-
-rails_dir = File.expand_path "#{File.dirname(__FILE__)}/../../../rails/"
-paths = %w(actionpack/lib/action_view/locale/en-US.yml 
-           activerecord/lib/active_record/locale/en-US.yml
-           activesupport/lib/active_support/locale/en-US.yml)
-paths.each{|path| I18n.load_path << "#{rails_dir}/#{path}" }
diff --git a/vendor/plugins/globalize2/notes.textile b/vendor/plugins/globalize2/notes.textile
deleted file mode 100644
index b686f41..0000000
--- a/vendor/plugins/globalize2/notes.textile
+++ /dev/null
@@ -1,51 +0,0 @@
-Stopped DB Backend in the middle, here's where we left off:
-
-h1. Some Notes
-
-* Started doing the migration generator in generators/db_backend.rb
-* Translation keys will be in dotted string format
-* Question: Do we need a plural_key column, or can we build it in to the dotted key?
-* We will probably have to code the following methods from scratch, to optimize db calls:
-** translate
-** localize
-** pluralize
-* We should refactor @interpolation@ code so that it can be included into backend code without inheriting SimpleBackend
-** Rationale: interpolation is something done entirely after a string is fetched from the data store
-** Alternately, it could be done from within the I18n module
-
-h1. Schema
-
-There will be two db tables. 
-
-# globalize_translations will have: locale, key, translation, created_at, updated_at.
-# globalize_translations_map will have: key, translation_id.
-
-globalize_translations_map will let us easily fetch entire sub-trees of namespaces. 
-However, this table may not be necessary, as it may be feasible to just use key LIKE "some.namespace.%".
-
-h1. Caching
-
-We'll almost certainly want to implement caching in the backend. Should probably be a customized
-implementation based on the Rails caching mechanism, to support memcached, etc.
-
-h1. Queries
-
-We'll want to pull in lots of stuff at once and return a single translation based on some
-quick Ruby selection. The query will look something like this:
-
-<pre>
-<code>
-SELECT * FROM globalize_translations
-WHERE locale in (<fallbacks>) AND
-key IN (key, default_key)
-</code>
-</pre>
-
-The Ruby code would then pick the first translation that satisfies a fallback, in fallback order. 
-Of course, the records with the supplied key would take precedence of those with the default key.
-
-h1. Misc
-
-We should revisit the :zero plural code. On the one hand it's certainly useful for 
-many apps in many languages. On the other hand it's not mentioned in CLDR, and not a real
-concept in language pluralization. Right now, I'm feeling it's still a good idea to keep it in. 
diff --git a/vendor/plugins/globalize2/test/active_record/fallbacks_test.rb b/vendor/plugins/globalize2/test/active_record/fallbacks_test.rb
new file mode 100644
index 0000000..449ec8b
--- /dev/null
+++ b/vendor/plugins/globalize2/test/active_record/fallbacks_test.rb
@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
+
+if I18n.respond_to?(:fallbacks)
+  class TranslatedTest < ActiveSupport::TestCase
+    def setup
+      I18n.locale = :'en-US'
+      I18n.fallbacks.clear
+      reset_db!
+      ActiveRecord::Base.locale = nil
+    end
+
+    def teardown
+      I18n.fallbacks.clear
+    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 "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 '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 'fallbacks with lots of locale switching' do
+      I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+      child = Child.create :content => 'foo'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'foo', child.content
+
+      I18n.locale = :'en-US'
+      child.update_attribute :content, 'bar'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'bar', child.content
+    end
+  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.
+
diff --git a/vendor/plugins/globalize2/test/model/active_record/migration_test.rb b/vendor/plugins/globalize2/test/active_record/migration_test.rb
index eb6533d..359d811 100644
--- a/vendor/plugins/globalize2/test/model/active_record/migration_test.rb
+++ b/vendor/plugins/globalize2/test/active_record/migration_test.rb
@@ -1,36 +1,32 @@
-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' )
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
 
 class MigrationTest < ActiveSupport::TestCase
   def setup
-    reset_db! File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'no_globalize_schema.rb'))
+    reset_db!
+    Post.drop_translation_table!
   end
 
   test 'globalize table added' do
-    assert !Post.connection.table_exists?( :post_translations )
-    assert !Post.connection.index_exists?( :post_translations, :post_id )
-    Post.create_translation_table! :subject => :string, :content => :text
-    assert Post.connection.table_exists?( :post_translations )
-    assert Post.connection.index_exists?( :post_translations, :post_id )
-    columns = Post.connection.columns( :post_translations )
-    assert locale = columns.detect {|c| c.name == 'locale' }
+    assert !Post.connection.table_exists?(:post_translations)
+    assert !Post.connection.index_exists?(:post_translations, :post_id)
+
+    Post.create_translation_table!(:subject => :string, :content => :text)
+    assert Post.connection.table_exists?(:post_translations)
+    assert Post.connection.index_exists?(:post_translations, :post_id)
+
+    columns = Post.connection.columns(:post_translations)
+    assert locale = columns.detect { |c| c.name == 'locale' }
     assert_equal :string, locale.type
-    assert subject = columns.detect {|c| c.name == 'subject' }
+    assert subject = columns.detect { |c| c.name == 'subject' }
     assert_equal :string, subject.type
-    assert content = columns.detect {|c| c.name == 'content' }
+    assert content = columns.detect { |c| c.name == 'content' }
     assert_equal :text, content.type
-    assert post_id = columns.detect {|c| c.name == 'post_id' }
+    assert post_id = columns.detect { |c| c.name == 'post_id' }
     assert_equal :integer, post_id.type
-    assert created_at = columns.detect {|c| c.name == 'created_at' }
+    assert created_at = columns.detect { |c| c.name == 'created_at' }
     assert_equal :datetime, created_at.type
-    assert updated_at = columns.detect {|c| c.name == 'updated_at' }
+    assert updated_at = columns.detect { |c| c.name == 'updated_at' }
     assert_equal :datetime, updated_at.type
   end
 
@@ -46,13 +42,13 @@ class MigrationTest < ActiveSupport::TestCase
   end
 
   test 'exception on missing field inputs' do
-    assert_raise Globalize::Model::MigrationMissingTranslatedField do
+    assert_raise Globalize::MigrationMissingTranslatedField do
       Post.create_translation_table! :content => :text
     end
   end
 
   test 'exception on bad input type' do
-    assert_raise Globalize::Model::BadMigrationFieldType do
+    assert_raise Globalize::BadMigrationFieldType do
       Post.create_translation_table! :subject => :string, :content => :integer
     end
   end
@@ -74,31 +70,29 @@ class MigrationTest < ActiveSupport::TestCase
       Blog.drop_translation_table!
     end
   end
-  
+
   test "translation_index_name returns a readable index name when it's not longer than 50 characters" do
     assert_equal 'index_post_translations_on_post_id', Post.send(:translation_index_name)
   end
-  
+
   test "translation_index_name returns a hashed index name when it's longer than 50 characters" do
     class UltraLongModelNameWithoutProper < ActiveRecord::Base
       translates :foo
     end
-    expected = 'index_44eba0f057e01a590ffccd0b8a3b5c78979539cd'
-    actual = UltraLongModelNameWithoutProper.send(:translation_index_name)
-
-    assert_equal expected, actual
+    name = UltraLongModelNameWithoutProper.send(:translation_index_name)
+    assert_match /^index_[a-z0-9]{40}$/, name
   end
-  
+
   test 'globalize table added when table has long name' do
     UltraLongModelNameWithoutProper.create_translation_table!(
       :subject => :string, :content => :text
     )
-    
+
     assert UltraLongModelNameWithoutProper.connection.table_exists?(
       :ultra_long_model_name_without_proper_translations
     )
-    assert UltraLongModelNameWithoutProper.connection.index_exists?( 
-      :ultra_long_model_name_without_proper_translations, 
+    assert UltraLongModelNameWithoutProper.connection.index_exists?(
+      :ultra_long_model_name_without_proper_translations,
       :name => UltraLongModelNameWithoutProper.send(
         :translation_index_name
       )
@@ -106,20 +100,19 @@ class MigrationTest < ActiveSupport::TestCase
   end
 
   test 'globalize table dropped when table has long name' do
+    UltraLongModelNameWithoutProper.drop_translation_table!
     UltraLongModelNameWithoutProper.create_translation_table!(
       :subject => :string, :content => :text
     )
-    
     UltraLongModelNameWithoutProper.drop_translation_table!
-    
+
     assert !UltraLongModelNameWithoutProper.connection.table_exists?(
       :ultra_long_model_name_without_proper_translations
     )
-    
     assert !UltraLongModelNameWithoutProper.connection.index_exists?(
-      :ultra_long_model_name_without_proper_translations, 
+      :ultra_long_model_name_without_proper_translations,
       :ultra_long_model_name_without_proper_id
     )
   end
 
-end
\ No newline at end of file
+end
diff --git a/vendor/plugins/globalize2/test/model/active_record/sti_translated_test.rb b/vendor/plugins/globalize2/test/active_record/sti_translated_test.rb
index 6980ba0..f529b8d 100644
--- a/vendor/plugins/globalize2/test/model/active_record/sti_translated_test.rb
+++ b/vendor/plugins/globalize2/test/active_record/sti_translated_test.rb
@@ -1,22 +1,10 @@
-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' )
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
 
 class StiTranslatedTest < ActiveSupport::TestCase
   def setup
     I18n.locale = :'en-US'
-    I18n.fallbacks.clear
-    reset_db! File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'schema.rb'))
-  end
-
-  def teardown
-    I18n.fallbacks.clear
+    reset_db!
   end
 
   test "works with simple dynamic finders" do
@@ -43,20 +31,6 @@ class StiTranslatedTest < ActiveSupport::TestCase
     assert_equal [ 'content' ], child.changed
   end
 
-  test 'fallbacks with lots of locale switching' do
-    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
-    child = Child.create :content => 'foo'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'foo', child.content
-
-    I18n.locale = :'en-US'
-    child.update_attribute :content, 'bar'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'bar', child.content
-  end
-
   test "saves all locales, even after locale switching" do
     child = Child.new :content => 'foo'
     I18n.locale = 'de-DE'
@@ -72,4 +46,4 @@ class StiTranslatedTest < ActiveSupport::TestCase
     I18n.locale = 'he-IL'
     assert_equal 'baz', child.content
   end
-end
\ No newline at end of file
+end
diff --git a/vendor/plugins/globalize2/test/active_record/translates_test.rb b/vendor/plugins/globalize2/test/active_record/translates_test.rb
new file mode 100644
index 0000000..4207bc4
--- /dev/null
+++ b/vendor/plugins/globalize2/test/active_record/translates_test.rb
@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
+
+class TranslatesTest < ActiveSupport::TestCase
+  def setup
+    I18n.locale = nil
+    ActiveRecord::Base.locale = nil
+    reset_db!
+  end
+
+  test 'defines a :locale accessors on ActiveRecord::Base' do
+    ActiveRecord::Base.locale = :de
+    assert_equal :de, ActiveRecord::Base.locale
+  end
+
+  test 'the :locale reader on ActiveRecord::Base does not default to I18n.locale (anymore)' do
+    I18n.locale = :en
+    assert_nil ActiveRecord::Base.locale
+  end
+
+  test 'ActiveRecord::Base.with_locale temporarily sets the given locale and yields the block' do
+    I18n.locale = :en
+    post = Post.with_locale(:de) do
+      Post.create!(:subject => 'Titel', :content => 'Inhalt')
+    end
+    assert_nil Post.locale
+    assert_equal :en, I18n.locale
+
+    I18n.locale = :de
+    assert_equal 'Titel', post.subject
+  end
+
+  test 'translation_class returns the Translation class' do
+    assert_equal Post::Translation, Post.translation_class
+  end
+
+  test 'defines a has_many association on the model class' do
+    assert_has_many Post, :translations
+  end
+
+  test 'defines a scope for retrieving locales that have complete translations' do
+    post = Post.create!(:subject => 'subject', :content => 'content')
+    assert_equal [:en], post.translated_locales
+  end
+
+  test 'sets the given attributes to translated_attribute_names' do
+    assert_equal [:subject, :content], Post.translated_attribute_names
+  end
+
+  test 'defines accessors for the translated attributes' do
+    post = Post.new
+    assert post.respond_to?(:subject)
+    assert post.respond_to?(:subject=)
+  end
+
+  test 'attribute reader without arguments will use the current locale on ActiveRecord::Base or I18n' do
+    post = Post.with_locale(:de) do
+      Post.create!(:subject => 'Titel', :content => 'Inhalt')
+    end
+    I18n.locale = :de
+    assert_equal 'Titel', post.subject
+
+    I18n.locale = :en
+    ActiveRecord::Base.locale = :de
+    assert_equal 'Titel', post.subject
+  end
+
+  test 'attribute reader when passed a locale will use the given locale' do
+    post = Post.with_locale(:de) do
+      Post.create!(:subject => 'Titel', :content => 'Inhalt')
+    end
+    assert_equal 'Titel', post.subject(:de)
+  end
+
+  test 'attribute reader will use the current locale on ActiveRecord::Base or I18n' do
+    post = Post.with_locale(:en) do
+      Post.create!(:subject => 'title', :content => 'content')
+    end
+    I18n.locale = :de
+    post.subject = 'Titel'
+    assert_equal 'Titel', post.subject
+
+    ActiveRecord::Base.locale = :en
+    post.subject = 'title'
+    assert_equal 'title', post.subject
+  end
+end
diff --git a/vendor/plugins/globalize2/test/active_record/translation_class_test.rb b/vendor/plugins/globalize2/test/active_record/translation_class_test.rb
new file mode 100644
index 0000000..1628416
--- /dev/null
+++ b/vendor/plugins/globalize2/test/active_record/translation_class_test.rb
@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
+
+class TranlationClassTest < ActiveSupport::TestCase
+  def setup
+    reset_db!
+  end
+
+  test 'defines a Translation class nested in the model class' do
+    assert Post.const_defined?(:Translation)
+  end
+
+  test 'defines a belongs_to association' do
+    assert_belongs_to Post::Translation, :post
+  end
+
+  test 'defines a reader for :locale that always returns a symbol' do
+    post = Post::Translation.new
+    post.write_attribute('locale', 'de')
+    assert_equal :de, post.locale
+  end
+
+  test 'defines a write for :locale that always writes a string' do
+    post = Post::Translation.new
+    post.locale = :de
+    assert_equal 'de', post.read_attribute('locale')
+  end
+end
+
+
diff --git a/vendor/plugins/globalize2/test/active_record/validation_tests.rb b/vendor/plugins/globalize2/test/active_record/validation_tests.rb
new file mode 100644
index 0000000..0148fa3
--- /dev/null
+++ b/vendor/plugins/globalize2/test/active_record/validation_tests.rb
@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
+
+class ValidationTest < ActiveSupport::TestCase
+  def setup
+    reset_db!
+  end
+  
+  def teardown
+    Validatee.instance_variable_set(:@validate_callbacks, CallbackChain.new)
+  end
+  
+  test "validates_presence_of" do
+    Validatee.class_eval { validates_presence_of :string }
+    assert !Validatee.new.valid?
+    assert Validatee.new(:string => 'foo').valid?
+  end
+
+  test "validates_confirmation_of" do
+    Validatee.class_eval { validates_confirmation_of :string }
+    assert !Validatee.new(:string => 'foo', :string_confirmation => 'bar').valid?
+    assert Validatee.new(:string => 'foo', :string_confirmation => 'foo').valid?
+  end
+
+  test "validates_acceptance_of" do
+    Validatee.class_eval { validates_acceptance_of :string, :accept => '1' }
+    assert !Validatee.new(:string => '0').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+  
+  test "validates_length_of (:is)" do
+    Validatee.class_eval { validates_length_of :string, :is => 1 }
+    assert !Validatee.new(:string => 'aa').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_format_of" do
+    Validatee.class_eval { validates_format_of :string, :with => /^\d+$/ }
+    assert !Validatee.new(:string => 'a').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+  
+  test "validates_inclusion_of" do
+    Validatee.class_eval { validates_inclusion_of :string, :in => %(a) }
+    assert !Validatee.new(:string => 'b').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_exclusion_of" do
+    Validatee.class_eval { validates_exclusion_of :string, :in => %(b) }
+    assert !Validatee.new(:string => 'b').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_numericality_of" do
+    Validatee.class_eval { validates_numericality_of :string }
+    assert !Validatee.new(:string => 'a').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+
+  # This doesn't pass and Rails' validates_uniqueness_of implementation doesn't
+  # seem to be extensible easily. One can work around that by either defining
+  # a custom validation on the Validatee model itself, or by using validates_uniqueness_of
+  # on Validatee::Translation.
+  # 
+  # test "validates_uniqueness_of" do
+  #   Validatee.class_eval { validates_uniqueness_of :string }
+  #   Validatee.create!(:string => 'a')
+  #   assert !Validatee.new(:string => 'a').valid?
+  #   assert Validatee.new(:string => 'b').valid?
+  # end
+
+  # test "validates_associated" do
+  # end
+end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/test/active_record_test.rb b/vendor/plugins/globalize2/test/active_record_test.rb
new file mode 100644
index 0000000..e6b54f0
--- /dev/null
+++ b/vendor/plugins/globalize2/test/active_record_test.rb
@@ -0,0 +1,442 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/data/models')
+
+# Higher level tests.
+
+class ActiveRecordTest < ActiveSupport::TestCase
+  def setup
+    I18n.locale = :en
+    reset_db!
+    ActiveRecord::Base.locale = nil
+  end
+
+  def assert_translated(locale, record, names, expected)
+    I18n.locale = locale
+    assert_equal Array(expected), Array(names).map { |name| record.send(name) }
+  end
+
+  test "a translated record has translations" do
+    assert_equal [], Post.new.translations
+  end
+
+  test "saves a translated version of the record for each locale" do
+    post = Post.create(:subject => 'title')
+    I18n.locale = :de
+    post.update_attributes(:subject => 'Titel')
+
+    assert_equal 2, post.translations.size
+    assert_equal %w(de en), post.translations.map(&:locale).map(&:to_s).sort
+    assert_equal %w(Titel title), post.translations.map(&:subject).sort
+  end
+
+  test "a translated record has German translations" do
+    I18n.locale = :de
+    post = Post.create(:subject => 'foo')
+    assert_equal 1, post.translations.size
+    assert_equal [:de], post.translations.map { |t| t.locale }
+  end
+
+  test "modifiying translated fields while switching locales" do
+    post = Post.create(:subject => 'title', :content => 'content')
+    assert_equal %w(title content), [post.subject, post.content]
+
+    I18n.locale = :de
+    post.subject, post.content = 'Titel', 'Inhalt'
+
+    assert_translated(:de, post, [:subject, :content], %w(Titel Inhalt))
+    assert_translated(:en, post, [:subject, :content], %w(title content))
+    assert_translated(:de, post, [:subject, :content], %w(Titel Inhalt))
+
+    post.save
+    post.reload
+
+    assert_translated(:en, post, [:subject, :content], %w(title content))
+    assert_translated(:de, post, [:subject, :content], %w(Titel Inhalt))
+  end
+
+  test "attribute writers do return their argument" do
+    value = Post.new.subject = 'foo'
+    assert_equal 'foo', value
+  end
+
+  test "update_attribute succeeds with valid values" do
+    post = Post.create(:subject => 'foo', :content => 'bar')
+    post.update_attribute(:subject, 'baz')
+    assert_equal 'baz', Post.first.subject
+  end
+
+  test "update_attributes fails with invalid values" 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 "passing the locale to create uses the given locale" do
+    post = Post.create(:subject => 'Titel', :content => 'Inhalt', :locale => :de)
+    assert_equal :en, I18n.locale
+    assert_nil ActiveRecord::Base.locale
+
+    I18n.locale = :de
+    assert_equal 'Titel', post.subject
+  end
+
+  test "passing the locale to attributes= uses the given locale" do
+    post = Post.create(:subject => 'title', :content => 'content')
+    post.update_attributes(:subject => 'Titel', :content => 'Inhalt', :locale => :de)
+    post.reload
+
+    assert_equal :en, I18n.locale
+    assert_nil ActiveRecord::Base.locale
+
+    assert_equal 'title', post.subject
+    I18n.locale = :de
+    assert_equal 'Titel', post.subject
+  end
+
+  test 'reload works' do
+    post = Post.create(:subject => 'foo', :content => 'bar')
+    post.subject = 'baz'
+    post.reload
+    assert_equal 'foo', post.subject
+  end
+
+  test "returns nil if no translations are found (unsaved record)" do
+    post = Post.new(:subject => 'foo')
+    assert_equal 'foo', post.subject
+    assert_nil post.content
+  end
+
+  test "returns nil if no translations are found (saved record)" do
+    post = Post.create(:subject => 'foo')
+    post.reload
+    assert_equal 'foo', post.subject
+    assert_nil post.content
+  end
+
+  test "finds a German post" do
+    post = Post.create(:subject => 'foo (en)', :content => 'bar')
+    I18n.locale = :de
+    post = Post.first
+    post.subject = 'baz (de)'
+    post.save
+    assert_equal 'baz (de)', Post.first.subject
+    I18n.locale = :en
+    assert_equal 'foo (en)', Post.first.subject
+  end
+
+  test "saves an English post and loads correctly" do
+    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 "returns the value for the correct locale, after locale switching" do
+    post = Post.create(:subject => 'foo')
+    I18n.locale = :de
+    post.subject = 'bar'
+    post.save
+    I18n.locale = :en
+    post = Post.first
+    assert_equal 'foo', post.subject
+    I18n.locale = :de
+    assert_equal 'bar', post.subject
+  end
+
+  test "returns the value for the correct locale, after locale switching, without saving" do
+    post = Post.create :subject => 'foo'
+    I18n.locale = :de
+    post.subject = 'bar'
+    I18n.locale = :en
+    assert_equal 'foo', post.subject
+    I18n.locale = :de
+    assert_equal 'bar', post.subject
+  end
+
+  test "saves all locales, even after locale switching" do
+    post = Post.new :subject => 'foo'
+    I18n.locale = :de
+    post.subject = 'bar'
+    I18n.locale = :he
+    post.subject = 'baz'
+    post.save
+    I18n.locale = :en
+    post = Post.first
+    assert_equal 'foo', post.subject
+    I18n.locale = :de
+    assert_equal 'bar', post.subject
+    I18n.locale = :he
+    assert_equal 'baz', post.subject
+  end
+
+  test "works with associations" do
+    blog = Blog.create
+    post1 = blog.posts.create(:subject => 'foo')
+
+    I18n.locale = :de
+    post2 = blog.posts.create(:subject => 'bar')
+    assert_equal 2, blog.posts.size
+
+    I18n.locale = :en
+    assert_equal 'foo', blog.posts.first.subject
+    assert_nil blog.posts.last.subject
+
+    I18n.locale = :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 'complex writing and stashing' do
+    post = Post.create(:subject => 'foo', :content => 'bar')
+    post.subject = nil
+    assert_nil post.subject
+    assert !post.valid?
+    post.subject = 'stashed_foo'
+    assert_equal 'stashed_foo', post.subject
+  end
+
+  test 'translated class locale setting' do
+    assert ActiveRecord::Base.respond_to?(:locale)
+    assert_equal :en, I18n.locale
+    assert_nil ActiveRecord::Base.locale
+
+    I18n.locale = :de
+    assert_equal :de, I18n.locale
+    assert_nil 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, I18n.locale
+    Post.create :subject => 'foo'
+    assert_equal :de, Post.first.translations.first.locale
+  end
+
+  test "attribute loading goes by content locale and not global locale" do
+    post = Post.create(:subject => 'foo')
+    assert_nil ActiveRecord::Base.locale
+
+    ActiveRecord::Base.locale = :de
+    assert_equal :en, I18n.locale
+    post.update_attribute(:subject, 'foo [de]')
+    assert_equal 'foo [de]', Post.first.subject
+
+    ActiveRecord::Base.locale = :en
+    assert_equal 'foo', Post.first.subject
+  end
+
+  test "access content locale before setting" do
+    Globalize::ActiveRecord::ActMacro.class_eval "remove_class_variable(:@@locale)"
+    assert_nothing_raised { ActiveRecord::Base.locale }
+  end
+
+  test "available_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.available_locales
+    assert_equal [:de, :es, :fr], Post.first.available_locales
+  end
+
+  test "saving record correctly after post-save reload" do
+    reloader = Reloader.create(:content => 'foo')
+    assert_equal 'foo', reloader.content
+  end
+
+  test "including translations" do
+    I18n.locale = :de
+    Post.create(:subject => "Foo1", :content => "Bar1")
+    Post.create(:subject => "Foo2", :content => "Bar2")
+
+    class << Post
+      def translations_included
+        self.all(:include => :translations)
+      end
+    end
+
+    default       = Post.all.map { |x| [x.subject, x.content] }
+    with_include  = Post.translations_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.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.translations.size
+  end
+
+  test "can create a proxy class for a namespaced model" do
+    assert_nothing_raised do
+      module Foo
+        module Bar
+          class Baz < ActiveRecord::Base
+            translates :bumm
+          end
+        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 class" do
+    assert PostTranslation.new.respond_to?(:existing_method)
+  end
+  
+  test "has_many and named scopes work with globalize" do
+    blog = Blog.create
+    assert_nothing_raised { blog.posts.foobar }
+  end
+end
+
+# 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?
diff --git a/vendor/plugins/globalize2/test/backends/chained_test.rb b/vendor/plugins/globalize2/test/backends/chained_test.rb
deleted file mode 100644
index bb0b3e0..0000000
--- a/vendor/plugins/globalize2/test/backends/chained_test.rb
+++ /dev/null
@@ -1,175 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/backend/chain'
-
-module Globalize
-  module Backend
-    class Dummy
-      def translate(locale, key, options = {})
-      end
-    end
-  end
-end
-
-class ChainedTest < ActiveSupport::TestCase
-  
-  test "instantiates a chained backend and sets test as backend" do
-    assert_nothing_raised { I18n.chain_backends }
-    assert_instance_of Globalize::Backend::Chain, I18n.backend
-  end
-  
-  test "passes all given arguments to the chained backends #initialize method" do
-    Globalize::Backend::Chain.expects(:new).with(:spec, :simple)
-    I18n.chain_backends :spec, :simple
-  end
-
-  test "passes all given arguments to #add assuming that they are backends" do
-    # no idea how to spec that
-  end
-end
-
-class AddChainedTest < ActiveSupport::TestCase
-  def setup
-    I18n.backend = Globalize::Backend::Chain.new  
-  end
-  
-  test "accepts an instance of a backend" do
-    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy.new }
-    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
-  end
-
-  test "accepts a class and instantiates the backend" do
-    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy }
-    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
-  end
-
-  test "accepts a symbol, constantizes test as a backend class and instantiates the backend" do
-    assert_nothing_raised { I18n.backend.add :dummy }
-    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
-  end
-
-  test "accepts any number of backend instances, classes or symbols" do
-    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy.new, Globalize::Backend::Dummy, :dummy }
-    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
-    assert_equal [ Globalize::Backend::Dummy, Globalize::Backend::Dummy, Globalize::Backend::Dummy ], 
-      I18n.backend.send(:backends).map{|backend| backend.class }
-  end
-  
-end
-
-class TranslateChainedTest < ActiveSupport::TestCase
-  def setup
-    I18n.locale = :en
-    I18n.backend = Globalize::Backend::Chain.new
-    @first_backend = I18n::Backend::Simple.new
-    @last_backend = I18n::Backend::Simple.new
-    I18n.backend.add @first_backend
-    I18n.backend.add @last_backend
-  end
-
-  test "delegates #translate to all backends in the order they were added" do
-    @first_backend.expects(:translate).with(:en, :foo, {})
-    @last_backend.expects(:translate).with(:en, :foo, {})
-    I18n.translate :foo
-  end
-
-  test "returns the result from #translate from the first backend if test's not nil" do
-    @first_backend.store_translations :en, {:foo => 'foo from first backend'}
-    @last_backend.store_translations :en, {:foo => 'foo from last backend'}
-    result = I18n.translate :foo
-    assert_equal 'foo from first backend', result
-  end
-
-  test "returns the result from #translate from the second backend if the first one returned nil" do
-    @first_backend.store_translations :en, {}
-    @last_backend.store_translations :en, {:foo => 'foo from last backend'}
-    result = I18n.translate :foo
-    assert_equal 'foo from last backend', result
-  end
-
-  test "looks up a namespace from all backends and merges them (if a result is a hash and no count option is present)" do
-    @first_backend.store_translations :en, {:foo => {:bar => 'bar from first backend'}}
-    @last_backend.store_translations :en, {:foo => {:baz => 'baz from last backend'}}
-    result = I18n.translate :foo
-    assert_equal( {:bar => 'bar from first backend', :baz => 'baz from last backend'}, result )
-  end
-
-  test "raises a MissingTranslationData exception if no translation was found" do
-    assert_raise( I18n::MissingTranslationData ) { I18n.translate :not_here, :raise => true }
-  end
-
-  test "raises an InvalidLocale exception if the locale is nil" do
-    assert_raise( I18n::InvalidLocale ) { Globalize::Backend::Chain.new.translate nil, :foo }
-  end
-
-  test "bulk translates a number of keys from different backends" do
-    @first_backend.store_translations :en, {:foo => 'foo from first backend'}
-    @last_backend.store_translations :en, {:bar => 'bar from last backend'}
-    result = I18n.translate [:foo, :bar]
-    assert_equal( ['foo from first backend', 'bar from last backend'], result )
-  end
-
-  test "still calls #translate on all the backends" do
-    @last_backend.expects :translate
-    I18n.translate :not_here, :default => 'default'
-  end
-
-  test "returns a given default string when no backend returns a translation" do
-    result = I18n.translate :not_here, :default => 'default'
-    assert_equal 'default', result
-  end
-
-end
-
-class CustomLocalizeBackend < I18n::Backend::Simple
-  def localize(locale, object, format = :default)
-    "result from custom localize backend" if locale == 'custom'
-  end
-end
-
-class LocalizeChainedTest < ActiveSupport::TestCase
-  def setup
-    I18n.locale = :en
-    I18n.backend = Globalize::Backend::Chain.new
-    @first_backend = CustomLocalizeBackend.new
-    @last_backend = I18n::Backend::Simple.new
-    I18n.backend.add @first_backend
-    I18n.backend.add @last_backend
-    @time = Time.now
-  end
-
-  test "delegates #localize to all backends in the order they were added" do
-    @first_backend.expects(:localize).with(:en, @time, :default)
-    @last_backend.expects(:localize).with(:en, @time, :default)
-    I18n.localize @time
-  end
-
-  test "returns the result from #localize from the first backend if test's not nil" do
-    @last_backend.expects(:localize).never
-    result = I18n.localize @time, :locale => 'custom'
-    assert_equal 'result from custom localize backend', result
-  end
-
-  test "returns the result from #localize from the second backend if the first one returned nil" do
-    @last_backend.expects(:localize).returns "value from last backend"
-    result = I18n.localize @time
-    assert_equal 'value from last backend', result
-  end
-end
-
-class NamespaceChainedTest < ActiveSupport::TestCase
-  def setup
-    @backend = Globalize::Backend::Chain.new
-  end
-  
-  test "returns false if the given result is not a Hash" do
-    assert !@backend.send(:namespace_lookup?, 'foo', {})
-  end
-
-  test "returns false if a count option is present" do
-    assert !@backend.send(:namespace_lookup?, {:foo => 'foo'}, {:count => 1})
-  end
-
-  test "returns true if the given result is a Hash AND no count option is present" do
-    assert @backend.send(:namespace_lookup?, {:foo => 'foo'}, {})
-  end  
-end
diff --git a/vendor/plugins/globalize2/test/backends/pluralizing_test.rb b/vendor/plugins/globalize2/test/backends/pluralizing_test.rb
deleted file mode 100644
index 7445e3f..0000000
--- a/vendor/plugins/globalize2/test/backends/pluralizing_test.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/backend/pluralizing'
-
-class PluralizingTest < ActiveSupport::TestCase
-  def setup
-    @backend = Globalize::Backend::Pluralizing.new
-    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
-  end
-
-  test "#pluralizer returns the pluralizer for a given locale if defined" do
-    assert_instance_of Proc, @backend.pluralizer(:en)
-  end
-  
-  test "#pluralizer returns the default pluralizer if no pluralizer is defined for the given locale" do
-    assert_equal @backend.pluralizer(:en), @backend.pluralizer(:de) 
-  end
-  
-  test "#add_pluralizer allows to store a pluralizer per locale" do
-    assert_nothing_raised { @backend.add_pluralizer(:cz, @cz_pluralizer) }
-    assert_equal @cz_pluralizer, @backend.pluralizer(:cz) 
-  end
-
-end
-
-class PluralizePluralizingTest < ActiveSupport::TestCase
-  def setup
-    @backend = Globalize::Backend::Pluralizing.new
-    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
-    @backend.store_translations :en, :foo => {:one => 'one en foo', :other => 'many en foos'}
-    @backend.store_translations :cz, :foo => {:one => 'one cz foo', :few => 'few cz foos', :other => 'many cz foos'}
-  end
-
-  test "looks up the :one translation when count is 1" do
-    assert_equal 'one en foo', @backend.translate(:en, :foo, :count => 1) 
-  end
-
-  test "looks up the :other translation when count is 2" do
-    assert_equal 'many en foos', @backend.translate(:en, :foo, :count => 2) 
-  end
-end
-
-class CzPluralizingTest < ActiveSupport::TestCase
-  def setup
-    @backend = Globalize::Backend::Pluralizing.new
-    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
-    @backend.store_translations :en, :foo => {:one => 'one en foo', :other => 'many en foos'}
-    @backend.store_translations :cz, :foo => {:one => 'one cz foo', :few => 'few cz foos', :other => 'many cz foos'}
-    @backend.add_pluralizer(:cz, @cz_pluralizer)
-  end
-
-  test "looks up the :one translation when count is 1 (:cz)" do
-    assert_equal 'one cz foo', @backend.translate(:cz, :foo, :count => 1) 
-  end
-
-  test "looks up the :few translation when count is 2 (:cz)" do
-    assert_equal 'few cz foos', @backend.translate(:cz, :foo, :count => 2)
-  end
-
-  test "looks up the :other translation when count is 5 (:cz)" do
-    assert_equal 'many cz foos', @backend.translate(:cz, :foo, :count => 5)
-  end
-
-end
diff --git a/vendor/plugins/globalize2/test/backends/static_test.rb b/vendor/plugins/globalize2/test/backends/static_test.rb
deleted file mode 100644
index 133e547..0000000
--- a/vendor/plugins/globalize2/test/backends/static_test.rb
+++ /dev/null
@@ -1,143 +0,0 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/backend/static'
-require 'globalize/translation'
-require 'action_view'
-include ActionView::Helpers::NumberHelper
-
-I18n.locale = :'en-US'    # Need to set this, since I18n defaults to 'en'
-
-class StaticTest < ActiveSupport::TestCase
-  def setup
-    I18n.backend = Globalize::Backend::Static.new
-    translations = {:"en-US" => {:foo => "foo in en-US", :boz => 'boz', :buz => {:bum => 'bum'}},
-                    :"en"    => {:bar => "bar in en"},
-                    :"de-DE" => {:baz => "baz in de-DE"},
-                    :"de"    => {:boo => "boo in de", :number => { :currency => { :format => { :unit => '€', :format => '%n %u'}}}}}
-    translations.each do |locale, data| 
-      I18n.backend.store_translations locale, data 
-    end
-    I18n.fallbacks.map :"de-DE" => :"en-US", :he => :en
-  end
-  
-  test "returns an instance of Translation:Static" do
-    translation = I18n.translate :foo
-    assert_instance_of Globalize::Translation::Static, translation
-  end
-    
-  test "returns the translation in en-US if present" do
-    assert_equal "foo in en-US", I18n.translate(:foo, :locale => :"en-US") 
-  end
-
-  test "returns the translation in en if en-US is not present" do
-    assert_equal "bar in en", I18n.translate(:bar, :locale => :"en-US") 
-  end
-  
-  test "returns the translation in de-DE if present" do
-    assert_equal "baz in de-DE", I18n.translate(:baz, :locale => :"de-DE") 
-  end
-  
-  test "returns the translation in de if de-DE is not present" do
-    assert_equal "boo in de", I18n.translate(:boo, :locale => :"de-DE") 
-  end
-  
-  test "returns the translation in en-US if none of de-DE and de are present" do
-    assert_equal "foo in en-US", I18n.translate(:foo, :locale => :"de-DE") 
-  end
-
-  test "returns the translation in en if none of de-DE, de and en-US are present" do
-    assert_equal "bar in en", I18n.translate(:bar, :locale => :"de-DE") 
-  end
-  
-  test "returns the translation in en if none in he is present" do
-    assert_equal "bar in en", I18n.translate(:bar, :locale => :he) 
-  end
-  
-  test "returns the given default String when the key is not present for any locale" do
-    assert_equal "default", I18n.translate(:missing, :default => "default") 
-  end
-
-  test "returns the fallback translation for the key if present for a fallback locale" do
-    I18n.backend.store_translations :de, :non_default => "non_default in de"
-    assert_equal "non_default in de", I18n.translate(:non_default, :default => "default", :locale => :"de-DE") 
-  end  
-
-  test "returns an array of translations" do
-    assert_instance_of Array, I18n.translate([:foo, :boz])
-  end
-  
-  test "returns an array of instances of Translation::Static" do
-    assert_equal [Globalize::Translation::Static], I18n.translate([:foo, :boz]).map(&:class).uniq
-  end
-  
-  test "returns a hash of translations" do
-    assert_instance_of Hash, I18n.translate(:"buz")
-  end
-  
-  test "returns an array of translations 2" do
-    assert_equal [Globalize::Translation::Static], I18n.translate(:"buz").values.map(&:class) 
-  end
-
-  test "returns currency properly formated" do
-    currency = number_to_currency(10)
-    assert_equal "$10.00", currency
-  end
-
-  test "returns currency properly formated for locale" do
-    currency = number_to_currency(10, :locale => :'de')
-    assert_equal "10.000 €", currency
-  end
-
-  test "returns currency properly formated from parameters" do
-    currency = number_to_currency(10, :format => "%n %u", :unit => '€')
-    assert_equal "10.00 €", currency
-  end
-
-  test "makes sure interpolation does not break even with False as string" do
-    assert_equal "translation missing: en, support, array, skip_last_comma", I18n.translate(:"support.array.skip_last_comma")
-  end
-end
-
-class TranslationStaticTest < ActiveSupport::TestCase
-  def setup
-    I18n.backend = Globalize::Backend::Static.new 
-    translations = {
-      :greeting => "Hi {{name}}",
-      :messages => { :one => "You have one message.", :other => "You have {{count}} messages."}
-    }
-    I18n.backend.store_translations :"en", translations
-  end
-
-  def greeting
-    I18n.translate :greeting, :locale => :"en-US", :name => "Joshua"
-  end
-  
-  test "stores the actual locale" do
-    assert_equal :en, greeting.locale
-  end
-  
-  test "stores the requested locale" do
-    assert_equal :'en-US', greeting.requested_locale
-  end
-  
-  test "stores the requested key" do
-    assert_equal :greeting, greeting.key
-  end
-  
-  test "stores the options given to #translate" do
-    assert_equal( {:name => "Joshua"}, greeting.options ) 
-  end
-  
-  test "stores the original translation before test was interpolated" do
-    assert_equal "Hi {{name}}", greeting.original 
-  end
-  
-  test "stores the plural_key :one if pluralized as such" do
-    message = I18n.translate :messages, :locale => :"en-US", :count => 1
-    assert_equal :one, message.plural_key
-  end
-  
-  test "stores the plural_key :other if pluralized as such" do
-    messages = I18n.translate :messages, :locale => :"en-US", :count => 2
-    assert_equal :other, messages.plural_key
-  end
-end
diff --git a/vendor/plugins/globalize2/test/data/locale/all.yml b/vendor/plugins/globalize2/test/data/locale/all.yml
deleted file mode 100644
index ee4fb4a..0000000
--- a/vendor/plugins/globalize2/test/data/locale/all.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-en-US:
-  from-all-file: From the "all" file.
diff --git a/vendor/plugins/globalize2/test/data/locale/de-DE.yml b/vendor/plugins/globalize2/test/data/locale/de-DE.yml
deleted file mode 100644
index d4c468e..0000000
--- a/vendor/plugins/globalize2/test/data/locale/de-DE.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-de-DE:
-  from-locale-file: Aus der Locale Datei.
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/test/data/locale/en-US.yml b/vendor/plugins/globalize2/test/data/locale/en-US.yml
deleted file mode 100644
index 866b171..0000000
--- a/vendor/plugins/globalize2/test/data/locale/en-US.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-en-US:
-  from-locale-file: From the locale file.
diff --git a/vendor/plugins/globalize2/test/data/locale/en-US/module.yml b/vendor/plugins/globalize2/test/data/locale/en-US/module.yml
deleted file mode 100644
index 6655e9b..0000000
--- a/vendor/plugins/globalize2/test/data/locale/en-US/module.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-en-US:
-  from-locale-dir: From the locale directory.
diff --git a/vendor/plugins/globalize2/test/data/locale/fi-FI/module.yml b/vendor/plugins/globalize2/test/data/locale/fi-FI/module.yml
deleted file mode 100644
index 62d00b1..0000000
--- a/vendor/plugins/globalize2/test/data/locale/fi-FI/module.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-fi-FI:
-  from-locale-dir: Locale hakemistosta.
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/test/data/locale/root.yml b/vendor/plugins/globalize2/test/data/locale/root.yml
deleted file mode 100644
index e69de29..0000000
--- a/vendor/plugins/globalize2/test/data/locale/root.yml
+++ /dev/null
diff --git a/vendor/plugins/globalize2/test/data/models.rb b/vendor/plugins/globalize2/test/data/models.rb
index f6dab90..553fca3 100644
--- a/vendor/plugins/globalize2/test/data/models.rb
+++ b/vendor/plugins/globalize2/test/data/models.rb
@@ -1,6 +1,16 @@
+#require 'ruby2ruby'
+#require 'parse_tree'
+#require 'parse_tree_extensions'
+#require 'pp'
+
+class PostTranslation < ActiveRecord::Base
+  def existing_method ; end
+end
+
 class Post < ActiveRecord::Base
   translates :subject, :content
   validates_presence_of :subject
+  named_scope :foobar, :conditions => { :title => "foobar" }
 end
 
 class Blog < ActiveRecord::Base
@@ -18,7 +28,7 @@ class Comment < ActiveRecord::Base
   validates_presence_of :content
   belongs_to :post
 end
- 
+
 class TranslatedComment < Comment
   translates :content
 end
@@ -26,4 +36,16 @@ end
 class UltraLongModelNameWithoutProper < ActiveRecord::Base
   translates :subject, :content
   validates_presence_of :subject
-end
\ No newline at end of file
+end
+
+class Reloader < Parent
+  after_create :do_reload
+
+  def do_reload
+    reload
+  end
+end
+
+class Validatee < ActiveRecord::Base
+  translates :string
+end
diff --git a/vendor/plugins/globalize2/test/i18n/missing_translations_test.rb b/vendor/plugins/globalize2/test/i18n/missing_translations_test.rb
index 8641d57..5d0ecd6 100644
--- a/vendor/plugins/globalize2/test/i18n/missing_translations_test.rb
+++ b/vendor/plugins/globalize2/test/i18n/missing_translations_test.rb
@@ -1,5 +1,5 @@
-require File.join( File.dirname(__FILE__), '..', 'test_helper' )
-require 'globalize/i18n/missing_translations_log_handler'
+require File.dirname(__FILE__) + '/../test_helper'
+require 'i18n/missing_translations_log_handler'
 
 class MissingTranslationsTest < ActiveSupport::TestCase
   test "defines I18n.missing_translations_logger accessor" do
@@ -19,18 +19,18 @@ class LogMissingTranslationsTest < ActiveSupport::TestCase
   def setup
     @locale, @key, @options = :en, :foo, {}
     @exception = I18n::MissingTranslationData.new(@locale, @key, @options)
-    
+
     @logger = TestLogger.new
     I18n.missing_translations_logger = @logger
   end
 
   test "still returns the exception message for MissingTranslationData exceptions" do
     result = I18n.send(:missing_translations_log_handler, @exception, @locale, @key, @options)
-    assert_equal 'translation missing: en, foo', result 
+    assert_equal 'translation missing: en, foo', result
   end
-  
+
   test "logs the missing translation to I18n.missing_translations_logger" do
     I18n.send(:missing_translations_log_handler, @exception, @locale, @key, @options)
-    assert_equal 'translation missing: en, foo', @logger 
+    assert_equal 'translation missing: en, foo', @logger
   end
 end
diff --git a/vendor/plugins/globalize2/test/load_path_test.rb b/vendor/plugins/globalize2/test/load_path_test.rb
deleted file mode 100644
index ff009b3..0000000
--- a/vendor/plugins/globalize2/test/load_path_test.rb
+++ /dev/null
@@ -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
diff --git a/vendor/plugins/globalize2/test/locale/fallbacks_test.rb b/vendor/plugins/globalize2/test/locale/fallbacks_test.rb
deleted file mode 100644
index 304d3da..0000000
--- a/vendor/plugins/globalize2/test/locale/fallbacks_test.rb
+++ /dev/null
@@ -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
diff --git a/vendor/plugins/globalize2/test/locale/language_tag_test.rb b/vendor/plugins/globalize2/test/locale/language_tag_test.rb
deleted file mode 100644
index 2448af1..0000000
--- a/vendor/plugins/globalize2/test/locale/language_tag_test.rb
+++ /dev/null
@@ -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
diff --git a/vendor/plugins/globalize2/test/model/active_record/translated_test.rb b/vendor/plugins/globalize2/test/model/active_record/translated_test.rb
deleted file mode 100644
index f54894e..0000000
--- a/vendor/plugins/globalize2/test/model/active_record/translated_test.rb
+++ /dev/null
@@ -1,478 +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 "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
-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?
diff --git a/vendor/plugins/globalize2/test/test_helper.rb b/vendor/plugins/globalize2/test/test_helper.rb
index 3a1c8c4..195907d 100644
--- a/vendor/plugins/globalize2/test/test_helper.rb
+++ b/vendor/plugins/globalize2/test/test_helper.rb
@@ -1,28 +1,41 @@
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../lib' )
+
 require 'rubygems'
 require 'test/unit'
+require 'active_record'
 require 'active_support'
 require 'active_support/test_case'
 require 'mocha'
+require 'globalize'
+require 'validation_reflection'
 
-$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../lib' )
+config = { :adapter => 'sqlite3', :database => ':memory:' }
+ActiveRecord::Base.establish_connection(config)
 
 class ActiveSupport::TestCase
-  def reset_db!( schema_path )
-    ::ActiveRecord::Migration.verbose = false   # Quiet down the migration engine
-    ::ActiveRecord::Base.establish_connection({
-      :adapter => 'sqlite3',
-      :database => ':memory:'
-    })
-    ::ActiveRecord::Base.silence do
-      load schema_path
-    end
+  def reset_db!(schema_path = nil)
+    schema_path ||= File.expand_path(File.dirname(__FILE__) + '/data/schema.rb')
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Base.silence { load(schema_path) }
   end
-  
-  def assert_member(item, arr)
-    assert_block "Item #{item} is not in array #{arr}" do
-      arr.member? item
+
+  def assert_member(item, array)
+    assert_block "Item #{item} is not in array #{array}" do
+      array.member?(item)
     end
   end
+
+  def assert_belongs_to(model, associated)
+    assert model.reflect_on_all_associations(:belongs_to).detect { |association|
+      association.name.to_s == associated.to_s
+    }
+  end
+
+  def assert_has_many(model, associated)
+    assert model.reflect_on_all_associations(:has_many).detect { |association|
+      association.name.to_s == associated.to_s
+    }
+  end
 end
 
 module ActiveRecord
@@ -33,4 +46,31 @@ module ActiveRecord
       end
     end
   end
-end
\ No newline at end of file
+end
+
+# module ActiveRecord
+#   class BaseWithoutTable < Base
+#     self.abstract_class = true
+#
+#     def create_or_update
+#       errors.empty?
+#     end
+#
+#     class << self
+#       def columns()
+#         @columns ||= []
+#       end
+#
+#       def column(name, sql_type = nil, default = nil, null = true)
+#         columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+#         reset_column_information
+#       end
+#
+#       # Do not reset @columns
+#       def reset_column_information
+#         read_methods.each { |name| undef_method(name) }
+#         @column_names = @columns_hash = @content_columns = @dynamic_methods_hash = @read_methods = nil
+#       end
+#     end
+#   end
+# end
\ No newline at end of file
diff --git a/vendor/plugins/globalize2/test/translation_test.rb b/vendor/plugins/globalize2/test/translation_test.rb
deleted file mode 100644
index 4b52bb1..0000000
--- a/vendor/plugins/globalize2/test/translation_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-require File.join( File.dirname(__FILE__), 'test_helper' )
-require 'globalize/translation'
-
-class TranslationTest < ActiveSupport::TestCase
-  include Globalize
-   
-  def setup
-    @translation = Translation::Static.new 'foo', :locale => :'en-US'
-  end
-
-  test "responds to fallback?" do
-    assert @translation.respond_to?( :fallback? )
-  end
-
-  test "returns true when :locale and :requested_locale are not equal" do
-    @translation.requested_locale = :'de-DE'
-    assert @translation.fallback?
-  end
-  
-  test "returns false when :locale and :requested_locale are equal" do
-    @translation.requested_locale = :'en-US'
-    assert !@translation.fallback?
-  end
-    
-  test "has the attribute :locale" do
-    assert @translation.respond_to?( :locale )
-  end
-  
-  test "has the attribute :requested_locale" do
-    assert @translation.respond_to?( :requested_locale )
-  end
-  
-  test "has the attribute :options" do
-    assert @translation.respond_to?( :options )
-  end
-  
-  test "has the attribute :plural_key" do
-    assert @translation.respond_to?( :plural_key )
-  end
-  
-  test "has the attribute :original" do
-    assert @translation.respond_to?( :original )    
-  end
-  
-  test "Translation::Attribute has the attribute :locale" do
-    translation = Translation::Attribute.new 'foo'
-    assert translation.respond_to?( :locale )
-  end
-  
-  test "Translation::Attribute has the attribute :requested_locale" do
-    translation = Translation::Attribute.new 'foo'
-    assert translation.respond_to?( :requested_locale )
-  end
-end