globalize3-jovoto 0.1.0.beta

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

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/README.textile

@@ -0,0 +1,122 @@
+h1. Globalize3
+
+Globalize3 is the successor of Globalize for Rails. Globalize is targeted at ActiveRecord 3. 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.
+
+Globalize3 is much more lightweight and compatible than its predecessor Globalize for Rails was. Model translations in Globalize3 use default ActiveRecord features and do not limit any ActiveRecord functionality any more.
+
+h2. Requirements
+
+ActiveRecord > 3.0.0.rc
+I18n
+
+h2. Installation
+
+To install Globalize3 with its default setup just use:
+
+<pre><code>
+$ gem install globalize3
+</code></pre>
+
+h2. Model translations
+
+Model translations allow you to translate your models' attribute values. E.g.
+
+<pre><code>
+class Post < ActiveRecord::Base
+  translates :title, :text
+end
+</code></pre>
+
+Allows you to translate the attributes :title and :text per locale:
+
+<pre><code>
+I18n.locale = :en
+post.title # => Globalize3 rocks!
+
+I18n.locale = :he
+post.title # => גלובאלייז2 שולט!
+</code></pre>
+
+In order to make this work, you'll need to add the appropriate translation tables. Globalize3 comes with a handy helper method to help you do this. It's called @create_translation_table!@. Here's an example:
+
+<pre><code>
+class CreatePosts < ActiveRecord::Migration
+  def self.up
+    create_table :posts do |t|
+      t.timestamps
+    end
+    Post.create_translation_table! :title => :string, :text => :text
+  end
+  def self.down
+    drop_table :posts
+    Post.drop_translation_table!
+  end
+end
+</code></pre>
+
+Note that the ActiveRecord model @Post@ must already exist and have a @translates@ directive listing the translated fields.
+
+h2. Migrating existing data to and from the translated version
+
+As well as creating a translation table, you can also use @create_translation_table!@ to migrate across any
+existing data to the default locale. This can also operate in reverse to restore any translations from the default locale
+back to the model when you don't want to use a translation table anymore using @drop_translation_table!@
+
+This feature makes use of @untranslated_attributes@ which allows access to the model's attributes as they were before
+the translation was applied. Here's an example (which assumes you already have a model called @Post@ and its table exists):
+
+<pre><code>
+  class TranslatePosts < ActiveRecord::Migration
+    def self.up
+      Post.create_translation_table!({
+        :title => :string,
+        :text => :text
+      }, {
+        :migrate_data => true
+      })
+    end
+    def self.down
+      Post.drop_translation_table! :migrate_data => true
+    end
+  end
+</code></pre>
+
+h2. Versioning with Globalize3
+
+Globalize3 nicely integrates with "vestal_versions":http://github.com/laserlemon/vestal_versions:
+
+<pre><code>
+require 'globalize/versioning/vestal_versions'
+</code></pre>
+
+As of writing (2010-08-05) the original vestal_versions respository has not been updated to be compatible with Rails 3 though. You can use "this fork":http://github.com/svenfuchs/vestal_versions though. "Globalize3's Gemfile":http://github.com/svenfuchs/globalize3/blob/master/Gemfile#L10 is currently set up accordingly.
+
+Please also note that @update_attribute@ currently hides itself from dirty tracking in ActiveRecord >= 3.0.0.beta (which is considered a "regression":http://github.com/rails/rails/commit/01629d180468049d17a8be6900e27a4f0d2b18c4#commitcomment-123199). That means that you currently need to use attribute writers or @update_attributes@ in order to track changes/versions for your models.
+
+Also, please see the tests in test/globalize3/versioning_test.rb for some current gotchas.
+
+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
+
+h2. Alternative Solutions
+
+* "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)
+
+h2. Related solutions
+
+* "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/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+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    = 'Globalize3'
+  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,52 @@
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
+
+module Globalize
+  autoload :ActiveRecord, 'globalize/active_record'
+  autoload :Versioning,   'globalize/versioning'
+
+  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
+      set_locale(locale)
+      result = yield(locale)
+      set_locale(previous_locale)
+      result
+    end
+
+    def with_locales(*locales, &block)
+      locales.flatten.map do |locale|
+        with_locale(locale, &block)
+      end
+    end
+
+    def fallbacks?
+      I18n.respond_to?(:fallbacks)
+    end
+
+    def fallbacks(locale = self.locale)
+      fallbacks? ? I18n.fallbacks[locale] : [locale.to_sym]
+    end
+
+    protected
+
+      def read_locale
+        Thread.current[:globalize_locale]
+      end
+
+      def set_locale(locale)
+        Thread.current[:globalize_locale] = locale
+      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,45 @@
+module Globalize
+  module ActiveRecord
+    module ActMacro
+      def translates(*attr_names)
+        return if translates?
+
+        options = attr_names.extract_options!
+        options[:table_name] ||= "#{table_name.singularize}_translations"
+
+        class_attribute :translated_attribute_names, :translation_options
+        self.translated_attribute_names = attr_names.map(&:to_sym)
+        self.translation_options        = options
+
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
+        has_many :translations, :class_name  => translation_class.name,
+                                :foreign_key => class_name.foreign_key,
+                                :dependent   => :delete_all,
+                                :extend      => HasManyExtensions
+
+        after_save :save_translations!
+
+        attr_names.each { |attr_name| translated_attr_accessor(attr_name) }
+      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
+    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,100 @@
+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_reader :record, :cache, :stash
+
+      delegate :translation_class, :to => :'record.class'
+
+      def initialize(record)
+        @record = record
+        @cache = Attributes.new
+        @stash = Attributes.new
+      end
+
+      def fetch(locale, name)
+        cache.contains?(locale, name) ?
+          type_cast(name, cache.read(locale, name)) :
+          cache.write(locale, name, fetch_attribute(locale, name))
+      end
+
+      def write(locale, name, value)
+        stash.write(locale, name, value)
+        cache.write(locale, name, value)
+      end
+
+      def save_translations!
+        stash.each do |locale, attrs|
+          translation = record.translations.find_or_initialize_by_locale(locale.to_s)
+          attrs.each { |name, value| translation[name] = value }
+          translation.save!
+        end
+        stash.clear
+      end
+
+      def reset
+        cache.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_translation(locale)
+          locale = locale.to_sym
+          record.translations.loaded? ? record.translations.detect { |t| t.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.with_locales(Globalize.fallbacks(locale))
+        end
+
+        def fetch_attribute(locale, name)
+          translations = fetch_translations(locale)
+          value, requested_locale = nil, locale
+
+          Globalize.fallbacks(locale).each do |fallback|
+            translation = translations.to_a.detect { |t| t.locale == fallback }
+            value  = translation && translation.send(name)
+            locale = fallback && break if value
+          end
+
+          set_metadata(value, :locale => locale, :requested_locale => requested_locale)
+          value
+        end
+
+        def set_metadata(object, metadata)
+          if object.respond_to?(:translation_metadata)
+            object.translation_metadata.merge!(meta_data)
+          end
+        end
+
+        def translation_metadata_accessor(object)
+          return if obj.respond_to?(:translation_metadata)
+          class << object; attr_accessor :translation_metadata end
+          object.translation_metadata ||= {}
+        end
+    end
+  end
+end
+

data/lib/globalize/active_record/attributes.rb

@@ -0,0 +1,26 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+
+module Globalize
+  module ActiveRecord
+    class Attributes < Hash
+      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)
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,90 @@
+module Globalize
+  module ActiveRecord
+    module ClassMethods
+      delegate :translated_locales, :set_translations_table_name, :to => :translation_class
+
+      def with_locales(*locales)
+        scoped & 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
+
+          if klass.table_name == 'translations'
+            klass.set_table_name(translation_options[:table_name])
+            klass.belongs_to name.underscore.gsub('/', '_')
+          end
+          klass
+        end
+      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)
+        method.to_s =~ /^find_(all_|)by_(\w+)$/ && translated?($2.to_sym) || super
+      end
+
+      def method_missing(method, *args)
+        if method.to_s =~ /^find_(all_|)by_(\w+)$/ && translated?($2.to_sym)
+          result = with_translated_attribute($2, args.first)
+          $1 == 'all_' ? result.all : result.first
+        else
+          super
+        end
+      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,112 @@
+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 = {})
+        # Make sure that we return some value as some methods might
+        # rely on the data
+        return_value = super(name, value)
+
+        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)
+          return_value = globalize.write(options[:locale] || Globalize.locale, name, value)
+        end
+        return_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]
+          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 => 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 = 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
+
+        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,
+          :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)
+        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

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/versioning.rb

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

data/lib/globalize/versioning/vestal_versions.rb

@@ -0,0 +1,35 @@
+require 'vestal_versions'
+
+module Globalize
+  module Versioning
+    module VestalVersions
+      def versioned_columns
+        super + self.class.translated_attribute_names
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  class << self
+    def versioned_with_globalize(*args)
+      versioned_without_globalize(*args)
+      include Globalize::Versioning::VestalVersions
+    end
+    alias_method_chain :versioned, :globalize
+  end
+end
+
+VestalVersions::Version.class_eval do
+  before_save do |version|
+    version.locale = Globalize.locale.to_s
+  end
+
+  class Condition
+    def to_sql
+      "locale = '#{Globalize.locale.to_s}'"
+    end
+  end
+
+  default_scope(:conditions => Condition.new)
+end

data/lib/globalize3.rb

@@ -0,0 +1 @@
+require 'globalize'

data/lib/globalize3/version.rb

@@ -0,0 +1,3 @@
+module Globalize3
+  VERSION = '0.1.0.beta'
+end

data/lib/i18n/missing_translations_log_handler.rb

@@ -0,0 +1,41 @@
+# A simple exception handler that behaves like the default exception handler
+# but additionally logs missing translations to a given log.
+#
+# Useful for identifying missing translations during testing.
+#
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_log_handler'
+#   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
+#   I18n.exception_handler = :missing_translations_log_handler
+#
+# To set up a different log file:
+#
+#   logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
+#   I18n.missing_translations_logger = logger
+
+module I18n
+  @@missing_translations_logger = nil
+
+  class << self
+    def missing_translations_logger
+      @@missing_translations_logger ||= begin
+        require 'logger' unless defined?(Logger)
+        Logger.new(STDOUT)
+      end
+    end
+
+    def missing_translations_logger=(logger)
+      @@missing_translations_logger = logger
+    end
+
+    def missing_translations_log_handler(exception, locale, key, options)
+      if MissingTranslationData === exception
+        missing_translations_logger.warn(exception.message)
+        return exception.message
+      else
+        raise exception
+      end
+    end
+  end
+end

data/lib/i18n/missing_translations_raise_handler.rb

@@ -0,0 +1,25 @@
+# A simple exception handler that behaves like the default exception handler
+# but also raises on missing translations.
+#
+# Useful for identifying missing translations during testing.
+#
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_raise_handler'
+#   I18n.exception_handler = :missing_translations_raise_handler
+module I18n
+  class << self
+    def missing_translations_raise_handler(exception, locale, key, options)
+      raise exception
+    end
+  end
+end
+
+I18n.exception_handler = :missing_translations_raise_handler
+
+ActionView::Helpers::TranslationHelper.module_eval do
+  def translate(key, options = {})
+    I18n.translate(key, options)
+  end
+  alias :t :translate
+end

data/lib/patches/active_record/query_method.rb

@@ -0,0 +1,35 @@
+require 'active_record/attribute_methods/query'
+
+module ActiveRecord
+  module AttributeMethods
+    module Query
+      def query_attribute(attr_name)
+        unless value = read_attribute(attr_name)
+          false
+        else
+          column = self.class.columns_hash[attr_name]
+          if column.nil?
+            
+            # TODO submit a rails patch
+
+            # not sure what active_record tests say but i guess this should mean:
+            # call to_i and check zero? if the value is a Numeric or starts with
+            # a digit, so it can meaningfully be typecasted by to_i
+
+            # if Numeric === value || value !~ /[^0-9]/
+            if Numeric === value || value.to_s =~ /^[0-9]/
+              !value.to_i.zero?
+            else
+              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/patches/active_record/xml_attribute_serializer.rb

@@ -0,0 +1,13 @@
+require 'active_record/serializers/xml_serializer'
+
+ActiveRecord::XmlSerializer::Attribute.class_eval do
+  def compute_type_with_translations
+    klass = @serializable.class
+    if klass.translates? && klass.translated_attribute_names.include?(name.to_sym)
+      :string
+    else
+      compute_type_without_translations
+    end
+  end
+  alias_method_chain :compute_type, :translations
+end

metadata

@@ -0,0 +1,211 @@
+--- !ruby/object:Gem::Specification 
+name: globalize3-jovoto
+version: !ruby/object:Gem::Version 
+  hash: 31098185
+  prerelease: true
+  segments: 
+  - 0
+  - 1
+  - 0
+  - beta
+  version: 0.1.0.beta
+platform: ruby
+authors: 
+- Sven Fuchs
+- Joshua Harvey
+- Clemens Kofler
+- John-Paul Bader
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-18 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 5
+        - 2
+        version: 0.5.2
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: pathname_local
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: test_declarative
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: "Rails I18n: de-facto standard library for ActiveRecord 3 model/data translation."
+email: nobody@globalize-rails.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/globalize/active_record/act_macro.rb
+- lib/globalize/active_record/adapter.rb
+- lib/globalize/active_record/attributes.rb
+- lib/globalize/active_record/class_methods.rb
+- lib/globalize/active_record/exceptions.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/versioning/vestal_versions.rb
+- lib/globalize/versioning.rb
+- lib/globalize.rb
+- lib/globalize3/version.rb
+- lib/globalize3.rb
+- lib/i18n/missing_translations_log_handler.rb
+- lib/i18n/missing_translations_raise_handler.rb
+- lib/patches/active_record/query_method.rb
+- lib/patches/active_record/xml_attribute_serializer.rb
+- Gemfile
+- LICENSE
+- Rakefile
+- README.textile
+has_rdoc: true
+homepage: http://github.com/jovoto-team/globalize3
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "Rails I18n: de-facto standard library for ActiveRecord 3 model/data translation"
+test_files: []
+