RubyGems - localite - Versions diffs - 0.3 → 0.5.6 - Mend

localite 0.3 → 0.5.6

Files changed (42) hide show

data/Manifest +44 -0
data/VERSION +1 -1
data/bin/list-tr +10 -0
data/lib/localite.rb +161 -43
data/lib/localite/filter.rb +23 -64
data/lib/localite/format.rb +36 -0
data/lib/localite/node_filter.rb +197 -0
data/lib/localite/scopes.rb +93 -0
data/lib/localite/settings.rb +139 -17
data/lib/localite/storage.rb +132 -0
data/lib/localite/template.rb +29 -25
data/lib/localite/tr.rb +292 -0
data/lib/localite/translate.rb +46 -20
data/localite.gemspec +9 -6
data/localite.tmproj +3 -99
data/tasks/echoe.rake +1 -1
data/test/i18n/de.tr +5 -0
data/test/i18n/en.tr +16 -0
data/test/rails/Rakefile +10 -0
data/test/rails/app/controllers/application_controller.rb +10 -0
data/test/rails/app/controllers/localite_controller.rb +20 -0
data/test/rails/app/views/localite/index.html.erb +19 -0
data/test/rails/app/views/localite/template.de.html.erb +1 -0
data/test/rails/app/views/localite/template.en.html.erb +1 -0
data/test/rails/config/boot.rb +110 -0
data/test/rails/config/environment.rb +50 -0
data/test/rails/config/environments/development.rb +17 -0
data/test/rails/config/environments/production.rb +28 -0
data/test/rails/config/environments/test.rb +28 -0
data/test/rails/config/initializers/new_rails_defaults.rb +21 -0
data/test/rails/config/initializers/session_store.rb +15 -0
data/test/rails/config/locales/de.yml +4 -0
data/test/rails/config/locales/en.yml +4 -0
data/test/rails/config/routes.rb +13 -0
data/test/rails/script/console +3 -0
data/test/rails/script/server +3 -0
data/test/rails/test/functional/localite_controller_test.rb +56 -0
data/test/rails/test/test_helper.rb +38 -0
data/test/test.rb +4 -1
metadata +51 -11
data/lib/localite/scope.rb +0 -140
data/test/i18n/de.yml +0 -15

@@ -0,0 +1,36 @@
+module Localite::Format
+  #
+  # convert from text into target format
+  def self.text(s)
+    case s
+    when /html:(.*)/m then $1
+    when /text:(.*)/m then $1
+    else              s
+    end
+  end
+  def self.html(s)
+    case s
+    when /html:(.*)/m then $1
+    when /text:(.*)/m then CGI.escapeHTML($1)
+    else              CGI.escapeHTML(s)
+    end
+  end
+end
+module Localite::Format::Etest
+  def test_format
+    assert_equal "xxx", Localite::Format.html("xxx")
+    assert_equal "xxx", Localite::Format.html("html:xxx")
+    assert_equal "xxx", Localite::Format.html("text:xxx")
+    assert_equal "&lt;&gt;", Localite::Format.html("text:<>")
+    assert_equal "&lt;&gt;", Localite::Format.html("<>")
+    assert_equal "<>", Localite::Format.html("html:<>")
+    assert_equal "xxx\nyyy", Localite::Format.html("xxx\nyyy")
+    assert_equal "xxx\nyyy", Localite::Format.html("html:xxx\nyyy")
+    assert_equal "xxx\nyyy", Localite::Format.html("text:xxx\nyyy")
+  end
+end

data/lib/localite/node_filter.rb ADDED

@@ -0,0 +1,197 @@
+require "nokogiri"
+module Localite::NodeFilter
+  #
+  # set up filter for this action.
+  def self.filter(controller, &block)
+    yield
+    return unless controller.response.headers["Content-Type"] =~ /text\/html/
+    r = controller.response
+    r.body = filter_body r.body, Localite.current_locale
+  rescue
+    if Rails.env.development?
+      controller.response.body = "Caught exception: " + CGI::escapeHTML($!.inspect)
+    end
+    raise
+  end
+  def self.included(klass)
+    klass.send :around_filter, self
+  end
+  private
+  def self.filter_body(body, locale)
+    if body =~ /(<body[^>]*>)(.*)(<\/body>)/m
+      $`.html_safe +
+      $1.html_safe +
+      filter_node($2, locale).html_safe +
+      $3.html_safe +
+      $'.html_safe
+    else
+      filter_node(body, locale).html_safe
+    end
+  end
+  def self.filter_node(body, locale)
+    locale = locale.to_s
+    body = fb_mark(body)
+    doc = Nokogiri.HTML "<html><body>#{body}</body></html>"
+    doc.css("[lang]").each do |node|
+      next unless locale != node["lang"]
+      node.remove
+    end
+    doc = doc.css("body").inner_html
+    doc = fb_unmark(doc)
+    doc.html_safe
+  end
+  #
+  # for <fb:XXXXXX> tags to survive Nokogiri's HTML parsing we rename
+  # them into something non-namespacy. THIS IS A HACK! I wished I knew
+  # how to make
+  #
+  # a) Nokogiri.XML to let entities live, or, preferredly
+  # b) Nokogiri.HTML to let namespaces survive
+  #
+  FB =            "fb:"
+  FB_RE =         /(<|<\/)fb:/
+  FB_MARKER =     "fb_marker_0xjgh_123_"
+  FB_MARKER_RE =  Regexp.new "(<|<\/)#{FB_MARKER}"
+  def self.fb_mark(s)
+    s.gsub(FB_RE) { $1 + FB_MARKER }
+  end
+  def self.fb_unmark(s)
+    s.gsub(FB_MARKER_RE) { $1 + FB }
+  end
+end
+module Localite::NodeFilter::Etest
+  def normalize_xml(str)
+    str.
+      gsub(/>(.*?)</m) do |s| ">#{$1.gsub(/\s+/m, " ")}<" end.  # normalize spaces between tags
+      gsub(/>\s*</m, ">\n<").                                   # normalize spaces in empty text nodes
+      gsub(/"/, "'")                                            # normalize ' and "
+  end
+  def assert_filtered(locale, src, expected)
+    filtered = Localite::NodeFilter.filter_body(src, locale)
+    filtered = normalize_xml(filtered)
+    expected = normalize_xml(expected)
+    if expected == filtered
+      assert true
+      return
+    end
+    puts "expected:\n\n" + expected + "\n\n"
+    puts "filtered:\n\n" + filtered + "\n\n"
+    assert_equal expected, filtered
+  end
+  ##
+  def test_normalize_xml
+    assert_equal "<p>ppp</p>", normalize_xml("<p>ppp</p>")
+    assert_equal "<p>a b c </p>\n", normalize_xml("<p>a   b c </p>\n")
+  end
+  def test_simple_html
+    assert_filtered :de, "<p>ppp</p>", "<p>ppp</p>"
+    assert_filtered :en, "<p>ppp</p>", "<p>ppp</p>"
+    assert_filtered :fr, "<p>ppp</p>", "<p>ppp</p>"
+  end
+  def test_simple_html_w_lang
+    assert_filtered :de, "<p lang='de'>ppp</p>", "<p lang='de'>ppp</p>"
+    assert_filtered :en, "<p lang='de'>ppp</p>", ""
+    assert_filtered :fr, "<p lang='de'>ppp</p>", ""
+    assert_filtered :de, "<p lang='en'>ppp</p>", ""
+    assert_filtered :en, "<p lang='en'>ppp</p>", "<p lang='en'>ppp</p>"
+    assert_filtered :fr, "<p lang='en'>ppp</p>", ""
+  end
+  def test_fbml_tags
+    assert_filtered :de, "<fb:p lang='de'>ppp</fb:p>", "<fb:p lang='de'>ppp</fb:p>"
+    assert_filtered :en, "<fb:p lang='de'>ppp</fb:p>", ""
+    assert_filtered :fr, "<fb:p lang='de'>ppp</fb:p>", ""
+    assert_filtered :de, "<fb:p lang='en'>ppp</fb:p>", ""
+    assert_filtered :en, "<fb:p lang='en'>ppp</fb:p>", "<fb:p lang='en'>ppp</fb:p>"
+    assert_filtered :fr, "<fb:p lang='en'>ppp</fb:p>", ""
+  end
+  def test_umlauts
+    assert_filtered :de, "<p lang='de'>&Auml; &Ouml;</p>", "<p lang='de'>&Auml; &Ouml;</p>"
+    #
+    # Nokogiri translates UTF-8 umlauts into entities. That is ok (for now)
+    assert_filtered :de, "<p lang='de'>Ä Ö</p>", "<p lang='de'>&Auml; &Ouml;</p>"
+  end
+  def test_full_html_match
+    src = <<-HTML
+<!--Force IE6 into quirks mode with this comment tag-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>socially.io</title>
+  </head>
+  <body x="y">
+    <p lang='de'>&Auml; &Ouml;</p>", "<p lang='de'>&Auml; &Ouml;</p>
+  </body>
+</html>
+HTML
+    expected = <<-HTML
+<!--Force IE6 into quirks mode with this comment tag-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>socially.io</title>
+  </head>
+  <body x="y">
+    <p lang='de'>&Auml; &Ouml;</p>", "<p lang='de'>&Auml; &Ouml;</p>
+  </body>
+</html>
+HTML
+    assert_filtered :de, src, expected
+  end
+  def test_full_html_miss
+    src = <<-HTML
+<!--Force IE6 into quirks mode with this comment tag-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>socially.io</title>
+  </head>
+  <body x="y">
+    <p lang='de'>&Auml; &Ouml;</p>
+  </body>
+</html>
+HTML
+    expected = <<-HTML
+<!--Force IE6 into quirks mode with this comment tag-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>socially.io</title>
+  </head>
+  <body x="y">
+  </body>
+</html>
+HTML
+    assert_filtered :en, src, expected
+  end
+end

data/lib/localite/scopes.rb ADDED

@@ -0,0 +1,93 @@
+class Localite::Scopes < Array
+  def initialize
+    @prebuilt = []
+  end
+  def push(*array)
+    array.each do |s|
+      if @prebuilt.last
+        @prebuilt.push("#{@prebuilt.last}.#{s}")
+      else
+        @prebuilt.push(s.to_s)
+      end
+      super(s)
+    end
+  end
+  def pop(*array)
+    array.each do
+      @prebuilt.pop
+      super()
+    end
+  end
+  def each(s)
+    @prebuilt.reverse_each do |entry|
+      yield "#{entry}.#{s}"
+    end
+    yield s.to_s
+  end
+  def first(s)
+    if @prebuilt.last
+      "#{@prebuilt.last}.#{s}"
+    else
+      s
+    end
+  end
+  def to_s
+    join(":")
+  end
+  def inspect
+    to_s.inspect
+  end
+end
+module Localite::Scopes::Etest
+  Scopes = Localite::Scopes
+  def test_scope
+    scope = Scopes.new
+    scope.push("a")
+    scope.push("b")
+    scope.push("b", "str")
+    assert_equal %w(a b b str), scope
+    assert_equal %w(a.b.b.str a.b.b a.b a), scope.instance_variable_get("@prebuilt").reverse
+    assert_equal "a:b:b:str", scope.to_s
+    assert_equal "\"a:b:b:str\"", scope.inspect
+  end
+  def test_more_scopes
+    Localite.scope("a", :b, "b") do
+      r = []
+      Localite.current_scope.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.current_scope.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.current_scope.each("str.y") do |scoped|
+      r << scoped
+    end
+    assert_equal %w(str.y), r
+  end
+end

data/lib/localite/settings.rb CHANGED

@@ -1,37 +1,159 @@
+#
+# Localite provides three dimensions for translation keys. A call like
+# that:
+#
+# Localite.locale(:de) do
+#   Localite.format(:fbml) do
+#     Localite.scope("outer") do
+#       Localite.scope("scope") do
+#         "msg".t
+#       end
+#     end
+#   end
+# end
+#
+# looks up the following entries in these formats and languages, in
+# that order:
+#
+# - "fbml.de.outer.scope.msg"
+# - "fbml.en.outer.scope.msg"
+# - "html.de.outer.scope.msg"
+# - "html.en.outer.scope.msg"
+# - "text.de.outer.scope.msg"
+# - "text.en.outer.scope.msg"
+# - "fbml.de.scope.msg"
+# - "fbml.en.scope.msg"
+# - "html.de.scope.msg"
+# - "html.en.scope.msg"
+# - "text.de.scope.msg"
+# - "text.en.scope.msg"
+# - "fbml.de.msg"
+# - "fbml.en.msg"
+# - "html.de.msg"
+# - "html.en.msg"
+# - "text.de.msg"
+# - "text.en.msg"
+#
 module Localite::Settings
   #
+  # == set/return the locale ==========================================
+  #
   # Returns the base locale; e.g. :en
   def base
-    I18n.default_locale
+    :en
   end
   #
   # returns the current locale; defaults to the base locale
-  def locale
-    I18n.locale
+  def current_locale
+    Thread.current[:"localite:locale"] || base
   end
-  #
-  # is a specific locale available?
-  def available?(locale)
-    locale && I18n.backend.available_locales.include?(locale.to_sym)
+  def current_locale=(locale)
+    I18n.locale = Thread.current[:"localite:locale"] = locale
   end
   #
-  # sets the current locale. If the locale is not available it changes
-  # the locale to the default locale.
-  def locale=(locale)
-    locale = locale.to_sym
-    I18n.locale = available?(locale) ? locale : base
+  # runs a block in the changed locale
+  def locale(locale, &block)
+    scope :locale => locale, &block
   end
   #
-  # runs a block in the changed locale
-  def in(locale, &block)
-    old = self.locale
-    self.locale = locale if locale
+  # 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)
+    options = if args.last.is_a?(Hash)
+      args.pop
+    else
+      {}
+    end
+    #
+    # set locale
+    if locale = options[:locale]
+      old_locale = self.current_locale
+      self.current_locale = if I18n.backend.available_locales.include?(locale = locale.to_sym)
+        locale
+      else
+        base
+      end
+    end
+    #
+    # set format
+    if format = options[:format]
+      old_format = self.current_format
+      self.current_format = format
+    end
+    #
+    # adjust scope (from the remaining arguments)
+    current_scope.push(*args)
     yield
   ensure
-    self.locale = old
+    current_scope.pop(*args)
+    self.current_format = old_format if old_format
+    self.current_locale = old_locale if old_locale
+  end
+  def scope!(*args, &block)
+    old = current_scope
+    Thread.current[:"localite:scopes"] = Localite::Scopes.new
+    scope(*args, &block)
+  ensure
+    Thread.current[:"localite:scopes"] = old
+  end
+  def current_scope
+    Thread.current[:"localite:scopes"] ||= Localite::Scopes.new
+  end
+  #
+  # == format setting =================================================
+  #
+  # The format 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 format(format, &block)
+    scope :format => format, &block
+  end
+  def current_format
+    Thread.current[:"localite:format"] || :text
+  end
+  def current_format=(fmt)
+    Thread.current[:"localite:format"] = fmt
+  end
+  #
+  # == Inspect ========================================================
+  def inspect
+    "<Localite: [#{current_locale}/#{current_format}]: #{Localite.current_scope.inspect}"
   end
 end