galetahub-globalize3 0.2.1

data/lib/globalize/active_record/translation.rb

@@ -0,0 +1,37 @@
+module Globalize
+  module ActiveRecord
+    class Translation < ::ActiveRecord::Base
+      attr_accessible :locale
+      
+      class << self
+        def with_locales(*locales)
+          # Avoid using "IN" with SQL queries when only using one locale.
+          locales = locales.flatten.map(&:to_s)
+          locales = locales.first if locales.one?
+          where(:locale => locales)
+        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
+
+# Setting this will force polymorphic associations to subclassed objects
+# to use their table_name rather than the parent object's table name,
+# which will allow you to get their models back in a more appropriate
+# format.
+#
+# See http://www.ruby-forum.com/topic/159894 for details.
+Globalize::ActiveRecord::Translation.abstract_class = true

data/lib/globalize/engine.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require 'rails'
+require 'globalize'
+
+module Globalize
+  class Engine < ::Rails::Engine
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)
+      end
+    end
+    
+    rake_tasks do
+      load "tasks/globalize.rake"
+    end
+  end
+end

data/lib/globalize/utils.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+module Globalize
+  class Utils
+    class << self
+      def model_dir
+        @model_dir || "app/models"
+      end
+
+      def model_dir=(dir)
+        @model_dir = dir
+      end
+      
+      def show_log(action, table_name, name=false, type=false)
+        log = []
+        log << action
+        log << ' ' + table_name.to_s
+        log << '.' + name.to_s if name
+        log << ' as ' + type.to_s if type
+        
+        puts log.join
+      end
+    
+      # Return a list of the model files to translate. If we have
+      # command line arguments, they're assumed to be either
+      # the underscore or CamelCase versions of model names.
+      # Otherwise we take all the model files in the
+      # model_dir directory.
+      def get_model_files
+        models = ARGV.dup
+        models.shift
+        models.reject!{|m| m.match(/^(.*)=/)}
+        if models.empty?
+          begin
+            Dir.chdir(model_dir) do
+              models = Dir["**/*.rb"]
+            end
+          rescue SystemCallError
+            puts "No models found in directory '#{model_dir}'."
+            exit 1;
+          end
+        end
+        models
+      end
+
+      # Retrieve the classes belonging to the model names we're asked to process
+      # Check for namespaced models in subdirectories as well as models
+      # in subdirectories without namespacing.
+      def get_model_class(file)
+        require File.expand_path("#{model_dir}/#{file}") # this is for non-rails projects, which don't get Rails auto-require magic
+        model = file.gsub(/\.rb$/, '').camelize
+        parts = model.split('::')
+        begin
+          parts.inject(Object) {|klass, part| klass.const_get(part) }
+        rescue LoadError, NameError
+          Object.const_get(parts.last)
+        end
+      end
+      
+      # create or delete parent model fields, such as is_locale_{locale}
+      def make_parent_checkers(klass, connect)
+        columns = connect.columns(klass.table_name)
+        
+        Globalize.available_locales.each do |locale|
+          name = "is_locale_#{locale}"
+          
+          unless columns.map(&:name).include?(name)
+            connect.add_column klass.table_name, name, :boolean, :default => false
+            show_log("add column", klass.table_name, name, :boolean)
+          end
+        end
+      end
+      
+      def make_up(klass)
+        conn = klass.connection
+        table_name = klass.translations_table_name
+        
+        make_parent_checkers(klass, conn)
+            
+        if conn.table_exists?(table_name) # translated table exits
+          columns = conn.columns(table_name)
+          
+          klass.translated_columns_hash.each do |key, value|
+            columns.each do |column|
+              if column.name.to_sym == key && column.type != value
+                conn.change_column table_name, key, value
+                show_log("change column", table_name, key, value)
+              end
+            end
+            
+            unless columns.map(&:name).include?(key.to_s)
+              conn.add_column table_name, key, value
+              show_log("add column", table_name, key, value)
+            end
+          end
+          
+          columns.each do |column|
+            if !klass.translated_attribute_names.include?(column.name.to_sym) && [:string, :text].include?(column.type) && column.name != "locale"
+              conn.remove_column table_name, column.name
+              show_log("remove column", table_name, column.name)
+            end
+          end
+        else
+          klass.create_translation_table!(klass.translated_columns_hash)
+          show_log("create table", table_name)
+        end
+      end
+      
+      def make_down(klass)
+        if klass.connection.table_exists?(klass.translations_table_name)
+          klass.drop_translation_table!
+          show_log("drop table", klass.translations_table_name)
+        end
+      end
+
+      def init(kind)
+        get_model_files.each do |file|
+          begin
+            klass = get_model_class(file)
+            if klass < ::ActiveRecord::Base && !klass.abstract_class? && klass.respond_to?(:translated_attribute_names)
+              case kind
+                when :up then make_up(klass)
+                when :down then make_down(klass)
+              end
+            end
+          rescue Exception => e
+            puts "Unable to #{kind} #{file}: #{e.inspect}"
+          end
+        end
+      end
+      
+      # Convert string "title:string" to hash { :title => :string }
+      # Convert array ["title:string", "content:text"] to hash { :title => :string, :content => :text }
+      def convert_columns(value)
+        [value].flatten.inject({}) do |hash, schema|
+          arr = schema.to_s.split(':')
+          hash[arr.first.to_sym] = (arr.size == 1 ? :text : arr.last.to_sym)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/globalize/versioning.rb

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

data/lib/globalize/versioning/paper_trail.rb

@@ -0,0 +1,41 @@
+require 'paper_trail'
+
+module Globalize
+  module Versioning
+    module PaperTrail
+      # At present this isn't used but we may use something similar in paper trail
+      # shortly, so leaving it around to reference easily.
+      #def versioned_columns
+        #super + self.class.translated_attribute_names
+      #end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  class << self
+    def has_paper_trail_with_globalize(*args)
+      has_paper_trail_without_globalize(*args)
+      include Globalize::Versioning::PaperTrail
+    end
+    alias_method_chain :has_paper_trail, :globalize
+  end
+end
+
+Version.class_eval do
+
+  before_save do |version|
+    version.locale = Globalize.locale.to_s
+  end
+
+  def self.locale_conditions_to_sql
+    "locale = '#{Globalize.locale.to_s}'"
+  end
+
+  scope :for_this_locale, lambda{ { :conditions => locale_conditions_to_sql } }
+
+  def sibling_versions_with_locales
+    sibling_versions_without_locales.for_this_locale
+  end
+  alias_method_chain :sibling_versions, :locales
+end

data/lib/globalize3.rb

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

data/lib/globalize3/version.rb

@@ -0,0 +1,3 @@
+module Globalize3
+  VERSION = '0.2.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/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

data/lib/tasks/globalize.rake

@@ -0,0 +1,13 @@
+namespace :db do
+  namespace :globalize do
+    desc "Synchronize translated columns with database (create/drop table or add/change/remove column)"
+    task :up => :environment do
+      Globalize::Utils.init(:up)
+    end
+    
+    desc "Drop all globalize translations tables (but be careful: non-refundable)"
+    task :down => :environment do
+      Globalize::Utils.init(:down)
+    end
+  end
+end

data/test/all.rb

@@ -0,0 +1 @@
+Dir[File.expand_path('../**/*_test.rb', __FILE__)].each { |file| require file }

data/test/data/models.rb

@@ -0,0 +1,68 @@
+# this little innocent class here makes 0.0.9 test fail
+class Translation < ActiveRecord::Base
+end
+
+class Post < ActiveRecord::Base
+  translates :title, :content, :published, :published_at, :versioning => true
+  validates_presence_of :title
+  scope :with_some_title, :conditions => { :title => 'some_title' }
+end
+
+class PostTranslation < ActiveRecord::Base
+  def existing_method ; end
+end
+
+class ReloadingPost < Post
+  after_create { reload }
+end
+
+class Blog < ActiveRecord::Base
+  has_many :posts, :order => 'id ASC'
+end
+
+
+class Validatee < ActiveRecord::Base
+  translates :string
+end
+
+
+class Parent < ActiveRecord::Base
+  translates :content
+end
+
+class Child < Parent
+end
+
+class Comment < ActiveRecord::Base
+  validates_presence_of :content
+  belongs_to :post
+end
+
+class TranslatedComment < Comment
+  translates :content
+end
+
+class User < ActiveRecord::Base
+  translates :name
+  validates_presence_of :name, :email
+end
+
+class Migrated < ActiveRecord::Base
+  translates :name
+end
+
+class MigratedWithUltraLongModelName < ActiveRecord::Base
+  translates :name
+end
+
+class UppercaseTableName < ActiveRecord::Base
+  set_table_name "UPPERCASE_TABLE_NAME"
+  translates :name
+end
+
+class Untranslated < ActiveRecord::Base
+end
+
+class Task < ActiveRecord::Base
+  translates :name, :fallbacks_for_empty_translations => true
+end