globalize3 0.0.1 → 0.0.2

data/README.textile

@@ -58,6 +58,11 @@ end
 
 Note that the ActiveRecord model @Post@ must already exist and have a @translates@ directive listing the translated fields.
 
+h2. Changes since Globalize2
+
+* `translation_table_name` was renamed to `translations_table_name`
+* `available_locales` has been removed. please use `translated_locales`
+
 h2. Migration from Globalize for Rails (version 1)
 
 See this script by Tomasz Stachewicz: http://gist.github.com/120867

data/lib/globalize.rb

@@ -4,11 +4,27 @@ module Globalize
   autoload :ActiveRecord, 'globalize/active_record'
 
   class << self
+    def locale
+      defined?(@@locale) && @@locale || I18n.locale
+    end
+
+    def locale=(locale)
+      @@locale = locale
+    end
+
+    def with_locale(locale, &block)
+      previous_locale = defined?(@@locale) && @@locale || nil
+      self.locale = locale
+      result = yield
+      self.locale = previous_locale
+      result
+    end
+
     def fallbacks?
       I18n.respond_to?(:fallbacks)
     end
 
-    def fallbacks(locale)
+    def fallbacks(locale = self.locale)
       fallbacks? ? I18n.fallbacks[locale] : [locale.to_sym]
     end
   end

data/lib/globalize/active_record.rb

@@ -10,46 +10,6 @@ module Globalize
     autoload :ClassMethods,    'globalize/active_record/class_methods'
     autoload :InstanceMethods, 'globalize/active_record/instance_methods'
     autoload :Migration,       'globalize/active_record/migration'
-
-    class << self
-      def build_translation_class(target, options)
-        options[:table_name] ||= "#{target.table_name.singularize}_translations"
-
-        klass = target.const_defined?(:Translation) ?
-          target.const_get(:Translation) :
-          target.const_set(:Translation, Class.new(::ActiveRecord::Base))
-
-        klass.class_eval do
-          set_table_name(options[:table_name])
-          
-          belongs_to target.name.underscore.gsub('/', '_')
-          
-          class << self
-            def by_locale(locale)
-              where(:locale => locale.to_s)
-            end
-
-            def by_locales(locales)
-              where(:locale => locales.map(&:to_s))
-            end
-
-            # TODO build is not defined here even when called through record.translations.find_or_initialize_by_locale(...)
-            # def find_or_initialize_by_locale(locale)
-            #   by_locale(locale.to_s).first || build(:locale => locale.to_s)
-            # end
-          end
-          
-          def locale
-            read_attribute(:locale).to_sym
-          end
-          
-          def locale=(locale)
-            write_attribute(:locale, locale.to_s)
-          end
-        end
-
-        klass
-      end
-    end
+    autoload :Translation,     'globalize/active_record/translation'
   end
 end

data/lib/globalize/active_record/act_macro.rb

@@ -1,43 +1,31 @@
 module Globalize
   module ActiveRecord
     module ActMacro
-      def locale
-        (defined?(@@locale) && @@locale)
-      end
-
-      def locale=(locale)
-        @@locale = locale
-      end
-
       def translates(*attr_names)
         return if translates?
-        options = attr_names.extract_options!
 
-        class_inheritable_accessor :translation_class, :translated_attribute_names
-        class_inheritable_writer :required_attributes
-
-        self.translation_class = ActiveRecord.build_translation_class(self, options)
-        self.translated_attribute_names = attr_names.map(&:to_sym)
+        options = attr_names.extract_options!
+        options[:table_name] ||= "#{table_name.singularize}_translations"
 
         include InstanceMethods
         extend  ClassMethods, Migration
 
+        class_inheritable_accessor :translated_attribute_names, :translation_options
+        class_inheritable_writer   :required_attributes
+
+        self.translated_attribute_names = attr_names.map(&:to_sym)
+        self.translation_options        = options
+
         after_save :save_translations!
+
         has_many :translations, :class_name  => translation_class.name,
                                 :foreign_key => class_name.foreign_key,
-                                :dependent   => :delete_all
-
-        scope :with_translations, lambda { |locale|
-          conditions = required_attributes.map do |attribute|
-            "#{quoted_translation_table_name}.#{attribute} IS NOT NULL"
-          end
-          conditions << "#{quoted_translation_table_name}.locale = ?"
-          { :include => :translations, :conditions => [conditions.join(' AND '), locale] }
-        }
+                                :dependent   => :delete_all,
+                                :extend      => HasManyExtensions
 
         attr_names.each { |attr_name| translated_attr_accessor(attr_name) }
       end
-      
+
       def class_name
         class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].camelize
         pluralize_table_names ? class_name.singularize : class_name
@@ -47,5 +35,11 @@ module Globalize
         included_modules.include?(InstanceMethods)
       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

@@ -24,9 +24,7 @@ module Globalize
 
       def save_translations!
         stash.each do |locale, attrs|
-          # TODO use find_or_initialize_by_locale
-          translation = record.translations.by_locale(locale.to_s).first
-          translation ||= record.translations.build(:locale => locale.to_s)
+          translation = record.translations.find_or_initialize_by_locale(locale.to_s)
           attrs.each { |attr_name, value| translation[attr_name] = value }
           translation.save!
         end
@@ -35,7 +33,6 @@ module Globalize
 
       def reset
         cache.clear
-        # stash.clear
       end
 
       protected
@@ -43,13 +40,13 @@ module Globalize
         def fetch_translation(locale)
           locale = locale.to_sym
           record.translations.loaded? ? record.translations.detect { |t| t.locale == locale } :
-            record.translations.by_locale(locale)
+            record.translations.with_locales(locale)
         end
 
         def fetch_translations(locale)
           # only query if not already included with :include => translations
           record.translations.loaded? ? record.translations :
-            record.translations.by_locales(Globalize.fallbacks(locale))
+            record.translations.with_locales(Globalize.fallbacks(locale))
         end
 
         def fetch_attribute(locale, attr_name)

data/lib/globalize/active_record/attributes.rb

@@ -1,5 +1,6 @@
 # Helper class for storing values per locale. Used by Globalize::Adapter
 # to stash and cache attribute values.
+
 module Globalize
   module ActiveRecord
     class Attributes < Hash

data/lib/globalize/active_record/class_methods.rb

@@ -1,27 +1,54 @@
 module Globalize
   module ActiveRecord
     module ClassMethods
-      delegate :set_translation_table_name, :to => :translation_class
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
 
-      def with_locale(locale)
-        previous_locale, self.locale = self.locale, locale
-        result = yield
-        self.locale = previous_locale
-        result
+      def with_locales(*locales)
+        scoped & translation_class.with_locales(*locales)
       end
 
-      def translation_table_name
-        translation_class.table_name
+      def with_translations(*locales)
+        locales = translated_locales if locales.empty?
+        includes(:translations).with_locales(locales).with_required_attributes
       end
 
-      def quoted_translation_table_name
-        translation_class.quoted_table_name
+      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) => locales.map(&:to_s)
+        )
       end
 
       def required_attributes
-        @required_attributes ||= reflect_on_all_validations.select do |validation|
-          validation.macro == :validates_presence_of && translated_attribute_names.include?(validation.name)
-        end.map(&:name)
+        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
+        klass = const_get(:Translation) rescue const_set(:Translation, Class.new(Translation))
+        if klass.table_name == 'translations'
+          klass.set_table_name(translation_options[:table_name])
+          klass.belongs_to name.underscore.gsub('/', '_')
+        end
+        klass
+      end
+
+      def translations_table_name
+        translation_class.table_name
+      end
+
+      def translated_column_name(name)
+        "#{translation_class.table_name}.#{name}"
       end
 
       def respond_to?(method, *args, &block)
@@ -29,8 +56,9 @@ module Globalize
       end
 
       def method_missing(method, *args)
-        if method.to_s =~ /^find_by_(\w+)$/ && translated_attribute_names.include?($1.to_sym)
-          find_first_by_translated_attr_and_locales($1, args.first)
+        if method.to_s =~ /^find_(first_|)by_(\w+)$/ && translated_attribute_names.include?($2.to_sym)
+          result = with_translated_attribute($2, args.first)
+          $1 == 'first_' ? result.first : result
         else
           super
         end
@@ -38,30 +66,15 @@ module Globalize
 
       protected
 
-        def find_first_by_translated_attr_and_locales(name, value)
-          query = "#{translated_attr_name(name)} = ? AND #{translated_attr_name('locale')} IN (?)"
-          locales = Globalize.fallbacks(locale || I18n.locale).map(&:to_s)
-          find(
-            :first,
-            :joins => :translations,
-            :conditions => [query, value, locales],
-            :readonly => false
-          )
-        end
-
         def translated_attr_accessor(name)
-          define_method "#{name}=", lambda { |value|
-            globalize.write(self.class.locale || I18n.locale, name, value)
+          define_method :"#{name}=", lambda { |value|
+            globalize.write(Globalize.locale, name, value)
             self[name] = value
           }
           define_method name, lambda { |*args|
-            globalize.fetch(args.first || self.class.locale || I18n.locale, name)
+            globalize.fetch(args.first || Globalize.locale, name)
           }
-          alias_method "#{name}_before_type_cast", name
-        end
-
-        def translated_attr_name(name)
-          "#{translation_class.table_name}.#{name}"
+          alias_method :"#{name}_before_type_cast", name
         end
     end
   end

data/lib/globalize/active_record/instance_methods.rb

@@ -1,21 +1,19 @@
 module Globalize
   module ActiveRecord
     module InstanceMethods
+      delegate :translated_locales, :to => :translations
+
       def globalize
         @globalize ||= Adapter.new self
       end
 
       def attributes
-        self.attribute_names.inject({}) do |attrs, name|
-          attrs[name] = read_attribute(name) ||
-            (globalize.fetch(I18n.locale, name) rescue nil)
-          attrs
-        end
+        super.merge(translated_attributes)
       end
 
       def attributes=(attributes, *args)
-        if attributes.respond_to?(:delete) && locale = attributes.delete(:locale)
-          self.class.with_locale(locale) { super }
+        if locale = attributes.try(:delete, :locale)
+          Globalize.with_locale(locale) { super }
         else
           super
         end
@@ -24,18 +22,10 @@ module Globalize
       def attribute_names
         translated_attribute_names.map(&:to_s) + super
       end
-
-      def available_locales
-        translations.select('DISTINCT locale').map(&:locale)
-      end
-
-      def translated_locales
-        translations.map(&:locale)
-      end
-
+      
       def translated_attributes
         translated_attribute_names.inject({}) do |attributes, name|
-          attributes.merge(name => send(name))
+          attributes.merge(name.to_s => send(name))
         end
       end
 

data/lib/globalize/active_record/migration.rb

@@ -12,7 +12,7 @@ module Globalize
           end
         end
 
-        self.connection.create_table(translation_table_name) do |t|
+        self.connection.create_table(translations_table_name) do |t|
           t.references table_name.sub(/^#{table_name_prefix}/, "").singularize
           t.string :locale
           fields.each do |name, type|
@@ -22,7 +22,7 @@ module Globalize
         end
 
         self.connection.add_index(
-          translation_table_name, 
+          translations_table_name, 
           "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
           :name => translation_index_name
         )
@@ -31,13 +31,13 @@ module Globalize
       def translation_index_name
         require 'digest/sha1'
         # FIXME what's the max size of an index name?
-        index_name = "index_#{translation_table_name}_on_#{self.table_name.singularize}_id"
+        index_name = "index_#{translations_table_name}_on_#{self.table_name.singularize}_id"
         index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
       end
 
       def drop_translation_table!
-        self.connection.remove_index(translation_table_name, :name => translation_index_name) rescue nil
-        self.connection.drop_table(translation_table_name)
+        self.connection.remove_index(translations_table_name, :name => translation_index_name) rescue nil
+        self.connection.drop_table(translations_table_name)
       end
     end
   end

data/lib/globalize/active_record/translation.rb

@@ -0,0 +1,24 @@
+module Globalize
+  module ActiveRecord
+    class Translation < ::ActiveRecord::Base
+      class << self
+        def with_locales(*locales)
+          where(:locale => locales.flatten.map(&:to_s))
+        end
+        alias with_locale with_locales
+
+        def translated_locales
+          select('DISTINCT locale').map(&:locale)
+        end
+      end
+
+      def locale
+        read_attribute(:locale).to_sym
+      end
+
+      def locale=(locale)
+        write_attribute(:locale, locale.to_s)
+      end
+    end
+  end
+end

data/lib/globalize/version.rb

@@ -1,3 +1,3 @@
 module Globalize
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: globalize3
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-30 00:00:00 +02:00
+date: 2010-07-31 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,6 +53,7 @@ files:
 - lib/globalize/active_record/class_methods.rb
 - lib/globalize/active_record/instance_methods.rb
 - lib/globalize/active_record/migration.rb
+- lib/globalize/active_record/translation.rb
 - lib/globalize/active_record.rb
 - lib/globalize/version.rb
 - lib/globalize.rb