localite 0.3 → 0.5.6

data/lib/localite/scope.rb

@@ -1,140 +0,0 @@
-module Localite::Scope
-  #
-  # scope allows to set a scope around a translation. A scoped translation
-  # 
-  #   Localite.scope("scope") do
-  #     "msg".t
-  #   end
-  #
-  # will look up "scope.msg" and "msg", in that order, and return the first
-  # matching translation in the current locale. Scopes can be stacked; looking
-  # up a scoped  translation
-  #   Localite.scope("outer") do
-  #     Localite.scope("scope") do
-  #       "msg".t
-  #     end
-  #   end
-  #
-  # will look up "outer.scope.msg", "scope.msg", "msg".
-  #
-  # If no translation will be found we look up the same entries in the base
-  # locale.
-  def scope(*args, &block)
-    return yield if args.empty?
-
-    scopes.exec(args.shift) do
-      scope *args, &block
-    end
-  end
-  
-  def scopes
-    Thread.current[:"localite:scopes"] ||= Scopes.new
-  end
-
-  #
-  # The mode setting defines how the template engine deals with its
-  # parameters. In :html mode all parameters will be subject to HTML
-  # escaping, while in :text mode the parameters remain unchanged.
-  def html(&block)
-    in_mode :html, &block
-  end
-
-  def text(&block)
-    in_mode :text, &block
-  end
-  
-  def mode
-    Thread.current[:"localite:mode"] || :text
-  end
-  
-  private
-
-  def in_mode(mode, &block)
-    old = Thread.current[:"localite:mode"]
-    Thread.current[:"localite:mode"] = mode
-    yield
-  ensure
-    Thread.current[:"localite:mode"] = old
-  end
-  
-  
-  class Scopes < Array
-    def exec(s, &block)
-      s = "#{last}.#{s}" if last
-      push s
-      
-      yield
-    ensure
-      pop
-    end
-    
-    def each(s)
-      reverse_each do |entry| 
-        yield "#{entry}.#{s}"
-      end
-
-      yield s
-    end
-  
-    def first(s)
-      each(s) do |entry|
-        return entry
-      end
-    end
-  end
-end
-
-module Localite::Scope::Etest
-  Scopes = Localite::Scope::Scopes
-  
-  def test_scope
-    scope = Scopes.new
-    scope.exec("a") do 
-      scope.exec("b") do 
-        scope.exec("b") do 
-          r = []
-          scope.each("str") do |scoped|
-            r << scoped
-          end
-          assert_equal %w(a.b.b.str a.b.str a.str str), r
-        end
-      end
-    end
-  end
-  
-  def test_more_scopes
-    Localite.scope("a", :b, "b") do 
-      r = []
-      Localite.scopes.each("str") do |scoped|
-        r << scoped
-      end
-      assert_equal %w(a.b.b.str a.b.str a.str str), r
-    end
-  end
-  
-  def test_more_scopes_w_dots
-    Localite.scope("a", :b, "b.c.d") do 
-      r = []
-      Localite.scopes.each("str.y") do |scoped|
-        r << scoped
-      end
-      assert_equal %w(a.b.b.c.d.str.y a.b.str.y a.str.y str.y), r
-    end
-  end
-  
-  def test_empty_scopes
-    r = []
-    Localite.scopes.each("str.y") do |scoped|
-      r << scoped
-    end
-    assert_equal %w(str.y), r
-  end
-
-  def test_modi
-    assert_equal "abc", "param".t(:xxx => "abc")
-    assert_equal "a > c", "param".t(:xxx => "a > c")
-    assert_equal "a > c", Localite.text { "param".t(:xxx => "a > c") }
-    assert_equal "a &gt; c", Localite.html { "param".t(:xxx => "a > c") }
-    assert_equal "a > c", "param".t(:xxx => "a > c")
-  end
-end

data/test/i18n/de.yml

@@ -1,15 +0,0 @@
-#
-# Some translation "fixtures"
-de:
-  t: "de.t"
-  outer:
-    inner:
-      x1: "de/outer/inner/x1"
-
-en:
-  param: "{* xxx *}"
-  base: "en_only"
-  t: "en.t"
-  outer:
-    inner:
-      x1: "en/outer/inner/x1"