i18n-sequel_bitemporal 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in i18n-sequel.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 Sven Fuchs <svenfuchs@artweb-design.de>
+Copyright (c) 2011 Jonathan Tron <jonathan.tron@thetalentbox.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,115 @@
+h1. I18n::Backend::SequelBitemporal
+
+This repository contains an "I18n":http://github.com/svenfuchs/i18n Sequel 
+backend storing translations using a bitemporal approach. This allows you go back in time
+in your translations and schedule new translations to appears in the future without
+needing any cron task to run.
+
+Most of the code is a port of the "ActiveRecord backend":http://github.com/svenfuchs/i18n-activerecord from SvenFuchs.
+
+It's compatible with both I18n ~> 0.5.0 (Rails 3.0.x) and ~> 0.6.0 (Rails 3.1.x)
+
+h2. Installation
+
+For Bundler put the following in your Gemfile:
+
+<pre>
+  gem 'i18n-sequel_bitemporal', :require => 'i18n/sequel_bitemporal'
+</pre>
+
+or to track master's HEAD:
+
+<pre>
+  gem 'i18n-sequel_bitemporal',
+      :git => 'git://github.com/TalentBox/i18n-sequel_bitemporal.git',
+      :require => 'i18n/sequel_bitemporal'
+</pre>
+
+Next create a sequel migration with the Rails Generator (if you're using rails-sequel).
+Your migration should look like this:
+
+<pre>
+  class CreateI18nTranslationsMigration < Sequel::Migration
+
+    def up
+      create_table :i18n_translations do
+        primary_key :id
+        String :locale, :null => false
+        String :key, :null => false
+        index [:locale, :key], :unique => true
+      end
+
+      create_table :i18n_translation_versions do
+        primary_key :id
+        foreign_key :master_id, :i18n_translations, :on_delete => :cascade
+        Time        :created_at
+        Time        :expired_at
+        Date        :valid_from
+        Date        :valid_to
+        String :value, :text => true
+        String :interpolations, :text => true
+        TrueClass :is_proc, :null => false, :default => false
+      end
+    end
+    
+    def down
+      drop_table :i18n_translation_versions
+      drop_table :i18n_translations
+    end
+
+  end
+</pre>
+
+With these translation tables you will be able to manage your translation, and add new translations or languages.
+
+To load @I18n::Backend::SequelBitemporal@ into your Rails application, create a new file in *config/initializers* named *locale.rb*.
+
+A simple configuration for your locale.rb could look like this:
+
+<pre>
+  require 'i18n/backend/sequel_bitemporal'
+  I18n.backend = I18n::Backend::SequelBitemporal.new
+</pre>
+
+A more advanced example (Thanks Moritz), which uses YAML files and ActiveRecord for lookups:
+
+Memoization is highly recommended if you use a DB as your backend.
+
+<pre>
+  require 'i18n/backend/sequel_bitemporal'
+  I18n.backend = I18n::Backend::SequelBitemporal.new
+
+  I18n::Backend::SequelBitemporal.send(:include, I18n::Backend::Memoize)
+  I18n::Backend::SequelBitemporal.send(:include, I18n::Backend::Flatten)
+  I18n::Backend::Simple.send(:include, I18n::Backend::Memoize)
+  I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+
+  I18n.backend = I18n::Backend::Chain.new(I18n::Backend::Simple.new, I18n.backend)
+</pre>
+
+h2. Usage
+
+You can now use @I18n.t('Your String')@ to lookup translations in the database.
+
+h2. Runnning tests
+
+<pre>
+gem install bundler
+pushd ci
+BUNDLE_GEMFILE=ci/Gemfile.rails-3.x bundle
+BUNDLE_GEMFILE=ci/Gemfile.rails-3.x-i18n-0.6 bundle
+popd
+BUNDLE_GEMFILE=ci/Gemfile.rails-3.x rake
+BUNDLE_GEMFILE=ci/Gemfile.rails-3.x-i18n-0.6 rake
+</pre>
+
+If you want to see what queries are executed:
+
+<pre>
+DEBUG=true BUNDLE_GEMFILE=ci/Gemfile.rails-3.x rake
+DEBUG=true BUNDLE_GEMFILE=ci/Gemfile.rails-3.x-i18n-0.6 rake
+</pre>
+
+h2. Maintainers
+
+* Jonathan Tron

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/ci/Gemfile.rails-3.x

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'i18n', '~> 0.5.0'
+
+gem 'sequel', '~> 3.28'
+gem 'sequel_bitemporal', '~> 0.1.6'
+gem 'sqlite3-ruby'
+gem 'mocha'
+gem 'test_declarative'
+gem 'rake'

data/ci/Gemfile.rails-3.x-i18n-0.6

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'i18n', '~> 0.6.0'
+
+gem 'sequel', '~> 3.28'
+gem 'sequel_bitemporal', '~> 0.1.6'
+gem 'sqlite3-ruby'
+gem 'mocha'
+gem 'test_declarative'
+gem 'rake'

data/ci/Gemfile.rails-3.x-i18n-0.6.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    i18n (0.6.0)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+    sequel (3.29.0)
+    sequel_bitemporal (0.1.7)
+      sequel
+    sqlite3 (1.3.4)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+    test_declarative (0.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  i18n (~> 0.6.0)
+  mocha
+  rake
+  sequel (~> 3.28)
+  sequel_bitemporal (~> 0.1.6)
+  sqlite3-ruby
+  test_declarative

data/ci/Gemfile.rails-3.x.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    i18n (0.5.0)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    sequel (3.29.0)
+    sequel_bitemporal (0.1.6)
+      sequel
+    sqlite3-ruby (1.3.1)
+    test_declarative (0.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  i18n (~> 0.5.0)
+  mocha
+  rake
+  sequel (~> 3.28)
+  sequel_bitemporal (~> 0.1.6)
+  sqlite3-ruby
+  test_declarative

data/i18n-sequel_bitemporal.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "i18n/sequel_bitemporal/version"
+
+Gem::Specification.new do |s|
+  s.name        = "i18n-sequel_bitemporal"
+  s.version     = I18n::SequelBitemporal::VERSION
+  s.authors     = ["Jonathan Tron"]
+  s.email       = ["jonathan.tron@thetalentbox.com"]
+  s.homepage    = "http://github.com/TalentBox/i18n-sequel_bitemporal"
+  s.summary      = "I18n Bitemporal Sequel backend"
+  s.description  = "I18n Bitemporal Sequel backend. Allows to store translations in a database using Sequel using a bitemporal approach, e.g. for providing a web-interface for managing translations."
+  s.rubyforge_project = "[none]"
+
+  s.platform     = Gem::Platform::RUBY
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'i18n', '>= 0.5', "< 0.7.0"
+  s.add_dependency 'sequel', '~> 3.28'
+  s.add_dependency 'sequel_bitemporal', '~> 0.1.7'
+
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "sqlite3"
+end

data/lib/i18n/backend/sequel_bitemporal.rb

@@ -0,0 +1,67 @@
+require 'i18n/backend/base'
+
+module I18n
+  module Backend
+    class SequelBitemporal
+      autoload :Missing,     'i18n/backend/sequel_bitemporal/missing'
+      autoload :StoreProcs,  'i18n/backend/sequel_bitemporal/store_procs'
+      autoload :Translation, 'i18n/backend/sequel_bitemporal/translation'
+
+      module Implementation
+        include Base, Flatten
+
+        def available_locales
+          begin
+            Translation.available_locales
+          rescue ::Sequel::Error
+            []
+          end
+        end
+
+        def store_translations(locale, data, options = {})
+          escape = options.fetch(:escape, true)
+          flatten_translations(locale, data, escape, false).each do |key, value|
+            # Invalidate all keys matching current one:
+            # key = foo.bar invalidates foo, foo.bar and foo.bar.*
+            Translation.locale(locale).lookup(expand_keys(key)).destroy
+            
+            # Find existing master for locale/key or create a new one
+            translation = Translation.locale(locale).lookup_exactly(expand_keys(key)).limit(1).all.first ||
+                          Translation.new(:locale => locale.to_s, :key => key.to_s)
+            translation.attributes = {:value => value}
+            translation.save
+          end
+        end
+
+      protected
+
+        def lookup(locale, key, scope = [], options = {})
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
+          result = Translation.locale(locale).lookup(key).all
+
+          if result.empty?
+            nil
+          elsif result.first.key == key
+            result.first.value
+          else
+            chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
+            result = result.inject({}) do |hash, r|
+              hash[r.key.slice(chop_range)] = r.value
+              hash
+            end
+            result.deep_symbolize_keys
+          end
+        end
+
+        # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
+        def expand_keys(key)
+          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
+            keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
+          end
+        end
+      end
+
+      include Implementation
+    end
+  end
+end

data/lib/i18n/backend/sequel_bitemporal/missing.rb

@@ -0,0 +1,73 @@
+#  This extension stores translation stub records for missing translations to
+#  the database.
+#
+#  This is useful if you have a web based translation tool. It will populate
+#  the database with untranslated keys as the application is being used. A
+#  translator can then go through these and add missing translations.
+#
+#  Example usage:
+#
+#     I18n::Backend::Chain.send(:include, I18n::Backend::Sequel::Missing)
+#     I18n.backend = I18n::Backend::Chain.new(I18n::Backend::Sequel.new, I18n::Backend::Simple.new)
+#
+#  Stub records for pluralizations will also be created for each key defined
+#  in i18n.plural.keys.
+#
+#  For example:
+#
+#    # en.yml
+#    en:
+#      i18n:
+#        plural:
+#          keys: [:zero, :one, :other]
+#
+#    # pl.yml
+#    pl:
+#      i18n:
+#        plural:
+#          keys: [:zero, :one, :few, :other]
+#
+#  It will also persist interpolation keys in Translation#interpolations so
+#  translators will be able to review and use them.
+module I18n
+  module Backend
+    class SequelBitemporal
+      module Missing
+        include Flatten
+
+        def store_default_translations(locale, key, options = {})
+          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
+          separator ||= I18n.default_separator
+          key = normalize_flat_keys(locale, key, scope, separator)
+
+          if Translation.locale(locale).lookup(key).empty?
+            interpolations = options.keys - I18n::RESERVED_KEYS
+            keys = count ? I18n.t('i18n.plural.keys', :locale => locale).map { |k| [key, k].join(FLATTEN_SEPARATOR) } : [key]
+            keys.each { |key| store_default_translation(locale, key, interpolations) }
+          end
+        end
+
+        def store_default_translation(locale, key, interpolations)
+          translation = Translation.new :locale => locale.to_s, :key => key
+          # We're storing interpolations in the version
+          translation.attributes = {:interpolations => interpolations}
+          translation.save
+        end
+
+        def translate(locale, key, options = {})
+          result = catch(:exception) do
+            super
+          end
+          if I18n.const_defined?(:MissingTranslation) && result.is_a?(I18n::MissingTranslation)
+            self.store_default_translations(locale, key, options)
+            throw(:exception, result)
+          end
+          result
+        rescue I18n::MissingTranslationData => e
+          self.store_default_translations(locale, key, options)
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/i18n/backend/sequel_bitemporal/store_procs.rb

@@ -0,0 +1,39 @@
+# This module is intended to be mixed into the Sequel backend to allow
+# storing Ruby Procs as translation values in the database.
+#
+#   I18n.backend = I18n::Backend::Sequel.new
+#   I18n::Backend::Sequel::Translation.send(:include, I18n::Backend::Sequel::StoreProcs)
+#
+# The StoreProcs module requires the ParseTree and ruby2ruby gems and therefor
+# was extracted from the original backend.
+#
+# ParseTree is not compatible with Ruby 1.9.
+
+begin
+  require 'ruby2ruby'
+  require 'parse_tree'
+  require 'parse_tree_extensions'
+rescue LoadError => e
+  puts "can't use StoreProcs because: #{e.message}"
+end
+
+module I18n
+  module Backend
+    class SequelBitemporal
+      module StoreProcs
+        def value=(v)
+          case v
+          when Proc
+            super(v.to_ruby)
+            self.is_proc = true
+          else
+            super(v)
+          end
+        end
+
+        Translation.send(:include, self) if method(:to_s).respond_to?(:to_ruby)
+      end
+    end
+  end
+end
+

data/lib/i18n/backend/sequel_bitemporal/translation.rb

@@ -0,0 +1,147 @@
+require 'sequel'
+
+module I18n
+  module Backend
+    # Sequel model used to store actual translations to the database.
+    #
+    # This model expects two tables like the following to be already set up in
+    # your the database:
+    #
+    # create_table :i18n_translations do
+    #   primary_key :id
+    #   String :locale, :null => false
+    #   String :key, :null => false
+    #   index [:locale, :key], :unique => true
+    # end
+    # 
+    # create_table :i18n_translation_versions do
+    #   primary_key :id
+    #   foreign_key :master_id, :i18n_translations, :on_delete => :cascade
+    #   Time        :created_at
+    #   Time        :expired_at
+    #   Date        :valid_from
+    #   Date        :valid_to
+    #   String :value, :text => true
+    #   String :interpolations, :text => true
+    #   TrueClass :is_proc, :null => false, :default => false
+    # end
+    #
+    # This model supports two named scopes :locale and :lookup. The :locale
+    # scope simply adds a condition for a given locale:
+    #
+    #   I18n::Backend::SequelBitemporal::Translation.locale(:en).all
+    #   # => all translation records that belong to the :en locale
+    #
+    # The :lookup scope adds a condition for looking up all translations
+    # that either start with the given keys (joined by an optionally given
+    # separator or I18n.default_separator) or that exactly have this key.
+    #
+    #   # with translations present for :"foo.bar" and :"foo.baz"
+    #   I18n::Backend::SequelBitemporal::Translation.lookup(:foo)
+    #   # => an array with both translation records :"foo.bar" and :"foo.baz"
+    #
+    #   I18n::Backend::SequelBitemporal::Translation.lookup([:foo, :bar])
+    #   I18n::Backend::SequelBitemporal::Translation.lookup(:"foo.bar")
+    #   # => an array with the translation record :"foo.bar"
+    #
+    # When the StoreProcs module was mixed into this model then Procs will
+    # be stored to the database as Ruby code and evaluated when :value is
+    # called.
+    #
+    #   Translation = I18n::Backend::SequelBitemporal::Translation
+    #   Translation.create \
+    #     :locale => 'en'
+    #     :key    => 'foo'
+    #     :value  => lambda { |key, options| 'FOO' }
+    #   Translation.find_by_locale_and_key('en', 'foo').value
+    #   # => 'FOO'
+    class SequelBitemporal
+      class TranslationVersion < ::Sequel::Model(:i18n_translation_versions)
+        plugin :serialization
+
+        TRUTHY_CHAR = "\001"
+        FALSY_CHAR = "\002"
+
+        # set_restricted_columns :is_proc, :interpolations
+        serialize_attributes :marshal, :value
+        serialize_attributes :marshal, :interpolations
+
+        # Sequel do not support default value for serialize_attributes
+        def interpolations
+          super || []
+        end
+        
+        def interpolates?(key)
+          self.interpolations.include?(key) if self.interpolations
+        end
+
+        def value
+          value = super
+          if is_proc
+            Kernel.eval(value)
+          elsif value == FALSY_CHAR
+            false
+          elsif value == TRUTHY_CHAR
+            true
+          else
+            value
+          end
+        end
+
+        def value=(value)
+          if value === false
+            value = FALSY_CHAR
+          elsif value === true
+            value = TRUTHY_CHAR
+          end
+
+          super(value)
+        end
+      end
+      
+      class Translation < ::Sequel::Model(:i18n_translations)
+        extend Forwardable
+        plugin :bitemporal, version_class: TranslationVersion
+        
+        delegate [:value, :interpolations, :interpolates?] => :pending_or_current_version
+        
+        def_dataset_method :locale do |locale|
+          filter(:locale => locale.to_s)
+        end
+
+        def_dataset_method :lookup do |keys, *separator|
+          lookup_and_current true, keys, *separator
+        end
+
+        def_dataset_method :lookup_any do |keys|
+          lookup_and_current false, keys
+        end
+
+        def_dataset_method :lookup_exactly do |keys|
+          keys = Array(keys).map! { |key| key.to_s }
+          eager_graph(:current_version).filter(:key => keys.last)
+        end
+        
+        def_dataset_method :lookup_and_current do |with_current, keys, *separator|
+          keys = Array(keys).map! { |key| key.to_s }
+
+          unless separator.empty?
+            warn "[DEPRECATION] Giving a separator to Translation.lookup is deprecated. " <<
+              "You can change the internal separator by overwriting FLATTEN_SEPARATOR."
+          end
+
+          namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_SEPARATOR}%"
+          set = eager_graph(:current_version).filter({:key => keys} | :key.like(namespace))
+          set = set.filter({:current_version__id => nil}.sql_negate) if with_current
+          set
+        end
+
+        class << self
+          def available_locales
+            Translation.distinct.select(:locale).map { |t| t.locale.to_sym }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/sequel_bitemporal.rb

@@ -0,0 +1,2 @@
+require 'i18n'
+require 'i18n/sequel_bitemporal/version'

data/lib/i18n/sequel_bitemporal/version.rb

@@ -0,0 +1,5 @@
+module I18n
+  module SequelBitemporal
+    VERSION = "0.0.1"
+  end
+end

data/test/all.rb

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+$:.unshift(dir)
+
+Dir["#{dir}/**/*_test.rb"].sort.each do |file|
+  require file.sub(/^#{dir}\/(.*)\.rb$/, '\1')
+end
+

data/test/api_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nSequelBitemporalApiTest < Test::Unit::TestCase
+  def setup
+    I18n::Backend::SequelBitemporal::Translation.delete
+    I18n.backend = I18n::Backend::SequelBitemporal.new
+    super
+  end
+    
+  def self.can_store_procs?
+    I18n::Backend::SequelBitemporal.included_modules.include?(I18n::Backend::SequelBitemporal::StoreProcs)
+  end
+
+  include I18n::Tests::Basics
+  include I18n::Tests::Defaults
+  include I18n::Tests::Interpolation
+  include I18n::Tests::Link
+  include I18n::Tests::Lookup
+  include I18n::Tests::Pluralization
+  include I18n::Tests::Procs if can_store_procs?
+  
+  include I18n::Tests::Localization::Date
+  include I18n::Tests::Localization::DateTime
+  include I18n::Tests::Localization::Time
+  include I18n::Tests::Localization::Procs if can_store_procs?
+  
+  test "make sure we use a Sequel backend" do
+    assert_equal I18n::Backend::SequelBitemporal, I18n.backend.class
+  end
+end if defined?(Sequel)
+

data/test/missing_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nSequelBitemporalMissingTest < Test::Unit::TestCase
+  class Backend < I18n::Backend::SequelBitemporal
+    include I18n::Backend::SequelBitemporal::Missing
+  end
+
+  def setup
+    I18n.backend.store_translations(:en, :bar => 'Bar', :i18n => { :plural => { :keys => [:zero, :one, :other] } })
+    I18n.backend = I18n::Backend::Chain.new(Backend.new, I18n.backend)
+    I18n::Backend::SequelBitemporal::Translation.delete
+  end
+
+  test "can persist interpolations" do
+    translation = I18n::Backend::SequelBitemporal::Translation.new(:key => 'foo', :locale => :en)
+    translation.attributes = {:value => 'bar', :interpolations => %w(count name)} 
+    translation.save
+    assert translation.valid?
+  end
+
+  test "lookup persists the key" do
+    I18n.t('foo.bar.baz')
+    assert_equal 1, I18n::Backend::SequelBitemporal::Translation.count
+    assert I18n::Backend::SequelBitemporal::Translation.locale(:en).filter(:key => 'foo.bar.baz').first
+  end
+
+  test "lookup does not persist the key twice" do
+    2.times { I18n.t('foo.bar.baz') }
+    assert_equal 1, I18n::Backend::SequelBitemporal::Translation.count
+    assert I18n::Backend::SequelBitemporal::Translation.locale(:en).filter(:key => 'foo.bar.baz').first
+  end
+
+  test "lookup persists interpolation keys when looked up directly" do
+    I18n.t('foo.bar.baz', :cow => "lucy" )  # creates stub translation.
+    translation_stub = I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup('foo.bar.baz').all.first
+    assert translation_stub.interpolates?(:cow)
+  end
+
+  test "creates one stub per pluralization" do
+    I18n.t('foo', :count => 999)
+    translations = I18n::Backend::SequelBitemporal::Translation.locale(:en).filter(:key => %w{ foo.zero foo.one foo.other }).all
+    assert_equal 3, translations.length
+  end
+
+  test "creates no stub for base key in pluralization" do
+    I18n.t('foo', :count => 999)
+    assert_equal 3, I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup("foo").count
+    assert !I18n::Backend::SequelBitemporal::Translation.locale(:en).filter(:key => "foo").first
+  end
+
+  test "creates a stub when a custom separator is used" do
+    I18n.t('foo|baz', :separator => '|')
+    I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup("foo.baz").all.first.update_attributes(:value => 'baz!')
+    assert_equal 'baz!', I18n.t('foo|baz', :separator => '|')
+  end
+
+  test "creates a stub per pluralization when a custom separator is used" do
+    I18n.t('foo|bar', :count => 999, :separator => '|')
+    translations = I18n::Backend::SequelBitemporal::Translation.locale(:en).filter(:key => %w{ foo.bar.zero foo.bar.one foo.bar.other }).all
+    assert_equal 3, translations.length
+  end
+
+  test "creates a stub when a custom separator is used and the key contains the flatten separator (a dot character)" do
+    key = 'foo|baz.zab'
+    I18n.t(key, :separator => '|')
+    I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup("foo.baz\001zab").all.first.update_attributes(:value => 'baz!')
+    assert_equal 'baz!', I18n.t(key, :separator => '|')
+  end
+
+end if defined?(Sequel)
+

data/test/sequel_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nBackendSequelBitemporalTest < Test::Unit::TestCase
+  def clear_all
+    I18n::Backend::SequelBitemporal::Translation.delete
+  end
+
+  def setup
+    I18n.backend = I18n::Backend::SequelBitemporal.new
+    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+  end
+
+  def teardown
+    clear_all
+    super
+  end
+  
+  test "store_translations does not allow ambiguous keys (1)" do
+    clear_all
+    I18n.backend.store_translations(:en, :foo => 'foo')
+    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
+    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
+
+    translations = I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup('foo').all
+    assert_equal %w(bar baz), translations.map(&:value)
+
+    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t(:foo))
+  end
+
+  test "store_translations does not allow ambiguous keys (2)" do
+    clear_all
+    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
+    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
+    I18n.backend.store_translations(:en, :foo => 'foo')
+
+    translations = I18n::Backend::SequelBitemporal::Translation.locale(:en).lookup('foo').all
+    assert_equal %w(foo), translations.map(&:value)
+
+    assert_equal 'foo', I18n.t(:foo)
+  end
+
+  test "can store translations with keys that are translations containing special chars" do
+    I18n.backend.store_translations(:es, :"Pagina's" => "Pagina's" )
+    assert_equal "Pagina's", I18n.t(:"Pagina's", :locale => :es)
+  end
+
+  with_mocha do
+    test "missing translations table does not cause an error in #available_locales" do
+      I18n::Backend::SequelBitemporal::Translation.expects(:available_locales).raises(::Sequel::Error)
+      assert_equal [], I18n.backend.available_locales
+    end
+  end
+
+  def test_expand_keys
+    assert_equal %w(foo foo.bar foo.bar.baz), I18n.backend.send(:expand_keys, :'foo.bar.baz')
+  end
+end if defined?(Sequel)

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+$:.unshift File.expand_path(".", File.dirname(__FILE__))
+
+require 'test_setup'
+
+I18n::Tests.parse_options!
+require 'bundler/setup'
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+require 'i18n/sequel_bitemporal'
+require 'i18n/tests'
+require 'mocha'
+require 'test_declarative'
+I18n::Tests.setup_sequel
+
+class Test::Unit::TestCase
+  def self.with_mocha
+    yield if Object.respond_to?(:expects)
+  end
+
+  def teardown
+    I18n.locale = nil
+    I18n.default_locale = :en
+    I18n.load_path = []
+    I18n.available_locales = nil
+    I18n.backend = nil
+  end
+
+  def translations
+    I18n.backend.instance_variable_get(:@translations)
+  end
+
+  def store_translations(*args)
+    data   = args.pop
+    locale = args.pop || :en
+    I18n.backend.store_translations(locale, data)
+  end
+
+  def locales_dir
+    File.dirname(__FILE__) + '/test_data/locales'
+  end
+end
+
+Object.class_eval do
+  def meta_class
+    class << self; self; end
+  end
+end unless Object.method_defined?(:meta_class)

data/test/test_setup.rb

@@ -0,0 +1,107 @@
+$KCODE = 'u' if RUBY_VERSION <= '1.9'
+
+require 'rubygems'
+require 'test/unit'
+require 'optparse'
+
+# Do not load the i18n gem from libraries like active_support.
+#
+# This is required for testing against Rails 2.3 because active_support/vendor.rb#24 tries
+# to load I18n using the gem method. Instead, we want to test the local library of course.
+alias :gem_for_ruby_19 :gem # for 1.9. gives a super ugly seg fault otherwise
+def gem(gem_name, *version_requirements)
+  puts("skipping loading the i18n gem ...") && return if gem_name =='i18n'
+  super(gem_name, *version_requirements)
+end
+
+module I18n
+  module Tests
+    class << self
+      def options
+        @options ||= { :with => [], :adapter => 'sqlite3' }
+      end
+
+      def parse_options!
+        OptionParser.new do |o|
+          o.on('-w', '--with DEPENDENCIES', 'Define dependencies') do |dep|
+            options[:with] = dep.split(',').map { |group| group.to_sym }
+          end
+        end.parse!
+        
+        options[:with].each do |dep|
+          case dep
+          when :sqlite3, :mysql, :postgres
+            @options[:adapter] = dep
+          when :r23, :'rails-2.3.x'
+            ENV['BUNDLE_GEMFILE'] = 'ci/Gemfile.rails-2.3.x'
+          when :r3, :'rails-3.0.x'
+            ENV['BUNDLE_GEMFILE'] = 'ci/Gemfile.rails-3.x'
+          when :'no-rails'
+            ENV['BUNDLE_GEMFILE'] = 'ci/Gemfile.no-rails'
+          end
+        end
+
+        ENV['BUNDLE_GEMFILE'] ||= 'ci/Gemfile.all'
+      end
+
+      def setup_sequel
+        begin
+          require 'sequel'
+          ::Sequel::Model.db
+          true
+        rescue LoadError => e
+          puts "can't use Sequel backend because: #{e.message}"
+        rescue ::Sequel::Error
+          connect_sequel
+          require 'i18n/backend/sequel_bitemporal'
+          require 'i18n/backend/sequel_bitemporal/store_procs'
+          true
+        end
+      end
+
+      def connect_sequel
+        connect_adapter
+        ::Sequel.extension :migration
+        ::Sequel.migration do
+          change do
+            create_table :i18n_translations do
+              primary_key :id
+              String :locale, :null => false
+              String :key, :null => false
+              index [:locale, :key], :unique => true
+            end
+
+            create_table :i18n_translation_versions do
+              primary_key :id
+              foreign_key :master_id, :i18n_translations, :on_delete => :cascade
+              Time        :created_at
+              Time        :expired_at
+              Date        :valid_from
+              Date        :valid_to
+              String :value, :text => true
+              String :interpolations, :text => true
+              TrueClass :is_proc, :null => false, :default => false
+            end
+          end
+        end.apply(::Sequel::Model.db, :up)
+      end
+
+      def connect_adapter
+        logger = nil
+        if ENV["DEBUG"]
+          require "logger"
+          logger =  Logger.new STDOUT
+        end
+        case options[:adapter].to_sym
+        when :sqlite3
+          ::Sequel.sqlite(":memory:", :logger => logger)
+        when :mysql
+          # CREATE DATABASE i18n_unittest;
+          # CREATE USER 'i18n'@'localhost' IDENTIFIED BY '';
+          # GRANT ALL PRIVILEGES ON i18n_unittest.* to 'i18n'@'localhost';
+          ::Sequel.mysql(:database => "i18n_unittest", :user => "i18n", :password => "", :host => "localhost", :logger => logger)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: i18n-sequel_bitemporal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Tron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70145825513080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - <
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70145825513080
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &70145825502160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.28'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70145825502160
+- !ruby/object:Gem::Dependency
+  name: sequel_bitemporal
+  requirement: &70145825499240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70145825499240
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70145825496400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70145825496400
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70145825488900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70145825488900
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70145825485520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70145825485520
+description: I18n Bitemporal Sequel backend. Allows to store translations in a database
+  using Sequel using a bitemporal approach, e.g. for providing a web-interface for
+  managing translations.
+email:
+- jonathan.tron@thetalentbox.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- ci/Gemfile.rails-3.x
+- ci/Gemfile.rails-3.x-i18n-0.6
+- ci/Gemfile.rails-3.x-i18n-0.6.lock
+- ci/Gemfile.rails-3.x.lock
+- i18n-sequel_bitemporal.gemspec
+- lib/i18n/backend/sequel_bitemporal.rb
+- lib/i18n/backend/sequel_bitemporal/missing.rb
+- lib/i18n/backend/sequel_bitemporal/store_procs.rb
+- lib/i18n/backend/sequel_bitemporal/translation.rb
+- lib/i18n/sequel_bitemporal.rb
+- lib/i18n/sequel_bitemporal/version.rb
+- test/all.rb
+- test/api_test.rb
+- test/missing_test.rb
+- test/sequel_test.rb
+- test/test_helper.rb
+- test/test_setup.rb
+homepage: http://github.com/TalentBox/i18n-sequel_bitemporal
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ! '[none]'
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: I18n Bitemporal Sequel backend
+test_files:
+- test/all.rb
+- test/api_test.rb
+- test/missing_test.rb
+- test/sequel_test.rb
+- test/test_helper.rb
+- test/test_setup.rb
+has_rdoc: