nulogy-gettext_i18n_rails 0.4.6.1

data/init.rb

@@ -0,0 +1,14 @@
+begin
+  require 'config/initializers/session_store'
+rescue LoadError
+  # weird bug, when run with rake rails reports error that session
+  # store is not configured, this fixes it somewhat...
+end
+
+if Rails::VERSION::MAJOR > 2
+  require 'gettext_i18n_rails'
+else
+  #requires fast_gettext to be present.
+  #We give rails a chance to install it using rake gems:install, by loading it later.
+  config.after_initialize { require 'gettext_i18n_rails' }
+end

data/lib/gettext_i18n_rails.rb

@@ -0,0 +1,33 @@
+module GettextI18nRails
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+  
+  extend self
+end
+
+require 'fast_gettext'
+if Gem::Version.new(FastGettext::VERSION) < Gem::Version.new("0.4.8")
+  raise "Please upgrade fast_gettext"
+end
+
+# include translations into all the places it needs to go...
+Object.send(:include, FastGettext::Translation)
+
+# make translations html_safe if possible and wanted
+if "".respond_to?(:html_safe?)
+  require 'gettext_i18n_rails/html_safe_translations'
+  Object.send(:include, GettextI18nRails::HtmlSafeTranslations)
+end
+
+require 'gettext_i18n_rails/backend'
+I18n.backend = GettextI18nRails::Backend.new
+
+require 'gettext_i18n_rails/i18n_hacks'
+
+require 'gettext_i18n_rails/active_record'
+# If configuration via Railties is not available force activerecord extensions
+if not defined?(Rails::Railtie) and defined?(ActiveRecord)
+  ActiveRecord::Base.extend GettextI18nRails::ActiveRecord
+end
+
+require 'gettext_i18n_rails/action_controller' if defined?(ActionController) # so that bundle console can work in a rails project
+require 'gettext_i18n_rails/railtie'

data/lib/gettext_i18n_rails/action_controller.rb

@@ -0,0 +1,8 @@
+class ActionController::Base
+  def set_gettext_locale
+    requested_locale = params[:locale] || session[:locale] || cookies[:locale] ||  request.env['HTTP_ACCEPT_LANGUAGE'] || I18n.default_locale
+    locale = FastGettext.set_locale(requested_locale)
+    session[:locale] = locale
+    I18n.locale = locale # some weird overwriting in action-controller makes this necessary ... see I18nProxy
+  end
+end

data/lib/gettext_i18n_rails/active_record.rb

@@ -0,0 +1,19 @@
+module GettextI18nRails::ActiveRecord
+  # CarDealer.sales_count -> s_('CarDealer|Sales count') -> 'Sales count' if no translation was found
+  def human_attribute_name(attribute, *args)
+    s_(gettext_translation_for_attribute_name(attribute))
+  end
+
+  # CarDealer -> _('car dealer')
+  def human_name(*args)
+    _(self.human_name_without_translation)
+  end
+
+  def human_name_without_translation
+    self.to_s.underscore.gsub('_',' ')
+  end
+
+  def gettext_translation_for_attribute_name(attribute)
+    "#{self}|#{attribute.to_s.split('.').map! {|a| a.humanize }.join('|')}"
+  end
+end

data/lib/gettext_i18n_rails/backend.rb

@@ -0,0 +1,67 @@
+module GettextI18nRails
+  #translates i18n calls to gettext calls
+  class Backend
+    @@translate_defaults = true
+    cattr_accessor :translate_defaults
+    attr_accessor :backend
+
+    def initialize(*args)
+      self.backend = I18n::Backend::Simple.new(*args)
+    end
+
+    def available_locales
+      FastGettext.available_locales || []
+    end
+
+    def translate(locale, key, options)
+      if gettext_key = gettext_key(key, options)
+        translation = FastGettext._(gettext_key)
+        interpolate(translation, options)
+      else
+        backend.translate locale, key, options
+      end
+    end
+
+    def method_missing(method, *args)
+      backend.send(method, *args)
+    end
+
+    protected
+
+    def gettext_key(key, options)
+      flat_key = flatten_key key, options
+      if FastGettext.key_exist?(flat_key)
+        flat_key
+      elsif self.class.translate_defaults
+        [*options[:default]].each do |default|
+          #try the scoped(more specific) key first e.g. 'activerecord.errors.my custom message'
+          flat_key = flatten_key default, options
+          return flat_key if FastGettext.key_exist?(flat_key)
+
+          #try the short key thereafter e.g. 'my custom message'
+          return default if FastGettext.key_exist?(default)
+        end
+        return nil
+      end
+    end
+
+    def interpolate(string, values)
+      if string.respond_to?(:%)
+        reserved_keys = if defined?(I18n::RESERVED_KEYS) # rails 3+
+          I18n::RESERVED_KEYS
+        else
+          I18n::Backend::Base::RESERVED_KEYS
+        end
+
+        string % values.except(*reserved_keys)
+      else
+        string
+      end
+    end
+
+    def flatten_key key, options
+      scope = [*(options[:scope] || [])]
+      scope.empty? ? key.to_s : "#{scope*'.'}.#{key}"
+    end
+  end
+end

data/lib/gettext_i18n_rails/base_parser.rb

@@ -0,0 +1,41 @@
+require 'gettext/utils'
+begin
+  require 'gettext/tools/rgettext'
+rescue LoadError #version prior to 2.0
+  require 'gettext/rgettext'
+end
+
+module GettextI18nRails
+  class BaseParser
+    def self.target?(file)
+      File.extname(file) == ".#{extension}"
+    end
+
+    def self.parse(file, msgids = [])
+      return msgids unless load_library
+      code = convert_to_code(File.read(file))
+      RubyGettextExtractor.parse_string(code, file, msgids)
+    rescue Racc::ParseError => e
+      $stderr.puts "file ignored: ruby_parser cannot read #{extension} files with 1.9 syntax --- (#{e.message})"
+      return msgids
+    end
+
+    def self.load_library
+      return true if @library_loaded
+
+      begin
+        require "#{::Rails.root.to_s}/vendor/plugins/#{extension}/lib/#{extension}"
+      rescue LoadError
+        begin
+          require extension # From gem
+        rescue LoadError
+          puts "A #{extension} file was found, but #{extension} library could not be found, so nothing will be parsed..."
+          return false
+        end
+      end
+
+      require 'gettext_i18n_rails/ruby_gettext_extractor'
+      @library_loaded = true
+    end
+  end
+end

data/lib/gettext_i18n_rails/haml_parser.rb

@@ -0,0 +1,15 @@
+require 'gettext_i18n_rails/base_parser'
+
+module GettextI18nRails
+  class HamlParser < BaseParser
+    def self.extension
+      "haml"
+    end
+
+    def self.convert_to_code(text)
+      Haml::Engine.new(text).precompiled()
+    end
+  end
+end
+
+GetText::RGetText.add_parser(GettextI18nRails::HamlParser)

data/lib/gettext_i18n_rails/hamlet_parser.rb

@@ -0,0 +1,16 @@
+require 'gettext_i18n_rails/base_parser'
+
+module GettextI18nRails
+  class HamletParser < BaseParser
+    def self.extension
+      "hamlet"
+    end
+
+    def self.convert_to_code(text)
+      Hamlet::Engine.new.call(text)
+    end
+  end
+end
+
+GetText::RGetText.add_parser(GettextI18nRails::HamletParser)
+

data/lib/gettext_i18n_rails/html_safe_translations.rb

@@ -0,0 +1,29 @@
+module GettextI18nRails
+  mattr_accessor :translations_are_html_safe
+
+  module HtmlSafeTranslations
+    # also make available on class methods
+    def self.included(base)
+      base.extend self
+    end
+
+    def _(*args)
+      html_safe_if_wanted super
+    end
+
+    def n_(*args)
+      html_safe_if_wanted super
+    end
+
+    def s_(*args)
+      html_safe_if_wanted super
+    end
+
+    private
+
+    def html_safe_if_wanted(text)
+      return text unless GettextI18nRails.translations_are_html_safe
+      text.to_s.html_safe
+    end
+  end
+end

data/lib/gettext_i18n_rails/i18n_hacks.rb

@@ -0,0 +1,25 @@
+I18n::Config # autoload
+
+module I18n
+  class Config
+    def locale
+      FastGettext.locale.to_sym
+    end
+
+     def locale=(new_locale)
+      FastGettext.locale=(new_locale)
+    end
+  end
+
+  # backport I18n.with_locale if it does not exist
+  # Executes block with given I18n.locale set.
+  def self.with_locale(tmp_locale = nil)
+    if tmp_locale
+      current_locale = self.locale
+      self.locale = tmp_locale
+    end
+    yield
+  ensure
+    self.locale = current_locale if tmp_locale
+  end unless defined? I18n.with_locale
+end

data/lib/gettext_i18n_rails/model_attributes_finder.rb

@@ -0,0 +1,108 @@
+module GettextI18nRails
+  #write all found models/columns to a file where GetTexts ruby parser can find them
+  def store_model_attributes(options)
+    file = options[:to] || 'locale/model_attributes.rb'
+    begin
+      File.open(file,'w') do |f|
+        f.puts "#DO NOT MODIFY! AUTOMATICALLY GENERATED FILE!"
+        ModelAttributesFinder.new.find(options).each do |table_name,column_names|
+          #model name
+          model = table_name_to_namespaced_model(table_name)
+          if model == nil
+            # Some tables are not models, for example: translation tables created by globalize2.
+            puts "[Warning] Model not found for table '#{table_name}'"
+            next
+          end
+          f.puts("_('#{model.human_name_without_translation}')")
+
+          #all columns namespaced under the model
+          column_names.each do |attribute|
+            translation = model.gettext_translation_for_attribute_name(attribute)
+            f.puts("_('#{translation}')")
+          end
+        end
+        f.puts "#DO NOT MODIFY! AUTOMATICALLY GENERATED FILE!"
+      end
+    rescue
+      puts "[Error] Attribute extraction failed. Removing incomplete file (#{file})"
+      File.delete(file)
+      raise
+    end
+  end
+  module_function :store_model_attributes
+
+  class ModelAttributesFinder
+    # options:
+    #   :ignore_tables => ['cars',/_settings$/,...]
+    #   :ignore_columns => ['id',/_id$/,...]
+    # current connection ---> {'cars'=>['model_name','type'],...}
+    def find(options)
+      found = Hash.new([])
+
+      connection = ::ActiveRecord::Base.connection
+      connection.tables.each do |table_name|
+        next if ignored?(table_name,options[:ignore_tables])
+        connection.columns(table_name).each do |column|
+          found[table_name] += [column.name] unless ignored?(column.name,options[:ignore_columns])
+        end
+      end
+
+      found
+    end
+
+    def ignored?(name,patterns)
+      return false unless patterns
+      patterns.detect{|p|p.to_s==name.to_s or (p.is_a?(Regexp) and name=~p)}
+    end
+  end
+
+private
+  # Tries to find the model class corresponding to specified table name.
+  # Takes into account that the model can be defined in a namespace.
+  # Searches only up to one level deep - won't find models nested in two
+  # or more modules.
+  #
+  # Note that if we allow namespaces, the conversion can be ambiguous, i.e.
+  # if the table is named "aa_bb_cc" and AaBbCc, Aa::BbCc and AaBb::Cc are
+  # all defined there's no absolute rule that tells us which one to use.
+  # This method prefers the less nested one and, if there are two at
+  # the same level, the one with shorter module name.
+  def table_name_to_namespaced_model(table_name)
+    # First assume that there are no namespaces
+    model = to_class(table_name.singularize.camelcase)
+    return model if model != nil
+
+    # If you were wrong, assume that the model is in a namespace.
+    # Iterate over the underscores and try to substitute each of them
+    # for a slash that camelcase() replaces with the scope operator (::).
+    underscore_position = table_name.index('_')
+    while underscore_position != nil
+      namespaced_table_name = table_name.dup
+      namespaced_table_name[underscore_position] = '/'
+      model = to_class(namespaced_table_name.singularize.camelcase)
+      return model if model != nil
+
+      underscore_position = table_name.index('_', underscore_position + 1)
+    end
+
+    # The model either is not defined or is buried more than one level
+    # deep in a module hierarchy
+    return nil
+  end
+
+  # Checks if there is a class of specified name and if so, returns
+  # the class object. Otherwise returns nil.
+  def to_class(name)
+    # I wanted to use Module.const_defined?() here to avoid relying
+    # on exceptions for normal program flow but it's of no use.
+    # If class autoloading is enabled, the constant may be undefined
+    # but turn out to be present when we actually try to use it.
+    begin
+      constant = name.constantize
+    rescue NameError
+      return nil
+    end
+
+    return constant.is_a?(Class) ? constant : nil
+  end
+end

data/lib/gettext_i18n_rails/railtie.rb

@@ -0,0 +1,22 @@
+# add rake tasks if we are inside Rails
+if defined?(Rails::Railtie)
+  module GettextI18nRails
+    class Railtie < ::Rails::Railtie
+      config.gettext_i18n_rails = ActiveSupport::OrderedOptions.new
+      config.gettext_i18n_rails.msgmerge = %w[--sort-output --no-location --no-wrap]
+      config.gettext_i18n_rails.use_for_active_record_attributes = true
+
+      rake_tasks do
+        require 'gettext_i18n_rails/tasks'
+      end
+
+      config.after_initialize do |app|
+        if app.config.gettext_i18n_rails.use_for_active_record_attributes
+          ActiveSupport.on_load :active_record do
+            extend GettextI18nRails::ActiveRecord
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gettext_i18n_rails/ruby_gettext_extractor.rb

@@ -0,0 +1,144 @@
+# new ruby parser from retoo, that should help extracting "#{_('xxx')}", which is needed especially when parsing haml files
+#
+#!/usr/bin/ruby
+# parser/ruby.rb - look for gettext msg strings in ruby files
+
+require 'rubygems'
+require 'ruby_parser'
+
+begin
+  require 'gettext/tools/rgettext'
+rescue LoadError #version prior to 2.0
+  require 'gettext/rgettext'
+end
+
+module RubyGettextExtractor
+  extend self
+
+  def parse(file, targets = [])  # :nodoc:
+    content = File.read(file)
+    parse_string(content, file, targets)
+  end
+
+  def parse_string(content, file, targets=[])
+    # file is just for information in error messages
+    parser = Extractor.new(file, targets)
+    parser.run(content)
+  end
+
+  def target?(file)  # :nodoc:
+    return file =~ /\.rb$/
+  end
+
+  class Extractor < RubyParser
+    def initialize(filename, targets)
+      @filename = filename
+      @targets = Hash.new
+      @results = []
+
+      targets.each do |a|
+        k, v = a
+        # things go wrong if k already exists, but this
+        # should not happen (according to the gettext doc)
+        @targets[k] = a
+        @results << a
+      end
+
+      super()
+    end
+
+    def run(content)
+      # ruby parser has an ugly bug which causes that several \000's take
+      # ages to parse. This avoids this probelm by stripping them away (they probably wont appear in keys anyway)
+      # See bug report: http://rubyforge.org/tracker/index.php?func=detail&aid=26898&group_id=439&atid=1778
+      safe_content = content.gsub(/\\\d\d\d/, '')
+      self.parse(safe_content)
+      return @results
+    end
+
+    def extract_string(node)
+      if node.first == :str
+        return node.last
+      elsif node.first == :call
+        type, recv, meth, args = node
+
+        # node has to be in form of "string"+("other_string")
+        return nil unless recv && meth == :+
+
+        # descent recurrsivly to determine the 'receiver' of the string concatination
+        # "foo" + "bar" + baz" is
+        # ("foo".+("bar")).+("baz")
+        first_part = extract_string(recv)
+
+        if args.first == :arglist && args.size == 2
+          second_part = extract_string(args.last)
+
+          return nil if second_part.nil?
+
+          return first_part.to_s + second_part.to_s
+        else
+          raise "uuh?"
+        end
+      else
+        return nil
+      end
+    end
+
+    def extract_key(args, seperator)
+      key = nil
+      if args.size == 2
+        key = extract_string(args.value)
+      else
+        # this could be n_("aaa","aaa2",1)
+        # all strings arguemnts are extracted and joined with \004 or \000
+
+        arguments = args[1..(-1)]
+
+        res = []
+        arguments.each do |a|
+          str = extract_string(a)
+          # only add strings
+          res << str if str
+        end
+
+        return nil if res.empty?
+        key = res.join(seperator)
+      end
+
+      return nil unless key
+
+      key.gsub!("\n", '\n')
+      key.gsub!("\t", '\t')
+      key.gsub!("\0", '\0')
+
+      return key
+    end
+
+    def new_call recv, meth, args = nil
+      # we dont care if the method is called on a a object
+      if recv.nil?
+        if (meth == :_ || meth == :p_ || meth == :N_ || meth == :pgettext || meth == :s_)
+          key = extract_key(args, "\004")
+        elsif meth == :n_
+          key = extract_key(args, "\000")
+        else
+          # skip
+        end
+
+        if key
+          res = @targets[key]
+
+          unless res
+            res = [key]
+            @results << res
+            @targets[key] = res
+          end
+
+          res << "#{@filename}:#{lexer.lineno}"
+        end
+      end
+
+      super recv, meth, args
+    end
+  end
+end