globalize-rails5 5.1.0

data/Rakefile

@@ -0,0 +1,55 @@
+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    = 'Globalize'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :load_path do
+  %w(lib test).each do |path|
+    $LOAD_PATH.unshift(File.expand_path("../#{path}", __FILE__))
+  end
+end
+
+namespace :db do
+  desc 'Create the database'
+  task :create => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.create!
+  end
+
+  desc "Drop the database"
+  task :drop => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.drop!
+  end
+
+  desc "Set up the database schema"
+  task :migrate => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.migrate!
+    # ActiveRecord::Schema.migrate :up
+  end
+
+  desc "Drop and recreate the database schema"
+  task :reset => [:drop, :create]
+end

data/lib/globalize.rb

@@ -0,0 +1,90 @@
+require 'request_store'
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
+require 'patches/active_record/relation'
+require 'patches/active_record/serialization'
+require 'patches/active_record/uniqueness_validator'
+require 'patches/active_record/persistence'
+
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+  autoload :Interpolation,   'globalize/interpolation'
+
+  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
+      begin
+        set_locale(locale)
+        result = yield(locale)
+      ensure
+        set_locale(previous_locale)
+      end
+      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
+
+    # Thread-safe global storage
+    def storage
+      RequestStore.store
+    end
+
+  protected
+
+    def read_locale
+      storage[:globalize_locale]
+    end
+
+    def set_locale(locale)
+      storage[:globalize_locale] = locale.try(:to_sym)
+    end
+
+    def read_fallbacks
+      storage[:globalize_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?
+
+      storage[:globalize_fallbacks] = fallback_hash
+    end
+  end
+end
+
+ActiveRecord::Base.mattr_accessor :globalize_serialized_attributes, instance_writer: false
+ActiveRecord::Base.globalize_serialized_attributes = {}
+
+ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)

data/lib/globalize/active_record.rb

@@ -0,0 +1,14 @@
+module Globalize
+  module ActiveRecord
+    autoload :ActMacro,        'globalize/active_record/act_macro'
+    autoload :Adapter,         'globalize/active_record/adapter'
+    autoload :AdapterDirty,    'globalize/active_record/adapter_dirty'
+    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'
+    autoload :QueryMethods,    'globalize/active_record/query_methods'
+  end
+end

data/lib/globalize/active_record/act_macro.rb

@@ -0,0 +1,111 @@
+module Globalize
+  module ActiveRecord
+    module ActMacro
+      def translates(*attr_names)
+        options = attr_names.extract_options!
+        # Bypass setup_translates! if the initial bootstrapping is done already.
+        setup_translates!(options) unless translates?
+        check_columns!(attr_names)
+
+        # Add any extra translatable attributes.
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= translated_attribute_names if defined?(translated_attribute_names)
+
+        allow_translation_of_attributes(attr_names) if attr_names.present?
+      end
+
+      def class_name
+        @class_name ||= begin
+          class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].downcase.camelize
+          pluralize_table_names ? class_name.singularize : class_name
+        end
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+
+      protected
+
+      def allow_translation_of_attributes(attr_names)
+        attr_names.each do |attr_name|
+          # Detect and apply serialization.
+          enable_serializable_attribute(attr_name)
+
+          # Create accessors for the attribute.
+          define_translated_attr_accessor(attr_name)
+          define_translations_accessor(attr_name)
+
+          # Add attribute to the list.
+          self.translated_attribute_names << attr_name
+        end
+
+        if ::ActiveRecord::VERSION::STRING > "5.0" && table_exists? && translation_class.table_exists?
+          self.ignored_columns += translated_attribute_names.map(&:to_s)
+          reset_column_information
+        end
+      end
+
+      def check_columns!(attr_names)
+        # If tables do not exist, do not warn about conflicting columns
+        return unless table_exists? && translation_class.table_exists?
+
+        if (overlap = attr_names.map(&:to_s) & column_names).present?
+          ActiveSupport::Deprecation.warn(
+            ["You have defined one or more translated attributes with names that conflict with column(s) on the model table. ",
+             "Globalize does not support this configuration anymore, remove or rename column(s) on the model table.\n",
+             "Model name (table name): #{model_name} (#{table_name})\n",
+             "Attribute name(s): #{overlap.join(', ')}\n"].join
+          )
+        end
+      end
+
+      def apply_globalize_options(options)
+        options[:table_name] ||= "#{table_name.singularize}_translations"
+        options[:foreign_key] ||= class_name.foreign_key
+
+        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]
+      end
+
+      def enable_serializable_attribute(attr_name)
+        serializer = self.globalize_serialized_attributes[attr_name]
+        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
+      end
+
+      def setup_translates!(options)
+        apply_globalize_options(options)
+
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
+        translation_class.table_name = options[:table_name]
+
+        has_many :translations, :class_name  => translation_class.name,
+                                :foreign_key => options[:foreign_key],
+                                :dependent   => :destroy,
+                                :extend      => HasManyExtensions,
+                                :autosave    => true,
+                                :inverse_of  => :globalized_model
+
+        before_create :save_translations!
+        before_update :save_translations!
+      end
+    end
+
+    module HasManyExtensions
+      def find_or_initialize_by_locale(locale)
+        with_locale(locale.to_s).first || build(:locale => locale.to_s)
+      end
+    end
+  end
+end

data/lib/globalize/active_record/adapter.rb

@@ -0,0 +1,99 @@
+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
+      private :record=, :stash=
+
+      delegate :translation_class, :to => :'record.class'
+
+      def initialize(record)
+        @record = record
+        @stash = Attributes.new
+      end
+
+      def fetch_stash(locale, name)
+        stash.read(locale, name)
+      end
+
+      delegate :contains?, :to => :stash, :prefix => :stash
+      delegate :write, :to => :stash
+
+      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 save_translations!
+        stash.each do |locale, attrs|
+          next if attrs.empty?
+
+          translation = record.translations_by_locale[locale] ||
+                        record.translations.build(locale: locale.to_s)
+          attrs.each do |name, value|
+            value = value.val if value.is_a?(Arel::Nodes::Casted)
+            translation[name] = value
+          end
+        end
+
+        reset
+      end
+
+      def reset
+        stash.clear
+      end
+
+      protected
+
+      def type_cast(name, value)
+        return value.presence unless column = column_for_attribute(name)
+
+        column.type_cast value
+      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, false)
+        if translation
+          translation.send(name)
+        else
+          record.class.translation_class.new.send(name)
+        end
+      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
+
+      delegate :fallbacks_for_empty_translations?, :to => :record, :prefix => false
+      prepend AdapterDirty
+    end
+  end
+end

data/lib/globalize/active_record/adapter_dirty.rb

@@ -0,0 +1,54 @@
+module Globalize
+  module ActiveRecord
+    module AdapterDirty
+      def write locale, name, value
+        # Dirty tracking, paraphrased from
+        # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+        name = name.to_s
+        store_old_value name, locale
+        old_values = dirty[name]
+        old_value = old_values[locale]
+        is_changed = record.send :attribute_changed?, name
+        if is_changed && value == old_value
+          # If there's already a change, delete it if this undoes the change.
+          old_values.delete locale
+          if old_values.empty?
+            _reset_attribute name
+          end
+        elsif !is_changed
+          # If there's not a change yet, record it.
+          record.send(:attribute_will_change!, name) if old_value != value
+        end
+
+        super locale, name, value
+      end
+
+      attr_writer :dirty
+      def dirty
+        @dirty ||= {}
+      end
+
+      def store_old_value name, locale
+        dirty[name] ||= {}
+        unless dirty[name].key? locale
+          old = fetch(locale, name)
+          old = old.dup if old.duplicable?
+          dirty[name][locale] = old
+        end
+      end
+      def clear_dirty
+        self.dirty = {}
+      end
+
+      def _reset_attribute name
+        record.send("#{name}=", record.changed_attributes[name])
+        record.original_changed_attributes.except!(name)
+      end
+
+      def reset
+        clear_dirty
+        super
+      end
+    end
+  end
+end

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