clicrdv_easy_translatable 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 50704672bccd72c0179e2acd83114e675d7c2301c564ba81a011fa64ac6c3f8c
+  data.tar.gz: cf389801803b8822a553c465e9e0568dbbfb2b5a320626a600ced51181b94588
+SHA512:
+  metadata.gz: 84a2c46f6ad7282664eaf750596f14a348e0a1a289fdac4dd0edb8deeed6af1d4b500a8b469f0614dd44492f4581818c01be9d96d12c1ab739414917078efed6
+  data.tar.gz: 7da00eed5cb246f1ace53df770e3887412c84854899a2189467d1c052467681239e883e7481227b07c4bebef643fbdce7776572853e12fa0cf35efc39f73c5a7

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008, 2009, 2010 Sven Fuchs, Joshua Harvey, Clemens Kofler, John-Paul Bader, ClicRDV
+
+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.md

@@ -0,0 +1,28 @@
+# Translatable [![Gem Version](https://badge.fury.io/rb/easy_translatable.png)](http://badge.fury.io/rb/easy_translatable) [![Code Climate](https://codeclimate.com/github/clicrdv/translatable.png)](https://codeclimate.com/github/clicrdv/translatable) [![Build Status](https://travis-ci.org/clicrdv/translatable.png)](https://travis-ci.org/clicrdv/translatable) [![Coverage Status](https://coveralls.io/repos/clicrdv/translatable/badge.png)](https://coveralls.io/r/clicrdv/translatable)
+## Requirements
+
+* ActiveRecord 3.2
+* I18n
+
+## Installation
+
+To install just use:
+
+```ruby
+gem install easy_translatable
+```
+
+When using bundler put this in your Gemfile:
+
+```ruby
+gem 'easy_translatable', '~> 0.1.0'
+```
+
+## Todo
+
+- cleanup
+- doc
+- migration/model for translation table
+
+
+Copyright (c) 2008, 2009, 2010 Sven Fuchs, Joshua Harvey, Clemens Kofler, John-Paul Bader, ClicRDV

data/lib/translatable/active_record/adapter.rb

@@ -0,0 +1,67 @@
+module Translatable
+  module ActiveRecord
+    class Adapter
+      # The cache caches attributes that already were looked up for read access.
+      # The stash keeps track of new or changed values that need to be saved.
+      attr_accessor :record, :stash, :translations
+      private :record=, :stash=
+
+      def initialize(record)
+        self.record = record
+        self.stash = Attributes.new
+      end
+
+      def fetch_stash(locale, name)
+        value = stash.read(locale, name)
+        return value if value
+        return nil
+      end
+
+      def stash_contains?(locale, name)
+        stash.contains?(locale, name)
+      end
+
+      def fetch(locale, name, value = nil)
+        value = stash_contains?(locale, name) ? fetch_stash(locale, name) : fetch_attribute(locale, name, value)
+
+        return value
+      end
+
+      def write(locale, name, value)
+        stash.write(locale, name, value)
+      end
+
+      def save_translations!
+        stash.reject {|locale, attrs| attrs.empty?}.each do |locale, attrs|
+          translations = record.translations_by_locale[locale]
+          attrs.each { |name, value|
+            translation = translations && translations[name] ||
+                record.translations.build(:locale => locale.to_s, :scope => record.class.table_name, :key => name)
+            translation['record_id'] = record.id
+            translation['value'] = value
+            translation.save!
+          }
+        end
+
+        reset
+      end
+
+      def reset
+        stash.clear
+      end
+
+      protected
+
+      def fetch_attribute(locale, name, value = nil)
+        if value.nil?
+          translation = record.translation_for(locale, name)
+          return translation && translation.send(:value)
+        else
+          translation = record.translation_for_serialized(locale, name, value)
+          return translation
+        end
+      end
+
+    end
+  end
+end

data/lib/translatable/active_record/attributes.rb

@@ -0,0 +1,27 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+
+module Translatable
+  module ActiveRecord
+    class Attributes < Hash # TODO: Think about using HashWithIndifferentAccess ?
+      def [](locale)
+        locale = locale.to_sym
+        self[locale] = {} unless has_key?(locale)
+        self.fetch(locale)
+      end
+
+      def contains?(locale, name)
+        self[locale].has_key?(name.to_s)
+      end
+
+      def read(locale, name)
+        self[locale][name.to_s]
+      end
+
+      def write(locale, name, value)
+        #raise 'z' if value.nil? # TODO
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/translatable/active_record/class_methods.rb

@@ -0,0 +1,60 @@
+module Translatable
+  module ActiveRecord
+    module ClassMethods
+      def translation_class
+        Translatable.translation_class
+      end
+
+      def translated?(name)
+        included = translated_attribute_names.detect { |attr| attr.is_a?(Hash) ? attr.keys.include?(name.to_sym) : attr == name.to_sym }
+        !included.nil?
+      end
+
+      protected
+
+      def translated_attr_accessor(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+        define_method(name) do |*args|
+          self.read_attribute(name, {:locale => args.detect {|a| !a.is_a? Hash }})
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+      def locale_from(args)
+        args.detect {|a| !a.is_a? Hash }
+      end
+
+      def translations_accessor(name)
+        define_method(:"#{name}_translations") do
+          translations.each_with_object(HashWithIndifferentAccess.new) do |translation, result|
+            result[translation.locale] = translation.send(name)
+          end
+        end
+        define_method(:"#{name}_translations=") do |value|
+          value.each do |(locale, value)|
+            write_attribute name, value, :locale => locale
+          end
+        end
+      end
+
+      def condition_callback(attr_names, callback)
+        Proc.new { |rec|
+          attr_names.any? do |translatable_attr|
+            callback && rec.changes.keys.include?(translatable_attr.to_s)
+          end
+        }
+      end
+
+      %w(after_save before_save after_update before_update).each do |cb|
+        class_eval  %{
+          def on_#{cb}_callback(attr_names, callback)
+            #{cb} callback, :if => condition_callback(attr_names, callback)
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/translatable/active_record/instance_methods.rb

@@ -0,0 +1,195 @@
+module Translatable
+  module ActiveRecord
+    module InstanceMethods
+      delegate :translated_locales, :to => :translations
+
+      def translatable
+        @translatable ||= Adapter.new(self)
+      end
+
+      def self.included(base)
+        # Maintian Rails 3.0.x compatibility ..
+        if base.method_defined?(:assign_attributes)
+          base.class_eval %{
+            def assign_attributes(attributes, *options)
+              with_given_locale(attributes) { super }
+            end
+          }
+        else
+          base.class_eval %{
+            def attributes=(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+
+            def update_attributes!(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+
+            def update_attributes(attributes, *args)
+              with_given_locale(attributes) { super }
+            end
+          }
+        end
+      end
+
+      # Always call the super method, the attribute is translatable and we asked a translated model
+      def write_attribute(name, value, options = {}, &block)
+        if r_translated?(name) && translate?
+          options = {:locale => Translatable.locale}.merge(options)
+
+          # We don't want to track any changes, but save the new value in a translation hash
+
+          translatable.write(options[:locale], name, value)
+        else
+          super(name, value)
+        end
+      end
+
+      def translate
+        @translate_me = true
+        self
+      end
+
+      def end_translate
+        @translate_me = nil
+        self
+      end
+
+      def reload(options = nil)
+        @translate_me = false
+        translation_caches.clear
+        translated_attribute_names.each { |name| @attributes.reset(name.to_s) }
+        translatable.reset
+        super(options)
+      end
+
+      def save(*)
+        @translate_me = false
+        super
+      end
+
+      def translate?
+        !@translate_me.nil? && @translate_me
+      end
+
+      def read_attribute(name, options = {}, &block)
+        options = {:translated => true, :locale => Translatable.locale}.merge(options)
+        if r_translated?(name) and options[:translated]
+          serialized_value = super(name) if self.attributes.has_key?(name)
+          if translate? && (value = translatable.fetch(options[:locale] || Translatable.locale, name, serialized_value))
+            value
+          else
+            super(name)
+          end
+        else
+          super(name)
+        end
+      end
+
+      def r_translated?(name)
+        self.class.translated?(name)
+      end
+
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => translation.send(name))
+        end
+      end
+
+      # This method is basically the method built into Rails
+      # but we have to pass {:translated => false}
+      def untranslated_attributes
+        attrs = {}
+        attribute_names.each do |name|
+          attrs[name] = read_attribute(name, {:translated => false})
+        end
+        attrs
+      end
+
+      def translation_for(locale, name, build_if_missing = false)
+        unless translation_caches["#{locale}_#{name}"]
+          # Fetch translations from database as those in the translation collection may be incomplete
+          _translation = translations.detect{|t| t.locale.to_s == locale.to_s && t.key.to_s == name.to_s }
+          _translation ||= translations.build(:locale => locale) if build_if_missing
+          translation_caches["#{locale}_#{name}"] = _translation if _translation
+        end
+        translation_caches["#{locale}_#{name}"]
+      end
+
+      # Fetch translations per keys in the form
+      # model_attr_serialized_attribute
+      # E.G.1: ```Model``` has attribute ```config``` which has a key ```auto_save```
+      #         will have a translation key ```config_auto_save```
+      # E.G.2: ```Model``` has attribute ```config``` which is an array of ```user_id => ([0-9]+)```
+      #         will have translations key containing the index: ```config_user_id_0```, ```config_user_id_1```...
+      def translation_for_serialized(locale, name, value, build_if_missing = false)
+
+        unless translation_caches["#{locale}_#{name}"]
+          engine = self.attributes.has_key?(name) ? nil : JSON
+          deserialized_value = engine.nil? ? value : engine.load(value)
+
+          only = self.translated_serialized_attributes[name.to_sym].map(&:to_s)
+          if only.empty?
+            regex_keys = /\A#{name.to_s}_([a-z_]+[a-z])(?:_([0-9]*))?\Z/
+          else
+            regex_keys = /\A#{name.to_s}_(#{only.join('|')})(?:_([0-9]*))?\Z/
+          end
+          # Fetch translations from database as those in the translation collection may be incomplete
+          _translations = translations.select{|t| t.locale.to_s == locale.to_s && t.key.to_s =~ regex_keys }
+          _translations.each do |t|
+            matched = t.key.match regex_keys
+            unless matched.nil?
+              if matched.size == 3
+                sub_attr = matched[1]
+                index = matched[2].to_i
+                value[index][sub_attr] = t.value if value.size > index && value[index].has_key?(sub_attr)
+              elsif matched.size == 3
+                sub_attr = matched[1]
+                value[sub_attr] = t.value if value.has_key?(sub_attr)
+              end
+            end
+          end
+
+          translation_caches["#{locale}_#{name}"] = value
+        end
+        translation_caches["#{locale}_#{name}"]
+      end
+
+      def translation_caches
+        @translation_caches ||= {}
+      end
+
+
+      def with_given_locale(attributes, &block)
+        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys!)
+
+        locale = respond_to?(:locale=) ? attributes.try(:[], :locale) :
+            attributes.try(:delete, :locale)
+
+        if locale && !respond_to?(:locale=)
+          already = translate?
+          translate unless translate?
+          Translatable.with_locale(locale, &block)
+          end_translate unless already
+        else
+          yield
+        end
+      end
+
+      def translations_by_locale(&block)
+        translations.each_with_object(HashWithIndifferentAccess.new) do |t, hash|
+          hash[t.locale] ||= HashWithIndifferentAccess.new
+          hash[t.locale][t.key] = block_given? ? block.call(t) : t
+        end
+      end
+
+      protected
+
+      def save_translations!
+        translatable.save_translations!
+        translation_caches.clear
+      end
+
+    end
+  end
+end

data/lib/translatable/active_record/macro.rb

@@ -0,0 +1,96 @@
+module Translatable
+  module ActiveRecord
+    module Macro
+
+      def translatable(*attr_names)
+
+        options = attr_names.extract_options!
+        setup_translatable!(options) unless translatable?
+
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= translated_attribute_names if defined?(translated_attribute_names)
+
+        if attr_names.present?
+
+          attr_names.each do |attr_name|
+            # Create accessors for the attribute.
+            translated_attr_accessor(attr_name)
+            translations_accessor(attr_name)
+
+            # Add attribute to the list.
+            self.translated_attribute_names << attr_name
+            if options[:only]
+              self.translated_serialized_attributes[attr_name] = options[:only] ? options[:only] : []
+            end
+          end
+
+          on_after_save_callback(attr_names, options[:after_save]) if options[:after_save]
+          on_before_save_callback(attr_names, options[:before_save]) if options[:before_save]
+          on_after_update_callback(attr_names, options[:after_update]) if options[:after_update]
+          on_before_update_callback(attr_names, options[:before_update]) if options[:before_update]
+
+          Translatable.add_translatable self
+
+        end
+      end
+
+      def class_name
+        @class_name ||= begin
+          class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].downcase.camelize
+          pluralize_table_names ? class_name.singularize : class_name
+        end
+      end
+
+      def translatable?
+        included_modules.include?(InstanceMethods)
+      end
+
+      protected
+      def setup_translatable!(options)
+        options[:table_name] ||= Translatable.translation_class.table_name
+        options[:foreign_key] ||= 'record_id'
+        options[:conditions] ||= {}
+        options[:after_save] ||= false
+        options[:before_save] ||= false
+
+        class_attribute :translated_attribute_names, :translation_options, :fallbacks_for_empty_translations, :translated_serialized_attributes
+        self.translated_attribute_names = []
+        self.translation_options        = options
+        self.fallbacks_for_empty_translations = options[:fallbacks_for_empty_translations]
+        self.translated_serialized_attributes = Hash.new
+
+        include InstanceMethods
+        extend  ClassMethods
+
+        translation_class.table_name = options[:table_name]
+
+        has_many :translations, conditions(options), :class_name  => translation_class.name,
+                 :foreign_key => options[:foreign_key],
+                 :dependent   => :destroy,
+                 :extend      => HasManyExtensions,
+                 :autosave    => false
+
+        after_create :save_translations!
+        after_update :save_translations!
+      end
+      
+      def conditions(options)        
+        table_name = self.table_name      
+        proc { 
+          c = options[:conditions]
+          c = self.instance_eval(&c) if c.is_a?(Proc) 
+          c.merge!(:scope => table_name, :locale => Translatable.locale)
+
+          where(c)
+        }  
+      end
+      
+    end
+
+    module HasManyExtensions
+      def find_or_initialize_by_locale(locale)
+        with_locale(locale.to_s).first || build(:locale => locale.to_s)
+      end
+    end
+  end
+end

data/lib/translatable/active_record/relation.rb

@@ -0,0 +1,31 @@
+module Translatable
+  module ActiveRecord
+    module Relation
+      def exec_queries
+        queries = super
+
+        return queries.map(&:translate) if @translate_records
+
+        queries
+      end
+
+      private
+
+      def translate
+        @translate_records = true
+
+        self.eager_load(:translations)
+      end
+    end
+  end
+end
+
+class Railtie < Rails::Railtie
+
+  initializer "easy_translatable.configure_rails_initialization" do
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Relation.send :prepend, Translatable::ActiveRecord::Relation
+    end
+  end
+
+end if defined?(Rails)

data/lib/translatable/active_record/translate.rb

@@ -0,0 +1,10 @@
+module Translatable
+  module ActiveRecord
+    module Translate
+      def self.translate
+        self.scoped.translate
+      end
+
+    end
+  end
+end

data/lib/translatable/active_record.rb

@@ -0,0 +1,12 @@
+require File.expand_path '../active_record/class_methods.rb', __FILE__
+require File.expand_path '../active_record/instance_methods.rb', __FILE__
+require File.expand_path '../active_record/attributes.rb', __FILE__
+require File.expand_path '../active_record/adapter.rb', __FILE__
+require File.expand_path '../active_record/macro.rb', __FILE__
+require File.expand_path '../active_record/translate.rb', __FILE__
+require File.expand_path '../active_record/relation.rb', __FILE__
+
+module Translatable
+  module ActiveRecord
+  end
+end

data/lib/translatable/default.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+require File.expand_path '../active_record.rb', __FILE__
+
+ActiveRecord::Base.extend(Translatable::ActiveRecord::Translate)
+ActiveRecord::Base.extend(Translatable::ActiveRecord::Macro)

data/lib/translatable/version.rb

@@ -0,0 +1,3 @@
+module Translatable
+  VERSION = '0.4.0'
+end

data/lib/translatable.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), 'translatable/default.rb')
+
+module Translatable
+
+  @@translatable ||= Hash.new
+  @@translation_class ||= nil
+
+  class << self
+    def locale
+      read_locale || I18n.locale
+    end
+
+    def locale=(locale)
+      set_locale(locale)
+    end
+
+    def with_locale(locale, &block)
+      previous_locale = read_locale
+      begin
+        set_locale(locale)
+        result = yield(locale)
+      ensure
+        set_locale(previous_locale)
+      end
+      result
+    end
+
+    def translation_class_name=(klass)
+      @@translation_class = klass.constantize
+    end
+    def translation_class
+      @@translation_class ||= nil
+    end
+
+    # Hash of models that are translatable (values are the attrs)
+    def list
+      @@translatable ||= Hash.new
+    end
+
+    def add_translatable(klass)
+      if @@translatable.has_key? klass.name
+        klass.translated_attribute_names.each do |attr|
+          @@translatable[klass.name] << attr unless @@translatable[klass.name].include?(attr)
+        end
+      else
+        @@translatable[klass.name] = klass.translated_attribute_names
+      end
+
+      unless klass.translated_serialized_attributes.nil?
+        @@translatable[klass.name].map! do |attr|
+          serialized = klass.translated_serialized_attributes.reject{|k,v| k != attr}
+          serialized.empty? ? attr : serialized
+        end
+      end
+    end
+
+    protected
+
+    def read_locale
+      Thread.current[:translatable_locale]
+    end
+
+    def set_locale(locale)
+      Thread.current[:translatable_locale] = locale.try(:to_sym)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: clicrdv_easy_translatable
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Paul Bonaud
+- Charly Poly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pathname_local
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_declarative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: friendly_id
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Handle translations for AR models into a single table. And provide a
+  helper to select translated values.
+email: paul.bonaud@clicrdv.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/translatable.rb
+- lib/translatable/active_record.rb
+- lib/translatable/active_record/adapter.rb
+- lib/translatable/active_record/attributes.rb
+- lib/translatable/active_record/class_methods.rb
+- lib/translatable/active_record/instance_methods.rb
+- lib/translatable/active_record/macro.rb
+- lib/translatable/active_record/relation.rb
+- lib/translatable/active_record/translate.rb
+- lib/translatable/default.rb
+- lib/translatable/version.rb
+homepage: http://rubygems.org/gems/single_translatable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Handle translations for AR models into a single table
+test_files: []