merb_global 0.0.4.2 → 0.0.5

data/lib/merb_global/message_providers/gettext.rb

@@ -0,0 +1,138 @@
+require 'gettext'
+require 'treetop'
+require 'pathname'
+
+# I'm not sure if it is the correct way of doing it.
+# As far it seems to be simpler.
+class Thread #:nodoc:
+  def gettext_context
+    @gettext_context ||= 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, opts)
+          context = Thread.current.gettext_context
+          context.set_locale opts[:lang], true
+          unless plural.nil?
+            context.ngettext singular, plural, opts[:n]
+          else
+            context.gettext singular
+          end
+        end
+
+        def support?(lang)
+          lang == 'en' ||
+            File.exist?(File.join(Merb::Global::MessageProviders.localedir, lang))
+        end
+
+        def create!
+          File.mkdirs Merb::Global::MessageProviders.localedir
+        end
+
+        def choose(except)
+          dir = Dir[Merb::Global::MessageProviders.localedir + '/*/']
+          dir.collect! {|p| File.basename p}
+          dir << 'en'
+          dir.reject! {|lang| except.include? lang}
+          dir.first
+        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

data/lib/merb_global/message_providers/gettext.treetop

@@ -0,0 +1,60 @@
+module Merb
+  module Global
+    module MessageProviders
+      grammar GetText
+        rule po_file
+	      entry* {
+	        def to_hash
+            hash = {}
+	          elements.each {|entry| hash.merge! entry.to_hash}
+	          hash
+	        end
+	      }
+	      end
+
+        rule entry
+	        whitespaces*
+          "msgid" whitespaces msgid:strings
+          "msgstr" whitespaces msgstr:strings {
+           def to_hash
+	           {msgid.to_string => {:plural => nil, nil => msgstr.to_string}}
+	         end
+	        }
+	        /
+	        whitespaces*
+	        "msgid" whitespaces msgid:strings
+	        "msgid_plural" whitespaces msgid_plural:strings
+	        msgstrs:("msgstr[" number:[0-9]+ "]" whitespaces strings)+ {
+	          def to_hash
+	            hash = {:plural => msgid_plural.to_string}
+	            msgstrs.elements.each do |msgstr|
+		             hash[msgstr.number.text_value.to_i] = msgstr.strings.to_string
+	            end
+	            {msgid.to_string => hash}
+	          end
+	        }
+	      end
+
+	      rule strings
+          (string whitespaces?)+ {
+       	    def to_string
+	            elements.collect {|element| element.string.to_string}.join
+	          end
+	        }
+	      end
+
+       	rule string
+	        '"' content:((!'"' ('\"' / .))*) '"' {
+	          def to_string
+	            content.text_value.gsub(/\\n/, "\n")
+	          end
+	        }
+	      end
+
+        rule whitespaces
+          (" " / "\t" / "\n" / ('#' (!"\n" .)* "\n") )+
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/{providers → message_providers}/mock.rb

@@ -1,10 +1,10 @@
 module Merb
   module Global
-    module Providers
+    module MessageProviders
       class Mock #:nodoc:
-        include Merb::Global::Provider
-        
-        def translate_to(singular, plural, opts)
+        include Merb::Global::MessageProviders::Base
+
+        def localize(singular, plural, opts)
           opts[:n] > 1 ? plural : singular
         end
 

data/lib/merb_global/message_providers/sequel.rb

@@ -0,0 +1,105 @@
+require 'sequel'
+require 'merb_global/plural'
+
+module Merb
+  module Global
+    module MessageProviders
+      class Sequel #:nodoc: all
+        include Merb::Global::MessageProviders::Base
+        include Merb::Global::MessageProviders::Base::Importer
+        include Merb::Global::MessageProviders::Base::Exporter
+
+        def localize(singular, plural, opts)
+          language = Language[:name => opts[:lang]] # I hope it's from MemCache
+          unless language.nil?
+            unless plural.nil?
+              n = Plural.which_form opts[:n], language[:plural]
+              translation = Translation[language.pk, singular, n]
+            else
+              translation = Translation[language.pk, singular, nil]
+            end
+            return translation[:msgstr] unless translation.nil?
+          end
+          return opts[:n] > 1 ? plural : singular # Fallback if not in database
+        end
+
+        def support?(lang)
+          Language.filter(:name => lang).count != 0
+        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 choose(except)
+          Language.filter(~{:name => except}).first[:name]
+        end
+
+        def import
+          data = {}
+          DB.transaction do
+            Language.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
+          data
+        end
+
+        def export(data)
+          DB.transaction do
+            Language.delete_all
+            Translation.delete_all
+            data.each do |lang_name, lang|
+              lang_obj = Language.create(:name => lang_name,
+                                         :plural => lang[:plural],
+                                         :nplural => lang[:nplural]) or raise
+              lang_id = lang_obj[: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) or raise
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        class Language < ::Sequel::Model(:merb_global_languages)
+          has_many :translations,
+                   :class => "Merb::Global::MessageProviders::Sequel::Translation",
+                   :key => :language_id
+        end
+
+        class Translation < ::Sequel::Model(:merb_global_translations)
+          set_primary_key :language_id, :msgid, :msgstr_index
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/message_providers/yaml.rb

@@ -0,0 +1,101 @@
+require 'yaml'
+require 'fileutils'
+
+module Merb
+  module Global
+    module MessageProviders
+      class Yaml #:nodoc:
+        include Merb::Global::MessageProviders::Base
+        include Merb::Global::MessageProviders::Base::Importer
+        include Merb::Global::MessageProviders::Base::Exporter
+
+        def initialize
+          # Not synchronized - make GC do it's work (may be not optimal
+          # but I don't think that some problem will occure).
+          # Shouldn't it be sort of cache with some expiration limit?
+          @lang = Hash.new
+        end
+
+        def localize(singular, plural, opts)
+          unless @lang.include? opts[:lang]
+            file = File.join Merb::Global::MessageProviders.localedir,
+                             opts[:lang] + '.yaml'
+            if File.exist? file
+              @lang[opts[:lang]] = YAML.load_file file
+            else
+              @lang[opts[:lang]] = nil
+            end
+          end
+
+          unless @lang[opts[:lang]].nil?
+            lang = @lang[opts[:lang]]
+            unless lang[singular].nil?
+              unless plural.nil?
+                n = Merb::Global::Plural.which_form opts[:n], lang[:plural]
+                return lang[singular][n] unless lang[singular][n].nil?
+              else
+                return lang[singular] unless lang[singular].nil?
+              end
+            end
+          end
+          return opts[:n] > 1 ? plural : singular
+        end
+
+        def support?(lang)
+          unless @lang.include? lang
+            file = File.join Merb::Global::MessageProviders.localedir,
+                             lang + '.yaml'
+            @lang[lang] = YAML.load_file file if File.exist? file
+          end
+          not @lang[lang].nil?
+        end
+
+        def create!
+          FileUtils.mkdir_p Merb::Global::MessageProviders.localedir
+        end
+
+        def choose(except)
+          dir = Dir[Merb::Global::MessageProviders.localedir + '/*.yaml']
+          dir.collect! {|p| File.basename p, '.yaml'}
+          dir.reject! {|lang| except.include? lang}
+          dir.first
+        end
+
+        def import
+          data = {}
+          Dir[Merb::Global::MessageProviders.localedir +
+              '/*.yaml'].each do |file|
+            lang_name = File.basename file, '.yaml'
+            data[lang_name] = lang = YAML.load_file(file)
+            lang.each do |msgid, msgstr|
+              if msgstr.is_a? String and msgid.is_a? String
+                lang[msgid] = {nil => msgstr, :plural => nil}
+              end
+            end
+          end
+          data
+        end
+        
+        def export(data)
+          File.unlink *Dir[Merb::Global::MessageProviders.localedir +
+                           '/*.yaml']
+          data.each do |lang_name, lang_orig|
+            lang = {}
+            lang_orig.each do |msgid, msgstr_hash|
+              lang[msgid] = {}
+              msgstr_hash.each do |msgstr_index, msgstr|
+                if msgstr_index.nil?
+                  lang[msgid] = msgstr
+                else
+                  lang[msgid][msgstr_index] = msgstr
+                end
+              end
+            end
+            YAML.dump File.join(Merb::Global::MessageProviders.localedir,
+                                lang_name + '.yaml')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/message_providers.rb

@@ -0,0 +1,175 @@
+require 'merb_global/providers'
+
+module Merb
+  module Global
+    module MessageProviders
+      include Providers
+      # call-seq:
+      #     localedir => localdir
+      #
+      # Returns the directory where locales are stored for file-backended
+      # providers (such as gettext or yaml)
+      #
+      # ==== Returns
+      # localedir<String>>:: Directory where the locales are stored
+      def self.localedir
+        localedir =
+          if Merb::Global.config :flat
+            'locale'
+          else
+            Merb::Global.config :localedir, File.join('app', 'locale')
+          end
+        File.join Merb.root, localedir
+      end
+      # call-seq:
+      #     provider => provider
+      #
+      # Returns the provider of required type
+      #
+      # ==== Returns
+      # provider<Provider>:: Returns provider
+      def self.provider
+        @@provider ||= self[Merb::Global.config(:message_provider, 'gettext')]
+      end
+      # Merb-global is able to store the translations in different types of
+      # storage. An interface betwean merb-global and those storages are
+      # providers.
+      #
+      # 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
+        # call-seq:
+        #     localize(singular, plural, opts) => translated
+        #
+        # Translate string using specific provider.
+        # It should be overloaded by the implementator.
+        #
+        # Do not use this method directly - use Merb::Global._ instead
+        #
+        # ==== Parameters
+        # singular<String>:: A string to translate
+        # plural<String>:: A plural form of string (nil if only singular)
+        # opts<Hash>:: An options hash (see below)
+        #
+        # ==== Options (opts)
+        # :lang<String>:: A language to translate on
+        # :n<Fixnum>:: A number of objects
+        #
+        # ==== Returns
+        # translated<String>:: A translated string
+        #
+        # ==== Raises
+        # NoMethodError:: Raised by default implementation. Should not be thrown.
+        def localize(singular, plural, opts)
+          raise NoMethodError.new 'method localize has not been implemented'
+        end
+        # call-seq:
+        #     support?(lang) => supported
+        #
+        # Checks if the language is supported (i.e. if the translation exists).
+        #
+        # In normal merb app the language is checked automatically in controller
+        # so probably you don't have to use this method
+        #
+        # ==== Parameters
+        # lang<String>:: A code of language
+        #
+        # ==== Returns
+        # supported<Boolean>:: Is a program translated to this language
+        #
+        # ==== Raises
+        # NoMethodError:: Raised by default implementation.
+        #                 Should not be thrown.
+        def support?(lang)
+          raise NoMethodError.new('method support? has not been implemented')
+        end
+        # This method creates basic files and/or directory structures
+        # (for example it adds migration) needed for provider to work.
+        #
+        # It is called from Rakefile.
+        def create!
+          raise NoMethodError.new('method create! has not been implemented')
+        end
+        # This method choos an supported language except those form the list
+        # given. It may fallback to english if none language can be found
+        # which agree with those criteria
+        def choose(except)
+          raise NoMethodError.new('method choose has not been implemented')
+        end
+        ##
+        # Transfer data from importer into exporter
+        #
+        # ==== Parameters
+        # importer<Importer>:: The provider providing the information
+        # exporter<Exporter>:: The provider receiving the information
+        def self.transfer(importer, exporter)
+          exporter.export importer.import
+        end
+        ##
+        # Importer is a provider through which one can iterate.
+        # Therefore it is possible to import data from this source
+        module Importer
+          ##
+          # This method import the data into a specified format from source.
+          # The format is nearly dump of the current YAML format.
+          #
+          # ==== Returns
+          # data<~each>::   Data in the specified format.
+          #
+          # ==== Raises
+          # NoMethodError:: Raised by default implementation.
+          #                 Should not be thrown.
+          def import # TODO: Describe the format
+            raise NoMethodError.new('method import has not been implemented')
+          end
+        end
+        ##
+        # Some sources are not only read-only but one can write to them.
+        # The provider is exporter if it handles this sort of source.
+        module Exporter
+          ##
+          # The method export the data from specified format into destination
+          # The format is nearly dump of the current YAML format.
+          #
+          # ==== Parameters
+          # data<~each>::   Data in the specified format.
+          #
+          # ==== Raises
+          # NoMethodError:: Raised by default implementation.
+          #                 Should not be thrown.
+          def export(data) # TODO: Describe the format
+            raise NoMethodError.new('method import has not been implemented')
+          end
+        end
+      end
+    end
+    # Perform the registration
+    #
+    # ==== Parameters
+    # provider_name<~to_sym>:: Name under which it is registred
+    # opts<Array[Symbol]>:: Additional imformations
+    #
+    # ==== Options
+    # importer:: Can perform import
+    # exporter:: Can perform export
+    def self.MessageProvider(provider_name, *opts)
+      Module.new do
+        @@mg_message_provider_name = provider_name
+        
+        include Merb::Global::MessageProviders::Base
+        if opts.include? :importer
+          include Merb::Global::MessageProviders::Base::Importer
+        end
+        if opts.include? :exporter
+          include Merb::Global::MessageProviders::Base::Exporter
+        end
+        
+        def self.included(klass)
+          Merb::Global::MessageProviders.register @@mg_message_provider_name,
+                                                  klass
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/numeric_providers/fork.rb

@@ -0,0 +1,35 @@
+require 'inline'
+
+module Merb
+  module Global
+    module NumericProviders
+      class Fork
+        include Merb::Global::DateProviders::Base
+
+        def localize(lang, number)
+          pipe_rd, pipe_wr = IO.pipe
+          pid = fork do
+            pipe_rd.close
+            setlocale(lang)
+            pipe_wr.write(number)
+            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/numeric_providers.rb

@@ -0,0 +1,48 @@
+require 'merb_global/providers'
+
+module Merb
+  module Global
+    module NumericProviders
+      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(:numeric_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, number)
+          raise NoMethodError.new('method localize has not been implemented')
+        end
+      end
+    end
+    # Perform the registration
+    #
+    # ==== Parameters
+    # name<~to_sym>:: Name under which it is registred
+    def self.NumericProvider(provider_name)
+      Module.new do
+        @@rb_numeric_provider_name = provider_name
+        include Merb::Global::NumericProviders::Base
+        
+        def self.included(klass)
+          Merb::Global::NumericProviders.register @@rb_numeric_provider_name,
+                                                  klass
+        end
+      end
+    end
+  end
+end