arena-i18n-active_record 0.0.4

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 Sven Fuchs <svenfuchs@artweb-design.de>
+
+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,72 @@
+h1. I18n::Backend::ActiveRecord
+
+This repository contains the I18n ActiveRecord backend and support code that has been extracted from the "I18n":http://github.com/svenfuchs/i18n.
+
+h2. Installation
+
+For Bundler put the following in your Gemfile:
+
+<pre>
+  gem 'i18n-active_record',
+      :git => 'git://github.com/svenfuchs/i18n-active_record.git',
+      :require => 'i18n/active_record'
+</pre>
+
+Next create a active record model named @Translation@ with the Rails Generator.
+Your migration should look like this:
+
+<pre>
+  class CreateTranslations < ActiveRecord::Migration
+    def self.up
+      create_table :translations do |t|
+        t.string :locale
+        t.string :key
+        t.text   :value
+        t.text   :interpolations
+        t.boolean :is_proc, :default => false
+
+        t.timestamps
+      end
+    end
+
+    def self.down
+      drop_table :translations
+    end
+  end
+</pre>
+
+With this translation model you will be able to manage your translation, and add new translations or languages through
+it.
+
+To load @I18n::Backend::ActiveRecord@ 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/active_record'
+  I18n.backend = I18n::Backend::ActiveRecord.new
+</pre>
+
+A more adavanced example (Thanks Moritz), which uses YAML files and ActiveRecord for lookups:
+
+<pre>
+  require 'i18n/backend/active_record'
+  I18n.backend = I18n::Backend::ActiveRecord.new
+
+  I18n::Backend::ActiveRecord.send(:include, I18n::Backend::Memoize)
+  I18n::Backend::ActiveRecord.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. Maintainers
+
+* Sven Fuchs
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+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 'i18n', :path => '~/Development/projects/i18n/i18n'
+
+gem 'activerecord', '~> 3.0.0'
+gem 'activesupport', '~> 3.0.0'
+gem 'sqlite3-ruby'
+gem 'mocha'
+

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

@@ -0,0 +1,36 @@
+PATH
+  remote: ~/Development/projects/i18n/i18n
+  specs:
+    i18n (0.4.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.1)
+      activesupport (= 3.0.1)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activerecord (3.0.1)
+      activemodel (= 3.0.1)
+      activesupport (= 3.0.1)
+      arel (~> 1.0.0)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.1)
+    arel (1.0.1)
+      activesupport (~> 3.0.0)
+    builder (2.1.2)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    sqlite3-ruby (1.3.1)
+    tzinfo (0.3.23)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.0)
+  activesupport (~> 3.0.0)
+  i18n!
+  mocha
+  sqlite3-ruby

data/lib/i18n/active_record.rb

@@ -0,0 +1 @@
+require 'i18n'

data/lib/i18n/active_record/version.rb

@@ -0,0 +1,6 @@
+module I18n
+  module ActiveRecord
+    VERSION = "0.0.4"
+  end
+end
+

data/lib/i18n/backend/active_record.rb

@@ -0,0 +1,62 @@
+require 'i18n/backend/base'
+require 'i18n/backend/active_record/translation'
+
+module I18n
+  module Backend
+    class ActiveRecord
+      autoload :Missing,     'i18n/backend/active_record/missing'
+      autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
+      autoload :Translation, 'i18n/backend/active_record/translation'
+
+      module Implementation
+        include Base, Flatten
+
+        def available_locales
+          begin
+            Translation.available_locales
+          rescue ::ActiveRecord::StatementInvalid
+            []
+          end
+        end
+
+        def store_translations(locale, data, options = {})
+          escape = options.fetch(:escape, true)
+          flatten_translations(locale, data, escape, false).each do |key, value|
+            Translation.locale(locale).lookup(expand_keys(key)).delete_all
+            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
+          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/active_record/missing.rb

@@ -0,0 +1,66 @@
+#  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::ActiveRecord::Missing)
+#     I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.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 ActiveRecord
+      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)
+
+          unless ActiveRecord::Translation.locale(locale).lookup(key).exists?
+            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 = ActiveRecord::Translation.new :locale => locale.to_s, :key => key
+          translation.interpolations = interpolations
+          translation.save
+        end
+
+        def translate(locale, key, options = {})
+          super
+        rescue I18n::MissingTranslationData => e
+          self.store_default_translations(locale, key, options)
+          raise e
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,39 @@
+# This module is intended to be mixed into the ActiveRecord backend to allow
+# storing Ruby Procs as translation values in the database.
+#
+#   I18n.backend = I18n::Backend::ActiveRecord.new
+#   I18n::Backend::ActiveRecord::Translation.send(:include, I18n::Backend::ActiveRecord::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 ActiveRecord
+      module StoreProcs
+        def value=(v)
+          case v
+          when Proc
+            write_attribute(:value, v.to_ruby)
+            write_attribute(:is_proc, true)
+          else
+            write_attribute(:value, v)
+          end
+        end
+
+        Translation.send(:include, self) if method(:to_s).respond_to?(:to_ruby)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,111 @@
+require 'active_record'
+
+module I18n
+  module Backend
+    # ActiveRecord model used to store actual translations to the database.
+    #
+    # This model expects a table like the following to be already set up in
+    # your the database:
+    #
+    #   create_table :translations do |t|
+    #     t.string :locale
+    #     t.string :key
+    #     t.text   :value
+    #     t.text   :interpolations
+    #     t.boolean :is_proc, :default => false
+    #   end
+    #
+    # This model supports to named scopes :locale and :lookup. The :locale
+    # scope simply adds a condition for a given locale:
+    #
+    #   I18n::Backend::ActiveRecord::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::ActiveRecord::Translation.lookup(:foo)
+    #   # => an array with both translation records :"foo.bar" and :"foo.baz"
+    #
+    #   I18n::Backend::ActiveRecord::Translation.lookup([:foo, :bar])
+    #   I18n::Backend::ActiveRecord::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::ActiveRecord::Translation
+    #   Translation.create \
+    #     :locale => 'en'
+    #     :key    => 'foo'
+    #     :value  => lambda { |key, options| 'FOO' }
+    #   Translation.find_by_locale_and_key('en', 'foo').value
+    #   # => 'FOO'
+    class ActiveRecord
+      class Translation < ::ActiveRecord::Base
+        TRUTHY_CHAR = "\001"
+        FALSY_CHAR = "\002"
+
+        self.table_name = 'translations'
+        attr_protected :is_proc, :interpolations
+
+        serialize :value
+        serialize :interpolations, Array
+
+        class << self
+          def locale(locale)
+            scoped(:conditions => { :locale => locale.to_s })
+          end
+
+          def lookup(keys, *separator)
+            column_name = connection.quote_column_name('key')
+            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}%"
+            scoped(:conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace])
+          end
+
+          def available_locales
+            Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale.to_sym }
+          end
+        end
+
+        def interpolates?(key)
+          self.interpolations.include?(key) if self.interpolations
+        end
+
+        def value
+          value = read_attribute(:value)
+          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
+
+          write_attribute(:value, value)
+        end
+      end
+    end
+  end
+end
+

data/test/active_record_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nBackendActiveRecordTest < Test::Unit::TestCase
+  def setup
+    I18n.backend = I18n::Backend::ActiveRecord.new
+    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+  end
+
+  def teardown
+    I18n::Backend::ActiveRecord::Translation.destroy_all
+    super
+  end
+
+  test "store_translations does not allow ambiguous keys (1)" do
+    I18n::Backend::ActiveRecord::Translation.delete_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::ActiveRecord::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
+    I18n::Backend::ActiveRecord::Translation.delete_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::ActiveRecord::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::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid)
+      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?(ActiveRecord)
+

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,30 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nActiveRecordApiTest < Test::Unit::TestCase
+  def setup
+    I18n.backend = I18n::Backend::ActiveRecord.new
+    super
+  end
+
+  def self.can_store_procs?
+    I18n::Backend::ActiveRecord.included_modules.include?(I18n::Backend::ActiveRecord::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 an ActiveRecord backend" do
+    assert_equal I18n::Backend::ActiveRecord, I18n.backend.class
+  end
+end if defined?(ActiveRecord)
+

data/test/missing_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class I18nActiveRecordMissingTest < Test::Unit::TestCase
+  class Backend < I18n::Backend::ActiveRecord
+    include I18n::Backend::ActiveRecord::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::ActiveRecord::Translation.delete_all
+  end
+
+  test "can persist interpolations" do
+    translation = I18n::Backend::ActiveRecord::Translation.new(:key => 'foo', :value => 'bar', :locale => :en)
+    translation.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::ActiveRecord::Translation.count
+    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+  end
+
+  test "lookup does not persist the key twice" do
+    2.times { I18n.t('foo.bar.baz') }
+    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
+    assert I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key('foo.bar.baz')
+  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::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
+    assert translation_stub.interpolates?(:cow)
+  end
+
+  test "creates one stub per pluralization" do
+    I18n.t('foo', :count => 999)
+    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).find_all_by_key %w{ foo.zero foo.one foo.other }
+    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::ActiveRecord::Translation.locale(:en).lookup("foo").count
+    assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key("foo")
+  end
+
+  test "creates a stub when a custom separator is used" do
+    I18n.t('foo|baz', :separator => '|')
+    I18n::Backend::ActiveRecord::Translation.locale(:en).lookup("foo.baz").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::ActiveRecord::Translation.locale(:en).find_all_by_key %w{ foo.bar.zero foo.bar.one foo.bar.other }
+    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::ActiveRecord::Translation.locale(:en).lookup("foo.baz\001zab").first.update_attributes!(:value => 'baz!')
+    assert_equal 'baz!', I18n.t(key, :separator => '|')
+  end
+
+end if defined?(ActiveRecord)
+

data/test/test_helper.rb

@@ -0,0 +1,56 @@
+require 'test_setup'
+
+I18n::Tests.parse_options!
+require 'bundler/setup'
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+require 'i18n/active_record'
+require 'i18n/tests'
+require 'mocha'
+I18n::Tests.setup_active_record
+
+class Test::Unit::TestCase
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+
+  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,92 @@
+$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_active_record
+        begin
+          require 'active_record'
+          ActiveRecord::Base.connection
+          true
+        rescue LoadError => e
+          puts "can't use ActiveRecord backend because: #{e.message}"
+        rescue ActiveRecord::ConnectionNotEstablished
+          require 'i18n/backend/active_record'
+          require 'i18n/backend/active_record/store_procs'
+          connect_active_record
+          true
+        end
+      end
+
+      def connect_active_record
+        connect_adapter
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Schema.define(:version => 1) do
+          create_table :translations, :force => true do |t|
+            t.string :locale
+            t.string :key
+            t.text :value
+            t.text :interpolations
+            t.boolean :is_proc, :default => false
+          end
+          add_index :translations, [:locale, :key], :unique => true
+        end
+      end
+
+      def connect_adapter
+        case options[:adapter].to_sym
+        when :sqlite3
+          ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+        when :mysql
+          # CREATE DATABASE i18n_unittest;
+          # CREATE USER 'i18n'@'localhost' IDENTIFIED BY '';
+          # GRANT ALL PRIVILEGES ON i18n_unittest.* to 'i18n'@'localhost';
+          ActiveRecord::Base.establish_connection(:adapter => "mysql", :database => "i18n_unittest", :username => "i18n", :password => "", :host => "localhost")
+        end
+      end
+    end
+  end
+end
+
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: arena-i18n-active_record
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-11 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id001
+description: I18n ActiveRecord backend. Allows to store translations in a database using ActiveRecord, e.g. for providing a web-interface for managing translations.
+email: svenfuchs@artweb-design.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ci/Gemfile.rails-3.x
+- ci/Gemfile.rails-3.x.lock
+- lib/i18n/active_record/version.rb
+- lib/i18n/active_record.rb
+- lib/i18n/backend/active_record/missing.rb
+- lib/i18n/backend/active_record/store_procs.rb
+- lib/i18n/backend/active_record/translation.rb
+- lib/i18n/backend/active_record.rb
+- test/active_record_test.rb
+- test/all.rb
+- test/api_test.rb
+- test/missing_test.rb
+- test/test_helper.rb
+- test/test_setup.rb
+- MIT-LICENSE
+- README.textile
+- Rakefile
+homepage: http://github.com/arenaflowers/i18n-active_record
+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.24
+signing_key: 
+specification_version: 3
+summary: I18n ActiveRecord backend
+test_files: []
+
+has_rdoc: