translatable_attributes 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+**/.*.sw?

data/Gemfile

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

data/README.md

@@ -0,0 +1,4 @@
+Translatable Attributes
+=======================
+
+Works with I18n to allow you to magically translate an attribute of an object.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |t|
+  t.main = "README.md"
+  t.rdoc_files.include "README.md", "lib/**/*.lib"
+end
+
+task :default => :test

data/lib/translatable_attributes.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'i18n/active_record'
+# Including this module into your model will allow you to add arbitrary
+# attributes whose values are persisted in multiple languages in the database.
+#
+# For example, supposing you have an online shop, and you need to store the
+# description of products in English and German. First, you should ensure that
+# I18n.available_locales returns [:en, :de] (at least).
+#
+#     class Product
+#       translatable_attribute_accessor :description
+#     end
+#     
+#     product = Product.create                        => a new Product#123
+#     product.description_en = "A thing"
+#     product.description_de = "Ein Ding"
+#
+# The descriptions will be persisted in the translations table (or whatever
+# your I18n::Backend::ActiveRecord is using - see that gem for more info),
+# with the key 'product.descriptions.123'.
+module TranslatableAttributes
+  def self.included(mod)
+    mod.send(:extend, ClassMethods)
+    mod.send(:include, InstanceMethods)
+    mod.send(:after_save, :save_translatable_attributes)
+  end
+
+  module ClassMethods
+    # Adds a reader and writer for each available locale for each of the given
+    # attributes. For example (and assuming that the available locales are :en
+    # and :de):
+    #
+    #     I18n.available_locales                            # => [:en, :de]
+    #
+    #     class Post < ActiveModel::Base
+    #       translatable_attribute_accessor :title, :body
+    #     end
+    #
+    # This creates the methods `title_en`, `title_en=`, `title_de`,
+    # `title_de=`, `body_en`, `body_en=`, `body_de` and `body_de=`
+    def translatable_attribute_accessor(*attributes)
+      attributes.each do |attr|
+        I18n.available_locales.map(&:to_s).each do |locale|
+          class_eval do
+            name = "#{attr.to_s}_#{locale.gsub('-', '_').downcase}"
+
+            define_method name do
+              translatable_attribute_record(attr, locale).value
+            end
+
+            define_method "#{name}=" do |value|
+              translatable_attribute_record(attr, locale).value = value
+            end
+
+          end
+        end
+      end
+    end
+  end
+
+  module InstanceMethods
+    def save_translatable_attributes
+      @translatable_attribute_records.each do |locale, records|
+        records.each do |attr, record|
+          record.key = translatable_attribute_record_key(attr)
+          record.save!
+        end
+      end unless @translatable_attribute_records.nil?
+    end
+
+    def translatable_attribute_record_key(attr)
+      "#{self.class.name.demodulize.tableize}.#{to_param}.#{attr}"
+    end
+
+    def translatable_attribute_record(attr, locale)
+      key = translatable_attribute_record_key(attr)
+      @translatable_attribute_records ||= {}
+      @translatable_attribute_records[locale] ||= {}
+      @translatable_attribute_records[locale][attr] ||= I18n::Backend::ActiveRecord::Translation.locale(locale).find_by_key(key)
+      @translatable_attribute_records[locale][attr] ||= I18n::Backend::ActiveRecord::Translation.locale(locale).build
+    end
+  end
+end

data/lib/translatable_attributes/version.rb

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

data/test/translatable_attributes_test.rb

@@ -0,0 +1,79 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'test/unit'
+require 'translatable_attributes'
+
+class TranslatableAttributesTest < Test::Unit::TestCase
+  class Model < ActiveRecord::Base; end
+
+  def setup
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'sqlite3',
+      :database => ':memory:'
+    )
+
+    ActiveRecord::Base.connection.create_table :models, :force => true do |t|
+      t.string :name
+    end
+
+    ActiveRecord::Base.connection.create_table :translations, :force => true do |t|
+      t.string :locale
+      t.string :key
+      t.string :value
+      t.text :interpolations
+      t.boolean :is_proc
+    end
+
+    I18n.backend = I18n::Backend::ActiveRecord.new
+    I18n.available_locales = %W(en de-DE)
+
+    Model.send(:include, TranslatableAttributes)
+    Model.send(:translatable_attribute_accessor, :foo)
+
+    @model = Model.create!
+  end
+
+  def test_setup
+    assert_nothing_raised do
+      model = Model.create!(:name => "Heidi Klum")
+      assert_equal "Heidi Klum", model.name
+    end
+    assert_nothing_raised do
+      I18n::Backend::ActiveRecord::Translation.create!(:locale => 'en', :key => 'foo', :value => 'bar')
+      assert_equal "bar", I18n.t("foo")
+    end
+  end
+
+  def test_creation_of_methods
+    assert @model.respond_to?('foo_en')
+    assert @model.respond_to?('foo_en=')
+    assert @model.respond_to?('foo_de_de')
+    assert @model.respond_to?('foo_de_de=')
+  end
+
+  def test_accessors
+    @model.foo_en = "Boo"
+    assert_equal "Boo", @model.foo_en
+    @model.foo_de_de = "Bü"
+    assert_equal "Bü", @model.foo_de_de
+  end
+
+  def test_after_save
+    count = I18n::Backend::ActiveRecord::Translation.count
+
+    @model.foo_en = "Hello"
+    @model.foo_de_de = "Hello"
+    @model.save
+    assert_equal count += 2, I18n::Backend::ActiveRecord::Translation.count
+
+    Model.create(:foo_en => "Boo")
+    assert_equal count += 1, I18n::Backend::ActiveRecord::Translation.count
+
+    Model.create(:foo_en => "Bar", :foo_de_de => "Yo")
+    assert_equal count += 2, I18n::Backend::ActiveRecord::Translation.count
+  end
+
+  def test_key_and_locale_method
+    key = @model.translatable_attribute_record_key("x_y")
+    assert_equal "models.#{@model.id}.x_y", key
+  end
+end

data/translatable_attributes.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "translatable_attributes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "translatable_attributes"
+  s.version     = TranslatableAttributes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["JJ Buckley"]
+  s.email       = ["translatable_attributes@bjjb.org"]
+  s.homepage    = "http://jjbuckley.github.com/translatable_attributes"
+  s.summary     = %q{Automagic attribute translations for ActiveRecord}
+  s.description = %q{A Ruby module which fakes out internationalised attributes on the fly.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'i18n-active_record', '>= 0.0.2'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: translatable_attributes
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- JJ Buckley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-03 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: i18n-active_record
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :runtime
+  version_requirements: *id001
+description: A Ruby module which fakes out internationalised attributes on the fly.
+email: 
+- translatable_attributes@bjjb.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/translatable_attributes.rb
+- lib/translatable_attributes/version.rb
+- test/translatable_attributes_test.rb
+- translatable_attributes.gemspec
+has_rdoc: true
+homepage: http://jjbuckley.github.com/translatable_attributes
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Automagic attribute translations for ActiveRecord
+test_files: []
+