has_localization_table 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.project
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Daniel Vandersluis
+
+MIT License
+
+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,78 @@
+# HasLocalizationTable
+
+ActiveRecord plugin which adds setup and convenience methods for working with a relational localization table for user-driven data.
+
+Adds accessors to retrieve localized attributes using the current locale, in order to avoid having to collect the correct object each time a value is needed. Localized attribute values are also cached for the current locale.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'has_localization_table'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install has_localization_table
+
+## Usage
+
+The gem assumes that the localization table has already been migrated, and the model for it contains `belongs_to` associations for the locale table and the base table. You only need to call the `has_localization_table` method on the base model.
+
+	class Article < ActiveRecord::Base
+	  # assuming ArticleLocalizations has name and body columns
+	  has_localization_table :localizations, required: true, class_name: "ArticleLocalizations"
+	end
+	
+	# Localized attributes can be retrieved by accessor...
+	a = Article.new(name: "Once Upon a Time...", body: "There once lived a princess locked away in a tower!")
+	a.name # "Once Upon a Time..."
+	a.body # "There once lived a princess locked away in a tower!"
+	
+	# ... or set directly
+	a.name = "Sleeping Beauty"
+	
+	# After changing to a different locale
+	a.name = "Belle au Bois Dormant"
+	a.body = "Il était une fois une princesse enfermée dans une tour!"
+	
+	a.localizations
+	=> [<ArticleLocalization id: 1, article_id: 1, locale_id: 1, name: "Sleeping Beauty", body: "There once lived a princess locked away in a tower!">,
+	    <ArticleLocalization id: 2, article_id: 1, locale_id: 2, name: "Belle au Bois Dormant", body: "Il était une fois une princesse enfermée dans une tour!">]
+	    
+	# Finder and order convenience methods are also provided:
+	Article.find_by_name("Snow White")
+	Article.find_by_body("...")
+	Article.find_by_name_and_body("...", "...")
+	Article.ordered_by_name # uses Arel, so it can be chained with other finder methods
+
+### `has_localization_table` Arguments
+If given, the first argument is the name used for the association, otherwise it defaults to `strings`.
+
+* `class_name` (default: base class name + "Strings"; ie. `ArticleStrings`) - the name of the localization class.
+* `required` (default: false) - if true, at least a localization object for the primary language (see Configuration section) must be present or validation will fail
+* `optional` (default: []) - if `required` is true, can be used to specify that specific attributes are optional
+
+Any options that can be passed into `has_many` can also be passed along and will be used when creating the association.
+	
+## Configuration
+`HasLocalizationTable` can also be configured as follows:
+
+	HasLocalizationTable.configure do |config|
+	  config.locale_class = "Locale"
+	  config.locale_foreign_key = "locale_id"
+	  config.primary_locale = Locale.primary_language
+	  config.current_locale = Locale.current_language
+	  config.all_locales = Locale.all
+	end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :test

data/has_localization_table.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/has_localization_table/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Daniel Vandersluis"]
+  gem.email         = ["dvandersluis@selfmgmt.com"]
+  gem.description   = %q{Automatically sets up usage of a relational table to contain user-created multi-locale string attributes}
+  gem.summary       = %q{Sets up associations and attribute methods for AR models that have a relational table to contain user-created data in multiple languages.}
+  gem.homepage      = "https://github.com/dvandersluis/has_localization_table"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "has_localization_table"
+  gem.require_paths = ["lib"]
+  gem.version       = HasLocalizationTable::VERSION
+  
+  gem.add_dependency 'activesupport', ['>= 3.0.0']
+  gem.add_dependency 'activerecord', ['>= 3.0.0']
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'sqlite3'
+end
+

data/lib/has_localization_table/active_record.rb

@@ -0,0 +1,185 @@
+module HasLocalizationTable
+  module ActiveRecord
+    def has_localization_table(*args)
+      options = args.extract_options!
+      options[:association_name] = args.first
+      
+      class_attribute :localization_table_options
+      self.localization_table_options = options
+      
+      extend(ClassMethods)
+      include(InstanceMethods)
+    end
+  end
+
+  module ClassMethods
+    def self.extended(klass)
+      options = { dependent: :delete_all }.merge(klass.localization_table_options)
+      
+      association_name = options.delete(:association_name) || :strings
+      
+      # If class_name isn't explicitly defined, try adding String onto the current class name
+      options[:class_name] = klass.name + "String" if options[:class_name].blank? and (Module.const_get(klass.name + "String") rescue false)
+      
+      # Define the association
+      klass.has_many association_name, options.except(:required, :optional)
+      association = klass.reflect_on_association(association_name)
+      
+      klass.class_eval do
+        # Initialize string records after main record initialization
+        after_initialize do
+          build_missing_strings
+        end
+        
+        before_validation do
+          reject_empty_strings
+          build_missing_strings
+        end
+        
+        # Reject any blank strings before saving the record
+        # Validation will have happened by this point, so if there is a required string that is needed, it won't be rejected
+        before_save do
+          reject_empty_strings
+        end
+        
+        # Add validation to ensure a string for the primary language exists if the string is required
+        validate do
+          if self.class.localization_table_options[:required] || false
+            errors.add(association_name, :primary_lang_string_required) unless send(association_name).any? do |string|
+              string.send(HasLocalizationTable.config.locale_foreign_key) == HasLocalizationTable.primary_locale.id
+            end
+          end
+        end
+        
+        define_method :build_missing_strings do
+          locale_ids = HasLocalizationTable.all_locales.map(&:id)
+          HasLocalizationTable.all_locales.each do |l|
+            send(association_name).build(HasLocalizationTable.config.locale_foreign_key => l.id) unless send(association_name).detect{ |str| str.send(HasLocalizationTable.config.locale_foreign_key) == l.id }
+            send(association_name).sort_by!{ |s| locale_ids.index(s.send(HasLocalizationTable.config.locale_foreign_key)) || 0 }
+          end
+        end
+        private :build_missing_strings
+        
+        define_method :reject_empty_strings do
+          send(association_name).reject! { |s| !s.persisted? and self.class.localized_attributes.all?{ |attr| s.send(attr).blank? } }
+        end
+        private :reject_empty_strings
+        
+        # Find a record by multiple string values
+        define_singleton_method :find_by_localized_attributes do |attributes, language = HasLocalizationTable.current_locale|
+          string_record = association.klass.where({ HasLocalizationTable.config.locale_foreign_key => language.id }.merge(attributes)).first
+          string_record.send(klass.to_s.underscore.to_sym) rescue nil
+        end
+        private_class_method :find_by_localized_attributes
+      end
+      
+      klass.localized_attributes.each do |attribute|
+        # Add validation to make all string fields required for the primary language
+        association.klass.class_eval do
+          validates attribute, presence: { message: :custom_this_field_is_required },
+            if: proc { |model| klass.name.constantize.localized_attribute_required?(attribute) && model.send(HasLocalizationTable.config.locale_foreign_key) == HasLocalizationTable.current_locale.id }
+        end
+      
+        # Set up accessors and ordering named_scopes for each non-FK attribute on the base model
+        klass.class_eval do
+          define_method attribute do |language = HasLocalizationTable.current_locale|
+            # Try to load a string for the given language
+            # If that fails, try for the primary language
+            get_memoized_string(language, association_name, attribute) || get_memoized_string(HasLocalizationTable.primary_locale, association_name, attribute)
+          end
+          
+          define_method "#{attribute}=" do |value|
+            set_memoized_string(HasLocalizationTable.current_locale, association_name, attribute, value)
+          end
+          
+          define_singleton_method "ordered_by_#{attribute}" do |direction = :asc|
+            direction = direction == :asc ? "ASC" : "DESC"
+            
+            joins(%{
+              LEFT OUTER JOIN #{association.table_name}
+                ON #{association.table_name}.#{association.foreign_key} = #{self.table_name}.#{self.primary_key}
+                  AND #{association.table_name}.#{HasLocalizationTable.config.locale_foreign_key} = %d
+              } % HasLocalizationTable.current_locale.id
+            ).
+            order( "#{association.table_name}.#{attribute} #{direction}")
+            #order{ Squeel::Nodes::Order.new(Squeel::Nodes::Stub.new(association.table_name).send(attribute), direction) }
+          end
+        end
+      end
+    end
+    
+    def localized_attributes
+      # Determine which attributes of the association model should be accessable through the base class
+      # ie. everything that's not a primary key, foreign key, or timestamp attribute
+      association_name = self.localization_table_options[:association_name] || :strings
+      association = reflect_on_association(association_name)
+      
+      attribute_names = association.klass.attribute_names
+      timestamp_attrs = association.klass.new.send(:all_timestamp_attributes_in_model).map(&:to_s)
+      foreign_keys = association.klass.reflect_on_all_associations.map{ |a| a.association_foreign_key }
+      primary_keys = [association.klass.primary_key]
+      # protected_attrs = association.klass.protected_attributes.to_a
+      
+      (attribute_names - timestamp_attrs - foreign_keys - primary_keys).map(&:to_sym)
+    end
+    
+    def localized_attribute_required?(attribute)
+      return false unless localization_table_options[:required] || false
+      return true unless localization_table_options[:optional]
+      
+      !localization_table_options[:optional].include?(attribute) 
+    end
+    
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
+        attributes = $1.split("_and_").map(&:to_sym)
+        if (attributes & localized_attributes).size == attributes.size and args.size == attributes.size
+          raise ArgumentError, "expected #{attributes.size} #{"argument".pluralize(attributes.size)}" unless args.size == attributes.size
+          args = attributes.zip(args).inject({}) { |memo, (key, val)| memo[key] = val; memo }
+          return find_by_localized_attributes(args)
+        end
+      end
+      
+      super
+    end
+    
+    def respond_to?(*args)
+      if args.first.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
+        attributes = $1.split("_and_").map(&:to_sym)
+        return ((attributes & localized_attributes).size == attributes.size)
+      end
+      
+      super
+    end
+  end
+  
+  module InstanceMethods
+  private
+    # Both strings and the associations are memoized, so that if an association adds more than one attribute to the main model, the association doesn't need 
+    # to be loaded each time a different attribute is accessed.
+    def get_memoized_string(language, association, attribute)
+      @_localized_attribute_cache ||= {}
+      @_localized_attribute_cache[attribute] ||= {}
+
+      @_localized_association_cache ||= {}
+      @_localized_association_cache[association] ||= {}
+    
+      @_localized_attribute_cache[attribute][language.id] ||= begin
+        @_localized_association_cache[association][language.id] ||= (send(association).where{ HasLocalizationTable.config.locale_foreign_key == language.id }.first || send(association).detect{ |a| a.send(HasLocalizationTable.config.locale_foreign_key) == language.id })
+        s = @_localized_association_cache[association][language.id].send(attribute) rescue nil
+        s.blank? ? nil : s
+      end
+    end
+    
+    def set_memoized_string(language, association, attribute, value)
+      string = send(association).detect{ |a| a.send(HasLocalizationTable.config.locale_foreign_key) == language.id } || send(association).build(HasLocalizationTable.config.locale_foreign_key => language.id)
+      value = value.to_s
+      
+      string.send(:"#{attribute}=", value)
+      
+      @_localized_attribute_cache ||= {}
+      @_localized_attribute_cache[attribute] ||= {}
+      @_localized_attribute_cache[attribute][language.id] = value.blank? ? nil : value
+    end
+  end
+end

data/lib/has_localization_table/config.rb

@@ -0,0 +1,38 @@
+require 'active_support/configurable'
+require 'active_support/inflector'
+
+module HasLocalizationTable
+  # Configures global settings for HasLocalizationTable
+  #   HasLocalizationTable.configure do |config|
+  #     config.default_locale = Locale.find_by_code("en")
+  #   end
+  def self.configure(&block)
+    yield @config ||= HasLocalizationTable::Configuration.new
+  end
+
+  # Global settings for ODF::Converter
+  def self.config
+    @config
+  end
+
+  # need a Class for 3.0
+  class Configuration #:nodoc:
+    include ActiveSupport::Configurable
+    include ActiveSupport::Inflector
+    
+    config_accessor :locale_class
+    config_accessor :locale_foreign_key
+    config_accessor :primary_locale
+    config_accessor :current_locale
+    config_accessor :all_locales
+  end
+
+  # this is ugly. why can't we pass the default value to config_accessor...?
+  configure do |config|
+    config.locale_class = "Locale"
+    config.locale_foreign_key = "locale_id"
+    config.primary_locale = ->{ config.locale_class.constantize.first }
+    config.current_locale = ->{ config.locale_class.constantize.first }
+    config.all_locales = ->{ config.locale_class.constantize.all }
+  end
+end

data/lib/has_localization_table/version.rb

@@ -0,0 +1,3 @@
+module HasLocalizationTable
+  VERSION = "0.0.2"
+end

data/lib/has_localization_table.rb

@@ -0,0 +1,15 @@
+require "has_localization_table/version"
+require "has_localization_table/config"
+require "has_localization_table/active_record"
+
+ActiveRecord::Base.extend(HasLocalizationTable::ActiveRecord) if defined?(ActiveRecord::Base)
+
+module HasLocalizationTable
+  [:primary_locale, :current_locale, :all_locales].each do |meth|
+    define_singleton_method meth do
+      l = config.send(meth)
+      return l.call if l.respond_to?(:call)
+      l
+    end
+  end
+end

data/spec/active_record_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+# Setup in-memory database so AR can work
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveRecord::Migration.tap do |m|
+  m.create_table :articles do |t|
+    t.timestamps
+  end
+
+  m.create_table :locales do |t|
+    t.string :name
+  end
+
+  m.create_table :article_strings do |t|
+    t.integer :article_id
+    t.integer :locale_id
+    t.string :name
+    t.string :description
+  end
+end
+
+# Set up locales
+Locale = Class.new(ActiveRecord::Base)
+Locale.create!(name: "English")
+Locale.create!(name: "French")
+
+ArticleString = Class.new(ActiveRecord::Base) do
+  belongs_to :article
+  belongs_to :locale
+end
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+  end
+  
+  describe "#has_localization_table" do
+    before do
+      Object.send(:remove_const, :Article) rescue nil
+      Article = Class.new(ActiveRecord::Base)
+    end
+    
+    it "should track any given options" do
+      Article.has_localization_table :localizations, required: true, optional: [:description]
+      Article.localization_table_options.must_equal({ association_name: :localizations, required: true, optional: [:description] })
+    end
+    
+    it "should define has_many association on the base class with a default name of :strings" do
+      Article.has_localization_table
+      assoc = Article.reflect_on_association(:strings)
+      assoc.wont_be_nil
+      assoc.macro.must_equal :has_many
+      assoc.klass.must_equal ArticleString
+    end
+    
+    it "should use the given association name" do
+      Article.has_localization_table :localizations
+      assoc = Article.reflect_on_association(:localizations)
+      assoc.wont_be_nil
+      assoc.macro.must_equal :has_many
+      assoc.klass.must_equal ArticleString
+    end
+    
+    it "should use the given class" do
+      ArticleText = Class.new(ArticleString)
+      Article.has_localization_table class_name: ArticleText
+      assoc = Article.reflect_on_association(:strings)
+      assoc.wont_be_nil
+      assoc.macro.must_equal :has_many
+      assoc.klass.name.must_equal "ArticleText"
+      
+      Object.send(:remove_const, :ArticleText)
+    end
+     
+    it "should add validations if given required: true" do
+      Article.has_localization_table required: true
+      a = Article.new
+      refute a.valid?
+      a.errors[:strings].wont_be_empty
+      
+      a = Article.new(description: "Wishing the world hello!")
+      s = a.strings.first
+      refute s.valid?
+      s.errors[:name].wont_be_empty
+    end
+    
+    it "should not add validations if given required: false" do
+      Article.has_localization_table required: false
+      a = Article.new
+      a.valid? or raise a.strings.map(&:errors).inspect
+      a.errors[:strings].must_be_empty
+      
+      a = Article.new(description: "Wishing the world hello!")
+      s = a.strings.first
+      assert s.valid?
+      s.errors[:name].must_be_empty
+    end
+    
+    it "should not add validations if required is not given" do
+      Article.has_localization_table
+      a = Article.new
+      assert a.valid?
+      a.errors[:strings].must_be_empty
+      
+      a = Article.new(description: "Wishing the world hello!")
+      s = a.strings.first
+      assert s.valid?
+      s.errors[:name].must_be_empty
+    end
+    
+    it "should not add validations for optional fields" do
+      Article.has_localization_table required: true, optional: [:description]
+      a = Article.new(name: "Test")
+      assert a.valid?
+      a.errors[:strings].must_be_empty
+      assert a.strings.all?{ |s| s.errors[:description].empty? }
+    end
+  end
+  
+  describe "other methods" do
+    before do
+      Object.send(:remove_const, :Article) rescue nil
+      Article = Class.new(ActiveRecord::Base)
+      Article.has_localization_table
+    end
+    
+    let(:a) { Article.new(name: "Test", description: "Description") }
+    
+    it "should set localized attributes" do
+      a.strings.first.name.must_equal "Test"
+      a.strings.first.description.must_equal "Description"
+    end
+    
+    it "should create accessor methods" do
+      a.name.must_equal "Test"
+      a.description.must_equal "Description"
+    end
+    
+    it "should save localized attributes" do
+      a.save!
+      a.reload
+      a.name.must_equal "Test"
+      a.description.must_equal "Description"
+    end
+    
+    it "should create mutator methods" do
+      a.name = "Changed"
+      a.description = "Changed Description"
+      a.name.must_equal "Changed"
+      a.description.must_equal "Changed Description"
+      a.strings.first.name.must_equal "Changed"
+      a.strings.first.description.must_equal "Changed Description"
+    end
+    
+    it "should use the current locale when setting" do
+      a
+      
+      HasLocalizationTable.configure do |c|
+        c.current_locale = Locale.last
+      end
+      
+      a.name = "French Name"
+      a.description = "French Description"
+      
+      eng = a.strings.detect{ |s| s.locale_id == Locale.first.id }
+      fre = a.strings.detect{ |s| s.locale_id == Locale.last.id }
+      
+      eng.name.must_equal "Test"
+      eng.description.must_equal "Description"
+      fre.name.must_equal "French Name"
+      fre.description.must_equal "French Description"
+    end
+    
+    it "should create finder methods" do
+      a.save!
+      Article.find_by_name("Test").must_equal a
+      Article.find_by_description("Description").must_equal a
+      Article.find_by_name_and_description("Test", "Description").must_equal a
+      Article.find_by_description_and_name("Description", "Test").must_equal a
+      
+      Article.find_by_name("Wrong").must_be_nil
+      Article.find_by_description("Wrong").must_be_nil
+    end
+    
+    it "should create ordered_by methods" do
+      a.save!
+      b = Article.create!(name: "Name", description: "Another Description")
+      c = Article.create!(name: "Once Upon a Time...", description: "Fairytale")
+      Article.ordered_by_name.must_equal [b, c, a]
+      Article.ordered_by_description.must_equal [b, a, c]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'active_record'
+require 'has_localization_table'
+
+class MiniTest::Spec
+  def run(*args, &block)
+    value = nil
+ 
+    begin
+      ActiveRecord::Base.connection.transaction do
+        value = super
+        raise ActiveRecord::Rollback
+      end
+    rescue ActiveRecord::Rollback
+    end
+ 
+    return value  # The result of run must be always returned for the pretty dots to show up
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: has_localization_table
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Vandersluis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &21307760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *21307760
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &21323460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *21323460
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &21322860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21322860
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &21322440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21322440
+description: Automatically sets up usage of a relational table to contain user-created
+  multi-locale string attributes
+email:
+- dvandersluis@selfmgmt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- has_localization_table.gemspec
+- lib/has_localization_table.rb
+- lib/has_localization_table/active_record.rb
+- lib/has_localization_table/config.rb
+- lib/has_localization_table/version.rb
+- spec/active_record_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dvandersluis/has_localization_table
+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: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Sets up associations and attribute methods for AR models that have a relational
+  table to contain user-created data in multiple languages.
+test_files:
+- spec/active_record_spec.rb
+- spec/spec_helper.rb
+has_rdoc: