lastobelus-merb_global 0.0.7 → 0.0.8

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/message_providers/mock.rb

@@ -0,0 +1,17 @@
+module Merb
+  module Global
+    module MessageProviders
+      class Mock #:nodoc:
+        include Merb::Global::MessageProviders::Base
+
+        def localize(singular, plural, n, locale)
+          n > 1 ? plural : singular
+        end
+
+        def create!
+          nil # It's mock after all ;)
+        end
+      end
+    end
+  end
+end

data/lib/merb_global/message_providers/sequel.rb

@@ -0,0 +1,99 @@
+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, n, locale)
+          # I hope it's from MemCache
+          language = Language[:name => locale.to_s]
+          unless language.nil?
+            unless plural.nil?
+              pn = Plural.which_form n, language[:plural]
+              translation = Translation[language.pk, singular, pn]
+            else
+              translation = Translation[language.pk, singular, nil]
+            end
+            return translation[:msgstr] unless translation.nil?
+          end
+          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 = {}
+          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)
+          set_primary_key :id
+          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,92 @@
+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, n, locale)
+          unless Merb.environment == "development"
+            lang = @lang
+          else
+            lang = {}
+          end
+          
+          unless lang.include? locale
+            file = File.join Merb::Global::MessageProviders.localedir,
+                             locale.to_s + '.yaml'
+            if File.exist? file
+              lang[locale] = YAML.load_file file
+            else
+              # TODO: Check if it not opens security risk
+              lang[locale] = nil
+            end
+          end
+
+          unless lang[locale].nil?
+            lang = lang[locale]
+            unless lang[singular].nil?
+              unless plural.nil?
+                n = Merb::Global::Plural.which_form n, lang[:plural]
+                return lang[singular][n] unless lang[singular][n].nil?
+              else
+                return lang[singular] unless lang[singular].nil?
+              end
+            end
+          end
+          return n > 1 ? plural : singular
+        end
+
+        def create!
+          FileUtils.mkdir_p Merb::Global::MessageProviders.localedir
+        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,146 @@
+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-backed
+      # 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 between 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 implementor.
+        #
+        # 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)
+        # n<Fixnum>:: A number of objects
+        # locale<Locale>:: A locale to which translate
+        #
+        # ==== Returns
+        # translated<String>:: A translated string
+        #
+        # ==== Raises
+        # NoMethodError:: Raised by default implementation. Should not be thrown.
+        def localize(singular, plural, n, locale)
+          raise NoMethodError.new('method localize 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
+        ##
+        # 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.to_s)
+            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/java.rb

@@ -0,0 +1,15 @@
+require 'java'
+
+module Merb
+  module Global
+    module NumericProviders
+      class Java
+        include Merb::Global::DateProviders::Base
+
+        def localize(locale, number)
+          java.text.NumberFormat.instance(locale).format(number)
+        end
+      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

data/lib/merb_global/plural.rb

@@ -0,0 +1,20 @@
+require 'treetop'
+
+module Merb
+  module Global
+    module Plural
+      path = (Pathname.new(__FILE__).dirname.expand_path + 'plural')
+      @parser = Treetop.load(path.to_s).new
+
+      # Returns which form should be returned
+      # ==== Parameters
+      # n<Fixnum>:: A number of elements
+      # plural<String>:: Expression
+      # ==== Returns
+      # Fixnum:: Which form should be translated
+      def self.which_form(n, plural)
+        @parser.parse(plural).to_lambda.call(n)
+      end
+    end
+  end
+end