globalize-danibachar 5.2.0

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,129 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
+
+      if ::ActiveRecord::VERSION::STRING < "5.0.0"
+        def columns_hash
+          super.except(*translated_attribute_names.map(&:to_s))
+        end
+      end
+
+      def with_locales(*locales)
+        all.merge translation_class.with_locales(*locales)
+      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],
+            inverse_of: :translations,
+            touch: translation_options.fetch(:touch, false)
+          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 and calculation methods
+      # for translated attributes.
+      def relation
+        super.extending!(TranslatedAttributesQuery)
+      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)
+        attribute(name, ::ActiveRecord::Type::Value.new)
+        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,13 @@
+module Globalize
+  module ActiveRecord
+    module Exceptions
+      class MigrationError < StandardError; end
+
+      class BadFieldName < MigrationError
+        def initialize(field)
+          super("Missing translated field #{field.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -0,0 +1,246 @@
+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=(new_attributes, *options)
+        super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+        attributes = new_attributes.stringify_keys
+        with_given_locale(attributes) { super(attributes.except("locale"), *options) }
+      end
+
+      if Globalize.rails_52?
+
+        # In Rails 5.2 we need to override *_assign_attributes* as it's called earlier
+        # in the stack (before *assign_attributes*)
+        # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/attribute_assignment.rb#L11
+        def _assign_attributes(new_attributes)
+          attributes = new_attributes.stringify_keys
+          with_given_locale(attributes) { super(attributes.except("locale")) }
+        end
+
+      else
+
+        def assign_attributes(new_attributes, *options)
+          super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+          attributes = new_attributes.stringify_keys
+          with_given_locale(attributes) { super(attributes.except("locale"), *options) }
+        end
+
+      end
+
+      def write_attribute(name, value, *args, &block)
+        return super(name, value, *args, &block) unless translated?(name)
+
+        options = {:locale => Globalize.locale}.merge(args.first || {})
+
+        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(attr_name, options = {}, &block)
+        name = if self.class.attribute_alias?(attr_name)
+                 self.class.attribute_alias(attr_name).to_s
+               else
+                 attr_name.to_s
+               end
+
+        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
+
+        _read_attribute(name, options, &block)
+      end
+
+      def _read_attribute(attr_name, options = {}, &block)
+        translated_value = read_translated_attribute(attr_name, options, &block)
+        translated_value.nil? ? super(attr_name, &block) : translated_value
+      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
+            translation.globalized_model.send :"#{key}=", value
+          end
+          translation.save if persisted?
+        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 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
+
+      # need to access instance variable directly since changed_attributes
+      # is frozen as of Rails 4.2
+      def original_changed_attributes
+        @changed_attributes
+      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 = _attributes.stringify_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
+
+      # nil or value
+      def read_translated_attribute(name, options)
+        options = {:translated => true, :locale => nil}.merge(options)
+        return nil unless options[:translated]
+        return nil unless translated?(name)
+
+        value = globalize.fetch(options[:locale] || Globalize.locale, name)
+        return nil if value.nil?
+
+        block_given? ? yield(value) : value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/migration.rb

@@ -0,0 +1,215 @@
+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 = {})
+          extra = options.keys - [:migrate_data, :remove_source_columns, :unique_index]
+          if extra.any?
+            raise ArgumentError, "Unknown migration #{'option'.pluralize(extra.size)}: #{extra}"
+          end
+          @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(options)
+          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
+          column_names = *fields.keys
+          column_names.each do |column|
+            if connection.column_exists?(table_name, column)
+              connection.remove_column(table_name, column)
+            end
+          end
+        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(options)
+          foreign_key = "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id".to_sym
+          connection.add_index(
+            translations_table_name,
+            foreign_key,
+            :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
+          )
+
+          if options[:unique_index]
+            connection.add_index(
+              translations_table_name,
+              [foreign_key, :locale],
+              :name => translation_unique_index_name,
+              unique: true
+            )
+          end
+        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
+          if connection.indexes(translations_table_name).map(&:name).include?(translation_locale_index_name)
+            connection.remove_index(translations_table_name, :name => translation_locale_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)
+          end
+        end
+
+        def column_type(name)
+          columns.detect { |c| c.name == name.to_s }.try(:type) || :string
+        end
+
+        def valid_field_name?(name)
+          translated_attribute_names.include?(name)
+        end
+
+        def translation_index_name
+          truncate_index_name "index_#{translations_table_name}_on_#{table_name.singularize}_id"
+        end
+
+        def translation_locale_index_name
+          truncate_index_name "index_#{translations_table_name}_on_locale"
+        end
+
+        def translation_unique_index_name
+          truncate_index_name "index_#{translations_table_name}_on_#{table_name.singularize}_id_and_locale"
+        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 truncate_index_name(index_name)
+          if index_name.size < connection.index_name_length
+            index_name
+          else
+            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+          end
+        end
+
+        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