efficient_translations 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in babel.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    efficient_translations (0.0.1)
+      activerecord (~> 2.3)
+      activesupport (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activerecord (2.3.11)
+      activesupport (= 2.3.11)
+    activesupport (2.3.11)
+    diff-lcs (1.1.3)
+    rake (0.9.2.2)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    sqlite3 (1.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  efficient_translations!
+  rake
+  rspec
+  sqlite3

data/README.md

@@ -0,0 +1,157 @@
+# EfficientTranslations
+
+EfficientTranslations is a translation library for ActiveRecord models in Rails 2
+
+I wrote EfficientTranslations because I'm working on several legacy rails apps with performance problems and I cannot migrate to Rails 3.
+
+EfficientTranslations is inspired to both [Globalize2](https://github.com/joshmh/globalize2) (for models architecture: translations are stored in a separated table) and [Puret](https://github.com/jo/puret) (for cache mechanics).
+
+
+## Requirements
+
+- ActiveSupport 2.3.x
+- ActiveRecord  2.3.x
+
+
+## Architecture
+
+The idea is always the same. One table for model records, another table for model translation records.
+This architecture works well if app languages could change in the future and you don't want to add a column each time a new language is added, or if you have a large number of translations to manage.
+
+EfficientTranslations is designed to reduce the number of queries done to get model+translations and the amount of data retrieved.
+
+I don't think it's a perfect solution, indeed *I think it's far to be a perfect solution*, but it's a step forward.
+
+
+## Translate a Model
+
+To explain the gem usage we'll use the following use case:
+
+    We need a Product model with two localizable fields:
+    - name (string)
+    - another_field (integer)
+
+### Migrations
+
+You can create the translation table using the helper *create_translation_table*. The following:
+
+    create_table :products do |t|
+      t.timestamps
+    end
+    create_translation_table :products, :name => :string, :another_field => :integer
+
+is equivalent to:
+
+    create_table :products do |t|
+      t.timestamps
+    end
+    create_table :product_translations do |t|
+      t.references :products, :null => false
+      t.string     :locale  , :null => false
+      t.string     :name
+      t.integer    :another_field
+    end
+
+
+#### Models
+
+Now we have to modify our Product model as the following:
+
+    class Prouct < ActiveRecord::Base
+      translates :name, :another_field
+    end
+
+Done! You have the EfficientTranslations power in your hands :-)
+
+
+## Usage
+
+### Manage Translations
+
+    product = Product.new
+    I18n.default_locale = :en
+    I18n.locale = :en
+
+    product.name_translation :en # => nil
+    # .name is a wrapper to .name_translation I18n.locale
+    product.name # => nil
+    product.set_name_translation :en, 'Efficient Translations'
+    # no sql query is executed. When possible, a local collection is used
+    product.name # => 'Efficient Translations'
+
+    I18n.locale = :it
+    # when the current locale is not found, the default locale will be used
+    product.name # => 'Efficient Translations'
+
+    # .name= is a wrapper to #set_name_translation I18n.locale
+    product.name = 'Traduzioni Efficienti'
+    product.name # => 'Traduzioni Efficienti'
+
+    product.name_translations # => { :en => 'Efficient Translations', :it => 'Traduzioni Efficienti' }
+
+    # translations are saved in the db
+    product.save!
+
+    # Create a product using nested attributes
+    Product.create! :translations_attributes => [{:locale => I18n.locale.to_s, :name => 'Another'}]
+    Product.last.name # => 'Another'
+
+### Validators
+
+The validator *validates_presence_of_default_locale* is provided to prevent a model to be saved without a translation for the default locale. Eg:
+
+    class Product < ActiveRecord::Base
+      translates :name, :another_field
+      validates_presence_of_default_locale
+    end
+
+### Named Scopes and Performances Overview
+
+Three named scopes are defined:
+
+#### with_translations:
+
+    # Fetch products with all translations
+    Product.with_translations
+
+This will include all the translations record. So in the case you have a product with translations for :en and :it.
+
+    p = Product.with_translations.first
+    p.name # No sql is executed
+    p.name_translation :it # No sql is executed
+    p.name_translation :fr # No sql is executed
+
+#### with_current_translations:
+
+    # Fetch products with translations for I18n.locale or I18n.default_locale
+    Product.with_current_translation
+
+This scope will fetch only the translations you usually need when you fetch your models.
+It's not perfect. Observe the following code to understand why:
+
+    Product.create! :translation_attributes => [
+      { :locale => :en, :name => 'Product1'  },
+      { :locale => :it, :name => 'Prodotto1' }
+    ]
+    Product.create! :translation_attributes => [
+      { :locale => :it, :name => 'Prodotto2' }
+    ]
+    I18n.locale = :en
+
+    # The second product is not included in the result because it doesn't have the I18n.locale or I18n.default_locale translation
+    # To prevent this you can use validates_presence_of_default_locale
+    Product.with_current_translation.size # => 1
+
+    p = Product.with_current_translation.first
+    p.name # => 'Product1'; No qury is executed because we used the named scope
+    # translations collection doesn't contain the 'it' value, so all calls to 'it' translations will return
+    # the I18n.default_locale value
+    p.name_translation :it # => 'Product2'
+
+    # To fetch the 'it' value you have to do the following:
+    p.translations true # reload all translations
+    p.name_translation :it # => 'Prodotto1'
+
+#### with_translation_for
+
+This scope behaves like *with_current_translation* but it will use, in order, a locale of your choice or I18n.default_locale to fetch the translations

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run those specs"
+task :spec do
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w{--colour --format progress}
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rspec_path = 'bundle exec rspec'
+  end
+end

data/efficient_translations.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+if RUBY_VERSION == '1.8.7'
+  $:.unshift File.expand_path("../lib", __FILE__)
+  require "efficient_translations/version"
+else
+  # ruby 1.9
+  require File.expand_path('../lib/efficient_translations/version', __FILE__)
+end
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Nicola Racco']
+  gem.email         = ['nicola@nicolaracco.com']
+  gem.description   = %q{Translation library for ActiveRecord models in Rails 2}
+  gem.summary       = %q{Translation library for ActiveRecord models in Rails 2 with an eye on performances}
+  gem.homepage      = ''
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_dependency 'activerecord' , '~> 2.3'
+  gem.add_dependency 'activesupport', '~> 2.3'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "efficient_translations"
+  gem.require_paths = ["lib"]
+  gem.version       = EfficientTranslations::VERSION
+end

data/lib/efficient_translations.rb

@@ -0,0 +1,11 @@
+require 'active_support'
+require 'active_record'
+
+dir = File.join File.expand_path(File.dirname __FILE__), 'efficient_translations'
+require File.join dir, 'version'
+require File.join dir, 'schema'
+require File.join dir, 'translation_factory'
+require File.join dir, 'translates_method'
+
+::ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, EfficientTranslations::Schema
+::ActiveRecord::Base.send :include, EfficientTranslations::TranslatesMethod

data/lib/efficient_translations/schema.rb

@@ -0,0 +1,23 @@
+module EfficientTranslations
+  # Holds schema information. To use it, just include its methods
+  # and overwrite the apply_schema method
+  module Schema
+    # Create the translation table for the given model
+    # It creates a table named <model_name>_translations
+    # translation_fields should contain an Hash that specify
+    # the column name to create and its type.
+    # eg. create_translation_table :product, :name => :string, :description => :string
+    def create_translation_table model_name, translation_fields
+      translation_table_name = "#{model_name.to_s}_translations"
+      create_table translation_table_name do |t|
+        t.references model_name, :null => false
+        t.string     :locale   , :null => false
+      end
+      translation_fields.each do |name, type|
+        add_column translation_table_name, name.to_s, type.to_sym
+      end
+      add_index translation_table_name, "#{model_name}_id"
+      add_index translation_table_name, ["#{model_name}_id", 'locale'], :unique => true
+    end
+  end
+end

data/lib/efficient_translations/translates_method.rb

@@ -0,0 +1,122 @@
+module EfficientTranslations
+  module TranslatesMethod
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def translates *field_names
+        make_efficient_translatable! unless defined?(translation_model)
+        field_names.each { |field| define_translation_accessors field }
+      end
+
+      def validates_presence_of_default_locale
+        validate :default_locale_required
+      end
+
+      private
+
+      def make_efficient_translatable!
+        cattr_accessor :translation_model
+        self.translation_model = TranslationFactory::new_model self
+
+        has_many :translations, :class_name => translation_model.name, :dependent => :destroy
+        accepts_nested_attributes_for :translations
+
+        named_scope :with_translations, :include => :translations
+        named_scope :with_current_translation, lambda {
+          {
+            :include => :translations,
+            :conditions => ["#{translation_model.table_name}.locale = ? OR #{translation_model.table_name}.locale = ?", I18n.locale.to_s, I18n.default_locale.to_s]
+          }
+        }
+        named_scope :with_translation_for, lambda { |locale|
+          {
+            :inlude => :translations,
+            :conditions => ["#{translation_model.table_name}.locale = ? OR #{translation_model.table_name}.locale = ?", locale.to_s, I18n.default_locale.to_s]
+          }
+        }
+
+        after_save :update_translations!
+
+        self.send :include, InstanceMethods
+      end
+
+      def define_translation_accessors field
+        field = field.to_sym
+        class_eval do
+          define_method "#{field}_translation" do |locale|
+            locale = locale.to_sym
+            # search in cache
+            if efficient_translations_attributes[locale][field]
+              efficient_translations_attributes[locale][field]
+            else
+              # search in relationship
+              translation = translations.detect { |t| t.locale.to_sym == locale }
+              if translation
+                translation[field]
+              elsif locale != I18n.default_locale
+                # try to fetch default locale
+                self.send "#{field}_translation", I18n.default_locale
+              end
+            end
+          end
+
+          define_method "set_#{field}_translation" do |locale, value|
+            locale = locale.to_sym
+            efficient_translations_attributes[locale][field] = value
+          end
+
+          define_method field do
+            self.send "#{field}_translation", I18n.locale
+          end
+
+          define_method "#{field}=" do |value|
+            self.send "set_#{field}_translation", I18n.locale, value
+          end
+
+          define_method("#{field}_translations") do
+            found = {}
+            efficient_translations_attributes.each do |locale, translation|
+              found[locale] = translation[field]
+            end
+            translations.inject(found) do |memo, translation|
+              memo[translation.locale.to_sym] ||= translation[field]
+              memo
+            end
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+
+      private
+
+      # attributes are stored in @efficient_attributes instance variable via setter
+      def efficient_translations_attributes
+        @efficient_translations_attributes ||= Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def update_translations!
+        if efficient_translations_attributes.present?
+          translations true #force reload all translations
+          efficient_translations_attributes.each do |locale, attributes|
+            translation = translations.detect { |t| t.locale.to_sym == locale } || begin
+              args = { :locale => locale }
+              args[self.class.translation_model.translatable_relation_field] = self
+              self.class.translation_model.new args
+            end
+            translation.update_attributes! attributes
+          end
+        end
+      end
+
+      def default_locale_required
+        unless translations.detect { |t| t.locale.to_sym == I18n.default_locale }
+          errors.add :translations, "for #{I18n.default_locale} is missing"
+        end
+      end
+    end
+  end
+end

data/lib/efficient_translations/translation_factory.rb

@@ -0,0 +1,31 @@
+module EfficientTranslations
+  module TranslationFactory
+    def self.new_model base_model
+      if base_model.const_defined?(:Translation)
+        base_model.const_get(:Translation)
+      else
+        klass = base_model.const_set(:Translation, Class.new(::ActiveRecord::Base))
+        klass.instance_eval do
+          cattr_accessor :translatable_model, :translatable_relation_field
+          self.translatable_model = base_model
+          self.translatable_relation_field = base_model.name.underscore.gsub '/', '_'
+
+          table_name = "#{base_model.table_name.singularize}_translations"
+          belongs_to translatable_relation_field
+
+          named_scope :for_locale, lambda { |locale|
+            { :conditions => ['locale = ? OR locale = ?', locale.to_s, I18n.locale.to_s] }
+          }
+
+          before_save :stringify_locale!
+        end
+        klass.class_eval do
+          def stringify_locale!
+            self.locale = locale.to_s
+          end
+        end
+        klass
+      end
+    end
+  end
+end

data/lib/efficient_translations/version.rb

@@ -0,0 +1,3 @@
+module EfficientTranslations
+  VERSION = "0.0.1"
+end

data/spec/fixtures/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define do
+  create_table 'my_models', :force => true do |t|
+  end
+
+  create_table 'my_model_translations', :force => true do |t|
+    t.integer :my_model_id, :null => false
+    t.string  :locale, :null => false
+    t.string  :name
+  end
+
+  create_table 'working_models', :force => true do |t|
+  end
+
+  create_table 'working_model_translations', :force => true do |t|
+    t.integer :working_model_id, :null => false
+    t.string  :locale, :null => false
+    t.string  :name
+    t.string  :content
+  end
+end

data/spec/lib/efficient_translations/schema_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe EfficientTranslations::Schema do
+  let(:schema) { EfficientTranslations::FakeSchemaAdapter.new }
+
+  describe '#create_translation_table' do
+    it 'should create a table named <model>_translations' do
+      schema.should_receive(:create_table).with('pippo_translations')
+      schema.create_translation_table 'pippo', :name => :string
+    end
+
+    it 'should create the given translation columns' do
+      schema.should_receive(:add_column).with('pippo_translations', 'name', :string)
+      schema.create_translation_table 'pippo', :name => :string
+    end
+
+    it 'should create indexes' do
+      schema.should_receive(:add_index).twice
+      schema.create_translation_table 'pippo', :name => :string
+    end
+  end
+end

data/spec/lib/efficient_translations/translates_method_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'active_record'
+
+describe EfficientTranslations do
+  def my_model_class
+    Kernel.silence_warnings do
+      Kernel.const_set :MyModel, Class.new(ActiveRecord::Base)
+    end
+  end
+
+  describe '::translates' do
+    it 'should be defined in ActiveRecord::Base' do
+      ActiveRecord::Base.should respond_to :translates
+    end
+
+    it 'could be invoked specifing multiple attributes' do
+      model = my_model_class
+      lambda { model.translates :name, :content }.should_not raise_error
+    end
+
+    it 'could be invoked multiple times' do
+      model = my_model_class
+      lambda { model.translates :name }.should_not raise_error
+      lambda { model.translates :content }.should_not raise_error
+    end
+
+    it 'should generate the translation model the first time it\'s invoked' do
+      model = my_model_class
+      model.should_receive :make_efficient_translatable!
+      model.translates :name
+    end
+
+    it 'should not regenerate the translation model when called multiple times' do
+      model = my_model_class
+      model.translates :name
+      model.should_not_receive :make_efficient_translatable!
+      model.translates :content
+    end
+  end
+
+  describe '::validates_presence_of_default_locale' do
+    it 'should be defined in ActiveRecord::Base' do
+      ActiveRecord::Base.should respond_to :validates_presence_of_default_locale
+    end
+
+    it 'should prevent saving a model without default locale' do
+      model = my_model_class
+      model.translates :name
+      model.validates_presence_of_default_locale
+      lambda { model.new.save! }.should raise_error ActiveRecord::RecordInvalid
+      inst = model.new :translations_attributes => [{ :locale => :en, :name => 'pippo' }]
+      lambda { inst.save! }.should_not raise_error
+    end
+  end
+
+  context '::WorkingModel' do
+    it 'should include the translation model' do
+      WorkingModel.translation_model.should be_kind_of(Class)
+    end
+
+    it 'should include the translations relationship' do
+      WorkingModel.new.should respond_to :translations
+    end
+
+    it 'should have some utility named scopes' do
+      WorkingModel.should respond_to :with_translations
+      WorkingModel.should respond_to :with_current_translation
+      WorkingModel.should respond_to :with_translation_for
+    end
+
+    it 'should accept nested attributes' do
+      WorkingModel.delete_all
+      WorkingModel.create! :translations_attributes => [{ :locale => :en, :name => 'pippo' }]
+      WorkingModel.first.name.should == 'pippo'
+    end
+
+    describe 'field_translation' do
+      before do
+        @model = WorkingModel.new
+        @model.set_name_translation :en, 'pippo'
+        @model.save!
+      end
+
+      context 'when cache contains the translated value' do
+        before do
+          @model.set_name_translation :en, 'foo'
+        end
+
+        it 'should fetch the value from cache' do
+          @model.name_translation(:en).should == 'foo'
+        end
+      end
+
+      context 'when cache is empty' do
+        it 'should search in the relationship' do
+          @model = WorkingModel.find @model.id
+          @model.translation_model.create! :working_model_id => @model.id, :locale => 'fr', :name => 'frfr'
+          @model.name_translation(:fr).should == 'frfr'
+        end
+      end
+
+      context 'when cache is empty and no value is found' do
+        it 'should search for I18n.default_locale if locale != I18n.default_locale' do
+          I18n.default_locale = :en
+          @model.name_translation(:de).should == @model.name_translation(:en)
+        end
+
+        it 'should return nil if locale == I18n.default_locale' do
+          I18n.default_locale = :de
+          @model.name_translation(:de).should be_nil
+        end
+      end
+    end
+
+    describe 'set_field_translation' do
+      it 'should only set values in a cache, until save' do
+        model = WorkingModel.create!
+        model.set_name_translation :en, 'pippo'
+        model.translation_model.find_all_by_working_model_id(model.id).should be_empty
+        model.save!
+        model.translation_model.find_all_by_working_model_id(model.id).should_not be_empty
+      end
+    end
+
+    describe 'field accessor' do
+      it '<field> should be a wrapper for <field>_translation' do
+        model = WorkingModel.new
+        model.should_receive(:name_translation).with(:en)
+        I18n.locale = :en
+        model.name
+      end
+
+      it '<field>= should be a wrapper for set_<field>_translation' do
+        model = WorkingModel.new
+        model.should_receive(:set_name_translation).with(:en, 'pippo')
+        I18n.locale = :en
+        model.name = 'pippo'
+      end
+    end
+  end
+end

data/spec/lib/efficient_translations/translation_factory_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe EfficientTranslations::TranslationFactory do
+  before :each do
+    Kernel.silence_warnings do
+      @model_class = Kernel.const_set :MyModel, Class.new(ActiveRecord::Base)
+    end
+  end
+
+  describe '::new_model' do
+    context 'when no translation model is found' do
+      before do
+        @klass = Class.new(ActiveRecord::Base)
+        @model_class.stub :const_set => @klass
+      end
+
+      it 'should create a new ::Translation class' do
+        @model_class.should_receive(:const_set).with(:Translation, kind_of(Class)) { |name, klass| klass }
+        EfficientTranslations::TranslationFactory::new_model @model_class
+      end
+
+      it 'should define a belongs_to association to the main model' do
+        @klass.should_receive(:belongs_to)
+        EfficientTranslations::TranslationFactory::new_model @model_class
+      end
+
+      it 'should assign the translatable model in an accessor' do
+        translation = EfficientTranslations::TranslationFactory::new_model @model_class
+        translation.translatable_model.should == @model_class
+      end
+
+      it 'should assign the translatable model field in an accessor' do
+        translation = EfficientTranslations::TranslationFactory::new_model @model_class
+        translation.translatable_relation_field.should == @model_class.name.underscore.gsub('/','_')
+      end
+
+      it 'should return the created translation class' do
+        klass = Class.new(ActiveRecord::Base)
+        @model_class.stub :const_set => klass
+        EfficientTranslations::TranslationFactory::new_model(@model_class).should == klass
+      end
+    end
+
+    context 'when a translation model is found' do
+      it 'should not create a ::Translation class' do
+        EfficientTranslations::TranslationFactory::new_model @model_class
+        @model_class.should_not_receive(:const_set)
+        EfficientTranslations::TranslationFactory::new_model @model_class
+      end
+
+      it 'should return the already defined translation class' do
+        klass = Class.new(ActiveRecord::Base)
+        @model_class.stub :const_set => klass
+        EfficientTranslations::TranslationFactory::new_model @model_class
+        EfficientTranslations::TranslationFactory::new_model(@model_class).should == klass
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# Load the Sinatra app
+require File.dirname(__FILE__) + '/../lib/efficient_translations'
+
+require 'rspec'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+RSpec.configure do |conf|
+  conf.before :suite do
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+    require File.join(File.dirname(__FILE__), 'fixtures', 'schema.rb')
+  end
+end

data/spec/support/fake_schema_adapter.rb

@@ -0,0 +1,16 @@
+module EfficientTranslations
+  class FakeSchemaAdapter
+    include Schema
+
+    #stubs methods
+
+    def create_table table
+    end
+
+    def add_column table, column_name, type
+    end
+
+    def add_index table, columns, args = {}
+    end
+  end
+end

data/spec/support/working_model.rb

@@ -0,0 +1,3 @@
+class WorkingModel < ActiveRecord::Base
+  translates :name, :content
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: efficient_translations
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nicola Racco
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-08 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70105172048080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70105172048080
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70105172047020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70105172047020
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70105172046400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70105172046400
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70105172045360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70105172045360
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70105172043440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70105172043440
+description: Translation library for ActiveRecord models in Rails 2
+email:
+- nicola@nicolaracco.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- efficient_translations.gemspec
+- lib/efficient_translations.rb
+- lib/efficient_translations/schema.rb
+- lib/efficient_translations/translates_method.rb
+- lib/efficient_translations/translation_factory.rb
+- lib/efficient_translations/version.rb
+- spec/fixtures/schema.rb
+- spec/lib/efficient_translations/schema_spec.rb
+- spec/lib/efficient_translations/translates_method_spec.rb
+- spec/lib/efficient_translations/translation_factory_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_schema_adapter.rb
+- spec/support/working_model.rb
+homepage: ''
+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'
+      segments:
+      - 0
+      hash: 4009622527868518176
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4009622527868518176
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Translation library for ActiveRecord models in Rails 2 with an eye on performances
+test_files:
+- spec/fixtures/schema.rb
+- spec/lib/efficient_translations/schema_spec.rb
+- spec/lib/efficient_translations/translates_method_spec.rb
+- spec/lib/efficient_translations/translation_factory_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_schema_adapter.rb
+- spec/support/working_model.rb