localite 0.3 → 0.5.6

data/Manifest

@@ -0,0 +1,44 @@
+Manifest
+Rakefile
+VERSION
+bin/list-tr
+config/dependencies.rb
+config/gem.yml
+lib/localite.rb
+lib/localite/filter.rb
+lib/localite/format.rb
+lib/localite/node_filter.rb
+lib/localite/scopes.rb
+lib/localite/settings.rb
+lib/localite/storage.rb
+lib/localite/template.rb
+lib/localite/tr.rb
+lib/localite/translate.rb
+localite.tmproj
+script/console
+script/rebuild
+tasks/echoe.rake
+test/i18n/de.tr
+test/i18n/en.tr
+test/initializers/fake_rails.rb
+test/rails/Rakefile
+test/rails/app/controllers/application_controller.rb
+test/rails/app/controllers/localite_controller.rb
+test/rails/app/views/localite/index.html.erb
+test/rails/app/views/localite/template.de.html.erb
+test/rails/app/views/localite/template.en.html.erb
+test/rails/config/boot.rb
+test/rails/config/environment.rb
+test/rails/config/environments/development.rb
+test/rails/config/environments/production.rb
+test/rails/config/environments/test.rb
+test/rails/config/initializers/new_rails_defaults.rb
+test/rails/config/initializers/session_store.rb
+test/rails/config/locales/de.yml
+test/rails/config/locales/en.yml
+test/rails/config/routes.rb
+test/rails/script/console
+test/rails/script/server
+test/rails/test/functional/localite_controller_test.rb
+test/rails/test/test_helper.rb
+test/test.rb

data/VERSION

@@ -1 +1 @@
-0.3
+0.5.6

data/bin/list-tr

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "#{File.dirname(__FILE__)}/../lib/localite"
+require "pp"
+ARGV.each do |file|
+  keys = Localite::Backend::Tr.new(File.new(file)).keys
+  keys.each do |key|
+    puts key
+  end
+end

data/lib/localite.rb

@@ -10,35 +10,34 @@ module Localite; end
 
 file_dir = File.expand_path(File.dirname(__FILE__))
 
-require "#{file_dir}/localite/scope"
-require "#{file_dir}/localite/settings"
-require "#{file_dir}/localite/translate"
-require "#{file_dir}/localite/template"
+$: << file_dir
+require "localite/format"
+require "localite/scopes"
+require "localite/settings"
+require "localite/translate"
+require "localite/template"
+require "localite/storage"
 
 module Localite
   #
   # a logger
   def self.logger
+    return @logger if @logger
+    
     klass = defined?(ActiveSupport) ? ActiveSupport::BufferedLogger : Logger
 
-    @logger ||= begin
+    @logger = begin
       klass.new("log/localite.log")
     rescue Errno::ENOENT
       ::Logger.new(STDERR)
     end
+    
+    @logger.warn "=== Initialize localite logging: #{Time.now}"
+    @logger
   end
   
   extend Settings
   extend Translate
-  extend Scope
-
-  private
-  
-  def self.template(template, *args)
-    Template.run mode, template, *args
-  end
-
-  public
   
   #
   # Translating a string:
@@ -49,7 +48,12 @@ module Localite
   module StringAdapter
     def t(*args)
       translated = Localite.translate(self, :no_raise) || self
-      Localite.template translated, *args
+      Localite::Template.run translated, *args
+    end
+
+    def t?(*args)
+      translated = Localite.translate(self, :no_raise)
+      Localite::Template.run translated, *args if translated
     end
   end
 
@@ -62,13 +66,13 @@ module Localite
   module SymbolAdapter
     def t(*args)
       translated = Localite.translate(self, :do_raise)
-      Localite.template translated, *args
+      Localite::Template.run translated, *args
     end
 
     # returns nil, if there is no translation.
     def t?(*args)
       translated = Localite.translate(self, :no_raise)
-      Localite.template translated, *args if translated
+      Localite::Template.run translated, *args if translated
     end
   end
   
@@ -91,51 +95,51 @@ module Localite::Etest
     assert !I18n.load_path.empty?
     
     assert_equal("en.t", "t".t)
-    Localite.in("en") { 
+    Localite.locale("en") { 
       assert_equal("en.t", "t".t )
     }
     
-    Localite.in("de") { 
+    Localite.locale("de") { 
       assert_equal("de.t", "t".t )
     }
     
-    assert_equal("de.t", Localite.in("de") { "t".t })
+    assert_equal("de.t", Localite.locale("de") { "t".t })
   end
   
   def test_lookup_de
-    Localite.in("de") do
+    Localite.locale("de") do
       # flat translation
       assert_equal "de.t", "t".t
 
       Localite.scope(:outer, :inner) do
         assert_equal("de/outer/inner/x1", "x1".t)
       end
-  
+        
       # Miss "x1", and don't translate missing entries
       assert_equal("x1", "x1".t)
     end
   end
   
   def test_lookup_in_base
-    Localite.in("en") do
+    Localite.locale("en") do
       # lookup "base" in base translation
       assert_equal "en_only", "base".t
     end
 
-    Localite.in("de") do
+    Localite.locale("de") do
       # lookup "base" in base (i.e. en) translation
       assert_equal "en_only", "base".t
     end
   end
   
   def test_lookup_en
-    Localite.in("en") do
+    Localite.locale("en") do
 
       # flat translation
       assert_equal "en.t", "t".t
 
-      Localite.scope(:outer, :inner, :x1) do
-        assert_equal("en/outer/inner/x1", "x1".t)
+      Localite.scope(:outer, :inner) do
+        assert_equal("en/outer/inner/x1", :x1.t)
       end
   
       # Miss "x1", and don't translate missing entries
@@ -160,11 +164,11 @@ module Localite::Etest
     
     assert_equal "en_only", :base.t
 
-    Localite.in("en") do
+    Localite.locale("en") do
       assert_equal "en_only", :base.t
     end
 
-    Localite.in("de") do
+    Localite.locale("de") do
       assert_equal "en_only", :base.t
     end
   end
@@ -175,13 +179,13 @@ module Localite::Etest
       assert_equal "en_only", :missing.t
     }
 
-    Localite.in("en") do
+    Localite.locale("en") do
       assert_raise(Localite::Translate::Missing) {
         :missing.t
       }
     end
 
-    Localite.in("de") do
+    Localite.locale("de") do
       assert_raise(Localite::Translate::Missing) {
         :missing.t
       }
@@ -193,16 +197,130 @@ module Localite::Etest
       assert_kind_of(String, $!.to_s)
     end
   end
-   
-#   def test_html
-#     assert_equal ">",                      "{*'>'*}".t(:xyz => [1, 2, 3], :fl => [1.0])
-#     assert_equal "&gt;",                   "{*'>'*}".t(:html, :xyz => [1, 2, 3], :fl => [1.0])
-#     assert_equal "3 Fixnums > 1 Float",    "{*pl xyz*} > {*pl fl*}".t(:xyz => [1, 2, 3], :fl => [1.0])
-#     assert_equal "3 Fixnums &gt; 1 Float", "{*pl xyz*} > {*pl fl*}".t(:html, :xyz => [1, 2, 3], :fl => [1.0])
-#   end
-# 
-#   def test_tmpl
-# #    assert_equal "3 chars", "{*len*} chars".t(:len => 3)
-#     assert_equal "3 chars", "{*length*} chars".t(:length => 3)
-#   end
+
+  def catch_exception(klass, &block)
+    yield
+    nil
+  rescue klass
+    $!
+  end
+  
+  def test_missing_translation_wo_scope
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.scope(:locale => :de, :format => :text) do
+        :x.t
+      end
+    end
+    
+    assert_equal(:de, r.locale)
+    assert_equal(:x, r.string)
+    assert_equal("", r.scope)
+
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.scope(:locale => :de, :format => :html) do
+        :x.t
+      end
+    end
+    
+    assert_equal(:de, r.locale)
+    assert_equal(:x, r.string)
+    assert_equal("", r.scope)
+
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.scope(:locale => :de) do
+        :x.t
+      end
+    end
+    
+    assert_equal(:de, r.locale)
+    assert_equal(:x, r.string)
+    assert_equal("", r.scope)
+  end
+
+  def test_missing_translation_w_scope
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.locale(:de) do
+        Localite.scope(:ab, :cd) do
+          :yx.t
+        end
+      end
+    end
+    
+    assert_equal(:de, r.locale)
+    assert_equal(:yx, r.string)
+    assert_equal("ab:cd", r.scope)
+  end
+
+  def test_reset_scope
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.scope(:ab) do
+        Localite.scope(:cd) do
+          :yx.t
+        end
+      end
+    end
+
+    assert_equal("ab:cd", r.scope)
+
+    r = catch_exception(Localite::Translate::Missing) do 
+      Localite.scope(:ab) do
+        Localite.scope!(:cd) do
+          assert_equal([:cd], Localite.current_scope)
+        end
+        assert_equal([:ab], Localite.current_scope)
+
+        Localite.scope!(:cd) do
+          :yx.t
+        end
+      end
+    end
+
+    assert_equal("cd", r.scope)
+  end
+
+  def test_default_format
+    assert_equal "abc", "param".t(:xxx => "abc")
+    assert_equal "a > c", "param".t(:xxx => "a > c")
+    assert_equal "abc", "param".t(:xxx => "abc")
+  end
+
+  def test_text_format
+    assert_equal "a > c", Localite.format(:text) { "param".t(:xxx => "a > c") }
+  end
+
+  def test_html_format
+    Localite.format(:html) { 
+      assert_equal(:html, Localite.current_format)
+      assert_equal "a &gt; c", "param".t(:xxx => "a > c")
+    }
+    
+    assert_equal "a &gt; c", Localite.format(:html) { "param".t(:xxx => "a > c") }
+  end
+  
+  def test_format_scope
+    Localite.format(:html) do
+      assert_equal :html, Localite.current_format
+      assert_equal("This is hypertext", :title.t)
+      assert_equal("This is &lt;&gt; hypertext", :title2.t)
+    end
+    Localite.format(:text) do
+      assert_equal :text, Localite.current_format
+      assert_equal("This is hypertext", :title.t)
+      assert_equal("This is <> hypertext", :title2.t)
+    end
+  end
+
+  def test_unavailable
+    Localite.locale("unknown") do
+      assert_equal(:en, Localite.current_locale)
+      assert_equal("This is hypertext", :title.t)
+    end
+  end
+
+  def test_inspect
+    assert_nothing_raised {
+      Localite.inspect
+    }
+  end
 end
+

data/lib/localite/filter.rb

@@ -1,78 +1,24 @@
 module Localite::Filter
   module ControllerFilter
-    def self.locale(controller)
-      #
-      # get the current locale
-      locale = begin
-        controller.send(:current_locale)
-      rescue NoMethodError
-      end
-    end
-
+    #
+    # set up localite for this action.
     def self.filter(controller, &block)
-      #
-      # set up localite for this action.
-      Localite.in(locale(controller)) do
-        Localite.html(&block)
+      args = controller.send(:localite_scopes)
+      args.push :locale => controller.send(:current_locale),
+        :format => controller.send(:localite_format)
 
-        filter_response controller
+      Localite.scope(*args) do
+        if controller.logger && Rails.env.development?
+          controller.logger.warn "localite: [#{Localite.current_locale}]"
+        end
+        yield
       end
     rescue
       if Rails.env.development?
         controller.response.body = "Caught exception: " + CGI::escapeHTML($!.inspect) 
-        STDERR.puts $!.to_s + "\n\t" + $!.backtrace.join("\n\t")
       end
       raise
     end
-
-    def self.filter_response(controller)
-      return unless controller.response.headers["Content-Type"] =~ /text\/html/
-      controller.response.body = filter_lang_nodes(controller.response.body)
-    end
-
-    def self.filter_lang_nodes(body)
-      doc = Nokogiri.XML "<filter-outer-span xmlns:fb='http://facebook.com/'>#{body}</filter-outer-span>"
-
-      doc.css("[lang]").each do |node|
-        if Localite.locale.to_s != node["lang"]
-          node.remove
-          next
-        end
-
-        #
-        # we have a node with content specific for the current locale,
-        # i.e. a node to keep. If we find a base locale sibling (i.e. 
-        # with identical attributes but no "lang" attribute) prior 
-        # this node we have to remove that.
-        next unless base = base_node(node)
-        base.remove 
-      end
-
-      doc.css("filter-outer-span").inner_html
-    end
-    
-    def self.base_node(node)
-      previous = node
-      while (previous = previous.previous) && previous.name == "text" do
-        :void
-      end
-
-      return previous if base_node?(node, previous)
-    end
-    
-    def self.base_node?(me, other_node)
-      return false if !other_node
-      return false if me.name != other_node.name
-      return false if other_node.attributes.key?("lang")
-      return false if me.attributes.length != other_node.attributes.length + 1
-
-      # do we have a mismatching attribute?
-      other_node.attributes.each { |k,v| 
-        return false if me.attributes[k] != v 
-      }
-
-      true
-    end
   end
 
   module ControllerMethods
@@ -82,10 +28,23 @@ module Localite::Filter
       return params[:locale] if params[:locale] && params[:locale] =~ /^[a-z][a-z]$/
       return params[:lang] if params[:lang] && params[:lang] =~ /^[a-z][a-z]$/
     end
+
+    #
+    # return the current scope(s) as an array.
+    def localite_scopes
+      []
+    end
+
+    #
+    # return the current scope(s) as an array.
+    def localite_format
+      :html
+    end
   end
   
   def self.included(klass)
     klass.send :include, ControllerMethods
+    klass.send :helper_method, :current_locale
     klass.send :around_filter, ControllerFilter
   end
 end