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

localite 0.3 → 0.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

data/lib/localite/format.rb ADDED

@@ -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