globalize 3.0.0

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,173 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
+
+      def with_locales(*locales)
+        scoped.merge(translation_class.with_locales(*locales))
+      end
+
+      def with_translations(*locales)
+        locales = translated_locales if locales.empty?
+        includes(:translations).with_locales(locales).with_required_attributes
+      end
+
+      def with_required_attributes
+        required_translated_attributes.inject(scoped) do |scope, name|
+          scope.where("#{translated_column_name(name)} IS NOT NULL")
+        end
+      end
+
+      def with_translated_attribute(name, value, locales = nil)
+        locales ||= Globalize.fallbacks
+        with_translations.where(
+          translated_column_name(name)    => value,
+          translated_column_name(:locale) => Array(locales).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
+        @translation_class ||= begin
+          klass = self.const_get(:Translation) rescue nil
+          if klass.nil? || klass.class_name != (self.class_name + "Translation")
+            klass = self.const_set(:Translation, Class.new(Globalize::ActiveRecord::Translation))
+          end
+
+          klass.belongs_to :globalized_model, :class_name => self.name, :foreign_key => translation_options[:foreign_key]
+          klass
+        end
+      end
+
+      def translations_table_name
+        translation_class.table_name
+      end
+
+      def translated_column_name(name)
+        "#{translation_class.table_name}.#{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|
+          Globalize::Interpolation.interpolate(name, self, args)
+        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.send(name)
+          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
+
+    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,224 @@
+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
+
+      def write_attribute(name, value, options = {})
+        if translated?(name)
+          # Deprecate old use of locale
+          unless options.is_a?(Hash)
+            warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
+            options = {:locale => options}
+          end
+          options = {:locale => Globalize.locale}.merge(options)
+          
+          # Dirty tracking, paraphrased from
+          # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+          name_str = name.to_s
+          if attribute_changed?(name_str)
+            # If there's already a change, delete it if this undoes the change.
+            old = changed_attributes[name_str]
+            changed_attributes.delete(name_str) if value == old
+          else
+            # If there's not a change yet, record it.
+            old = globalize.fetch(options[:locale], name)
+            old = old.clone if old.duplicable?
+            changed_attributes[name_str] = old if value != old
+          end
+          
+          globalize.write(options[:locale], name, value)
+        else
+          super(name, value)
+        end
+      end
+
+      def read_attribute(name, options = {})
+        # Deprecate old use of locale
+        unless options.is_a?(Hash)
+          warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
+          options = {:locale => options}
+        end
+
+        options = {:translated => true, :locale => nil}.merge(options)
+        if self.class.translated?(name) and options[:translated]
+          if (value = globalize.fetch(options[:locale] || Globalize.locale, name))
+            value
+          else
+            super(name)
+          end
+        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.send(name))
+        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|
+          translation = translation_for(locale) ||
+                        translations.build(:locale => locale.to_s)
+
+          options[locale].each do |key, value|
+            translation.send :"#{key}=", value
+          end
+          translation.save
+        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
+        translation_for(::Globalize.locale)
+      end
+
+      def translation_for(locale, build_if_missing = true)
+        unless translation_caches[locale]
+          # Fetch translations from database as those in the translation collection may be incomplete
+          _translation = translations.detect{|t| t.locale.to_s == locale.to_s}
+          _translation ||= translations.with_locale(locale).first unless translations.loaded?
+          _translation ||= translations.build(:locale => locale) if build_if_missing
+          translation_caches[locale] = _translation if _translation
+        end
+        translation_caches[locale]
+      end
+
+      def translation_caches
+        @translation_caches ||= {}
+      end
+
+      def globalize_fallbacks(locale)
+        Globalize.fallbacks(locale)
+      end
+
+      def rollback
+        translation_caches[::Globalize.locale] = translation.previous_version
+      end
+
+      def column_for_attribute name
+        translated_attribute_names.include?(name) ? globalize.send(:column_for_attribute, name) : super
+      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
+        locales = globalize.stash.keys.concat(globalize.stash.keys).concat(translations.translated_locales)
+        locales.uniq!
+        locales
+      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/migration.rb

@@ -0,0 +1,191 @@
+require 'digest/sha1'
+
+module Globalize
+  module ActiveRecord
+    module Migration
+      attr_reader :globalize_migrator
+
+      def globalize_migrator
+        @globalize_migrator ||= Migrator.new(self)
+      end
+
+      delegate :create_translation_table!, :add_translation_fields!, :drop_translation_table!,
+        :translation_index_name, :translation_locale_index_name,
+        :to => :globalize_migrator
+
+      class Migrator
+        include Globalize::ActiveRecord::Exceptions
+
+        attr_reader :model, :fields
+        delegate :translated_attribute_names, :connection, :table_name,
+          :table_name_prefix, :translations_table_name, :columns, :to => :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def create_translation_table!(fields = {}, options = {})
+          @fields = fields
+          # If we have fields we only want to create the translation table with those fields
+          complete_translated_fields if fields.blank?
+          validate_translated_fields
+
+          create_translation_table
+          add_translation_fields!(fields, options)
+          create_translations_index
+          clear_schema_cache!
+        end
+
+        def add_translation_fields!(fields, options = {})
+          @fields = fields
+          validate_translated_fields
+
+          add_translation_fields
+          clear_schema_cache!
+          move_data_to_translation_table if options[:migrate_data]
+          remove_source_columns if options[:remove_source_columns]
+          clear_schema_cache!
+        end
+
+        def remove_source_columns
+          connection.remove_columns(table_name, *fields.keys)
+        end
+
+        def drop_translation_table!(options = {})
+          move_data_to_model_table if options[:migrate_data]
+          drop_translations_index
+          drop_translation_table
+          clear_schema_cache!
+        end
+
+        # This adds all the current translated attributes of the model
+        # It's a problem because in early migrations would add all the translated attributes
+        def complete_translated_fields
+          translated_attribute_names.each do |name|
+            fields[name] = column_type(name) unless fields[name]
+          end
+        end
+
+        def create_translation_table
+          connection.create_table(translations_table_name) do |t|
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false
+            t.string :locale, :null => false
+            t.timestamps
+          end
+        end
+
+        def add_translation_fields
+          connection.change_table(translations_table_name) do |t|
+            fields.each do |name, options|
+              if options.is_a? Hash
+                t.column name, options.delete(:type), options
+              else
+                t.column name, options
+              end
+            end
+          end
+        end
+
+        def create_translations_index
+          connection.add_index(
+            translations_table_name,
+            "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
+            :name => translation_index_name
+          )
+          # index for select('DISTINCT locale') call in translation.rb
+          connection.add_index(
+            translations_table_name,
+            :locale,
+            :name => translation_locale_index_name
+          )
+        end
+
+        def drop_translation_table
+          connection.drop_table(translations_table_name)
+        end
+
+        def drop_translations_index
+          connection.remove_index(translations_table_name, :name => translation_index_name)
+        end
+
+        def move_data_to_translation_table
+          model.find_each do |record|
+            translation = record.translation_for(I18n.default_locale) || record.translations.build(:locale => I18n.default_locale)
+            fields.each do |attribute_name, attribute_type|
+              translation[attribute_name] = record.read_attribute(attribute_name, {:translated => false})
+            end
+            translation.save!
+          end
+        end
+
+        def move_data_to_model_table
+          add_missing_columns
+
+          # Find all of the translated attributes for all records in the model.
+          all_translated_attributes = @model.all.collect{|m| m.attributes}
+          all_translated_attributes.each do |translated_record|
+            # Create a hash containing the translated column names and their values.
+            translated_attribute_names.inject(fields_to_update={}) do |f, name|
+              f.update({name.to_sym => translated_record[name.to_s]})
+            end
+
+            # Now, update the actual model's record with the hash.
+            @model.update_all(fields_to_update, {:id => translated_record['id']})
+          end
+        end
+
+        def validate_translated_fields
+          fields.each do |name, options|
+            raise BadFieldName.new(name) unless valid_field_name?(name)
+            if options.is_a? Hash
+              raise BadFieldType.new(name, options[:type]) unless valid_field_type?(name, options[:type])
+            else
+              raise BadFieldType.new(name, options) unless valid_field_type?(name, options)
+            end
+          end
+        end
+
+        def column_type(name)
+          columns.detect { |c| c.name == name.to_s }.try(:type)
+        end
+
+        def valid_field_name?(name)
+          translated_attribute_names.include?(name)
+        end
+
+        def valid_field_type?(name, type)
+          !translated_attribute_names.include?(name) || [:string, :text].include?(type)
+        end
+
+        def translation_index_name
+          index_name = "index_#{translations_table_name}_on_#{table_name.singularize}_id"
+          index_name.size < connection.index_name_length ? index_name :
+            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+        end
+
+        def translation_locale_index_name
+          index_name = "index_#{translations_table_name}_on_locale"
+          index_name.size < connection.index_name_length ? index_name :
+            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+        end
+
+        def clear_schema_cache!
+          connection.schema_cache.clear! if connection.respond_to? :schema_cache
+          model::Translation.reset_column_information
+          model.reset_column_information
+        end
+
+        private
+
+        def add_missing_columns
+          translated_attribute_names.map(&:to_s).each do |attribute|
+            unless model.column_names.include?(attribute)
+              connection.add_column(table_name, attribute, model::Translation.columns_hash[attribute].type)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end