galetahub-globalize3 0.2.1

data/lib/globalize/active_record/attributes.rb

@@ -0,0 +1,27 @@
+# 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)
+        #raise 'z' if value.nil? # TODO
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,125 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
+      
+      def with_locale(locale)
+        scoped.where(:"is_locale_#{locale}" => true)
+      end
+      
+      def with_locales(*locales)
+        scoped.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
+      end
+
+      def with_required_attributes
+        required_translated_attributes.inject(scoped) do |scope, name|
+          scope.where("#{translated_column_name(name)} IS NOT NULL")
+        end
+      end
+
+      def with_translated_attribute(name, value, locales = nil)
+        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
+        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
+      end
+
+      def required_translated_attributes
+        translated_attribute_names & required_attributes
+      end
+
+      def translation_class
+        @translation_class ||= begin
+          klass = self.const_get(:Translation) rescue nil
+          if klass.nil? || klass.class_name != (self.class_name + "Translation")
+            klass = self.const_set(:Translation, Class.new(Globalize::ActiveRecord::Translation))
+          end
+
+          klass.belongs_to name.underscore.gsub('/', '_')
+          klass
+        end
+      end
+
+      def translations_table_name
+        translation_class.table_name
+      end
+
+      def translated_column_name(name)
+        "#{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
+        end
+      end
+
+      def supported_on_missing?(method_id)
+        return super unless RUBY_VERSION < '1.9' || respond_to?(:translated_attribute_names)
+        match = ::ActiveRecord::DynamicFinderMatch.match(method_id) || ::ActiveRecord::DynamicScopeMatch.match(method_id)
+        return false if match.nil?
+
+        attribute_names = match.attribute_names.map(&:to_sym)
+        translated_attributes = attribute_names & translated_attribute_names
+        return false if translated_attributes.empty?
+
+        untranslated_attributes = attribute_names - translated_attributes
+        return false if untranslated_attributes.any?{|unt| ! respond_to?(:"scoped_by_#{unt}")}
+        return [match, attribute_names, translated_attributes, untranslated_attributes]
+      end
+
+      def method_missing(method_id, *arguments, &block)
+        match, attribute_names, translated_attributes, untranslated_attributes = supported_on_missing?(method_id)
+        return super unless match
+
+        scope = scoped
+
+        translated_attributes.each do |attr|
+          scope = scope.with_translated_attribute(attr, arguments[attribute_names.index(attr)])
+        end
+
+        untranslated_attributes.each do |unt|
+          index = attribute_names.index(unt)
+          raise StandarError unless index
+          scope = scope.send(:"scoped_by_#{unt}", arguments[index])
+        end
+
+        return scope.send(match.finder) if match.is_a?(::ActiveRecord::DynamicFinderMatch)
+        return scope
+      end
+
+    protected
+
+      def translated_attr_accessor(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+        define_method(name) do |*args|
+          read_attribute(name, {:locale => args.first})
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+    end
+
+  end
+
+end

data/lib/globalize/active_record/exceptions.rb

@@ -0,0 +1,19 @@
+module Globalize
+  module ActiveRecord
+    module Exceptions
+      class MigrationError < StandardError; end
+  
+      class BadFieldName < MigrationError
+        def initialize(field)
+          super("Missing translated field #{field.inspect}")
+        end
+      end
+  
+      class BadFieldType < MigrationError
+        def initialize(name, type)
+          super("Bad field type for field #{name.inspect} (#{type.inspect}), should be :string or :text")
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -0,0 +1,166 @@
+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=(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
+
+      def write_attribute(name, value, options = {})
+        # raise 'y' if value.nil? # TODO.
+
+        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 => nil}.merge(options)
+          attribute_will_change! name.to_s
+          globalize.write(options[:locale] || Globalize.locale, name, value)
+        else
+          super(name, value)
+        end
+      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]
+          globalize.fetch(options[:locale] || Globalize.locale, name)
+        else
+          super(name)
+        end
+      end
+
+      def attribute_names
+        translated_attribute_names.map(&:to_s) + super
+      end
+
+      def translated?(name)
+        self.class.translated?(name)
+      end
+
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => translation.send(name))
+        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})
+        end
+        attrs
+      end
+
+      def set_translations(options)
+        options.keys.each do |locale|
+          translation = translation_for(locale) ||
+            translations.build(:locale => locale.to_s)
+          translation.update_attributes!(options[locale])
+        end
+      end
+
+      def reload(options = nil)
+        translated_attribute_names.each { |name| @attributes.delete(name.to_s) }
+        globalize.reset
+        super(options)
+      end
+
+      def clone
+        obj = super
+        return obj unless respond_to?(:translated_attribute_names)
+
+        obj.instance_variable_set(:@translations, nil) if new_record? # Reset the collection because of rails bug: http://pastie.org/1521874
+        obj.instance_variable_set(:@globalize, nil )
+        each_locale_and_translated_attribute do |locale, name|
+          obj.globalize.write(locale, name, globalize.fetch(locale, name) )
+        end
+
+        return obj
+      end
+
+      def translation
+        translation_for(::Globalize.locale)
+      end
+
+      def translation_for(locale)
+        @translation_caches ||= {}
+        unless @translation_caches[locale]
+          # Enumberable#detect is better since we have the translations collection (already) loaded
+          # using either Model.includes(:translations) or Model.with_translations
+          _translation = translations.detect{|t| t.locale.to_s == locale.to_s}
+          _translation ||= translations.build(:locale => locale)
+          @translation_caches[locale] = _translation
+        end
+        @translation_caches[locale]
+      end
+
+      def rollback
+        @translation_caches[::Globalize.locale] = translation.previous_version
+      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 update_checkers!
+        Globalize.available_locales.each do |locale|
+          self["is_locale_#{locale}"] = !globalize.all_blank?(locale, translated_attribute_names)
+        end
+      end
+      
+      def save_translations!
+        globalize.save_translations!
+        @translation_caches = {}
+      end
+
+      def with_given_locale(attributes, &block)
+        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys!)
+        if locale = attributes.try(:delete, :locale)
+          Globalize.with_locale(locale, &block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/migration.rb

@@ -0,0 +1,125 @@
+require 'digest/sha1'
+
+module Globalize
+  module ActiveRecord
+    module Migration
+      attr_reader :globalize_migrator
+
+      def globalize_migrator
+        @globalize_migrator ||= Migrator.new(self)
+      end
+
+      delegate :create_translation_table!, :drop_translation_table!,
+        :translation_index_name, :to => :globalize_migrator
+
+      class Migrator
+        include Globalize::ActiveRecord::Exceptions
+
+        attr_reader :model, :fields
+        delegate :translated_attribute_names, :connection, :table_name, :translated_columns_hash,
+          :table_name_prefix, :translations_table_name, :columns, :to => :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def create_translation_table!(fields = {}, options = {})
+          @fields = fields
+          complete_translated_fields
+          validate_translated_fields
+
+          create_translation_table
+          move_data_to_translation_table if options[:migrate_data]
+          create_translations_index
+        end
+
+        def drop_translation_table!(options = {})
+          move_data_to_model_table if options[:migrate_data]
+          drop_translations_index
+          drop_translation_table
+        end
+
+        def complete_translated_fields
+          translated_attribute_names.each do |name|
+            fields[name] = column_type(name) unless fields[name]
+          end
+        end
+
+        def create_translation_table
+          connection.create_table(translations_table_name) do |t|
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize
+            t.string :locale
+            fields.each { |name, type| t.column name, type }
+            t.timestamps
+          end
+        end
+
+        def create_translations_index
+          connection.add_index(
+            translations_table_name,
+            "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
+            :name => translation_index_name
+          )
+        end
+
+        def drop_translation_table
+          connection.drop_table(translations_table_name)
+        end
+
+        def drop_translations_index
+          connection.remove_index(translations_table_name, :name => translation_index_name) rescue nil
+        end
+
+        def move_data_to_translation_table
+          # Find all of the existing untranslated attributes for this model.
+          all_model_fields = @model.all
+          model_attributes = all_model_fields.collect {|m| m.untranslated_attributes}
+          all_model_fields.each do |model_record|
+            # Assign the attributes back to the model which will enable globalize3 to translate them.
+            model_record.attributes = model_attributes.detect{|a| a['id'] == model_record.id}
+            model_record.save!
+          end
+        end
+
+        def move_data_to_model_table
+          # 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.update_all(fields_to_update, {:id => translated_record['id']})
+          end
+        end
+
+        def validate_translated_fields
+          fields.each do |name, type|
+            raise BadFieldName.new(name) unless valid_field_name?(name)
+            raise BadFieldType.new(name, type) unless valid_field_type?(name, type)
+          end
+        end
+
+        def column_type(name)
+          columns.detect { |c| c.name == name.to_s }.try(:type) || translated_columns_hash[name.to_s]
+        end
+
+        def valid_field_name?(name)
+          translated_attribute_names.include?(name)
+        end
+
+        def valid_field_type?(name, type)
+          !translated_attribute_names.include?(name) || [:string, :text].include?(type)
+        end
+
+        def translation_index_name
+          # FIXME what's the max size of an index name?
+          index_name = "index_#{translations_table_name}_on_#{table_name.singularize}_id"
+          index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
+        end
+      end
+    end
+  end
+end