globalize 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7415d0b0223d5ace130c535aaee60e36929a4c7d
+  data.tar.gz: b4b6553f95f6f662aab9036c96b66ad0d7cac875
+SHA512:
+  metadata.gz: 79141074b2c0943e9af5d02a1cb2c44bee1394f061398fc338d762891799b0d952ebe3e1a0ae25911759e00afb66c52227f20cac4907fe6af472f82d39a21307
+  data.tar.gz: e4d92686bcbd19736730327ef01f478d179fa0c60229dc4b17e038e274e66216f30e69845d6b29d409c091a36ebe4bb29eca08dfb2b00fc1672ae5adf36b34d6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,87 @@
+PATH
+  remote: .
+  specs:
+    globalize (3.0.0)
+      activemodel (>= 3.0.0)
+      activerecord (>= 3.0.0)
+      paper_trail (~> 2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (3.2.15)
+      activemodel (= 3.2.15)
+      activesupport (= 3.2.15)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.15)
+      activesupport (= 3.2.15)
+      builder (~> 3.0.0)
+    activerecord (3.2.15)
+      activemodel (= 3.2.15)
+      activesupport (= 3.2.15)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.15)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.4)
+    database_cleaner (0.6.7)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.5)
+    journey (1.0.4)
+    json (1.8.1)
+    metaclass (0.0.1)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.8.2)
+    paper_trail (2.7.2)
+      activerecord (~> 3.0)
+      railties (~> 3.0)
+    pathname_local (0.0.2)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.3)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    railties (3.2.15)
+      actionpack (= 3.2.15)
+      activesupport (= 3.2.15)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.7)
+    test_declarative (0.0.5)
+    thor (0.18.1)
+    tilt (1.4.1)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 0.6.0)
+  globalize!
+  mocha
+  pathname_local
+  sqlite3
+  test_declarative

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008, 2009, 2010 Sven Fuchs, Joshua Harvey, Clemens Kofler, John-Paul Bader
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+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

data/lib/globalize.rb

@@ -0,0 +1,80 @@
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
+require 'patches/active_record/uniqueness_validator'
+require 'patches/active_record/relation'
+
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+  autoload :Versioning,   'globalize/versioning'
+  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
+
+  protected
+
+    def read_locale
+      Thread.current[:globalize_locale]
+    end
+
+    def set_locale(locale)
+      Thread.current[:globalize_locale] = locale.try(:to_sym)
+    end
+
+    def read_fallbacks
+      Thread.current[: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?
+
+      Thread.current[:fallbacks] = fallback_hash
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)

data/lib/globalize/active_record.rb

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

data/lib/globalize/active_record/act_macro.rb

@@ -0,0 +1,96 @@
+module Globalize
+  module ActiveRecord
+    module ActMacro
+      def translates(*attr_names)
+
+        options = attr_names.extract_options!
+        setup_translates!(options) unless translates?
+
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= translated_attribute_names if defined?(translated_attribute_names)
+
+        if attr_names.present?
+          translation_class.instance_eval %{
+            attr_accessible :#{attr_names.join(', :')}
+          }
+
+          attr_names.each do |attr_name|
+            # Detect and apply serialization.
+            serializer = self.serialized_attributes[attr_name.to_s]
+            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
+
+            # Create accessors for the attribute.
+            translated_attr_accessor(attr_name)
+            translations_accessor(attr_name)
+
+            # Add attribute to the list.
+            self.translated_attribute_names << attr_name
+          end
+        end
+      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 setup_translates!(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]
+
+        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    => false
+
+        after_create :save_translations!
+        after_update :save_translations!
+
+        if options[:versioning]
+          if options[:versioning].is_a?(Hash)
+            translation_class.versioned options[:versioning]
+          else
+            ::ActiveRecord::Base.extend(Globalize::Versioning::PaperTrail)
+
+            translation_class.has_paper_trail
+            delegate :version, :versions, :to => :translation
+          end
+        end
+
+        translation_class.instance_eval %{ attr_accessible :locale }
+      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,111 @@
+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)
+        self.record = record
+        self.stash = Attributes.new
+      end
+
+      def fetch_stash(locale, name)
+        value = stash.read(locale, name)
+        return value if value
+        return nil
+      end
+
+      def stash_contains?(locale, name)
+        stash.contains?(locale, name)
+      end
+
+      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 write(locale, name, value)
+        stash.write(locale, name, value)
+      end
+
+      def save_translations!
+        existing_translations_by_locale = {}
+        record.translations.each do |t|
+          existing_translations_by_locale[t.locale.to_s] = t
+        end
+        
+        stash.each do |locale, attrs|
+          if attrs.any?
+            locale_str = locale.to_s
+            translation = existing_translations_by_locale[locale_str] ||
+              record.translations.find_or_initialize_by_locale(locale_str)
+            attrs.each { |name, value| translation[name] = value }
+            translation.save!
+          end
+        end
+
+        reset
+      end
+
+      def reset
+        stash.clear
+      end
+
+    protected
+
+      def type_cast(name, value)
+        if value.nil?
+          nil
+        elsif column = column_for_attribute(name)
+          column.type_cast(value)
+        else
+          value
+        end
+      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)
+        return translation && translation.send(name)
+      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
+
+      def fallbacks_for_empty_translations?
+        record.fallbacks_for_empty_translations
+      end
+    end
+  end
+end