lastobelus-merb_global 0.0.7 → 0.0.8

data/lib/merb_global/controller.rb

@@ -0,0 +1,38 @@
+require 'merb_global/base'
+
+module Merb
+  class Controller
+    include Merb::Global
+
+    class_inheritable_accessor :_mg_locale
+
+    before do
+      # Set up the language
+      accept_language = self.request.env['HTTP_ACCEPT_LANGUAGE']
+      Merb::Global::Locale.current =
+        Merb::Global::Locale.new(params[:locale]) ||
+        (self._mg_locale &&
+         Merb::Global::Locale.new(self.instance_eval(&self._mg_locale))) ||
+         Merb::Global::Locale.from_accept_language(accept_language) || 
+         Merb::Global::Locale.new('en')
+    end
+
+    # Sets the language of block.
+    #
+    # The block should return language or nil if other method should be used
+    # to determine the language
+    #
+    # Please note that this method is deprecated and the preferred method is
+    # locale.
+    def self.language(&block)
+      self._mg_locale = block
+    end
+    # Sets the language of block.
+    #
+    # The block should return language or nil if other method should be used
+    # to determine the language
+    def self.locale(&block)
+      self._mg_locale = block
+    end
+  end
+end

data/lib/merb_global/date_providers/fork.rb

@@ -0,0 +1,35 @@
+require 'inline'
+
+module Merb
+  module Global
+    module DateProviders
+      class Fork
+        include Merb::Global::DateProviders::Base
+
+        def localize(lang, date, format)
+          pipe_rd, pipe_wr = IO.pipe
+          pid = fork do
+            pipe_rd.close
+            setlocale(lang.to_s)
+            pipe_wr.write(date.strftime(format))
+            pipe_wr.flush
+          end
+          pipe_wr.close
+          Process.wait(pid)
+          pipe_rd.read
+        end
+
+        inline do |builder|
+          builder.include '<locale.h>'
+          builder.c <<C
+void set_locale(const char *locale)
+{
+  setlocale(LC_ALL, locale);
+}
+C
+        end
+        private :set_locale
+      end
+    end
+  end
+end

data/lib/merb_global/date_providers.rb

@@ -0,0 +1,47 @@
+require 'merb_global/providers'
+
+module Merb
+  module Global
+    module DateProviders
+      include Providers
+      # call-seq:
+      #     provider => provider
+      #
+      # Returns the provider of required type
+      #
+      # ==== Returns
+      # provider<Provider>:: Returns provider
+      def self.provider
+        @@provider ||= self[Merb::Global.config(:date_provider, 'fork')]
+      end
+      # Merb-global is able to handle localization in different ways.
+      # Providers are the interface.
+      #
+      # Please note that it is not required to include this module - despite it
+      # is recomended both as a documentation part and the more customized
+      # error messages.
+      module Base
+        ##
+        # 
+        # Localize date using format as in strftime
+        def localize(lang, date, format)
+          raise NoMethodError.new('method localize has not been implemented')
+        end
+      end
+    end
+    # Perform the registration
+    #
+    # ==== Parameters
+    # name<~to_sym>:: Name under which it is registered
+    def self.DateProvider(provider_name)
+      Module.new do
+        @@rb_date_provider_name = provider_name
+        include Merb::Global::DateProviders::Base
+        
+        def self.included(klass)
+          Merb::Global::DateProviders.register @@rb_date_provider_name, klass
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/locale.rb

@@ -0,0 +1,139 @@
+require 'merb_global/base'
+require 'thread'
+require 'weakref'
+
+class Thread
+  attr_accessor :mg_locale
+end
+
+module Merb
+  module Global
+    class Locale
+      attr_reader :language, :country
+
+      def initialize(name)
+        # TODO: Understand RFC 1766 fully
+        @language, @country = name.split('-')
+      end
+
+      def any?
+        language == '*' && country.nil?
+      end
+
+      def base_locale
+        if not @country.nil?
+          Locale.new(@language)
+        else
+          nil
+        end
+      end
+
+      def to_s
+        if country.nil?
+          "#{@language.downcase}"
+        else
+          "#{@language.downcase}_#{@country.upcase}"
+        end
+      end
+
+      if defined? RUBY_ENGINE and RUBY_ENGINE == "jruby"
+        def java_locale
+          require 'java'
+          @java_locale ||=
+            if @country.nil?
+              java.util.Locale.new(@language.downcase)
+            else
+              java.util.Locale.new(@language.downcase, @country.upcase)
+            end
+        end
+      else
+        def java_locale
+          nil
+        end
+      end
+      
+      def self.parse(header)
+        header = header.split(',')
+        header.collect! {|lang| lang.delete ' ' "\n" "\r" "\t"}
+        header.reject! {|lang| lang.empty?}
+        header.collect! {|lang| lang.split ';q='}
+        header.collect! do |lang|
+          if lang.size == 1
+            [lang[0], 1.0]
+          else
+            [lang[0], lang[1].to_f]
+          end
+        end
+        header.sort! {|lang_a, lang_b| lang_b[1] <=> lang_a[1]} # sorting by decreasing quality
+        header.collect! {|lang| Locale.new(lang[0])}
+      end
+
+      def self.from_accept_language(accept_language)
+        unless accept_language.nil?
+          accept_language = Merb::Global::Locale.parse(accept_language)
+          accept_language.each_with_index do |lang, i|
+            if lang.any?
+              # In this case we need to choose a locale that is not in accept_language[i+1..-1]
+              return Merb::Global::Locale.choose(accept_language[i+1..-1])
+            elsif Merb::Global::Locale.support? lang
+              return lang
+            end
+            lang = lang.base_locale
+            return lang if lang && Merb::Global::Locale.support?(lang)
+          end
+        end
+      end
+
+      def self.current
+        Thread.current.mg_locale
+      end
+
+      def self.current=(new_locale)
+        Thread.current.mg_locale = new_locale
+      end
+
+      class << self
+        alias_method :pure_new, :new
+        private :pure_new
+      end
+
+      @@current = {}
+      @@current_mutex = Mutex.new
+      # Create new locale object and returns it.
+      # 
+      # Please note that this method is cached.
+      def self.new(name)
+        return nil if name.nil?
+        return name if name.is_a? Locale
+        @@current_mutex.synchronize do
+          begin
+            n = @@current[name]
+            if n.nil?
+              n = pure_new(name)
+              @@current[name] = WeakRef.new(n)
+            else
+              n = n.__getobj__
+            end
+            n
+          rescue WeakRef::RefError
+            n = pure_new(name)
+            @@current[name] = WeakRef.new(n)
+            n
+          end
+        end
+      end
+
+      def self.support?(locale)
+        supported_locales.include? locale.to_s
+      end
+      
+      def self.supported_locales
+        Merb::Global::config('locales', ['en'])
+      end
+      
+      def self.choose(except)
+        new((supported_locales - except.map{|e| e.to_s}).first)
+      end
+    end
+  end
+end

data/lib/merb_global/merbrake.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+
+namespace :merb_global do
+
+  task :merb_start do
+    Merb.start_environment :adapter => 'runner',
+                           :environment => ENV['MERB_ENV'] || 'development'
+  end
+
+  desc 'Create migration'
+  task :migration => :merb_start do
+    Merb::Global::MessageProviders.provider.create!
+  end
+
+  desc 'Transfer the translations from one provider to another'
+  task :transfer => :merb_start do
+    from = Merb::Global.config 'source', 'gettext'
+    into = Merb::Global.config 'provider', 'gettext'
+    if from == 'gettext' and into == 'gettext'
+      Dir[Merb::Global::MessageProviders.localedir + '/*.po'].each do |file|
+        lang = File.basename file, '.po'
+        lang_dir = File.join(Merb::Global::MessageProviders.localedir,
+                             lang, 'LC_MESSAGES')
+        FileUtils.mkdir_p lang_dir
+        domain = Merb::Global.config([:gettext, :domain], 'merbapp')
+        `msgfmt #{file} -o #{lang_dir}/#{domain}.mo`
+      end
+    elsif from == into
+      Merb.logger.error 'Tried transfer from and into the same provider'
+    else
+      from = Merb::Global::MessageProviders[from]
+      into = Merb::Global::MessageProviders[into]
+      Merb::Global::Provider.transfer from, into
+    end
+  end
+
+end

data/lib/merb_global/message_providers/active_record.rb

@@ -0,0 +1,113 @@
+require 'activerecord'
+# As far as I understand, we need it to have composite keys.
+# However it may be better idea to drop them.
+# So far I implement it in this way - then we will see
+require 'composite_primary_keys' # As far as I understand we need
+require 'merb_global/plural'
+
+module Merb
+  module Global
+    module MessageProviders
+      class ActiveRecord #:nodoc: all
+        include Merb::Global::MessageProviders::Base
+        include Merb::Global::MessageProviders::Base::Importer
+        include Merb::Global::MessageProviders::Base::Exporter
+
+        def localize(singular, plural, n, locale)
+          language = Language.find :first,
+                                   :conditions => {:name => locale.to_s}
+          unless language.nil?
+            unless plural.nil?
+              pn = Plural.which_form n, language.plural
+              translation = Translation.find [language.id, singular, pn]
+            else
+              # Bug of composite_primary_keys?
+              conditions = {
+                :language_id  => language.id,
+                :msgid => singular,
+                :msgstr_index => nil
+              }
+              translation = Translation.find(:first, conditions)
+            end
+            return translation.msgstr
+          end rescue nil
+          return n > 1 ? plural : singular # Fallback if not in database
+        end
+
+        def create!
+          migration_exists = Dir[File.join(Merb.root, 'schema',
+                                           'migrations', '*.rb')].detect do |f|
+            f =~ /translations\.rb/
+          end
+          if migration_exists
+            puts "\nThe Translation Migration File already exists\n\n"
+          else
+            sh %{merb-gen translations_migration}
+          end
+        end
+
+        def import
+          data = {}
+          Language.transaction do
+            Translation.transaction do
+              Language.find(:all).each do |lang|
+                data[lang.name] = lang_hash = {
+                  :plural => lang.plural,
+                  :nplural => lang.nplural
+                }
+                lang.translations.each do |translation|
+                  lang_hash[translation.msgid] ||= {
+                    :plural => translation.msgid_plural
+                  }
+                  lang_hash[translation.msgid][translation.msgstr_index] =
+                    translation.msgstr
+                end
+              end
+            end
+          end
+          data
+        end
+
+        def export(data)
+          Language.transaction do
+            Translation.transaction do
+              Translation.delete_all
+              Language.delete_all
+              data.each do |lang_name, lang|
+                lang_id = Language.create!(:name => lang_name,
+                                           :plural => lang[:plural],
+                                           :nplural => lang[:nplural]).id
+                lang.each do |msgid, msgstrs|
+                  if msgid.is_a? String
+                    plural = msgstrs[:plural]
+                    msgstrs.each do |index, msgstr|
+                      if index.nil? or index.is_a? Fixnum
+                        Translation.create! :language_id => lang_id,
+                                            :msgid => msgid,
+                                            :msgid_plural => plural,
+                                            :msgstr => msgstr,
+                                            :msgstr_index => index
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        class Language < ::ActiveRecord::Base
+          set_table_name :merb_global_languages
+          has_many :translations,
+            :class_name =>
+              "::Merb::Global::MessageProviders::ActiveRecord::Translation"
+        end
+
+        class Translation < ::ActiveRecord::Base
+          set_table_name :merb_global_translations
+          set_primary_keys :language_id, :msgid, :msgstr_index
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/message_providers/data_mapper.rb

@@ -0,0 +1,113 @@
+require 'dm-core'
+require 'dm-aggregates'
+require 'merb_global/plural'
+
+module Merb
+  module Global
+    module MessageProviders
+      class DataMapper #:nodoc: all
+        include Merb::Global::MessageProviders
+        include Merb::Global::MessageProviders::Base::Importer
+        include Merb::Global::MessageProviders::Base::Exporter
+
+        def localize(singular, plural, n, locale)
+          # I hope it's from MemCache
+          language = Language.first :name => locale.to_s
+          unless language.nil?
+            unless plural.nil?
+              pn = Plural.which_form n, language.plural
+              translation = Translation.first :language_id => language.id,
+                                              :msgid => singular,
+                                              :msgstr_index => pn
+            else
+              translation = Translation.first :language_id => language.id,
+                                              :msgid => singular,
+                                              :msgstr_index => nil
+            end
+            return translation.msgstr unless translation.nil?
+          end
+          # Fallback if not in database
+          return n != 1 ? plural : singular
+        end
+
+        def create!
+          Language.auto_migrate!
+          Translation.auto_migrate!
+        end
+
+        def import
+          data = {}
+          ::DataMapper::Transaction.new(Language, Translation) do
+            Language.all.each do |language|
+              data[language.name] = lang_hash = {
+                :plural => language.plural,
+                :nplural => language.nplural
+              }
+              language.translations(:fields => Translation.properties.to_a).
+                       each do |translation|
+                lang_hash[translation.msgid] ||= {
+                  :plural => translation.msgid_plural
+                }
+                lang_hash[translation.msgid][translation.msgstr_index] =
+                  translation.msgstr
+              end
+            end
+          end
+          data
+        end
+
+        def export(data)
+          ::DataMapper::Transaction.new(Language, Translation) do
+            Translation.all.each {|translation| translation.destroy}
+            Language.all.each {|language| language.destroy}
+            data.each do |lang_name, lang|
+              lang_obj = Language.create!(:name => lang_name,
+                                          :plural => lang[:plural],
+                                          :nplural => lang[:nplural])
+              lang.each do |msgid, msgstr_hash|
+                if msgstr_hash.is_a? Hash
+                  plural = msgstr_hash[:plural]
+                  msgstr_hash.each do |msgstr_index, msgstr|
+                    if msgstr_index.nil? or msgstr_index.is_a? Fixnum
+                      Translation.create!(:language_id => lang_obj.id,
+                                          :msgid => msgid,
+                                          :msgid_plural => plural,
+                                          :msgstr => msgstr,
+                                          :msgstr_index => msgstr_index) or
+                                                                          raise
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # When table structure becomes stable it *should* be documented
+        class Language
+          include ::DataMapper::Resource
+          storage_names[:default] = 'merb_global_languages'
+          property :id, Integer, :serial => true
+          property :name, String, :unique_index => true
+          property :nplural, Integer
+          property :plural, Text, :lazy => false
+          # validates_is_unique :name
+          has n, :translations,
+            :class_name => "Merb::Global::MessageProviders::DataMapper::Translation",
+            :child_key => [:language_id]
+        end
+
+        class Translation
+          include ::DataMapper::Resource
+          storage_names[:default] = 'merb_global_translations'
+          property :language_id, Integer, :nullable => false, :key => true
+          property :msgid, Text, :nullable => false, :key => true
+          property :msgid_plural, Text, :lazy => true
+          property :msgstr, Text, :nullable => false, :lazy => false
+          property :msgstr_index, Integer, :nullable => true, :key => true
+          belongs_to :language, :class_name =>  Language.name
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/message_providers/gettext.rb

@@ -0,0 +1,123 @@
+require 'gettext'
+require 'treetop'
+require 'pathname'
+
+class Merb::Global::Locale #:nodoc:
+  def _mg_gettext
+    @mg_gettext ||= Merb::Global::MessageProviders::Gettext::GettextContext.new
+  end
+end
+
+module Merb
+  module Global
+    module MessageProviders
+      class Gettext #:nodoc: all
+        include Merb::Global::MessageProviders::Base
+        include Merb::Global::MessageProviders::Base::Importer
+        include Merb::Global::MessageProviders::Base::Exporter
+
+        def localize(singular, plural, n, locale)
+          context = locale._mg_gettext
+          context.set_locale locale.to_s, true
+          unless plural.nil?
+            context.ngettext singular, plural, n
+          else
+            context.gettext singular
+          end
+        end
+
+        def create!
+          File.mkdirs Merb::Global::MessageProviders.localedir
+        end
+
+        def import
+          Treetop.load(Pathname(__FILE__).dirname.expand_path.to_s +
+                       '/gettext')
+          parser = Merb::Global::MessageProviders::GetTextParser.new
+          data = {}
+          Dir[Merb::Global::MessageProviders.localedir +
+              '/*.po'].each do |file|
+            lang_name = File.basename file, '.po'
+            lang_tree = nil
+            open file do |f|
+              lang_tree = parser.parse f.read
+            end
+            # Put the parsed file in data
+            data[lang_name] = lang_tree.to_hash
+            # Remove the metadata to futher managing
+            opts = data[lang_name].delete('')[nil].split("\n")
+            # Find the line about plural line
+            plural_line = nil
+            for l in opts
+              if l[0..."Plural-Forms:".length] == "Plural-Forms:"
+                plural_line = l
+                break
+              end
+            end
+            # Remove the "Plural-Forms:" from the beginning...
+            plural_line =
+              plural_line["Plural-Forms:".length...plural_line.length]
+            # and ; from end
+            plural_line = plural_line[0...plural_line.length-1]
+            # Split the line and build the hash
+            plural_line = plural_line.gsub(/[[:space:]]/, '').split(/[=;]/, 4)
+            # And change the plural and nplurals into :plural and :nplurals
+            plural_line[2] = :plural
+            plural_line[0] = :nplural
+            # Adn the nplural value into integer
+            plural_line[1] = plural_line[1].to_i
+            data[lang_name].merge! Hash[*plural_line]
+          end
+          data
+        end
+
+        def export(data)
+          data.each do |lang_name, lang|
+            lang_file = File.join(Merb::Global::MessageProviders.localedir,
+                                  lang_name + '.po')
+            open(lang_file, 'w') do |po|
+              po.puts <<EOF
+msgid ""
+msgstr ""
+"Project-Id-Version: 0.0.1\\n"
+"POT-Creation-Date: #{Time.now.strftime('%Y-%m-%d %H:%M%z')}\\n"
+"PO-Revision-Date: #{Time.now.strftime('%Y-%m-%d %H:%M%z')}\\n"
+"Last-Translator:  <user@example.com>\\n"
+"Language-Team: Language type\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=UTF-8\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+"Plural-Forms: nplurals=#{lang[:nplurals]}; plural=#{lang[:plural]}\\n"
+EOF
+              
+              lang.each do |msgid, msgstr_hash|
+                po.puts ""
+                po.puts "msgid \"#{msgid}\""
+                if msgstr_hash[:plural]
+                  po.puts "msgid_plural \"#{msgstr_hash[:plural]}\""
+                  msgstr_hash.each do |msgstr_index, msgstr|
+                    po.puts "msgstr[#{msgstr_index}] \"#{msgstr}\""
+                  end
+                else
+                  po.puts "msgstr \"#{msgstr_hash[nil]}\""
+                end
+              end
+            end
+            lang_dir = File.join(Merb::Global::MessageProviders.localedir,
+                                 lang, 'LC_MESSAGES')
+            FileUtils.mkdir_p lang_dir
+            domain = Merb::Global.config([:gettext, :domain], 'merbapp')
+            `msgfmt #{lang_file} -o #{lang_dir}/#{domain}.mo`
+          end
+        end
+
+        class GettextContext
+          include ::GetText
+          bindtextdomain Merb::Global.config([:gettext, :domain], 'merbapp'),
+                         Merb::Global::MessageProviders.localedir
+          public :set_locale, :ngettext, :gettext
+        end
+      end
+    end
+  end
+end