zlocalize 4.1.0

data/lib/zlocalize/rails/generators/templates/initializer_template.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+
+# ZLocalize configuration.
+
+# ZLocalize is bound to use I18n.locale, I18n.default_locale, as to remain consistent
+# with the locale used by the Rails framework itself
+I18n.default_locale = :fr
+
+# define_gettext_methods will add _ and n_ methods to the Object class (so that they are globally accessible)
+# if you do not define the gettext methods, you will need to use ZLocalize.translate and ZLocalize.pluralize
+ZLocalize.config.define_gettext_methods = true
+
+# specify which Rails environments will reload the translation files on each request
+ZLocalize.config.reload_per_request = { :development => false, :test => false,
+                                        :production => false, :staging => false }
+
+# specify which Rails environments will return the source string when a translation is not found
+# when false. Defaults to false for all environments, meaning a missing translation will raise
+# a ZLocalize::TranslationMissing error
+ZLocalize.config.return_source_on_missing = { :development => true, :test => true,
+                                              :production => true, :staging => true }
+
+# +ZLocalize.config.locales+ is the configuration of locales supported by your application.
+# each locale must be a Hash with the configuration values for that locale.
+#
+# You must define, for each language, the +plural_select+ Proc, which must return the
+# index in the translation entry Array to use.
+#
+# +titleize+ handles the way a String is titleized (it defaults to the way ActiveSupport does it
+# if it is not defined)
+#
+# :convert_float must be defined to handle input by users of your application so that those values
+# are converted to the format used by your database (and Ruby).
+#
+# +:translations+ is the path of the YAML file containing the translations to be loaded for the locale.
+# The default_locale doesn't need translation strings, since it is the base locale and it will
+# simply return the string itself.
+
+ZLocalize.config.locales = {
+  :en => {
+     :plural_select     => lambda { |n| n <= 0 ? 0 : (n > 1 ? 2 : 1) },
+     :translations      => File.join(Rails.root,'config/locales/en.strings.yml'),
+     :convert_float     => lambda { |s| s.to_s.gsub(',','') }
+  },
+#  :fr => {
+#     :plural_select    => lambda { |n| n <= 0 ? 0 : (n > 1 ? 2 : 1) },
+#     :translations     => File.join(Rails.root,'config/locales/fr.strings.yml'),
+#     :titleize         => lambda { |s| s.capitalize.to_s },
+#     :convert_float    => lambda { |s| s.to_s.gsub(' ','').gsub(',','.') }
+#  }
+}
+
+

data/lib/zlocalize/rails/generators/templates/translations_migration_template.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+
+class CreateZLocalizeTranslationsTable < ActiveRecord::Migration
+   def self.up
+     create_table :translations do |t|
+       t.string :translated_type
+       t.integer :translated_id
+       t.string :name
+       t.string :locale
+       t.text :value
+
+       t.timestamps
+    end
+    add_index 'translations', ['translated_type','translated_id'], :name => 'index_on_translated'
+    add_index 'translations', ['name','locale'], :name => 'index_for_lookup'
+  end
+
+  def self.down
+    drop_table :translations
+  end
+end

data/lib/zlocalize/rails/generators/translations_migration.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/base'
+require 'rails/generators/migration'
+
+# module here is deliberately named Zlocalize (as opposed to ZLocalize), for consistency
+# between the namespacing of rake tasks and rails generators
+module Zlocalize
+    module Generators
+      class TranslationsMigrationGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        desc "Generate the migration to create a `translations` table used by ZLocalize"
+
+        source_root File.join(File.dirname(__FILE__),'templates')
+
+        def self.next_migration_number(path)
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+
+        def create_migration_file
+          migration_template 'translations_migration_template.rb', 'db/migrate/create_translations_table.rb'
+        end
+
+      end
+   end
+end

data/lib/zlocalize/rails/railtie.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+
+require 'zlocalize'
+require 'rails'
+require 'active_record'
+
+module ZLocalize
+  class Railtie < Rails::Railtie
+
+    initializer "Zlocalize.load_translation_model" do
+      require File.expand_path('./translation',File.dirname(__FILE__))
+    end
+
+    initializer "ZLocalize.load_active_record_extensions" do
+      require File.expand_path('./active_record.rb',File.dirname(__FILE__))
+    end
+
+    rake_tasks do
+      load File.expand_path('./tasks/harvest.rake',File.dirname(__FILE__))
+    end
+
+    generators do
+      load File.expand_path('./generators/initializer.rb',File.dirname(__FILE__))
+      load File.expand_path('./generators/translations_migration.rb',File.dirname(__FILE__))
+    end
+
+  end
+end

data/lib/zlocalize/rails/tasks/harvest.rake

@@ -0,0 +1,43 @@
+# -*- encoding : utf-8 -*-
+
+require 'zlocalize/harvester'
+
+namespace :zlocalize do
+
+  desc "Collect all translatable strings (used in _('...') and n_('...') calls) in your Rails application\n\n" +
+       "Usage: rake zlocalize:harvest\n" +
+       "Options and their defaults are:\n\n" +
+       "  output=FILE_PATH       Output file, relative to Rails.root (default: \'config/locales/app-strings.yml\')\n" +
+       "  purge=true|false       Remove unused entries in the existing output file (if it exists). (default: false)\n" +
+       "  clear=true|false       Clearing the existing translations in output file (if it exists). (default: false)\n" +
+       "  silent=true|false      If true, do not report progress. (default: false)\n" +
+       "  add_paths              Comma-separated list of path specs (relative to Rails.root) to harvest in addition to default paths"
+
+  task :harvest => :environment do
+    options = { :clear      => ['1','true'].include?(ENV['clear']),
+                :purge      => ['1','true'].include?(ENV['purge']),
+                :output     => ENV['output'].to_s.empty? ? 'config/locales/app-strings.yml' : ENV['output'],
+                :add_paths  => ENV['add_paths'].to_s.empty? ? [] : ENV['add_paths'].split(','),
+                :silent     => ['1','true'].include?(ENV['silent']) }
+
+    h = ZLocalize::Harvester.new(File.expand_path(Rails.root), options)
+    h.harvest
+  end
+
+  desc "Display which entries are not translated in given file\n\n" +
+       "Usage: rake zlocalize:check_untranslated file=FILE_PATH\n\n" +
+       "where FILE_PATH is the path to the YAML translation file relative to Rails.Root\n"
+  task :check_untranslated => :environment do
+    f = ZLocalize::TranslationFile.load(File.join(Rails.root,ENV['file']))
+    num = 0
+    f.entries.each_pair do |key,entry|
+      if entry.translation.to_s == ""
+         puts entry.to_yaml + "\n"
+         num += 1
+      end
+    end
+    puts "\n#{num} entries without a translation"
+  end
+
+end
+

data/lib/zlocalize/rails/translated_columns.rb

@@ -0,0 +1,73 @@
+# -*- encoding : utf-8 -*-
+
+#
+# === Translated columns ====
+#
+#  Allows an ActiveRecord Model to declare multiple values (one for each locale) for given attributes.
+#  This module stores the values of each locale in table columns, such as:
+#
+#    create_table :articles do |t|
+#      t.string  :title_fr, :default => ''
+#      t.string  :title_en, :default => ''
+#      t.text    :content_fr
+#      t.text    :content_en
+#    end
+#
+#    class Article < ActiveRecord::Base
+#      ...
+#      translates_columns [:title, :content]
+#
+#    end
+#
+#    > @article = Article.new({ :title_fr => "L'année en revue", :title_en => "The Year in Review" })
+#    > I18n.locale = :fr
+#    > @article.title
+#      => "L'année en revue"
+#    > I18n.locale = :en
+#    > @article.title
+#      => "The Year in Review"
+#
+module ZLocalize
+  module Translatable #:nodoc:
+
+    module TranslatedColumns #:nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def translates_columns(column_names)
+
+          [column_names].flatten.each do |col_name|
+            class_eval "def #{col_name}(options = {})
+                          read_translated_column('#{col_name}',(options[:locale] || ZLocalize.locale),options[:fetch_default] == true)
+                        end"
+          end
+
+          include ZLocalize::Translatable::TranslatedColumns::InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+
+        def read_translated_column(col_name,locale,fetch_default = true)
+          s = self.read_attribute("#{col_name}_#{locale}")
+          if !s.nil?
+            return s
+          elsif fetch_default == true
+            return self.read_attribute("#{col_name}_#{ZLocalize.default_locale}")
+          end
+          nil
+        end
+
+      end # module InstanceMethods
+
+    end # module TranslatedColumns
+  end # module Translatable
+end # module ZLocalize
+
+
+
+

data/lib/zlocalize/rails/translation.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+class Translation < ActiveRecord::Base
+   belongs_to :translated, :polymorphic => true
+
+   def to_s
+     return self.value
+   end
+
+end

data/lib/zlocalize/rails/translation_validator.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+
+class TranslationValidator < ActiveModel::EachValidator
+
+  def evaluate_required_locales(locales,record,attr_name,value)
+    case locales
+      when Symbol then record.send(locales)
+      when Array  then locales
+      when String then [locales]
+      else
+         if locales.respond_to?("call")
+           locales.call(record,attr_name,value)
+         else
+            raise(
+              ActiveRecord::ActiveRecordError,
+              "Required locales need to be either an Array instance, a symbol/string (method to be called on the instance) " +
+              "or a proc/method that returns an Array of locale codes"
+            )
+         end
+    end
+  end
+
+  def validate_each(record,attr_name,value)
+    configuration = { :message => 'is missing its translation in {{locales}}',
+                      :required_locales => record.respond_to?(:get_required_locales) ? :get_required_locales : [] }
+    configuration.update(options)
+    locales = evaluate_required_locales(configuration[:required_locales],record,attr_name,value)
+    missing_locales = []
+    if locales.is_a?(Array)
+      locales.each do |loc|
+        begin
+          s = record.translate(attr_name,loc)
+        rescue ZLocalize::Translatable::TranslationError
+          s = nil
+        end
+        missing_locales << loc if s.blank?
+      end
+    end
+    if missing_locales.size > 0
+      record.errors.add(attr_name, configuration[:message], { :locales => missing_locales.to_sentence })
+    end
+  end
+
+end