globalize 3.1.0 → 4.0.0.alpha.1

data/lib/globalize/active_record/attributes.rb

@@ -19,7 +19,6 @@ module Globalize
       end
 
       def write(locale, name, value)
-        #raise 'z' if value.nil? # TODO
         self[locale][name.to_s] = value
       end
     end

data/lib/globalize/active_record/class_methods.rb

@@ -4,16 +4,16 @@ module Globalize
       delegate :translated_locales, :set_translations_table_name, :to => :translation_class
 
       def with_locales(*locales)
-        scoped.merge(translation_class.with_locales(*locales))
+        all.merge translation_class.with_locales(*locales)
       end
 
       def with_translations(*locales)
         locales = translated_locales if locales.empty?
-        includes(:translations).with_locales(locales).with_required_attributes
+        includes(:translations).with_locales(locales).with_required_attributes.references(:translations)
       end
 
       def with_required_attributes
-        required_translated_attributes.inject(scoped) do |scope, name|
+        required_translated_attributes.inject(all) do |scope, name|
           scope.where("#{translated_column_name(name)} IS NOT NULL")
         end
       end
@@ -58,18 +58,22 @@ module Globalize
         "#{translation_class.table_name}.#{name}"
       end
 
-      if RUBY_VERSION < '1.9'
-        def respond_to?(method_id, *args, &block)
-          supported_on_missing?(method_id) || super
-        end
-      else
-        def respond_to_missing?(method_id, include_private = false)
-          supported_on_missing?(method_id) || super
+      def relation
+        relation = Relation.new(self, arel_table)
+
+        if finder_needs_type_condition?
+          relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
+        else
+          relation
         end
       end
 
+      def respond_to_missing?(method_id, include_private = false)
+        supported_on_missing?(method_id) || super
+      end
+
       def supported_on_missing?(method_id)
-        return super unless RUBY_VERSION < '1.9' || respond_to?(:translated_attribute_names)
+        return super unless respond_to?(:translated_attribute_names)
         match = defined?(::ActiveRecord::DynamicFinderMatch) && (::ActiveRecord::DynamicFinderMatch.match(method_id) || ::ActiveRecord::DynamicScopeMatch.match(method_id))
         return false if match.nil?
 
@@ -86,7 +90,7 @@ module Globalize
         match, attribute_names, translated_attributes, untranslated_attributes = supported_on_missing?(method_id)
         return super unless match
 
-        scope = scoped
+        scope = all
 
         translated_attributes.each do |attr|
           scope = scope.with_translated_attribute(attr, arguments[attribute_names.index(attr)])
@@ -99,20 +103,20 @@ module Globalize
         end
 
         if defined?(::ActiveRecord::DynamicFinderMatch) && match.is_a?(::ActiveRecord::DynamicFinderMatch)
-          if match.instantiator? and scope.blank?
+          if match.instantiator? && scope.blank?
             return scope.find_or_instantiator_by_attributes match, attribute_names, *arguments, &block
           end
           match_finder_method = match.finder.to_s
-          match_finder_method << "!" if match.bang? && ::ActiveRecord::VERSION::STRING >= "3.1.0"
+          match_finder_method << "!" if match.bang?
           return scope.send(match_finder_method).tap do |found|
-            found.is_a?(Array) ? found.map { |f| f.translations.reload } : found.translations.reload unless found.nil?
+            Array(found).map { |f| f.translations.reload } unless found.nil?
           end
         end
         return scope
       end
 
       def find_or_instantiator_by_attributes(match, attributes, *args)
-        options = args.size > 1 && args.last(2).all?{ |a| a.is_a?(Hash) } ? args.extract_options! : {}
+        options = args.many? && args.last(2).all?{ |a| a.is_a?(Hash) } ? args.extract_options! : {}
         protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
         args.each_with_index do |arg, i|
           if arg.is_a?(Hash)
@@ -122,15 +126,8 @@ module Globalize
           end
         end
 
-        record = if ::ActiveRecord::VERSION::STRING < "3.1.0"
-          new do |r|
-            r.send(:attributes=, protected_attributes_for_create, true) unless protected_attributes_for_create.empty?
-            r.send(:attributes=, unprotected_attributes_for_create, false) unless unprotected_attributes_for_create.empty?
-          end
-        else
-          new(protected_attributes_for_create, options) do |r|
-            r.assign_attributes(unprotected_attributes_for_create, :without_protection => true)
-          end
+        record = new(protected_attributes_for_create, options) do |r|
+          r.assign_attributes(unprotected_attributes_for_create)
         end
         yield(record) if block_given?
         record.send(match.bang? ? :save! : :save) if match.instantiator.eql?(:create)
@@ -138,33 +135,7 @@ module Globalize
         record
       end
 
-      private
-
-      # Override the default relation method in order to return a subclass
-      # of ActiveRecord::Relation with custom where_values_hash method,
-      # for use in find_or_create_by_instantiator (Rails version >= 3.2.1)
-      if ::ActiveRecord::VERSION::STRING >= "3.2.1"
-        def relation
-          relation = globalize_relation_class.new(self, arel_table)
-
-          if finder_needs_type_condition?
-            relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
-          else
-            relation
-          end
-        end
-
-        # Use pattern defined in FriendlyId 4.x to avoid conflict with any other
-        # gems (such as FriendlyId) which override relation method.
-        def globalize_relation_class
-          @globalize_relation_class ||= Class.new(relation_without_globalize.class).tap do |klass|
-            klass.send :include, QueryMethods
-            const_set('GlobalizeActiveRecordRelation', klass)
-          end
-        end
-      end
-
-      protected
+    protected
 
       def translated_attr_accessor(name)
         define_method(:"#{name}=") do |value|

data/lib/globalize/active_record/instance_methods.rb

@@ -11,69 +11,43 @@ module Globalize
         super.merge(translated_attributes)
       end
 
-      def self.included(base)
-        # Maintain Rails 3.0.x compatibility while adding Rails 3.1.x compatibility
-        if base.method_defined?(:assign_attributes)
-          base.class_eval %{
-            def assign_attributes(attributes, options = {})
-              with_given_locale(attributes) { super }
-            end
-          }
-        else
-          base.class_eval %{
-            def attributes=(attributes, *args)
-              with_given_locale(attributes) { super }
-            end
-
-            def update_attributes!(attributes, *args)
-              with_given_locale(attributes) { super }
-            end
-
-            def update_attributes(attributes, *args)
-              with_given_locale(attributes) { super }
-            end
-          }
-        end
+      def attributes=(attributes, *args)
+        with_given_locale(attributes) { super }
+      end
+
+      def assign_attributes(attributes, *args)
+        with_given_locale(attributes) { super }
       end
 
       def write_attribute(name, value, options = {})
-        if translated?(name)
-          # Deprecate old use of locale
-          unless options.is_a?(Hash)
-            warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
-            options = {:locale => options}
-          end
-          options = {:locale => Globalize.locale}.merge(options)
-          
-          # Dirty tracking, paraphrased from
-          # ActiveRecord::AttributeMethods::Dirty#write_attribute.
-          name_str = name.to_s
-          if attribute_changed?(name_str)
-            # If there's already a change, delete it if this undoes the change.
-            old = changed_attributes[name_str]
-            changed_attributes.delete(name_str) if value == old
-          else
-            # If there's not a change yet, record it.
-            old = globalize.fetch(options[:locale], name)
-            old = old.clone if old.duplicable?
-            changed_attributes[name_str] = old if value != old
-          end
-          
-          globalize.write(options[:locale], name, value)
+        return super(name, value) unless translated?(name)
+
+        options = {:locale => Globalize.locale}.merge(options)
+
+        # Dirty tracking, paraphrased from
+        # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+        name_str = name.to_s
+        if attribute_changed?(name_str)
+          # If there's already a change, delete it if this undoes the change.
+          old = changed_attributes[name_str]
+          changed_attributes.delete(name_str) if value == old
         else
-          super(name, value)
+          # If there's not a change yet, record it.
+          old = globalize.fetch(options[:locale], name)
+          old = old.dup if old.duplicable?
+          changed_attributes[name_str] = old if value != old
         end
+
+        globalize.write(options[:locale], name, value)
       end
 
       def read_attribute(name, options = {})
-        # Deprecate old use of locale
-        unless options.is_a?(Hash)
-          warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
-          options = {:locale => options}
-        end
-
         options = {:translated => true, :locale => nil}.merge(options)
-        if self.class.translated?(name) and options[:translated]
+        return super(name) unless options[:translated]
+
+        if name == :locale
+          self.try(:locale).presence || self.translation.locale
+        elsif self.class.translated?(name)
           if (value = globalize.fetch(options[:locale] || Globalize.locale, name))
             value
           else
@@ -88,24 +62,24 @@ module Globalize
         translated_attribute_names.map(&:to_s) + super
       end
 
-      def translated?(name)
-        self.class.translated?(name)
-      end
+      delegate :translated?, :to => :class
 
       def translated_attributes
         translated_attribute_names.inject({}) do |attributes, name|
-          attributes.merge(name.to_s => translation.send(name))
+          if self.respond_to?(name) && Globalize.locale == I18n.default_locale
+            attributes.merge(name.to_s => self.send(name))
+          else
+            attributes.merge(name.to_s => translation.send(name))
+          end
         end
       end
 
       # This method is basically the method built into Rails
       # but we have to pass {:translated => false}
       def untranslated_attributes
-        attrs = {}
-        attribute_names.each do |name|
-          attrs[name] = read_attribute(name, {:translated => false})
+        attribute_names.inject({}) do |attrs, name|
+          attrs[name] = read_attribute(name, {:translated => false}); attrs
         end
-        attrs
       end
 
       def set_translations(options)
@@ -168,22 +142,16 @@ module Globalize
         translation_caches[::Globalize.locale] = translation.previous_version
       end
 
-      def column_for_attribute name
-        translated_attribute_names.include?(name) ? globalize.send(:column_for_attribute, name) : super
-      end
-
-    private
-
-      def update(*)
-        I18n.with_locale(read_attribute(:locale) || I18n.default_locale) do
+      def save(*)
+        Globalize.with_locale(read_attribute(:locale) || I18n.default_locale) do
           super
         end
       end
 
-      def create(*)
-        I18n.with_locale(read_attribute(:locale) || I18n.default_locale) do
-          super
-        end
+      def column_for_attribute name
+        return super if translated_attribute_names.exclude?(name)
+
+        globalize.send(:column_for_attribute, name)
       end
 
     protected

data/lib/globalize/active_record/migration.rb

@@ -68,7 +68,7 @@ module Globalize
 
         def create_translation_table
           connection.create_table(translations_table_name) do |t|
-            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false
             t.string :locale, :null => false
             t.timestamps
           end
@@ -130,7 +130,7 @@ module Globalize
             end
 
             # Now, update the actual model's record with the hash.
-            @model.update_all(fields_to_update, {:id => translated_record['id']})
+            @model.where(:id => translated_record['id']).update_all(fields_to_update)
           end
         end
 

data/lib/globalize/active_record/relation.rb

@@ -0,0 +1,63 @@
+module Globalize
+  module ActiveRecord
+    class Relation < ::ActiveRecord::Relation
+
+      attr_accessor :translations_reload_needed
+
+      class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
+        def not(*args)
+          if @scope.parse_translated_conditions!(*args)
+            @scope.translations_reload_needed = true
+            @scope.with_translations_in_this_locale.where.not(*args)
+          else
+            super
+          end
+        end
+      end
+
+      def where(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif parse_translated_conditions!(opts, *rest)
+          self.translations_reload_needed = true
+          super.with_translations_in_this_locale
+        else
+          super
+        end
+      end
+
+      def exists?(conditions = :none)
+        if parse_translated_conditions!(conditions)
+          with_translations_in_this_locale.exists?(conditions)
+        else
+          super
+        end
+      end
+
+      %w[ first last take ].each do |method_name|
+        eval <<-END_RUBY
+          def #{method_name}
+            super.tap do |f|
+              if translations_reload_needed
+                f.translations.reload
+                translations_reload_needed = false
+              end
+            end
+          end
+        END_RUBY
+      end
+
+      def with_translations_in_this_locale
+        with_translations(Globalize.locale)
+      end
+
+      def parse_translated_conditions!(opts, *rest)
+        if opts.is_a?(Hash) && (keys = opts.symbolize_keys.keys & translated_attribute_names).present?
+          keys.each do |key|
+            opts[translated_column_name(key)] = opts.delete(key) || opts.delete(key.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/translation.rb

@@ -2,7 +2,6 @@ module Globalize
   module ActiveRecord
     class Translation < ::ActiveRecord::Base
 
-      attr_accessible :locale
       validates :locale, :presence => true
 
       class << self

data/lib/globalize/versioning.rb

@@ -0,0 +1,5 @@
+module Globalize
+  module Versioning
+    autoload :PaperTrail, 'globalize/versioning/paper_trail'
+  end
+end

data/lib/globalize/versioning/paper_trail.rb

@@ -0,0 +1,39 @@
+require 'paper_trail'
+
+module Globalize
+  module Versioning
+    module PaperTrail
+      # At present this isn't used but we may use something similar in paper trail
+      # shortly, so leaving it around to reference easily.
+      #def versioned_columns
+        #super + self.class.translated_attribute_names
+      #end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  class << self
+    def has_paper_trail_with_globalize(*args)
+      has_paper_trail_without_globalize(*args)
+      include Globalize::Versioning::PaperTrail
+    end
+    alias_method_chain :has_paper_trail, :globalize
+  end
+end
+
+PaperTrail::Version.class_eval do
+
+  before_save do |version|
+    version.locale = Globalize.locale.to_s
+  end
+
+  def self.for_this_locale
+    where :locale => Globalize.locale.to_s
+  end
+
+  def sibling_versions_with_locales
+    sibling_versions_without_locales.for_this_locale
+  end
+  alias_method_chain :sibling_versions, :locales
+end

data/lib/patches/active_record/relation.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  class Relation
+    if ::ActiveRecord::VERSION::STRING >= "3.2.1"
+      def where_values_hash
+        _translations_table_name = klass.respond_to?(:translations_table_name) ? klass.translations_table_name : nil
+
+        equalities = with_default_scope.where_values.grep(Arel::Nodes::Equality).find_all { |node|
+          [table_name, _translations_table_name].compact.include? node.left.relation.name
+        }
+
+        binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+
+        Hash[equalities.map { |where|
+          name = where.left.name
+          [name, binds.fetch(name.to_s) { where.right } ]
+        }].with_indifferent_access
+      end
+    end
+  end
+end