globalize2 0.1.0 → 0.2.0

data/.gitignore

@@ -1,4 +1,5 @@
 doc
 spec/spec/db/*
 vendor
-NOTES
+NOTES
+.DS_Store

data/README.textile

@@ -1,16 +1,17 @@
 h1. Globalize2
 
-Globalize2 is the successor of Globalize for Rails. 
+Globalize2 is the successor of Globalize for Rails.
 
-It is compatible with and builds on the new "I18n api in Ruby on Rails":http://rails-i18n.org. and adds model translations as well as a bunch of other useful features, such as Locale fallbacks (RFC4647 compliant) and automatic loading of Locale data from defined directory/file locations.
+It is compatible with and builds on the new "I18n api in Ruby on Rails":http://guides.rubyonrails.org/i18n.html. and adds model translations to ActiveRecord.
 
-Globalize2 is much more lightweight and modular than its predecessor was. Content translations in Globalize2 use default ActiveRecord features and do not limit any functionality any more. 
-
-All features and tools in Globalize2 are implemented in the most unobstrusive and loosely-coupled way possible, so you can pick whatever features or tools you need for your application and combine them with other tools from other libraries or plugins.
+Globalize2 is much more lightweight and compatible than its predecessor was. Model translations in Globalize2 use default ActiveRecord features and do not limit any ActiveRecord functionality any more.
 
 h2. Requirements
 
-Rails 2.2 (currently Rails edge)
+ActiveRecord
+I18n
+
+(or Rails > 2.2)
 
 h2. Installation
 
@@ -20,19 +21,9 @@ To install Globalize2 with its default setup just use:
 script/plugin install git://github.com/joshmh/globalize2.git
 </code></pre>
 
-This will:
-
-* activate model translations
-* set I18n.load_path to an instance of Globalize::LoadPath
-* set I18n.backend to an instance of Globalize::Backend::Static
-
-h2. Configuration
-
-You might want to add additional configuration to an initializer, e.g. config/initializers/globalize.rb
-
 h2. Model translations
 
-Model translations (or content translations) allow you to translate your models' attribute values. E.g.
+Model translations allow you to translate your models' attribute values. E.g.
 
 <pre><code>
 class Post < ActiveRecord::Base
@@ -44,10 +35,10 @@ Allows you to values for the attributes :title and :text per locale:
 
 <pre><code>
 I18n.locale = :en
-post.title # Globalize2 rocks!
+post.title # => Globalize2 rocks!
 
 I18n.locale = :he
-post.title # גלובאלייז2 שולט!
+post.title # => גלובאלייז2 שולט!
 </code></pre>
 
 In order to make this work, you'll need to add the appropriate translation tables. Globalize2 comes with a handy helper method to help you do this. It's called @create_translation_table!@. Here's an example:
@@ -69,134 +60,27 @@ end
 
 Note that the ActiveRecord model @Post@ must already exist and have a @translates@ directive listing the translated fields.
 
-h2. Globalize::Backend::Static
-
-Globalize2 ships with a Static backend that builds on the Simple backend from the I18n library (which is shipped with Rails) and adds the following features:
-
-* It uses locale fallbacks when looking up translation data.
-* It returns an instance of Globalize::Translation::Static instead of a plain Ruby String as a translation.
-* It allows to hook in custom pluralization logic as lambdas.
-
-h2. Custom pluralization logic
-
-The Simple backend has its pluralization algorithm baked in hardcoded. This algorithm is only suitable for English and other languages that have the same pluralization rules. It is not suitable for, e.g., Czech though.
-
-To add custom pluralization logic to Globalize' Static backend you can do something like this:
-
-<pre><code>
-@backend.add_pluralizer :cz, lambda{|c| 
-  c == 1 ? :one : (2..4).include?(c) ? :few : :other 
-}
-</code></pre>
-
-h2. Locale Fallbacks
-
-Globalize2 ships with a Locale fallback tool which extends the I18n module to hold a fallbacks instance which is set to an instance of Globalize::Locale::Fallbacks by default but can be swapped with a different implementation. 
-
-Globalize2 fallbacks will compute a number of other locales for a given locale. For example:
-
-<pre><code>
-I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :"en-US", :en]
-</code></pre>
-
-Globalize2 fallbacks always fall back to 
-
-* all parents of a given locale (e.g. :es for :"es-MX"), 
-* then to the fallbacks' default locales and all of their parents and 
-* finally to the :root locale. 
-
-The default locales are set to [:"en-US"] by default but can be set to something else. The root locale is a concept borrowed from "CLDR":http://unicode.org and makes sense for storing common locale data which works as a last default fallback (e.g. "ltr" for bidi directions).
-
-One can additionally add any number of additional fallback locales manually. These will be added before the default locales to the fallback chain. For example:
-
-<pre><code>
-fb = I18n.fallbacks
-
-fb.map :ca => :"es-ES"
-fb[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
-
-fb.map :"ar-PS" => :"he-IL"
-fb[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
-fb[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
-
-fb.map :sms => [:"se-FI", :"fi-FI"]
-fb[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
-</code></pre>
-
-h2. Globalize::LoadPath
-
-Globalize2 replaces the plain Ruby array that is set to I18n.load_path by default through an instance of Globalize::LoadPath.
-
-This object can be populated with both paths to files and directories. If a path to a directory is added to it it will look up all locale data files present in that directory enforcing the following convention:
-
-<pre><code>
-I18n.load_path << "#{RAILS_ROOT}/lib/locales"
-
-# will load all the following files if present:
-lib/locales/all.yml
-lib/locales/fr.yml
-lib/locales/fr/*.yaml
-lib/locales/ru.yml
-lib/locales/ru/*.yaml
-...
-</code></pre>
-
-One can also specify which locales are used. By default this is set to "*" meaning that files for all locales are added. To define that only files for the locale :es are added one can specify:
-
-<pre><code>
-I18n.load_path.locales = [:es]
-</code></pre>
-
-One can also specify which file extensions are used. By default this is set to ['rb', 'yml'] so plain Ruby and YAML files are added if found. To define that only *.sql files are added one can specify:
-
-<pre><code>
-I18n.load_path.extensions = ['sql']
-</code></pre>
-
-Note that Globalize::LoadPath "expands" a directory to its contained file paths immediately when you add it to the load_path. Thus, if you change the locales or extensions settings in the middle of your application the change won't be applied to already added file paths.
-
-
-h2. Globalize::Translation classes
-
-Globalize2's Static backend as well as Globalize2 model translations return instances of Globalize::Translation classes (instead of plain Ruby Strings). These are simple and lightweight value objects that carry some additional meta data about the translation and how it was looked up.
-
-Model translations return instances of Globalize::Translation::Attribute, the Static backend returns instances of Globalize::Translation::Static.
-
-For example:
-
-<pre><code>
-I18n.locale = :de
-
-# Translation::Attribute
-title = Post.first.title  # assuming that no translation can be found:
-title.locale              # => :en
-title.requested_locale    # => :de 
-title.fallback?           # => true
-
-# Translation::Static
-rails = I18n.t :rails     # assuming that no translation can be found:
-rails.locale              # => :en
-rails.requested_locale    # => :de 
-rails.fallback?           # => true
-rails.options             # returns the options passed to #t
-rails.plural_key          # returns the plural_key (e.g. :one, :other)
-rails.original            # returns the original translation with no values 
-                          # interpolated to it (e.g. "Hi {{name}}!")
-</code></pre>
+h2. Migration from Globalize
 
-h2. Missing Translations Log Handler
+See this script by Tomasz Stachewicz: http://gist.github.com/120867
 
-A simple exception handler that behaves like the default exception handler but additionally logs missing translations to a given log.
+h2. Changes since Globalize2 v0.1.0
 
-Useful for identifying missing translations during testing.
+* The association globalize_translations has been renamed to translations.
 
-E.g. 
+h2. Alternative Solutions
 
-  require 'globalize/i18n/missing_translations_log_handler
-  I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
-  I18n.exception_handler = :missing_translations_log_handler
+* "Veger's fork":http://github.com/veger/globalize2 - uses default AR schema for the default locale, delegates to the translations table for other locales only
+* "TranslatableColumns":http://github.com/iain/translatable_columns - have multiple languages of the same attribute in a model (Iain Hecker)
+* "localized_record":http://github.com/glennpow/localized_record - allows records to have localized attributes without any modifications to the database (Glenn Powell)
+* "model_translations":http://github.com/janne/model_translations - Minimal implementation of Globalize2 style model translations (Jan Andersson)
 
-To set up a different log file:
+h2. Related solutions
 
-  logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
-  I18n.missing_translations_logger = logger
+* "globalize2_versioning":http://github.com/joshmh/globalize2_versioning - acts_as_versioned style versioning for Globalize2 (Joshua Harvey)
+* "i18n_multi_locales_validations":http://github.com/ZenCocoon/i18n_multi_locales_validations - multi-locales attributes validations to validates attributes from Globalize2 translations models (Sébastien Grosjean)
+* "Globalize2 Demo App":http://github.com/svenfuchs/globalize2-demo - demo application for Globalize2 (Sven Fuchs)</li>
+* "migrate_from_globalize1":http://gist.github.com/120867 - migrate model translations from Globalize1 to Globalize2 (Tomasz Stachewicz)</li>
+* "easy_globalize2_accessors":http://github.com/astropanic/easy_globalize2_accessors - easily access (read and write) globalize2-translated fields (astropanic, Tomasz Stachewicz)</li>
+* "globalize2-easy-translate":http://github.com/bsamman/globalize2-easy-translate - adds methods to easily access or set translated attributes to your model (bsamman)</li>
+* "batch_translations":http://github.com/alvarezrilla/batch_translations - allow saving multiple Globalize2 translations in the same request (Jose Alvarez Rilla)</li>

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/generators/templates/db_backend_migration.rb

@@ -8,16 +8,16 @@ class ActsAsTaggableMigration < ActiveRecord::Migration
     end
 
 # TODO: FINISH DOING MIGRATION -- stopped in the middle
-    
+
     create_table :globalize_translations_map do |t|
       t.string  :key, :null => false
       t.integer :translation_id, :null => false
     end
-    
+
     add_index :taggings, :tag_id
     add_index :taggings, [:taggable_id, :taggable_type]
   end
-  
+
   def self.down
     drop_table :globalize_translations
     drop_table :tags

data/globalize2.gemspec

@@ -1,15 +1,15 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{globalize2}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sven Fuchs, Joshua Harvey, Clemens Kofler"]
-  s.date = %q{2009-11-08}
+  s.date = %q{2010-04-22}
   s.description = %q{Rails I18n: de-facto standard library for ActiveRecord data translation}
   s.email = %q{joshmh@gmail.com}
   s.extra_rdoc_files = [
@@ -26,66 +26,46 @@ Gem::Specification.new do |s|
      "generators/templates/db_backend_migration.rb",
      "globalize2.gemspec",
      "init.rb",
-     "lib/globalize/backend/chain.rb",
-     "lib/globalize/backend/pluralizing.rb",
-     "lib/globalize/backend/static.rb",
-     "lib/globalize/i18n/missing_translations_log_handler.rb",
-     "lib/globalize/i18n/missing_translations_raise_handler.rb",
-     "lib/globalize/load_path.rb",
-     "lib/globalize/locale/fallbacks.rb",
-     "lib/globalize/locale/language_tag.rb",
-     "lib/globalize/model/active_record.rb",
-     "lib/globalize/model/active_record/adapter.rb",
-     "lib/globalize/model/active_record/translated.rb",
-     "lib/globalize/translation.rb",
-     "lib/locale/root.yml",
-     "lib/rails_edge_load_path_patch.rb",
-     "notes.textile",
+     "lib/globalize.rb",
+     "lib/globalize/active_record.rb",
+     "lib/globalize/active_record/adapter.rb",
+     "lib/globalize/active_record/attributes.rb",
+     "lib/globalize/active_record/migration.rb",
+     "lib/i18n/missing_translations_log_handler.rb",
+     "lib/i18n/missing_translations_raise_handler.rb",
+     "test/active_record/fallbacks_test.rb",
+     "test/active_record/migration_test.rb",
+     "test/active_record/sti_translated_test.rb",
+     "test/active_record/translates_test.rb",
+     "test/active_record/translation_class_test.rb",
+     "test/active_record/validation_tests.rb",
+     "test/active_record_test.rb",
      "test/all.rb",
-     "test/backends/chained_test.rb",
-     "test/backends/pluralizing_test.rb",
-     "test/backends/static_test.rb",
-     "test/data/locale/all.yml",
-     "test/data/locale/de-DE.yml",
-     "test/data/locale/en-US.yml",
-     "test/data/locale/en-US/module.yml",
-     "test/data/locale/fi-FI/module.yml",
-     "test/data/locale/root.yml",
      "test/data/models.rb",
      "test/data/no_globalize_schema.rb",
      "test/data/schema.rb",
      "test/i18n/missing_translations_test.rb",
-     "test/load_path_test.rb",
-     "test/locale/fallbacks_test.rb",
-     "test/locale/language_tag_test.rb",
-     "test/model/active_record/migration_test.rb",
-     "test/model/active_record/sti_translated_test.rb",
-     "test/model/active_record/translated_test.rb",
-     "test/test_helper.rb",
-     "test/translation_test.rb"
+     "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/joshmh/globalize2}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Rails I18n: de-facto standard library for ActiveRecord data translation}
   s.test_files = [
-    "test/all.rb",
-     "test/backends/chained_test.rb",
-     "test/backends/pluralizing_test.rb",
-     "test/backends/static_test.rb",
+    "test/active_record/fallbacks_test.rb",
+     "test/active_record/migration_test.rb",
+     "test/active_record/sti_translated_test.rb",
+     "test/active_record/translates_test.rb",
+     "test/active_record/translation_class_test.rb",
+     "test/active_record/validation_tests.rb",
+     "test/active_record_test.rb",
+     "test/all.rb",
      "test/data/models.rb",
      "test/data/no_globalize_schema.rb",
      "test/data/schema.rb",
      "test/i18n/missing_translations_test.rb",
-     "test/load_path_test.rb",
-     "test/locale/fallbacks_test.rb",
-     "test/locale/language_tag_test.rb",
-     "test/model/active_record/migration_test.rb",
-     "test/model/active_record/sti_translated_test.rb",
-     "test/model/active_record/translated_test.rb",
-     "test/test_helper.rb",
-     "test/translation_test.rb"
+     "test/test_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -98,3 +78,4 @@ Gem::Specification.new do |s|
   else
   end
 end
+

data/init.rb

@@ -1,8 +1 @@
-require 'globalize/model/active_record'
-
-I18n.backend = Globalize::Backend::Static.new
-
-I18n.load_path = Globalize::LoadPath.new I18n.load_path
-I18n.load_path << "#{File.dirname(__FILE__)}/lib/locale"
-I18n.load_path << "#{RAILS_ROOT}/lib/locale"
-
+require 'globalize'

data/lib/globalize.rb

@@ -0,0 +1,15 @@
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+
+  class << self
+    def fallbacks?
+      I18n.respond_to?(:fallbacks)
+    end
+
+    def fallbacks(locale)
+      fallbacks? ? I18n.fallbacks[locale] : [locale.to_sym]
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Globalize::ActiveRecord)

data/lib/globalize/active_record.rb

@@ -0,0 +1,195 @@
+module Globalize
+  class MigrationError < StandardError; end
+  class MigrationMissingTranslatedField < MigrationError; end
+  class BadMigrationFieldType < MigrationError; end
+
+  module ActiveRecord
+    autoload :Adapter,      'globalize/active_record/adapter'
+    autoload :Attributes,   'globalize/active_record/attributes'
+    autoload :Migration,    'globalize/active_record/migration'
+
+    def self.included(base)
+      base.extend ActMacro
+    end
+
+    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('/', '_')
+          def locale; read_attribute(:locale).to_sym; end
+          def locale=(locale); write_attribute(:locale, locale.to_s); end
+        end
+
+        klass
+      end
+    end
+
+    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)
+
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
+        after_save :save_translations!
+        has_many :translations, :class_name  => translation_class.name,
+                                :foreign_key => class_name.foreign_key,
+                                :dependent   => :delete_all,
+                                :extend      => HasManyExtensions
+
+        named_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] }
+        }
+
+        attr_names.each { |attr_name| translated_attr_accessor(attr_name) }
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+    end
+
+    module HasManyExtensions
+      def by_locale(locale)
+        first(:conditions => { :locale => locale.to_s })
+      end
+
+      def by_locales(locales)
+        all(:conditions => { :locale => locales.map(&:to_s) })
+      end
+    end
+
+    module ClassMethods
+      delegate :set_translation_table_name, :to => :translation_class
+
+      def with_locale(locale)
+        previous_locale, self.locale = self.locale, locale
+        result = yield
+        self.locale = previous_locale
+        result
+      end
+
+      def translation_table_name
+        translation_class.table_name
+      end
+
+      def quoted_translation_table_name
+        translation_class.quoted_table_name
+      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)
+      end
+
+      def respond_to?(method, *args, &block)
+        method.to_s =~ /^find_by_(\w+)$/ && translated_attribute_names.include?($1.to_sym) || super
+      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)
+        else
+          super
+        end
+      end
+
+      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])
+        end
+
+        def translated_attr_accessor(name)
+          define_method "#{name}=", lambda { |value|
+            globalize.write(self.class.locale || I18n.locale, name, value)
+            self[name] = value
+          }
+          define_method name, lambda { |*args|
+            globalize.fetch(args.first || self.class.locale || I18n.locale, name)
+          }
+          alias_method "#{name}_before_type_cast", name
+        end
+
+        def translated_attr_name(name)
+          "#{translation_class.table_name}.#{name}"
+        end
+    end
+
+    module InstanceMethods
+      def globalize
+        @globalize ||= Adapter.new self
+      end
+
+      def attributes=(attributes, *args)
+        if attributes.respond_to?(:delete) && locale = attributes.delete(:locale)
+          self.class.with_locale(locale) { super }
+        else
+          super
+        end
+      end
+
+      def available_locales
+        translations.scoped(: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))
+        end
+      end
+
+      def set_translations(options)
+        options.keys.each do |locale|
+          translation = translations.find_by_locale(locale.to_s) ||
+            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
+
+      protected
+
+        def save_translations!
+          globalize.save_translations!
+        end
+    end
+  end
+end