radiant-globalize2-extension 0.2.0

data/vendor/plugins/globalize2/Rakefile

@@ -0,0 +1,39 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the globalize2 plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the globalize2 plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Globalize2'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "globalize2"
+    s.summary = "Rails I18n: de-facto standard library for ActiveRecord data translation"
+    s.description = "Rails I18n: de-facto standard library for ActiveRecord data translation"
+    s.email = "joshmh@gmail.com"
+    s.homepage = "http://github.com/joshmh/globalize2"
+    # s.rubyforge_project = ''
+    s.authors = ["Sven Fuchs, Joshua Harvey, Clemens Kofler, John-Paul Bader"]
+    # s.add_development_dependency ''
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/vendor/plugins/globalize2/VERSION

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

data/vendor/plugins/globalize2/generators/templates/db_backend_migration.rb

@@ -0,0 +1,25 @@
+class ActsAsTaggableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :globalize_translations do |t|
+      t.string :locale, :null => false
+      t.string :key, :null => false
+      t.string :translation
+      t.timestamps
+    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
+  end
+end

data/vendor/plugins/globalize2/globalize2.gemspec

@@ -0,0 +1,81 @@
+# Generated by jeweler
+# 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.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, John-Paul Bader"]
+  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 = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "generators/db_backend.rb",
+     "generators/templates/db_backend_migration.rb",
+     "globalize2.gemspec",
+     "init.rb",
+     "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/data/models.rb",
+     "test/data/no_globalize_schema.rb",
+     "test/data/schema.rb",
+     "test/i18n/missing_translations_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.6}
+  s.summary = %q{Rails I18n: de-facto standard library for ActiveRecord data translation}
+  s.test_files = [
+    "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/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/vendor/plugins/globalize2/init.rb

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

data/vendor/plugins/globalize2/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/vendor/plugins/globalize2/lib/globalize/active_record.rb

@@ -0,0 +1,215 @@
+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
+        
+        (subclasses_of(self) + [self]).each do |klass|
+          klass.translation_class = ActiveRecord.build_translation_class(self, options)
+          klass.translated_attribute_names = attr_names.map(&:to_sym)
+        end
+
+        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],
+            :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
+
+    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.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

data/vendor/plugins/globalize2/lib/globalize/active_record/adapter.rb

@@ -0,0 +1,80 @@
+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|
+          translation = record.translations.find_or_initialize_by_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