single_table_globalize3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d9d9b6bb1b7c9a01b80fa37c207d172b26bf321
+  data.tar.gz: 1f6344d88c60c9a226491d3280b2e23ae639e621
+SHA512:
+  metadata.gz: 3c82d94486a79cd745cdba46ca13463ad2cda67b321b654263c9e598a4bdb3422a9e286125c61407827c2d55068d1558b0b0c5d421a3b9302ce7ffdce0f2f45e
+  data.tar.gz: b22a0c72c1cad41885978ebe89b389afbd727e3bdeb230467beea39f2a3e54c694c76a6be52f30583a8cc01fe820fa077b7ab71b5456a1152a3200ff4050d74d

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    single_table_globalize3 (0.3.0)
+      activemodel (>= 3.0.0)
+      activerecord (>= 3.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (3.2.12)
+      activesupport (= 3.2.12)
+      builder (~> 3.0.0)
+    activerecord (3.2.12)
+      activemodel (= 3.2.12)
+      activesupport (= 3.2.12)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.4)
+    coderay (1.0.8)
+    database_cleaner (0.6.7)
+    i18n (0.6.1)
+    json (1.7.7)
+    metaclass (0.0.1)
+    method_source (0.8.1)
+    mocha (0.13.2)
+      metaclass (~> 0.0.1)
+    multi_json (1.6.1)
+    pathname_local (0.0.2)
+    pry (0.9.12)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-nav (0.2.3)
+      pry (~> 0.9.10)
+    rake (10.0.3)
+    rdoc (3.12.1)
+      json (~> 1.4)
+    slop (3.4.3)
+    sqlite3 (1.3.7)
+    test_declarative (0.0.5)
+    tzinfo (0.3.35)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 0.6.0)
+  mocha
+  pathname_local
+  pry
+  pry-nav
+  rake
+  rdoc
+  single_table_globalize3!
+  sqlite3
+  test_declarative

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008, 2009, 2010, 2012 Sven Fuchs, Joshua Harvey, Clemens Kofler, John-Paul Bader, Trong Tran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Run all tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SingleTableGlobalize3'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/generators/globalize3/migration_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/active_record'
+
+module SingleTableGlobalize3
+  module Generators
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+      argument :name, :type => :string, :default => "application"
+
+      def copy_devise_migration
+        migration_template "migration.rb", "db/migrate/create_globalize_translations"
+      end
+    end
+  end
+end

data/lib/generators/globalize3/templates/migration.rb

@@ -0,0 +1,22 @@
+class CreateGlobalizeTranslations < ActiveRecord::Migration
+  def up
+    create_table :globalize_translations do |t|
+      t.integer :translatable_id
+      t.string :translatable_type
+      t.string :locale
+      t.string :attribute_name
+      t.text :value
+      t.timestamps
+    end
+    add_index :globalize_translations, [:translatable_id, :translatable_type], :name => :index_globalize_translalation_1
+    add_index :globalize_translations, [:translatable_id, :translatable_type, :locale], :name => :index_globalize_translalation_2
+    add_index :globalize_translations, [:translatable_id, :translatable_type, :locale, :attribute_name], :name => :index_globalize_translalation_3
+  end
+
+  def down
+    remove_index :globalize_translations, :name => :index_globalize_translalation_3
+    remove_index :globalize_translations, :name => :index_globalize_translalation_2
+    remove_index :globalize_translations, :name => :index_globalize_translalation_1
+    drop_table :globalize_translations
+  end
+end

data/lib/globalize/active_record/act_macro.rb

@@ -0,0 +1,66 @@
+module Globalize
+  module ActiveRecord
+    module ActMacro
+      def translates(*attr_names)
+
+        options = attr_names.extract_options!
+        setup_translates!(options) unless translates?
+
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= translated_attribute_names if defined?(translated_attribute_names)
+
+        if attr_names.present?
+          translation_class.instance_eval %{
+            attr_accessible :#{attr_names.join(', :')}
+          }
+
+          attr_names.each do |attr_name|
+            # Detect and apply serialization.
+            serializer = self.serialized_attributes[attr_name.to_s]
+            if serializer.present?
+              if defined?(::ActiveRecord::Coders::YAMLColumn) &&
+                 serializer.is_a?(::ActiveRecord::Coders::YAMLColumn)
+
+                serializer = serializer.object_class
+              end
+
+              translation_class.send :serialize, attr_name, serializer
+            end
+
+            # Create accessors for the attribute.
+            translated_attr_accessor(attr_name)
+            translations_accessor(attr_name)
+
+            # Add attribute to the list.
+            self.translated_attribute_names << attr_name
+          end
+        end
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+
+      protected
+      def setup_translates!(options)
+        class_attribute :translated_attribute_names, :translation_options, :fallbacks_for_empty_translations
+        self.translated_attribute_names = []
+        self.translation_options        = options
+        self.fallbacks_for_empty_translations = options[:fallbacks_for_empty_translations]
+
+        include InstanceMethods
+        extend  ClassMethods
+
+        has_many :translations, :class_name  => translation_class.name,
+                                :foreign_key => :translatable_id,
+                                :dependent   => :destroy,
+                                :as => :translatable
+
+        after_create :save_translations!
+        after_update :save_translations!
+
+        translation_class.instance_eval %{ attr_accessible :locale }
+      end
+    end
+  end
+end

data/lib/globalize/active_record/adapter.rb

@@ -0,0 +1,112 @@
+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_accessor :record, :stash, :translations
+      private :record=, :stash=
+
+      delegate :translation_class, :to => :'record.class'
+
+      def initialize(record)
+        self.record = record
+        self.stash = Attributes.new
+      end
+
+      def fetch_stash(locale, name)
+        value = stash.read(locale, name)
+        return value if value
+        return nil
+      end
+
+      def stash_contains?(locale, name)
+        stash.contains?(locale, name)
+      end
+
+      def fetch(locale, name)
+        record.globalize_fallbacks(locale).each do |fallback|
+          value = stash.contains?(fallback, name) ? fetch_stash(fallback, name) : fetch_attribute(fallback, name)
+
+          unless fallbacks_for?(value)
+            set_metadata(value, :locale => fallback, :requested_locale => locale)
+            return value
+          end
+        end
+
+        return nil
+      end
+
+      def write(locale, name, value)
+        stash.write(locale, name, value)
+      end
+
+      def save_translations!
+        existing_translations = {}
+        record.translations.each do |t|
+          locale_str = t.locale.to_s
+          existing_translations[locale_str] ||= {}
+          existing_translations[locale_str][t.attribute_name] = t
+        end
+
+        stash.each do |locale, attrs|
+          locale_str = locale.to_s
+          attrs.each do |name, value|
+            translation = existing_translations[locale_str].try('[]', name) ||
+              record.translations.build(:locale => locale_str, :attribute_name => name)
+            translation.update_attribute(:value, value)
+          end
+        end
+
+        reset
+      end
+
+      def reset
+        stash.clear
+      end
+
+    protected
+
+      def type_cast(name, value)
+        if value.nil?
+          nil
+        elsif column = column_for_attribute(name)
+          column.type_cast(value)
+        else
+          value
+        end
+      end
+
+      def column_for_attribute(name)
+        translation_class.columns_hash[name.to_s]
+      end
+
+      def unserializable_attribute?(name, column)
+        column.text? && translation_class.serialized_attributes[name.to_s]
+      end
+
+      def fetch_attribute(locale, name)
+        translation = record.translation_for(locale, name, false)
+        return translation && translation.value
+      end
+
+      def set_metadata(object, metadata)
+        object.translation_metadata.merge!(metadata) if object.respond_to?(:translation_metadata)
+        object
+      end
+
+      def translation_metadata_accessor(object)
+        return if obj.respond_to?(:translation_metadata)
+        class << object; attr_accessor :translation_metadata end
+        object.translation_metadata ||= {}
+      end
+
+      def fallbacks_for?(object)
+        object.nil? || (fallbacks_for_empty_translations? && object.blank?)
+      end
+
+      def fallbacks_for_empty_translations?
+        record.fallbacks_for_empty_translations
+      end
+    end
+  end
+end

data/lib/globalize/active_record/attributes.rb

@@ -0,0 +1,27 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+
+module Globalize
+  module ActiveRecord
+    class Attributes < Hash # TODO: Think about using HashWithIndifferentAccess ?
+      def [](locale)
+        locale = locale.to_sym
+        self[locale] = {} unless has_key?(locale)
+        self.fetch(locale)
+      end
+
+      def contains?(locale, name)
+        self[locale].has_key?(name.to_s)
+      end
+
+      def read(locale, name)
+        self[locale][name.to_s]
+      end
+
+      def write(locale, name, value)
+        #raise 'z' if value.nil? # TODO
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,168 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :to => :translation_class
+
+      def with_translations(*locales)
+        locales = [locales].flatten
+        index = locales.pop if locales.last.is_a?(Fixnum)
+        locales = Globalize.fallbacks if locales.empty?
+        joins("LEFT OUTER JOIN #{translation_class.table_name} #{translations_table_name(index)} ON #{translations_table_name(index)}.translatable_id = #{self.table_name}.id").
+        select("distinct #{table_name}.*").
+        where(translated_column_name('locale', index) => locales)
+      end
+
+      def with_translated_attribute(name, value, locales = nil)
+        locales ||= Globalize.fallbacks
+        self.join_index = self.join_index + 1
+        with_translations(locales, self.join_index).where(
+          translated_column_name('attribute_name', self.join_index) => name.to_s,
+          translated_column_name('value', self.join_index) => Array(value).map(&:to_s)
+        )
+      end
+
+      def translated?(name)
+        translated_attribute_names.include?(name.to_sym)
+      end
+
+      def required_attributes
+        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
+      end
+
+      def required_translated_attributes
+        translated_attribute_names & required_attributes
+      end
+
+      def translation_class
+        Globalize::ActiveRecord::Translation
+      end
+
+      def translations_table_name(index = nil)
+        "#{translation_class.table_name}#{index}"
+      end
+
+      def translated_column_name(name, index = nil)
+        "#{translations_table_name(index)}.#{name}"
+      end
+
+      if RUBY_VERSION < '1.9'
+        def respond_to?(method_id, *args, &block)
+          supported_on_missing?(method_id) || super
+        end
+      else
+        def respond_to_missing?(method_id, include_private = false)
+          supported_on_missing?(method_id) || super
+        end
+      end
+
+      def supported_on_missing?(method_id)
+        return super unless RUBY_VERSION < '1.9' || respond_to?(:translated_attribute_names)
+        match = defined?(::ActiveRecord::DynamicFinderMatch) && (::ActiveRecord::DynamicFinderMatch.match(method_id) || ::ActiveRecord::DynamicScopeMatch.match(method_id))
+        return false if match.nil?
+
+        attribute_names = match.attribute_names.map(&:to_sym)
+        translated_attributes = attribute_names & translated_attribute_names
+        return false if translated_attributes.empty?
+
+        untranslated_attributes = attribute_names - translated_attributes
+        return false if untranslated_attributes.any?{|unt| ! respond_to?(:"scoped_by_#{unt}")}
+        return [match, attribute_names, translated_attributes, untranslated_attributes]
+      end
+
+      def method_missing(method_id, *arguments, &block)
+        match, attribute_names, translated_attributes, untranslated_attributes = supported_on_missing?(method_id)
+        return super unless match
+
+        scope = scoped
+
+        translated_attributes.each do |attr|
+          scope = scope.with_translated_attribute(attr, arguments[attribute_names.index(attr)])
+        end
+
+        untranslated_attributes.each do |unt|
+          index = attribute_names.index(unt)
+          raise StandarError unless index
+          scope = scope.send(:"scoped_by_#{unt}", arguments[index])
+        end
+
+        if defined?(::ActiveRecord::DynamicFinderMatch) && match.is_a?(::ActiveRecord::DynamicFinderMatch)
+          if match.instantiator? and scope.blank?
+            return scope.find_or_instantiator_by_attributes match, attribute_names, *arguments, &block
+          end
+          match_finder_method = match.finder.to_s
+          match_finder_method << "!" if match.bang? && ::ActiveRecord::VERSION::STRING >= "3.1.0"
+          return scope.send(match_finder_method).tap do |found|
+            found.is_a?(Array) ? found.map { |f| f.translations.reload } : found.translations.reload unless found.nil?
+          end
+        end
+        return scope
+      end
+
+      def find_or_instantiator_by_attributes(match, attributes, *args)
+        options = args.size > 1 && args.last(2).all?{ |a| a.is_a?(Hash) } ? args.extract_options! : {}
+        protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
+        args.each_with_index do |arg, i|
+          if arg.is_a?(Hash)
+            protected_attributes_for_create = args[i].with_indifferent_access
+          else
+            unprotected_attributes_for_create[attributes[i]] = args[i]
+          end
+        end
+
+        record = if ::ActiveRecord::VERSION::STRING < "3.1.0"
+          new do |r|
+            r.send(:attributes=, protected_attributes_for_create, true) unless protected_attributes_for_create.empty?
+            r.send(:attributes=, unprotected_attributes_for_create, false) unless unprotected_attributes_for_create.empty?
+          end
+        else
+          new(protected_attributes_for_create, options) do |r|
+            r.assign_attributes(unprotected_attributes_for_create, :without_protection => true)
+          end
+        end
+        yield(record) if block_given?
+        record.send(match.bang? ? :save! : :save) if match.instantiator.eql?(:create)
+
+        record
+      end
+
+    protected
+
+      def translated_attr_accessor(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+        define_method(name) do |*args|
+          read_attribute(name, {:locale => args.first})
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+      def translations_accessor(name)
+        define_method(:"#{name}_translations") do
+          result = translations.each_with_object(HashWithIndifferentAccess.new) do |translation, result|
+            result[translation.locale] = translation.value
+          end
+          globalize.stash.keys.each_with_object(result) do |locale, result|
+            result[locale] = globalize.fetch_stash(locale, name) if globalize.stash_contains?(locale, name)
+          end
+        end
+        define_method(:"#{name}_translations=") do |value|
+          value.each do |(locale, value)|
+            write_attribute name, value, :locale => locale
+          end
+        end
+      end
+
+      def join_index
+        @join_index = 0 if @join_index.nil? || @join_index > 100
+        @join_index
+      end
+
+      def join_index=(value)
+        @join_index = value
+      end
+    end
+
+  end
+
+end

data/lib/globalize/active_record/exceptions.rb

@@ -0,0 +1,19 @@
+module Globalize
+  module ActiveRecord
+    module Exceptions
+      class MigrationError < StandardError; end
+  
+      class BadFieldName < MigrationError
+        def initialize(field)
+          super("Missing translated field #{field.inspect}")
+        end
+      end
+  
+      class BadFieldType < MigrationError
+        def initialize(name, type)
+          super("Bad field type for field #{name.inspect} (#{type.inspect}), should be :string or :text")
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -0,0 +1,210 @@
+module Globalize
+  module ActiveRecord
+    module InstanceMethods
+      delegate :translated_locales, :to => :translations
+
+      def globalize
+        @globalize ||= Adapter.new(self)
+      end
+
+      def attributes
+        super.merge(translated_attributes)
+      end
+
+      def self.included(base)
+        # Maintain Rails 3.0.x compatibility while adding Rails 3.1.x compatibility
+        if base.method_defined?(:assign_attributes)
+          base.class_eval %{
+            def assign_attributes(attributes, options = {})
+              with_given_locale(attributes) { super }
+            end
+          }
+        else
+          base.class_eval %{
+            def attributes=(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+
+            def update_attributes!(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+
+            def update_attributes(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+          }
+        end
+      end
+
+      # Deprecate old use of locale
+      def deprecated_options(options)
+        unless options.is_a?(Hash)
+          warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
+          {:locale => options}
+        else
+          options
+        end
+      end
+
+      def write_attribute(name, value, options = {})
+        if translated?(name)
+          options = {:locale => Globalize.locale}.merge(deprecated_options(options))
+
+          # Dirty tracking, paraphrased from
+          # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+          name_str = name.to_s
+          # If there's already a change, delete it if this undoes the change.
+          if attribute_changed?(name_str) && value == changed_attributes[name_str]
+            changed_attributes.delete(name_str)
+          elsif !attribute_changed?(name_str) && value != (old = globalize.fetch(options[:locale], name))
+            changed_attributes[name_str] = old
+          end
+
+          globalize.write(options[:locale], name, value)
+        else
+          super(name, value)
+        end
+      end
+
+      def read_attribute(name, options = {})
+        options = {:translated => true, :locale => nil}.merge(deprecated_options(options))
+        if (self.class.translated?(name) && options[:translated]) && (value = globalize.fetch(options[:locale] || Globalize.locale, name))
+          value
+        else
+          super(name)
+        end
+      end
+
+      def attribute_names
+        translated_attribute_names.map(&:to_s) + super
+      end
+
+      def translated?(name)
+        self.class.translated?(name)
+      end
+
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => translation[name.to_s].try(:value))
+        end
+      end
+
+      # This method is basically the method built into Rails
+      # but we have to pass {:translated => false}
+      def untranslated_attributes
+        attrs = {}
+        attribute_names.each do |name|
+          attrs[name] = read_attribute(name, {:translated => false})
+        end
+        attrs
+      end
+
+      def set_translations(options)
+        options.keys.each do |locale|
+          options[locale].each do |key, value|
+            raise NoMethodError.new("unknown attribute: #{key}") unless attribute_names.flatten.include?(key.to_s)
+            translation = translation_for(locale, key.to_s)
+            translation.value = value
+            translation.save
+          end
+        end
+        globalize.reset
+      end
+
+      def reload(options = nil)
+        translation_caches.clear
+        translated_attribute_names.each { |name| @attributes.delete(name.to_s) }
+        globalize.reset
+        super(options)
+      end
+
+      def clone
+        obj = super
+        return obj unless respond_to?(:translated_attribute_names)
+
+        obj.instance_variable_set(:@translations, nil) if new_record? # Reset the collection because of rails bug: http://pastie.org/1521874
+        obj.instance_variable_set(:@globalize, nil )
+        each_locale_and_translated_attribute do |locale, name|
+          obj.globalize.write(locale, name, globalize.fetch(locale, name) )
+        end
+
+        return obj
+      end
+
+      def translation
+        translations_for_locale(::Globalize.locale)
+      end
+
+      def translation_for(locale, name, build_if_missing = true)
+        translation_caches[locale] ||= {}
+        translation_caches[locale][name] ||= (translations.detect{|t| t.locale == locale && t.attribute_name == name.to_s}) ||
+          (translations.attribute(name).with_locale(locale).first) ||
+          (translations.build(:locale => locale, :attribute_name => name) if build_if_missing)
+      end
+
+      def translations_for_locale(locale)
+        translation_caches[locale] = if translations.loaded?
+                                       translations.select{|t| t.locale.to_s == locale.to_s }
+                                     else
+                                       translations.with_locale(locale)
+                                     end.inject({}) do |hash, t|
+                                       hash.update(t.attribute_name => t)
+                                     end
+      end
+
+      def translation_caches
+        @translation_caches ||= {}
+      end
+
+      def globalize_fallbacks(locale)
+        Globalize.fallbacks(locale)
+      end
+
+      private
+
+      def update(*)
+        I18n.with_locale(read_attribute(:locale) || I18n.default_locale) do
+          super
+        end
+      end
+
+      def create(*)
+        I18n.with_locale(read_attribute(:locale) || I18n.default_locale) do
+          super
+        end
+      end
+
+      protected
+
+      def each_locale_and_translated_attribute
+        used_locales.each do |locale|
+          translated_attribute_names.each do |name|
+            yield locale, name
+          end
+        end
+      end
+
+      def used_locales
+        globalize.stash.keys.concat(globalize.stash.keys).concat(translations.translated_locales).uniq
+      end
+
+      def save_translations!
+        globalize.save_translations!
+        translation_caches.clear
+      end
+
+      def with_given_locale(attributes, &block)
+        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys!)
+
+        locale = respond_to?(:locale=) ? attributes.try(:[], :locale) :
+          attributes.try(:delete, :locale)
+
+        if locale
+          Globalize.with_locale(locale, &block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/translation.rb

@@ -0,0 +1,43 @@
+module Globalize
+  module ActiveRecord
+    class Translation < ::ActiveRecord::Base
+      if self.respond_to?(:table_name=)
+        self.table_name = :globalize_translations
+      else
+        set_table_name :globalize_translations
+      end
+
+      attr_accessible :locale, :attribute_name, :value
+      validates :locale, :attribute_name, :presence => true
+      belongs_to :translatable, :polymorphic => true
+
+      class << self
+        def with_locales(*locales)
+          # Avoid using "IN" with SQL queries when only using one locale.
+          locales = locales.flatten.map(&:to_s)
+          locales = locales.first if locales.one?
+          where :locale => locales
+        end
+        alias with_locale with_locales
+
+        def translated_locales
+          select('DISTINCT locale').map(&:locale).sort { |l,r| l.to_s <=> r.to_s }
+        end
+
+        def attribute(attribute)
+          attribute = attribute.to_s
+          where :attribute_name => attribute
+        end
+      end
+
+      def locale
+        _locale = read_attribute :locale
+        _locale.present? ? _locale.to_sym : _locale
+      end
+
+      def locale=(locale)
+        write_attribute :locale, locale.to_s
+      end
+    end
+  end
+end

data/lib/globalize/active_record.rb

@@ -0,0 +1,12 @@
+module Globalize
+  module ActiveRecord
+    autoload :ActMacro,        'globalize/active_record/act_macro'
+    autoload :Adapter,         'globalize/active_record/adapter'
+    autoload :Attributes,      'globalize/active_record/attributes'
+    autoload :ClassMethods,    'globalize/active_record/class_methods'
+    autoload :Exceptions,      'globalize/active_record/exceptions'
+    autoload :InstanceMethods, 'globalize/active_record/instance_methods'
+    autoload :Migration,       'globalize/active_record/migration'
+    autoload :Translation,     'globalize/active_record/translation'
+  end
+end

data/lib/globalize.rb

@@ -0,0 +1,74 @@
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
+require 'patches/active_record/uniqueness_validator'
+
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+
+  class << self
+    def locale
+      read_locale || I18n.locale
+    end
+
+    def locale=(locale)
+      set_locale(locale)
+    end
+
+    def with_locale(locale, &block)
+      previous_locale = read_locale
+      set_locale(locale)
+      result = yield(locale)
+      set_locale(previous_locale)
+      result
+    end
+
+    def with_locales(*locales, &block)
+      locales.flatten.map do |locale|
+        with_locale(locale, &block)
+      end
+    end
+
+    def fallbacks=(locales)
+      set_fallbacks(locales)
+    end
+
+    def i18n_fallbacks?
+      I18n.respond_to?(:fallbacks)
+    end
+
+    def fallbacks(for_locale = self.locale)
+      read_fallbacks[for_locale] || default_fallbacks(for_locale)
+    end
+
+    def default_fallbacks(for_locale = self.locale)
+      i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
+    end
+
+  protected
+
+    def read_locale
+      Thread.current[:globalize_locale]
+    end
+
+    def set_locale(locale)
+      Thread.current[:globalize_locale] = locale.try(:to_sym)
+    end
+
+    def read_fallbacks
+      Thread.current[:fallbacks] || HashWithIndifferentAccess.new
+    end
+
+    def set_fallbacks(locales)
+      fallback_hash = HashWithIndifferentAccess.new
+
+      locales.each do |key, value|
+        fallback_hash[key] = value.presence || [key]
+      end if locales.present?
+
+      Thread.current[:fallbacks] = fallback_hash
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)

data/lib/i18n/missing_translations_log_handler.rb

@@ -0,0 +1,41 @@
+# 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:
+#
+#   logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
+#   I18n.missing_translations_logger = logger
+
+module I18n
+  @@missing_translations_logger = nil
+
+  class << self
+    def missing_translations_logger
+      @@missing_translations_logger ||= begin
+        require 'logger' unless defined?(Logger)
+        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
+      else
+        raise exception
+      end
+    end
+  end
+end

data/lib/i18n/missing_translations_raise_handler.rb

@@ -0,0 +1,25 @@
+# A simple exception handler that behaves like the default exception handler
+# but also raises on missing translations.
+#
+# Useful for identifying missing translations during testing.
+#
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_raise_handler'
+#   I18n.exception_handler = :missing_translations_raise_handler
+module I18n
+  class << self
+    def missing_translations_raise_handler(exception, locale, key, options)
+      raise exception
+    end
+  end
+end
+
+I18n.exception_handler = :missing_translations_raise_handler
+
+ActionView::Helpers::TranslationHelper.module_eval do
+  def translate(key, options = {})
+    I18n.translate(key, options)
+  end
+  alias :t :translate
+end

data/lib/patches/active_record/query_method.rb

@@ -0,0 +1,35 @@
+require 'active_record/attribute_methods/query'
+
+module ActiveRecord
+  module AttributeMethods
+    module Query
+      def query_attribute(attr_name)
+        unless value = read_attribute(attr_name)
+          false
+        else
+          column = self.class.columns_hash[attr_name]
+          if column.nil?
+            
+            # TODO submit a rails patch
+
+            # not sure what active_record tests say but i guess this should mean:
+            # call to_i and check zero? if the value is a Numeric or starts with
+            # a digit, so it can meaningfully be typecasted by to_i
+
+            # if Numeric === value || value !~ /[^0-9]/
+            if Numeric === value || value.to_s =~ /^[0-9]/
+              !value.to_i.zero?
+            else
+              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/patches/active_record/uniqueness_validator.rb

@@ -0,0 +1,61 @@
+require 'active_record/validations/uniqueness.rb'
+
+ActiveRecord::Validations::UniquenessValidator.class_eval do
+  def validate_each_with_translations(record, attribute, value)
+    klass = record.class
+    if klass.translates? && klass.translated?(attribute)
+      if methods.include?(:build_relation) || respond_to?(:build_relation)
+        finder_class = klass.translation_class
+        table = finder_class.arel_table
+
+        relation = build_relation(finder_class, table, 'attribute_name', attribute).
+          and(table[:locale].eq(Globalize.locale)).
+          and(table[:value].eq(value)).
+          and(table[:translatable_type].eq(klass.name))
+        relation = relation.and(table[klass.reflect_on_association(:translations).foreign_key].not_eq(record.send(:id))) if record.persisted?
+
+  #      TODO: add scope with translated attributes
+        if options[:scope]
+          ActiveRecord::Base.logger.warn("WARNING: SingleTableGlobalize3 does not currently support `scope` option on uniqueness validation for translated attributes.")
+        end
+
+        if finder_class.unscoped.where(relation).exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      else
+        finder_class = klass.translation_class
+        table = finder_class.unscoped
+
+        table_name   = finder_class.quoted_table_name
+
+        if value && klass.serialized_attributes.key?(attribute.to_s)
+          value = YAML.dump value
+        end
+
+        sql, params  = mount_sql_and_params(finder_class, table_name, 'value', value)
+
+        relation = table.where(sql, *params).
+          where(:locale => Globalize.locale).
+          where(:attribute_name => attribute).
+          where(:translatable_type => klass.name)
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.where(scope_item => scope_value)
+        end
+
+        if record.persisted?
+          fk = klass.reflect_on_association(:translations).options[:foreign_key]
+          relation = relation.where(finder_class.arel_table[fk].not_eq(record.send(:id)))
+        end
+
+        if relation.exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      end
+    else
+      validate_each_without_translations(record, attribute, value)
+    end
+  end
+  alias_method_chain :validate_each, :translations
+end

data/lib/patches/active_record/xml_attribute_serializer.rb

@@ -0,0 +1,13 @@
+require 'active_record/serializers/xml_serializer'
+
+ActiveRecord::XmlSerializer::Attribute.class_eval do
+  def compute_type_with_translations
+    klass = @serializable.class
+    if klass.translates? && klass.translated_attribute_names.include?(name.to_sym)
+      :string
+    else
+      compute_type_without_translations
+    end
+  end
+  alias_method_chain :compute_type, :translations
+end

data/lib/single_table_globalize3/version.rb

@@ -0,0 +1,3 @@
+module SingleTableGlobalize3
+  VERSION = '0.0.1'
+end

data/lib/single_table_globalize3.rb

@@ -0,0 +1 @@
+require 'globalize'

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: single_table_globalize3
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sven Fuchs
+- Joshua Harvey
+- Clemens Kofler
+- John-Paul Bader
+- Tomasz Stachewicz
+- Philip Arndt
+- Trong Tran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pathname_local
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_declarative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails I18n de-facto standard library for ActiveRecord 3 model/data translation
+  with single table.
+email: trong.v.tran@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/globalize3/migration_generator.rb
+- lib/generators/globalize3/templates/migration.rb
+- lib/globalize/active_record/act_macro.rb
+- lib/globalize/active_record/adapter.rb
+- lib/globalize/active_record/attributes.rb
+- lib/globalize/active_record/class_methods.rb
+- lib/globalize/active_record/exceptions.rb
+- lib/globalize/active_record/instance_methods.rb
+- lib/globalize/active_record/translation.rb
+- lib/globalize/active_record.rb
+- lib/globalize.rb
+- lib/i18n/missing_translations_log_handler.rb
+- lib/i18n/missing_translations_raise_handler.rb
+- lib/patches/active_record/query_method.rb
+- lib/patches/active_record/uniqueness_validator.rb
+- lib/patches/active_record/xml_attribute_serializer.rb
+- lib/single_table_globalize3/version.rb
+- lib/single_table_globalize3.rb
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Rakefile
+homepage: http://github.com/trongrg/single_table_globalize3
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: '[none]'
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Rails I18n de-facto standard library for ActiveRecord 3 model/data translation
+  with single table
+test_files: []