localite 0.1

data/Rakefile

@@ -0,0 +1,15 @@
+task :default => :test
+
+task :test do
+	sh "ruby test/test.rb"
+end
+
+task :rcov do
+  sh "cd test; rcov -o ../coverage -x ruby/.*/gems -x ^test.rb test.rb"
+end
+
+task :rdoc do
+  sh "rdoc -o doc/rdoc"
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/VERSION

@@ -0,0 +1 @@
+0.1

data/config/dependencies.rb

@@ -0,0 +1,5 @@
+#
+# require all dependent gems
+# require "nokogiri"
+
+require "i18n"

data/config/gem.yml

@@ -0,0 +1,7 @@
+description: An easy to use localization gem.
+url: http://github.com/pboy/localite
+author: pboy
+email: eno-pboy@open-lab.org  
+ignore_pattern:
+  - "tmp/*"
+  - "**/.*"

data/init.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+
+gem_root = File.expand_path(File.dirname(__FILE__))
+
+load "#{gem_root}/config/dependencies.rb"
+load "#{gem_root}/lib/#{File.basename(gem_root)}.rb"
+
+module Localite; end
+
+require "#{gem_root}/lib/localite"
+Localite.init

data/lib/localite.rb

@@ -0,0 +1,204 @@
+require "logger"
+
+#
+# This is a *really* simple template and translation engine.
+#
+# TODO: Use erubis instead of this simple engine...
+
+module Localite; end
+
+file_dir = File.expand_path(File.dirname(__FILE__))
+
+# require "#{file_dir}/localite/missing_translation"
+require "#{file_dir}/localite/scope"
+require "#{file_dir}/localite/settings"
+require "#{file_dir}/localite/translate"
+require "#{file_dir}/localite/template"
+
+module Localite
+  #
+  # Add the Localite adapters for Strings ad Symbols.
+  def self.init
+    String.send :include, StringAdapter
+    Symbol.send :include, SymbolAdapter
+  end
+
+  #
+  # a logger
+  def self.logger
+    klass = defined?(ActiveSupport) ? ActiveSupport::BufferedLogger : Logger
+
+    @logger ||= klass.new("log/localite.log")
+  end
+  
+  extend Settings
+  extend Translate
+  extend Scope
+
+  public
+  
+  #
+  # Translating a string:
+  #
+  # If no translation is found we try to translate the string in the base 
+  # language. If there is no base language translation we return the 
+  # string, assuming a base language string.
+  module StringAdapter
+    def t(*args)
+      translated = Localite.translate(self, :no_raise) || self
+      Localite.template translated, *args
+    end
+  end
+
+  #
+  # Translating a string:
+  #
+  # If no translation is found we try to translate the string in the base 
+  # language. If there is no base language translation we raise areturn the 
+  # string, assuming a base language string.
+  module SymbolAdapter
+    def t(*args)
+      translated = Localite.translate(self, :do_raise)
+      Localite.template 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
+    end
+  end
+  
+  def self.template(template, *args)
+    Template.run mode, template, *args
+  end
+end
+
+module Localite::Etest
+
+  #
+  # make sure .t actually runs the Template engine
+  def test_tmpl
+    assert_equal "xyz",                   "xyz".t(:xyz => "abc")
+    assert_equal "abc",                   "{*xyz*}".t(:xyz => "abc")
+  end
+
+  def test_base_lookup
+    assert !I18n.load_path.empty?
+    
+    assert_equal("en.t", "t".t)
+    Localite.in("en") { 
+      assert_equal("en.t", "t".t )
+    }
+    
+    Localite.in("de") { 
+      assert_equal("de.t", "t".t )
+    }
+    
+    assert_equal("de.t", Localite.in("de") { "t".t })
+  end
+  
+  def test_lookup_de
+    Localite.in("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
+      # lookup "base" in base translation
+      assert_equal "en_only", "base".t
+    end
+
+    Localite.in("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
+
+      # flat translation
+      assert_equal "en.t", "t".t
+
+      Localite.scope(:outer, :inner, :x1) do
+        assert_equal("en/outer/inner/x1", "x1".t)
+      end
+  
+      # Miss "x1", and don't translate missing entries
+      assert_equal("x1", "x1".t)
+    end
+  end
+  
+  def test_lookup_no_specific_lang
+    # flat translation
+    assert_equal "en.t", "t".t
+
+    Localite.scope(:outer, :inner, :x1) do
+      assert_equal("en/outer/inner/x1", "x1".t)
+    end
+
+    # Miss "x1", and don't translate missing entries
+    assert_equal("x1", "x1".t)
+  end
+
+  def test_lookup_symbols
+    assert :base.t?
+    
+    assert_equal "en_only", :base.t
+
+    Localite.in("en") do
+      assert_equal "en_only", :base.t
+    end
+
+    Localite.in("de") do
+      assert_equal "en_only", :base.t
+    end
+  end
+
+  def test_missing_lookup_symbols
+    assert !:missing.t?
+    assert_raise(Localite::Translate::Missing) {
+      assert_equal "en_only", :missing.t
+    }
+
+    Localite.in("en") do
+      assert_raise(Localite::Translate::Missing) {
+        :missing.t
+      }
+    end
+
+    Localite.in("de") do
+      assert_raise(Localite::Translate::Missing) {
+        :missing.t
+      }
+    end
+
+    begin
+      :missing.t
+    rescue Localite::Translate::Missing
+      assert_kind_of(String, $!.to_s)
+    end
+  end
+   
+#   def test_html
+#     assert_equal ">",                      "{*'>'*}".t(:xyz => [1, 2, 3], :fl => [1.0])
+#     assert_equal ">",                   "{*'>'*}".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 > 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
+end

data/lib/localite/rails_filter.rb

@@ -0,0 +1,35 @@
+module Localite::RailsFilter
+  def self.filter(controller, &block)
+    #
+    # get the current locale
+    locale = begin
+      controller.send(:current_locale)
+    rescue NoMethodError
+    end
+
+    #
+    # get the current locale
+    begin
+      scope = controller.send(:localite_scope)
+      scope = [ scope ] if scope && !scope.is_a?(Array)
+    rescue NoMethodError
+    end
+
+    #
+    # set up localite for this action.
+    Localite.html do
+      Localite.in(locale) do 
+        Localite.scope(*scope, &block)
+      end
+    end
+  end
+  
+  private
+
+  #
+  # override this method to adjust localite parameters
+  def current_locale
+    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
+end

data/lib/localite/scope.rb

@@ -0,0 +1,140 @@
+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/lib/localite/settings.rb

@@ -0,0 +1,37 @@
+module Localite::Settings
+  #
+  # Returns the base locale; e.g. :en
+  def base
+    I18n.default_locale
+  end
+
+  #
+  # returns the current locale; defaults to the base locale
+  def locale
+    @locale || base
+  end
+
+  #
+  # is a specific locale available?
+  def available?(locale)
+    locale && I18n.backend.available_locales.include?(locale.to_sym)
+  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
+    @locale = available?(locale) ? locale : base
+  end
+
+  #
+  # runs a block in the changed locale
+  def in(locale, &block)
+    old = self.locale
+    self.locale = locale if locale
+    yield
+  ensure
+    self.locale = old
+  end
+end

data/lib/localite/template.rb

@@ -0,0 +1,126 @@
+require "cgi"
+
+class Localite::Template < String
+  def self.run(mode, template, opts = {})
+    new(template).run(mode, opts)
+  end
+
+  #
+  # the environment during run
+  class Env
+    module Helpers
+      # def html(s)
+      #   CGI.escapeHTML s
+      # end
+      # 
+      # def hi(s)
+      #   "&ldquo;" + CGI.escapeHTML(s) + "&rdquo;"
+      # end
+
+      #
+      # pluralize something and add count
+      # pl("apple", 1) -> "1 apple"
+      # pl("apple", 2) -> "2 apples"
+      #
+      # Note a special case on arrays:
+      # pl(%w(apple peach cherry)) -> "3 Strings"
+      def pl(name, count=nil)
+        if count
+          "#{count} #{count != 1 ? name.pluralize : name.singularize}"
+        elsif name.respond_to?(:first) && !name.is_a?(String)
+          pl name.first.class.name, name.length # special case, see above.
+        else
+          name.pluralize
+        end
+      end
+    end
+
+    def method_missing(sym, *args, &block)
+      begin
+        return @host.fetch(sym.to_sym)
+      rescue IndexError
+        :void
+      end
+      
+      begin
+        return @host.fetch(sym.to_s)
+      rescue IndexError
+        :void
+      end
+
+      super
+    end
+    
+    def initialize(host)
+      @host = host
+      extend Helpers
+    end
+
+    def [](code)
+      eval(code).to_s
+    end
+  end
+  
+  def run(mode, opts = {})
+    #
+    env = Env.new(opts)
+
+    #
+    # get all --> {* code *} <-- parts from the template strings and send
+    # them thru the environment.
+    gsub(/\{\*([^\}]+?)\*\}/) do |_|
+      Modi.send mode, env[$1]
+    end
+  end
+
+  module Modi
+    def self.text(s); s; end
+    def self.html(s); CGI.escapeHTML(s); end
+  end
+end
+
+module Localite::Template::Etest
+  Template = Localite::Template
+  
+  def test_templates
+    assert_equal "abc",                   Template.run(:text, "{*xyz*}", :xyz => "abc")
+    assert_equal "3 items",               Template.run(:text, "{*pl 'item', xyz.length*}", :xyz => "abc")
+    assert_equal "xyz",                   Template.run(:text, "xyz", :xyz => "abc")
+    assert_equal "abc",                   Template.run(:text, "{*xyz*}", :xyz => "abc")
+    assert_equal "3",                     Template.run(:text, "{*xyz.length*}", :xyz => "abc")
+    assert_equal "3",                     Template.run(:text, "{*xyz.length*}", :xyz => "abc")
+    assert_equal "3 Fixnums",             Template.run(:text, "{*pl xyz*}", :xyz => [1, 2, 3])
+    assert_equal "3 Fixnums and 1 Float", Template.run(:text, "{*pl xyz*} and {*pl fl*}", :xyz => [1, 2, 3], :fl => [1.0])
+  end
+
+  def test_pl
+    h = Object.new.extend(Localite::Template::Env::Helpers)
+    assert_equal      "1 apple", h.pl("apple", 1)
+    assert_equal      "2 apples", h.pl("apple", 2)
+    assert_equal      "1 apple", h.pl("apples", 1)
+    assert_equal      "2 apples", h.pl("apples", 2)
+
+    assert_equal      "apples", h.pl("apples")
+    assert_equal      "apples", h.pl("apple")
+    
+    assert_equal      "3 Strings", h.pl(%w(apple peach cherry))
+  end
+
+  def test_html_env
+    assert_equal "a>c",                 Template.run(:text, "{*xyz*}", :xyz => "a>c")
+    assert_equal "a&gt;c",              Template.run(:html, "{*xyz*}", :xyz => "a>c")
+    assert_equal "> a>c",               Template.run(:text, "> {*xyz*}", :xyz => "a>c")
+    assert_equal "> a&gt;c",            Template.run(:html, "> {*xyz*}", :xyz => "a>c")
+  end
+
+  def test_template_hash
+    assert_equal "a>c",                 Template.run(:text, "{*xyz*}", :xyz => "a>c")
+    assert_equal "a>c",                 Template.run(:text, "{*xyz*}", "xyz" => "a>c")
+  end
+
+  def test_template_hash_missing
+    assert_raise(NameError) {
+      Template.run(:text, "{*abc*}", :xyz => "a>c")
+    }
+  end
+end

data/lib/localite/translate.rb

@@ -0,0 +1,65 @@
+require "set"
+
+module Localite::Translate
+  # 
+  # translate a string 
+  #
+  # returns the translated string in the current locale.
+  # If no translation is found try the base locale. 
+  # If still no translation is found, return nil
+  # 
+  def translate(s, raise_mode)
+    r = do_translate(locale, s)
+    return r if r
+
+    r = do_translate(base, s) if base != locale
+    return r if r
+    
+    raise Missing, [locale, s] if raise_mode != :no_raise
+  end
+
+  private
+
+  def do_translate(locale, s)
+    scopes.each(s) do |scoped_string|
+      tr = Localite::Translate.translate_via_i18n locale, scoped_string
+      return tr if tr
+    end
+
+    record_missing locale, scopes.first(s)
+    nil
+  end
+  
+  def self.translate_via_i18n(locale, s)
+    locale = base unless I18n.backend.available_locales.include?(locale)
+    I18n.locale = locale
+    I18n.translate(s, :raise => true)
+  rescue I18n::MissingTranslationData
+    nil
+  end
+  
+  #
+  # log a missing translation and raise an exception 
+  def record_missing(locale, s)
+    @missing_translations ||= Set.new
+    entry = [ locale, s ]
+    return if @missing_translations.include?(entry)
+    @missing_translations << entry
+    logger.warn "Missing translation: [#{locale}] #{s.inspect}"
+  end
+  
+  public
+  
+  class Missing < RuntimeError
+    attr :locale
+    attr :string
+
+    def initialize(opts)
+      @locale, @string = *opts
+    end
+
+    def to_s
+      "Missing translation: [#{locale}] #{string.inspect}"
+    end
+  end
+end

data/localite.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{localite}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["pboy"]
+  s.date = %q{2010-05-11}
+  s.description = %q{An easy to use localization gem.}
+  s.email = %q{eno-pboy@open-lab.org}
+  s.extra_rdoc_files = ["lib/localite.rb", "lib/localite/rails_filter.rb", "lib/localite/scope.rb", "lib/localite/settings.rb", "lib/localite/template.rb", "lib/localite/translate.rb", "tasks/echoe.rake"]
+  s.files = ["Manifest", "Rakefile", "VERSION", "config/dependencies.rb", "config/gem.yml", "init.rb", "lib/localite.rb", "lib/localite/rails_filter.rb", "lib/localite/scope.rb", "lib/localite/settings.rb", "lib/localite/template.rb", "lib/localite/translate.rb", "localite.tmproj", "script/console", "script/rebuild", "tasks/echoe.rake", "test/i18n/de.yml", "test/initializers/fake_rails.rb", "test/test.rb", "localite.gemspec"]
+  s.homepage = %q{http://github.com/pboy/localite}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Localite"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{localite}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{An easy to use localization gem.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<i18n>, [">= 0"])
+    else
+      s.add_dependency(%q<i18n>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<i18n>, [">= 0"])
+  end
+end

data/localite.tmproj

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>documents</key>
+	<array>
+		<dict>
+			<key>expanded</key>
+			<true/>
+			<key>name</key>
+			<string>localite</string>
+			<key>regexFolderFilter</key>
+			<string>!.*/(\.[^/]*|CVS|localite|_darcs|_MTN|\{arch\}|blib|.*~\.nib|.*\.(framework|app|pbproj|pbxproj|xcode(proj)?|bundle))$</string>
+			<key>sourceDirectory</key>
+			<string></string>
+		</dict>
+	</array>
+	<key>fileHierarchyDrawerWidth</key>
+	<integer>339</integer>
+	<key>metaData</key>
+	<dict/>
+	<key>showFileHierarchyDrawer</key>
+	<true/>
+	<key>windowFrame</key>
+	<string>{{10, 0}, {924, 778}}</string>
+</dict>
+</plist>

data/script/console

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+#
+# Start a console that initializes the gem
+#
+require "irb"
+require "rubygems"
+
+begin
+  require 'wirble'
+  Wirble.init
+  Wirble.colorize
+rescue LoadError
+  STDERR.puts "To enable colorized and tab completed run 'gem install wirble'"
+end
+
+$: << "#{File.dirname(__FILE__)}/../lib"
+load "#{File.dirname(__FILE__)}/../init.rb"
+
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/../test/i18n/*.yml"]
+
+IRB.start

data/script/rebuild

@@ -0,0 +1,7 @@
+#!/bin/sh
+rake default build_gemspec package || exit 1 
+echo "============================================="
+echo "I built the gem for you. To upload, run "
+echo
+echo "gem push $(ls -d pkg/*.gem | tail -n 1)"
+

data/tasks/echoe.rake

@@ -0,0 +1,48 @@
+#
+# GEM settings
+#
+GEM_ROOT = File.expand_path("#{File.dirname(__FILE__)}/..")
+
+if gem_config = YAML.load(File.read("#{GEM_ROOT}/config/gem.yml"))
+  require 'echoe'  
+
+  #
+  # a dependency reader
+  module Dependency
+    @@dependencies = []
+
+    def self.require(file)
+      @@dependencies << file
+    end
+
+    def self.load
+      eval File.read("#{GEM_ROOT}/config/dependencies.rb"), binding
+      @@dependencies
+    end
+  end
+
+  Echoe.new(File.basename(GEM_ROOT), File.read("#{GEM_ROOT}/VERSION")) do |p|  
+    gem_config.each do |k,v|
+      p.send "#{k}=",v
+    end
+    
+    p.runtime_dependencies = Dependency.load
+  end
+
+  desc "Rebuild and install the gem"
+  task :rebuild => %w(manifest default build_gemspec package) do
+    gem = Dir.glob("pkg/*.gem").sort_by do |filename|
+      File.new(filename).mtime
+    end.last
+  
+    puts "============================================="
+    puts "Installing gem..."
+  
+    system "gem install #{gem} > /dev/null 2>&1"
+  
+    puts ""
+    puts "I built and installed the gem for you. To upload, run "
+    puts
+    puts "    gem push #{gem}"
+  end
+end

data/test/i18n/de.yml

@@ -0,0 +1,15 @@
+#
+# 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"

data/test/initializers/fake_rails.rb

@@ -0,0 +1,20 @@
+#
+# set up fake rails
+
+require "active_record"
+require "fileutils"
+
+LOGFILE = "log/test.log"
+SQLITE_FILE = ":memory:"
+
+#
+# -- set up fake rails ------------------------------------------------
+
+RAILS_ENV="test"
+RAILS_ROOT="#{DIRNAME}"
+
+if !defined?(RAILS_DEFAULT_LOGGER)
+  FileUtils.mkdir_p File.dirname(LOGFILE)
+  RAILS_DEFAULT_LOGGER = Logger.new(LOGFILE)
+  RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+end

data/test/test.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+DIRNAME = File.expand_path File.dirname(__FILE__)
+Dir.chdir(DIRNAME)
+
+#
+# initialize the gem and the test runner
+require '../init'
+
+require 'logger'
+require 'ruby-debug'
+
+require "#{DIRNAME}/initializers/fake_rails.rb"
+
+I18n.load_path += Dir["#{DIRNAME}/i18n/*.yml"]
+
+# ---------------------------------------------------------------------
+
+begin
+  require 'minitest-rg'
+rescue MissingSourceFile
+  STDERR.puts "'gem install minitest-rg' gives you redgreen minitests"
+  require 'minitest/unit'
+end
+
+#
+# run tests
+
+require "etest"
+
+Etest.autorun

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: localite
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- pboy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-11 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: An easy to use localization gem.
+email: eno-pboy@open-lab.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/localite.rb
+- lib/localite/rails_filter.rb
+- lib/localite/scope.rb
+- lib/localite/settings.rb
+- lib/localite/template.rb
+- lib/localite/translate.rb
+- tasks/echoe.rake
+files: 
+- Manifest
+- Rakefile
+- VERSION
+- config/dependencies.rb
+- config/gem.yml
+- init.rb
+- lib/localite.rb
+- lib/localite/rails_filter.rb
+- lib/localite/scope.rb
+- lib/localite/settings.rb
+- lib/localite/template.rb
+- lib/localite/translate.rb
+- localite.tmproj
+- script/console
+- script/rebuild
+- tasks/echoe.rake
+- test/i18n/de.yml
+- test/initializers/fake_rails.rb
+- test/test.rb
+- localite.gemspec
+has_rdoc: true
+homepage: http://github.com/pboy/localite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Localite
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: localite
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An easy to use localization gem.
+test_files: []
+