globalize-r5 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/globalize.gemspec

@@ -0,0 +1,27 @@
+require File.expand_path('../lib/globalize/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name         = 'globalize-r5'
+  s.version      = Globalize::Version
+  s.authors      = ['Sven Fuchs', 'Joshua Harvey', 'Clemens Kofler', 'John-Paul Bader', 'Tomasz Stachewicz', 'Philip Arndt', 'Chris Salzberg']
+  s.email        = 'nobody@globalize-rails.org'
+  s.homepage     = 'http://github.com/globalize/globalize'
+  s.summary      = 'Rails I18n de-facto standard library for ActiveRecord model/data translation'
+  s.description  = "#{s.summary}."
+  s.license      = "MIT"
+
+  s.files        = Dir['{lib/**/*,[A-Z]*}']
+  s.platform     = Gem::Platform::RUBY
+  s.require_path = 'lib'
+  s.rubyforge_project = '[none]'
+
+  s.add_dependency 'activerecord', '>= 4.2', '< 5.1'
+  s.add_dependency 'activemodel', '>= 4.2', '< 5.1'
+  s.add_dependency 'request_store', '~> 1.0'
+
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-reporters'
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'rake'
+end

data/issue_template.rb

@@ -0,0 +1,38 @@
+# Activate the gem you are reporting the issue against.
+gem 'activerecord', '4.2.0'
+gem 'globalize', '5.0.1'
+require 'active_record'
+require 'globalize'
+require 'minitest/autorun'
+require 'logger'
+
+# Ensure backward compatibility with Minitest 4
+Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
+
+# This connection will do for database-independent bug reports.
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+  end
+
+  create_table :post_translations, force: true do |t|
+    t.references :post
+    t.string     :title
+    t.text       :content
+    t.string     :locale
+  end
+end
+
+class Post < ActiveRecord::Base
+  translates :content, :title
+end
+
+class BugTest < Minitest::Test
+  def test_association_stuff
+    post = Post.create!(title: 'HI')
+
+    assert_equal 'HI', post.title
+  end
+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,95 @@
+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?
+
+        # 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)
+
+          if ::ActiveRecord::VERSION::STRING >= "5.0.0"
+            # use virtual attribute
+            attribute attr_name, :string
+          end
+
+          # 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
+      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
+
+        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, :translations
+      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,53 @@
+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(:restore_attribute!, name) if record.respond_to? :restore_attribute!, true
+      end
+
+      def reset
+        clear_dirty
+        super
+      end
+    end
+  end
+end