fast_gettext 0.4.16

data/lib/fast_gettext/translation.rb

@@ -0,0 +1,53 @@
+module FastGettext
+  # this module should be included
+  # Responsibility:
+  #  - direct translation queries to the current repository
+  #  - handle untranslated values
+  #  - understand / enforce namespaces
+  #  - decide which plural form is used
+  module Translation
+    extend self
+
+    #make it usable in class definition, e.g.
+    # class Y
+    #   include FastGettext::Translation
+    #   @@x = _('y')
+    # end
+    def self.included(klas)  #:nodoc:
+      klas.extend self
+    end
+
+    def _(key)
+      FastGettext.cached_find(key) or key
+    end
+
+    #translate pluralized
+    # some languages have up to 4 plural forms...
+    # n_(singular, plural, plural form 2, ..., count)
+    # n_('apple','apples',3)
+    def n_(*keys)
+      count = keys.pop
+      translations = FastGettext.cached_plural_find *keys
+      selected = FastGettext.pluralisation_rule.call(count)
+      selected = selected ? 1 : 0 unless selected.is_a? Numeric #convert booleans to numbers
+      translations[selected] || keys[selected] || keys.last
+    end
+
+    #translate, but discard namespace if nothing was found
+    # Car|Tire -> Tire if no translation could be found
+    def s_(key,seperator=nil)
+      translation = FastGettext.cached_find(key) and return translation
+      key.split(seperator||NAMESPACE_SEPERATOR).last
+    end
+
+    #tell gettext: this string need translation (will be found during parsing)
+    def N_(translate)
+      translate
+    end
+
+    #tell gettext: this string need translation (will be found during parsing)
+    def Nn_(*keys)
+      keys
+    end
+  end
+end

data/lib/fast_gettext/translation_repository.rb

@@ -0,0 +1,15 @@
+module FastGettext
+  # Responsibility:
+  #  - decide which repository to choose from given input
+  module TranslationRepository
+    extend self
+
+    # only single-word types supported atm (mytype works, MyType will not)
+    def build(name,options)
+      type = options[:type] || :mo
+      require "fast_gettext/translation_repository/#{type}"
+      klas = eval(type.to_s.capitalize)
+      klas.new(name,options)
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/base.rb

@@ -0,0 +1,49 @@
+module FastGettext
+  module TranslationRepository
+    # Responsibility:
+    #  - base for all repositories
+    #  - fallback as empty repository, that cannot translate anything but does not crash
+    class Base
+      def initialize(name,options={})
+        @name = name
+        @options = options
+      end
+
+      def pluralisation_rule
+        nil
+      end
+
+      def available_locales
+        []
+      end
+
+      def [](key)
+        current_translations[key]
+      end
+
+      def plural(*keys)
+        current_translations.plural(*keys)
+      end
+
+      protected
+
+      def current_translations
+        MoFile.empty
+      end
+
+      def find_files_in_locale_folders(relative_file_path,path)
+        path ||= "locale"
+        raise "path #{path} cound not be found!" unless File.exist?(path)
+
+        @files = {}
+        Dir[File.join(path,'*')].each do |locale_folder|
+          next unless File.basename(locale_folder) =~ LOCALE_REX
+          file = File.join(locale_folder,relative_file_path)
+          next unless File.exist? file
+          locale = File.basename(locale_folder)
+          @files[locale] = yield(locale,file)
+        end
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/chain.rb

@@ -0,0 +1,43 @@
+require 'fast_gettext/translation_repository/base'
+
+module FastGettext
+  module TranslationRepository
+    # Responsibility:
+    #  - delegate calls to members of the chain in turn
+    #TODO cache should be expired after a repo was added
+    class Chain < Base
+      attr_accessor :chain
+
+      def initialize(name,options={})
+        super
+        self.chain = options[:chain]
+      end
+
+      def available_locales
+        chain.map{|c|c.available_locales}.flatten.uniq
+      end
+
+      def pluralisation_rule
+        chain.each do |c|
+          result = c.pluralisation_rule and return result
+        end
+        nil
+      end
+
+      def [](key)
+        chain.each do |c|
+          result = c[key] and return result
+        end
+        nil
+      end
+
+      def plural(*keys)
+        chain.each do |c|
+          result = c.plural(*keys)
+          return result unless result.compact.empty?
+        end
+        []
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/db.rb

@@ -0,0 +1,57 @@
+require 'active_record'
+module FastGettext
+  module TranslationRepository
+    # Responsibility:
+    #  - provide access to translations in database through a database abstraction
+    #
+    #  Options:
+    #   :model => Model that represents your keys
+    #   you can either use the models supplied under db/, extend them or build your own
+    #   only constraints:
+    #     key: find_by_key, translations
+    #     translation: text, locale
+    class Db
+      def initialize(name,options={})
+        @model = options[:model]
+      end
+
+      @@seperator = '||||' # string that seperates multiple plurals
+      def self.seperator=(sep);@@seperator = sep;end
+      def self.seperator;@@seperator;end
+
+      def available_locales
+        if @model.respond_to? :available_locales
+          @model.available_locales || []
+        else
+          []
+        end
+      end
+
+      def pluralisation_rule
+        if @model.respond_to? :pluralsation_rule
+          @model.pluralsation_rule
+        else
+          nil
+        end
+      end
+
+      def [](key)
+        @model.translation(key, FastGettext.locale)
+      end
+
+      def plural(*args)
+        if translation = @model.translation(args*self.class.seperator, FastGettext.locale)
+          translation.to_s.split(self.class.seperator)
+        else
+          []
+        end
+      end
+
+      def self.require_models
+        require 'fast_gettext/translation_repository/db_models/translation_key'
+        require 'fast_gettext/translation_repository/db_models/translation_text'
+        FastGettext::TranslationRepository::DbModels
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/db_models/translation_key.rb

@@ -0,0 +1,26 @@
+module FastGettext::TranslationRepository
+  module DbModels
+    class TranslationKey < ActiveRecord::Base
+      has_many :translations, :class_name=>'TranslationText'
+      accepts_nested_attributes_for :translations, :allow_destroy => true
+      
+      validates_uniqueness_of :key
+      validates_presence_of :key
+
+      def self.translation(key, locale)
+        return unless translation_key = find_by_key(key)
+        return unless translation_text = translation_key.translations.find_by_locale(locale)
+        translation_text.text
+      end
+
+      def self.available_locales
+        @@available_locales ||= TranslationText.count(:group=>:locale).keys.sort
+      end
+
+      #this is only for ActiveSupport to get polymorphic_url FastGettext::... namespace free
+      def self.model_name
+        ActiveSupport::ModelName.new('TranslationKey')
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/db_models/translation_text.rb

@@ -0,0 +1,9 @@
+module FastGettext::TranslationRepository
+  module DbModels
+    class TranslationText < ActiveRecord::Base
+      belongs_to :key, :class_name=>'TranslationKey'
+      validates_presence_of :locale
+      validates_uniqueness_of :locale, :scope=>:translation_key_id
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/logger.rb

@@ -0,0 +1,27 @@
+require 'fast_gettext/translation_repository/base'
+
+module FastGettext
+  module TranslationRepository
+    # This should be used in a TranslationRepository::Chain, so tat untranslated keys can be found
+    # Responsibility:
+    #  - log every translation call
+    class Logger < Base
+      attr_accessor :callback
+
+      def initialize(name,options={})
+        super
+        self.callback = options[:callback]
+      end
+
+      def [](key)
+        callback.call(key)
+        nil
+      end
+
+      def plural(*keys)
+        callback.call(keys)
+        []
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/mo.rb

@@ -0,0 +1,35 @@
+require 'fast_gettext/translation_repository/base'
+module FastGettext
+  module TranslationRepository
+     # Responsibility:
+    #  - find and store mo files
+    #  - provide access to translations in mo files
+    class Mo < Base
+      def initialize(name,options={})
+        find_and_store_files(name,options)
+        super
+      end
+
+      def available_locales
+        @files.keys
+      end
+
+      def pluralisation_rule
+        current_translations.pluralisation_rule
+      end
+
+      protected
+
+      def find_and_store_files(name,options)
+        # parse all .mo files with the right name, that sit in locale/LC_MESSAGES folders
+        find_files_in_locale_folders(File.join('LC_MESSAGES',"#{name}.mo"),options[:path]) do |locale,file|
+          @files[locale] = MoFile.new(file)
+        end
+      end
+
+      def current_translations
+        @files[FastGettext.locale] || MoFile.empty
+      end
+    end
+  end
+end

data/lib/fast_gettext/translation_repository/po.rb

@@ -0,0 +1,18 @@
+require 'fast_gettext/translation_repository/base'
+require 'fast_gettext/translation_repository/mo'
+module FastGettext
+  module TranslationRepository
+     # Responsibility:
+    #  - find and store po files
+    #  - provide access to translations in po files
+    class Po < Mo
+      protected
+      def find_and_store_files(name,options)
+        require 'fast_gettext/po_file'
+        find_files_in_locale_folders("#{name}.po",options[:path]) do |locale,file|
+          @files[locale] = PoFile.to_mo_file(file)
+        end
+      end
+    end
+  end
+end

data/spec/aa_unconfigued_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe 'unconfigured' do
+  it "gives a useful error message when trying to just translate" do
+    FastGettext.text_domain = nil
+    begin
+      FastGettext._('x')
+      "".should == "success!?"
+    rescue FastGettext::Storage::NoTextDomainConfigured
+    end
+  end
+
+  it "gives a useful error message when only locale was set" do
+    FastGettext.locale = 'de'
+    begin
+      FastGettext._('x')
+      "".should == "success!?"
+    rescue FastGettext::Storage::NoTextDomainConfigured
+    end
+  end
+end

data/spec/fast_gettext/mo_file_spec.rb

@@ -0,0 +1,36 @@
+current_folder = File.dirname(__FILE__)
+require File.join(current_folder,'..','spec_helper')
+
+include FastGettext
+de_file = File.join(current_folder,'..','locale','de','LC_MESSAGES','test.mo')
+de = MoFile.new(de_file)
+
+describe MoFile do
+  before :all do
+    File.exist?(de_file).should == true
+  end
+
+  it "parses a file" do
+    de['car'].should == 'Auto'
+  end
+
+  it "stores untranslated values as nil" do
+    de['Car|Model'].should == nil
+  end
+
+  it "finds pluralized values" do
+    de.plural('Axis','Axis').should == ['Achse','Achsen']
+  end
+
+  it "returns singular translations when pluralisation could not be found" do
+    de.plural('Axis','Axis','Axis').should == ['Achse','Achse','Achse']
+  end
+
+  it "returns ids when not plural and singular translations could not be found" do
+    de.plural('Axis','Axis','NOTFOUND').should == ['Achse','Achse','NOTFOUND']
+  end
+
+  it "can access plurals through []" do
+    de['Axis'].should == 'Achse' #singular
+  end
+end

data/spec/fast_gettext/storage_spec.rb

@@ -0,0 +1,309 @@
+current_folder = File.dirname(__FILE__)
+require File.join(current_folder,'..','spec_helper')
+
+include FastGettext::Storage
+
+describe 'Storage' do
+  before do
+    #reset everything to nil
+    self.available_locales = nil
+    self.default_text_domain = nil
+    self.default_locale = nil
+    send(:_locale=,nil)#nil is not allowed to be set...
+    default_locale.should be_nil
+    available_locales.should be_nil
+    locale.should == 'en'
+  end
+
+  def thread_save(method, value)
+    send("#{method}=",value)
+
+    # mess around with other threads
+    100.times do
+      Thread.new {FastGettext.send("#{method}=",'en')}
+    end
+    
+    send(method) == value
+  end
+
+  {:locale=>'de', :available_locales=>['de'], :text_domain=>'xx', :pluralisation_rule=>lambda{|x|x==4}}.each do |method, value|
+    it "stores #{method} thread-save" do
+      thread_save(method, value).should == true
+    end
+  end
+
+  it "stores translation_repositories non-thread-safe" do
+    self.translation_repositories[:x]=1
+    t = Thread.new{self.translation_repositories[:x]=2}
+    t.join
+    self.translation_repositories[:x].should == 2
+  end
+
+  describe :pluralisation_rule do
+    it "defaults to singular-if-1 when it is not set" do
+      stub!(:current_repository).and_return mock('',:pluralisation_rule=>nil)
+      self.pluralisation_rule = nil
+      pluralisation_rule.call(1).should == false
+      pluralisation_rule.call(0).should == true
+      pluralisation_rule.call(2).should == true
+    end
+  end
+
+  describe :default_locale do
+    it "stores default_locale non-thread-safe" do
+      thread_save(:default_locale, 'de').should == false
+    end
+
+    it "does not overwrite locale" do
+      self.locale = 'de'
+      self.default_locale = 'yy'
+      self.locale.should == 'de'
+    end
+
+    it "falls back to default if locale is missing" do
+      self.default_locale = 'yy'
+      self.locale.should == 'yy'
+    end
+
+    it "does not set non-available-locales as default" do
+      self.available_locales = ['xx']
+      self.default_locale = 'yy'
+      self.default_locale.should == nil
+    end
+
+    it "can set default_locale to nil" do
+      self.default_locale = 'xx'
+      self.default_locale = nil
+      default_locale.should be_nil
+    end
+  end
+
+  describe :default_text_domain do
+    it "stores default_text_domain non-thread-safe" do
+      thread_save(:default_text_domain, 'xx').should == false
+    end
+
+    it "uses default_text_domain when text_domain is not set" do
+      self.text_domain = nil
+      self.default_text_domain = 'x'
+      text_domain.should == 'x'
+    end
+
+    it "does not use default when domain is set" do
+      self.text_domain = 'x'
+      self.default_text_domain = 'y'
+      text_domain.should == 'x'
+    end
+  end
+
+  describe :default_available_locales do
+    after do
+      self.default_available_locales = nil
+    end
+
+    it "stores default_available_locales non-thread-safe" do
+      thread_save(:default_available_locales, 'xx').should == false
+    end
+
+    it "uses default_available_locales when available_locales is not set" do
+      self.available_locales = nil
+      self.default_available_locales = 'x'
+      available_locales.should == 'x'
+    end
+
+    it "does not use default when available_locales is set" do
+      self.available_locales = 'x'
+      self.default_available_locales = 'y'
+      available_locales.should == 'x'
+    end
+  end
+
+  describe :locale do
+    it "stores everything as long as available_locales is not set" do
+      self.available_locales = nil
+      self.locale = 'XXX'
+      locale.should == 'XXX'
+    end
+
+    it "is en if no locale and no available_locale were set" do
+      FastGettext.send(:_locale=,nil)
+      self.available_locales = nil
+      locale.should == 'en'
+    end
+
+    it "does not change the locale if locales was called with nil" do
+      self.locale = nil
+      locale.should == 'en'
+    end
+
+    it "is the first available_locale if one was set" do
+      self.available_locales = ['de']
+      locale.should == 'de'
+    end
+
+    it "does not store a locale if it is not available" do
+      self.available_locales = ['de']
+      self.locale = 'en'
+      locale.should == 'de'
+    end
+
+    it "set_locale returns the old locale if the new could not be set" do
+      self.locale = 'de'
+      self.available_locales = ['de']
+      self.set_locale('en').should == 'de'
+    end
+
+    {
+      'Opera' => "de-DE,de;q=0.9,en;q=0.8",
+      'Firefox' => "de-de,de;q=0.8,en-us;q=0.5,en;q=0.3",
+    }.each do |browser,accept_language|
+      it "sets the locale from #{browser} headers" do
+        FastGettext.available_locales = ['de_DE','de','xx']
+        FastGettext.locale = 'xx'
+        FastGettext.locale = accept_language
+        FastGettext.locale.should == 'de_DE'
+      end
+    end
+
+    it "sets a unimportant locale if it is the only available" do
+      FastGettext.available_locales = ['en','xx']
+      FastGettext.locale = "de-de,de;q=0.8,en-us;q=0.5,en;q=0.3"
+      FastGettext.locale.should == 'en'
+    end
+
+    it "sets the locale with the highest wheight" do
+      FastGettext.available_locales = ['en','de']
+      FastGettext.locale = "xx-us;q=0.5,de-de,de;q=0.8,en;q=0.9"
+      FastGettext.locale.should == 'en'
+    end
+
+    it "sets the locale from languages" do
+      FastGettext.available_locales = ['de']
+      FastGettext.locale = "xx-us;q=0.5,de-de;q=0.8,en-uk;q=0.9"
+      FastGettext.locale.should == 'de'
+    end
+
+    it "sets locale from comma seperated" do
+      FastGettext.available_locales = ['de_DE','en','xx']
+      FastGettext.locale = "de,de-de,en"
+      FastGettext.locale.should == 'de_DE'
+    end
+  end
+
+  describe :silence_errors do
+    before do
+      FastGettext.text_domain = 'xxx'
+    end
+
+    it "raises when a textdomain was empty" do
+      begin 
+        FastGettext._('x')
+        "".should == "success!?"
+      rescue FastGettext::Storage::NoTextDomainConfigured
+      end
+    end
+
+    it "can silence erros" do
+      FastGettext.silence_errors
+      FastGettext._('x').should == 'x'
+    end
+  end
+
+  describe :current_cache do
+    before do
+      FastGettext.text_domain = 'xxx'
+      FastGettext.available_locales = ['de','en']
+      FastGettext.locale = 'de'
+      FastGettext.current_repository.stub!(:"[]").with('abc').and_return 'old'
+      FastGettext.current_repository.stub!(:"[]").with('unfound').and_return nil
+      FastGettext._('abc')
+      FastGettext._('unfound')
+      FastGettext.locale = 'en'
+    end
+
+    it "stores a translation seperate by locale" do
+      FastGettext.current_cache['abc'].should == nil
+    end
+
+    it "stores a translation seperate by domain" do
+      FastGettext.locale = 'de'
+      FastGettext.text_domain = nil
+      FastGettext.current_cache['abc'].should == nil
+    end
+
+    it "cache is restored through setting of default_text_domain" do
+      FastGettext.locale = 'de'
+      FastGettext.text_domain = nil
+      FastGettext.default_text_domain = 'xxx'
+      FastGettext.current_cache['abc'].should == 'old'
+    end
+
+    it "cache is restored through setting of default_locale" do
+      FastGettext.send(:_locale=,nil)#reset locale to nil
+      FastGettext.default_locale = 'de'
+      FastGettext.locale.should == 'de'
+      FastGettext.current_cache['abc'].should == 'old'
+    end
+
+    it "stores a translation permanently" do
+      FastGettext.locale = 'de'
+      FastGettext.current_cache['abc'].should == 'old'
+    end
+
+    it "stores a unfound translation permanently" do
+      FastGettext.locale = 'de'
+      FastGettext.current_cache['unfound'].should == false
+    end
+  end
+
+  describe :key_exist? do
+    it "does not find default keys" do
+      _('abcde')
+      key_exist?('abcde').should be_false
+    end
+
+    it "finds using the current repository" do
+      should_receive(:current_repository).and_return '1234'=>'1'
+      key_exist?('1234').should == true
+    end
+
+    it "sets the current cache with a found result" do
+      should_receive(:current_repository).and_return 'xxx'=>'1'
+      key_exist?('xxx')
+      current_cache['xxx'].should == '1'
+    end
+
+    it "does not overwrite an existing cache value" do
+      current_cache['xxx']='xxx'
+      stub!(:current_repository).and_return 'xxx'=>'1'
+      key_exist?('xxx')
+      current_cache['xxx'].should == 'xxx'
+    end
+
+    it "is false for gettext meta key" do
+      key_exist?("").should == false
+    end
+  end
+
+  describe :cached_find do
+    it "is nil for gettext meta key" do
+      cached_find("").should == false
+    end
+  end
+
+  describe NoTextDomainConfigured do
+    it "shows what to do" do
+      NoTextDomainConfigured.new.to_s.should =~ /FastGettext\.add_text_domain/
+    end
+
+    it "warns when text_domain is nil" do
+      FastGettext.text_domain = nil
+      NoTextDomainConfigured.new.to_s.should =~ /\(nil\)/
+    end
+
+    it "shows current text_domain" do
+      FastGettext.text_domain = 'xxx'
+      NoTextDomainConfigured.new('xxx').to_s.should =~ /xxx/
+    end
+  end
+end