globalize-r5 5.1.0

data/lib/globalize/active_record/attributes.rb

@@ -0,0 +1,26 @@
+# 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)
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,122 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
+
+      def with_locales(*locales)
+        all.merge translation_class.with_locales(*locales)
+      end
+
+      def with_where(opts = {})
+        all.merge translation_class.where(opts)
+      end
+
+      def with_translations(*locales)
+        locales = translated_locales if locales.empty?
+        preload(:translations).joins(:translations).readonly(false).with_locales(locales).tap do |query|
+          query.distinct! unless locales.flatten.one?
+        end
+      end
+
+      def with_required_attributes
+        warn 'with_required_attributes is deprecated and will be removed in the next release of Globalize.'
+        required_translated_attributes.inject(all) do |scope, name|
+          scope.where("#{translated_column_name(name)} IS NOT NULL")
+        end
+      end
+
+      def with_translated_attribute(name, value, 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
+        warn 'required_attributes is deprecated and will be removed in the next release of Globalize.'
+        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
+      end
+
+      def required_translated_attributes
+        warn 'required_translated_attributes is deprecated and will be removed in the next release of Globalize.'
+        translated_attribute_names & required_attributes
+      end
+
+      def translation_class
+        @translation_class ||= begin
+          if self.const_defined?(:Translation, false)
+            klass = self.const_get(:Translation, false)
+          else
+            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
+
+      private
+
+      # Override the default relation method in order to return a subclass
+      # of ActiveRecord::Relation with custom finder methods for translated
+      # attributes.
+      def relation
+        super.extending!(QueryMethods)
+      end
+
+      protected
+
+      def define_translated_attr_reader(name)
+        define_method(name) do |*args|
+          Globalize::Interpolation.interpolate(name, self, args)
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+      def define_translated_attr_writer(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+      end
+
+      def define_translated_attr_accessor(name)
+        define_translated_attr_reader(name)
+        define_translated_attr_writer(name)
+      end
+
+      def define_translations_reader(name)
+        define_method(:"#{name}_translations") do
+          hash = translated_attribute_by_locale(name)
+          globalize.stash.keys.each_with_object(hash) do |locale, result|
+            result[locale] = globalize.fetch_stash(locale, name) if globalize.stash_contains?(locale, name)
+          end
+        end
+      end
+
+      def define_translations_writer(name)
+        define_method(:"#{name}_translations=") do |value|
+          value.each do |(locale, _value)|
+            write_attribute name, _value, :locale => locale
+          end
+        end
+      end
+
+      def define_translations_accessor(name)
+        define_translations_reader(name)
+        define_translations_writer(name)
+      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,219 @@
+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 attributes=(attributes, *args)
+        with_given_locale(attributes) { super(attributes_without_locale(attributes)) }
+      end
+
+      def assign_attributes(attributes, *args)
+        with_given_locale(attributes) { super(attributes_without_locale(attributes)) }
+      end
+
+
+
+      def write_attribute(name, value, options = {})
+        return super(name, value) unless translated?(name)
+
+        options = {:locale => Globalize.locale}.merge(options)
+
+        globalize.write(options[:locale], name, value)
+      end
+
+      def [](attr_name)
+        if translated?(attr_name)
+          read_attribute(attr_name)
+        else
+          read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+        end
+      end
+
+      def read_attribute(name, options = {})
+        options = {:translated => true, :locale => nil}.merge(options)
+        return super(name) unless options[:translated]
+
+        if translated?(name)
+          if !(value = globalize.fetch(options[:locale] || Globalize.locale, name)).nil?
+            value
+          else
+            super(name)
+          end
+        else
+          super(name)
+        end
+      end
+
+      def attribute_names
+        translated_attribute_names.map(&:to_s) + super
+      end
+
+      delegate :translated?, :to => :class
+
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => send(name))
+        end
+      end
+
+      # This method is basically the method built into Rails
+      # but we have to pass {:translated => false}
+      def untranslated_attributes
+        attribute_names.inject({}) do |attrs, name|
+          attrs[name] = read_attribute(name, {:translated => false}); attrs
+        end
+      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.reset(name.to_s) }
+        globalize.reset
+        super(options)
+      end
+
+      def initialize_dup(other)
+        @globalize = nil
+        @translation_caches = nil
+        super
+        other.each_locale_and_translated_attribute do |locale, name|
+          globalize.write(locale, name, other.globalize.fetch(locale, name) )
+        end
+      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 translations_by_locale
+        translations.each_with_object(HashWithIndifferentAccess.new) do |t, hash|
+          hash[t.locale] = block_given? ? yield(t) : t
+        end
+      end
+
+      def translated_attribute_by_locale(name)
+        translations_by_locale(&:"#{name}")
+      end
+
+      # Get available locales from translations association, without a separate distinct query
+      def available_locales
+        translations.map(&:locale).uniq
+      end
+
+      def globalize_fallbacks(locale)
+        Globalize.fallbacks(locale)
+      end
+
+      def rollback
+        translation_caches[::Globalize.locale] = translation.previous_version
+      end
+
+      def save(*)
+        result = Globalize.with_locale(translation.locale || I18n.default_locale) do
+          without_fallbacks do
+            super
+          end
+        end
+        if result
+          globalize.clear_dirty
+        end
+
+        result
+      end
+
+      def column_for_attribute name
+        return super if translated_attribute_names.exclude?(name)
+
+        globalize.send(:column_for_attribute, name)
+      end
+
+      def cache_key
+        [super, translation.cache_key].join("/")
+      end
+
+      def changed?
+        changed_attributes.present? || translations.any?(&:changed?)
+      end
+
+    protected
+
+      def attributes_without_locale(attributes)
+        attributes.try(:except, :locale)
+      end
+
+      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 = _attributes.dup
+        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys)
+
+        if locale = attributes.try(:delete, :locale)
+          Globalize.with_locale(locale, &block)
+        else
+          yield
+        end
+      end
+
+      def without_fallbacks
+        before = self.fallbacks_for_empty_translations
+        self.fallbacks_for_empty_translations = false
+        yield
+      ensure
+        self.fallbacks_for_empty_translations = before
+      end
+
+    end
+  end
+end

data/lib/globalize/active_record/migration.rb

@@ -0,0 +1,192 @@
+require 'digest/sha1'
+
+module Globalize
+  module ActiveRecord
+    module Migration
+      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
+        delegate :translated_attribute_names, :connection, :table_name,
+          :table_name_prefix, :translations_table_name, :columns, :to => :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def fields
+          @fields ||= complete_translated_fields
+        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)
+          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, :index => false, :type => column_type(model.primary_key).to_sym
+            t.string :locale, :null => false
+            t.timestamps :null => false
+          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
+          if connection.indexes(translations_table_name).map(&:name).include?(translation_index_name)
+            connection.remove_index(translations_table_name, :name => translation_index_name)
+          end
+        end
+
+        def move_data_to_translation_table
+          model.find_each do |record|
+            translation = record.translation_for(I18n.locale) || record.translations.build(:locale => I18n.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.where(model.primary_key.to_sym => translated_record[model.primary_key]).update_all(fields_to_update)
+          end
+        end
+
+        def validate_translated_fields
+          fields.each do |name, options|
+            raise BadFieldName.new(name) unless valid_field_name?(name)
+            type = (options.is_a? Hash) ? options[:type] : options
+            raise BadFieldType.new(name, type) unless valid_field_type?(name, type)
+          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, :citext].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
+          clear_schema_cache!
+          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