globalize3 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008, 2009 Joshua Harvey
+
+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,80 @@
+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 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 values for 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. 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/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/globalize.rb

@@ -0,0 +1,17 @@
+require 'patches/active_record/xml_attribute_serializer'
+
+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.extend(Globalize::ActiveRecord::ActMacro)

data/lib/globalize/active_record.rb

@@ -0,0 +1,55 @@
+module Globalize
+  class MigrationError < StandardError; end
+  class MigrationMissingTranslatedField < MigrationError; end
+  class BadMigrationFieldType < MigrationError; end
+
+  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 :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
+  end
+end

data/lib/globalize/active_record/act_macro.rb

@@ -0,0 +1,51 @@
+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)
+
+        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
+
+        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 class_name
+        class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].camelize
+        pluralize_table_names ? class_name.singularize : class_name
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+    end
+  end
+end

data/lib/globalize/active_record/adapter.rb

@@ -0,0 +1,82 @@
+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
+
+      def initialize(record)
+        @record = record
+        @cache = Attributes.new
+        @stash = Attributes.new
+      end
+
+      def fetch(locale, attr_name)
+        cache.contains?(locale, attr_name) ?
+          cache.read(locale, attr_name) :
+          cache.write(locale, attr_name, fetch_attribute(locale, attr_name))
+      end
+
+      def write(locale, attr_name, value)
+        stash.write(locale, attr_name, value)
+        cache.write(locale, attr_name, value)
+      end
+
+      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)
+          attrs.each { |attr_name, value| translation[attr_name] = value }
+          translation.save!
+        end
+        stash.clear
+      end
+
+      def reset
+        cache.clear
+        # stash.clear
+      end
+
+      protected
+
+        def fetch_translation(locale)
+          locale = locale.to_sym
+          record.translations.loaded? ? record.translations.detect { |t| t.locale == locale } :
+            record.translations.by_locale(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))
+        end
+
+        def fetch_attribute(locale, attr_name)
+          translations = fetch_translations(locale)
+          value, requested_locale = nil, locale
+
+          Globalize.fallbacks(locale).each do |fallback|
+            translation = translations.detect { |t| t.locale == fallback }
+            value  = translation && translation.send(attr_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,25 @@
+# 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, attr_name)
+        self[locale].has_key?(attr_name)
+      end
+
+      def read(locale, attr_name)
+        self[locale][attr_name]
+      end
+
+      def write(locale, attr_name, value)
+        self[locale][attr_name] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -0,0 +1,68 @@
+module Globalize
+  module ActiveRecord
+    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],
+            :readonly => false
+          )
+        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
+  end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -0,0 +1,63 @@
+module Globalize
+  module ActiveRecord
+    module InstanceMethods
+      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
+      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 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))
+        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

data/lib/globalize/active_record/migration.rb

@@ -0,0 +1,44 @@
+module Globalize
+  module ActiveRecord
+    module Migration
+      def create_translation_table!(fields)
+        translated_attribute_names.each do |f|
+          raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
+        end
+
+        fields.each do |name, type|
+          if translated_attribute_names.include?(name) && ![:string, :text].include?(type)
+            raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
+          end
+        end
+
+        self.connection.create_table(translation_table_name) do |t|
+          t.references table_name.sub(/^#{table_name_prefix}/, "").singularize
+          t.string :locale
+          fields.each do |name, type|
+            t.column name, type
+          end
+          t.timestamps
+        end
+
+        self.connection.add_index(
+          translation_table_name, 
+          "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
+          :name => translation_index_name
+        )
+      end
+
+      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.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)
+      end
+    end
+  end
+end

data/lib/globalize/version.rb

@@ -0,0 +1,3 @@
+module Globalize
+  VERSION = '0.0.1'
+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/xml_attribute_serializer.rb

@@ -0,0 +1,12 @@
+require 'active_record/serializers/xml_serializer'
+
+ActiveRecord::XmlSerializer::Attribute.class_eval do
+  def compute_type_with_translations
+    if @serializable.class.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,101 @@
+--- !ruby/object:Gem::Specification 
+name: globalize3
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+- Joshua Harvey
+- Clemens Kofler
+- John-Paul Bader
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-30 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: 7712042
+        segments: 
+        - 3
+        - 0
+        - 0
+        - rc
+        version: 3.0.0.rc
+  type: :runtime
+  version_requirements: *id001
+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/instance_methods.rb
+- lib/globalize/active_record/migration.rb
+- lib/globalize/active_record.rb
+- lib/globalize/version.rb
+- lib/globalize.rb
+- lib/i18n/missing_translations_log_handler.rb
+- lib/i18n/missing_translations_raise_handler.rb
+- lib/patches/active_record/xml_attribute_serializer.rb
+- LICENSE
+- Rakefile
+- README.textile
+- VERSION
+has_rdoc: true
+homepage: http://github.com/svenfuchs/globlize3
+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: 3
+      segments: 
+      - 0
+      version: "0"
+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: []
+