lolita-translation 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", ">=3.0.0"
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 ITHouse
+
+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,180 @@
+LolitaHasTranslations
+======================
+
+This is a fork of http://github.com/dmitry/has_translations with small changes.
+
+1. The main difference is that the translations table holds only translations, but not the original data from default_locale, so:
+
+    I18n.default_locale = :en
+    I18n.locale = :lv
+    
+    a = Article.create :title => "Title in EN"
+    a.title
+    # returns blank, because current locale is LV and there is no translation in it
+    => ""
+    I18n.locale = :en
+    a.title
+    => "Title in EN"
+    a.translations.create :title => "Title in LV", :locale => 'lv'
+    I18n.locale = :lv
+    a.title
+    => "Title in LV"
+
+2. When a "find" is executed and current language is not the same as default language then :translations are added to :includes
+   to pre fetch all translations.
+
+3. The "ModelNameTranslation" class is created for you automaticly with all validations for ranslated fields. Of course you can create it manualy for custom vlidations and other.
+
+4. You dont have to create migration for the translation table, just add a line for every translated model in `db/seed.rb`
+
+    TextPage.sync_translation_table!
+    Blog::Article.sync_translation_table!
+
+   And run `rake db:seed` and it will do it for you. It also updates the table if you add news columns in the `translations :name, :title .....` method.
+
+HasTranslations v0.3.1
+======================
+
+This simple plugin creates translations for your model.
+Uses delegation pattern: http://en.wikipedia.org/wiki/Delegation_pattern
+
+Tested with ActiveRecord versions: 2.3.5, 2.3.9, 3.0.0 (to test with Rails 3 run `rake RAILS_VERSION=3.0`)
+
+Installation
+============
+
+    gem install has_translations
+
+or as a plugin
+
+    script/plugin install git://github.com/dmitry/has_translations.git
+
+Example
+=======
+
+For example you have Article model and you want to have title and text to be translated.
+
+Create model named ArticleTranslation (Rule: [CamelCaseModelName]Translation)
+
+Migration should have `locale` as a string with two letters and `belongs_to associative id`, like:
+
+    class CreateArticleTranslations < ActiveRecord::Migration
+      def self.up
+        create_table :article_translations do |t|
+          t.integer :article_id, :null => false
+          t.string :locale, :null => false, :limit => 2
+          t.string :title, :null => false
+          t.text :text, :null => false
+        end
+
+        add_index :article_translations, [:article_id, :locale], :unique => true
+      end
+
+      def self.down
+        drop_table :article_translations
+      end
+    end
+
+Add to article model `translations :value1, :value2`:
+
+    class Article < ActiveRecord::Base
+      translations :title, :text
+    end
+
+And that's it. Now you can add your translations using:
+
+    article = Article.create
+
+    article.translations.create(:locale => 'en', :title => 'title', :text => 'text') # or ArticleTranslation.create(:article => article, :locale => 'en', :title => 'title', :text => 'text')
+    article.translations.create(:locale => 'ru', :title => 'заголовок', :text => 'текст')
+    article.reload # reload cached translations association array
+    I18n.locale = :en
+    article.text # text
+    I18n.locale = :ru
+    article.title # заголовок
+
+You can use text filtering plugins, like acts_as_sanitiled and validations, and anything else that is available to the ActiveRecord:
+
+    class ArticleTranslation < ActiveRecord::Base
+      acts_as_sanitiled :title, :text
+
+      validates_presence_of :title, :text
+      validates_length_of :title, :maximum => 100
+    end
+
+Options:
+
+* :fallback => true [default: false] - fallback 1) default locale; 2) first from translations;
+* :reader => false [default: true] - add reader to the model object
+* :writer => true [default: false] - add writer to the model object
+* :nil => nil [default: ''] - if no model found by default returns empty string, you can set it for example to `nil` (no `lambda` supported)
+
+It's better to use translations with `accepts_nested_attributes_for`:
+
+    accepts_nested_attributes_for :translations
+
+To create a form for this you can use `all_translations` method. It's have all
+the locales that you have added using the `I18n.available_locales=` method.
+If translation for one of the locale isn't exists, it will build it with :locale.
+So an example which I used in the production (using `formtastic` gem):
+
+    <% semantic_form_for [:admin, @article] do |f| %>
+      <%= f.error_messages %>
+
+      <% f.inputs :name => "Basic" do %>
+        <% object.all_translations.values.each do |translation| %>
+          <% f.semantic_fields_for :translations, translation do |ft| %>
+            <%= ft.input :title, :label => "Title #{ft.object.locale.to_s.upcase}" %>
+            <%= ft.input :text, :label => "Text #{ft.object.locale.to_s.upcase}" %>
+            <%= ft.input :locale, :as => :hidden %>
+          <% end %>
+        <% end %>
+      <% end %>
+    <% end %>
+
+Sometimes you have validations in the translation model, and if you want to skip
+the translations that you don't want to add to the database, you can use
+`:reject_if` option, which is available for the `accepts_nested_attributes_for`:
+
+    accepts_nested_attributes_for :translations, :reject_if => lambda { |attrs| attrs['title'].blank? && attrs['text'].blank? }
+
+named_scope `translated(locale)` - with that named_scope you can find only
+those models that is translated only to specific locale. For example if you will
+have 2 models, one is translated to english and the second one isn't, then it
+`Article.translated(:en)` will find only first one.
+
+PS
+==
+
+I suggest you to use latest i18n gem, include it in your rails 2 environment:
+
+    config.gem 'i18n', :version => '0.4.1' # change version to the latest
+
+TODO
+====
+
+* add installation description to readme
+* model and migration generators
+* caching
+* write more examples: fallback feature
+* write blog post about comparison and benefits of this plugin between another translation model plugins
+
+
+Alternatives
+============
+
+I know three of them:
+
+* [puret](http://github.com/jo/puret) - special for Rails 3 and almost the same as this project.
+* [globalite2](http://github.com/joshmh/globalize2) - a lot of magic.
+* [model_translations](http://github.com/janne/model_translations) - almost the same as this project, but more with more code in lib.
+* [translatable_columns](http://github.com/iain/translatable_columns) - different approach: every column have own postfix "_#{locale}" in the same table (sometimes it could be fine).
+
+
+Used in
+=======
+
+[noch.es](http://noch.es/), [eten.es](http://www.eten.es), [sem.ee](http://sem.ee/)
+
+
+Copyright (c) 2009-2010 [Dmitry Polushkin], released under the MIT license

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "lolita-translation"
+  gem.homepage = "http://github.com/ithouse/lolita-translations"
+  gem.license = "MIT"
+  gem.summary = %Q{Lolita models translation plugin}
+  gem.description = %Q{Translates models in Lolita}
+  gem.email = "support@ithouse.lv"
+  gem.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lolita-translation #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/app/views/components/lolita/configuration/tab/translation/_display.html.erb

@@ -0,0 +1,76 @@
+<% if resource.new_record? %>
+  <p>-</p>
+<% else %>
+  <form "#">
+    <div class="tab-content">
+      <div class="field" id="field_translation_language">
+        <label for="translation_language"><%=I18n.t("lolita.tabs.translation.fields.language")%>
+        <div class="field-value" id="field_translation_language_value">
+          <%= select_tag :has_translations_locale, options_for_select([""] + I18n.available_locales.clone.delete_if{|l| l == I18n.default_locale}), :onchange => "switch_has_translations_language($(this))" %>
+        </div>
+      </div>
+      
+      <div id="has_translations_fields" class="field" style="display: none">
+        <% resource.class.columns_has_translations.each do |column| %>
+          <label for="<%=column.name%>_field"><%=resource.class.human_attribute_name(column.name)%></label>
+          <div class="fl field-value" id="<%=column.name%>_field">
+            <% if column.type == :string %>
+              <%= text_field_tag 'has_translations_' + column.name, nil, :class => 'txt' %>
+            <% elsif column.type == :text %>
+              <%= text_area_tag 'has_translations_' + column.name, nil, :class => "textarea",:rows=>20, :cols=>40 %>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    </div>
+  </form>
+  <% resource.build_nested_translations %>
+  <%= form_for resource, :url => "/" do |form| %>
+    <%= form.fields_for :translations do |tf| %>
+      <div id="object_translation_fields_<%= tf.object.locale %>">
+        <% resource.class.columns_has_translations.each do |column| %>
+          <%= tf.hidden_field column.name, :class => column.name %>
+        <% end %>
+        <%= tf.hidden_field :id, :class => "id" %>
+        <%= tf.hidden_field tf.object.class.master_id, :value => resource.id %>
+        <%= tf.hidden_field :locale, :class => "locale" %>
+      </div>
+    <% end %>
+  <% end %>
+  <script type="text/javascript">
+    var columns = [<%= resource.class.columns_has_translations.map{|r| "'#{r.name}'"}.join(",") %>];
+    var blur = false;
+    function switch_has_translations_language(select){
+      var locale = select.val();
+      if(locale == ""){
+        $('#has_translations_fields').hide()
+      }else{
+        $.each(columns,function(i,column){
+          var content = $('#object_translation_fields_'+locale+' .'+column).val();
+          $('#has_translations_'+column).val(content);
+          if($('#has_translations_'+column).get(0).tagName == 'TEXTAREA'){
+            tinymce.EditorManager.getInstanceById('has_translations_'+column).setContent(content);
+          }
+        });
+        $('#has_translations_fields').show()
+      }
+      if(!blur){
+        $.each($('#has_translations_fields textarea'), function(i,area){
+          var item = $(area);
+          var tiny_editor = tinymce.EditorManager.getInstanceById(item.attr("id"));
+          tinymce.dom.Event.add(tiny_editor.getWin(), "blur", function(){
+            var textarea = $(tinymce.EditorManager.getInstanceById(item.attr("id")).getElement());
+            tiny_editor.save();
+            textarea.blur();
+          });
+        });
+        blur = true;
+      }
+    }
+    $.each(columns,function(i,column){
+      $('#has_translations_'+column).blur(function(){
+        $('#object_translation_fields_'+$("#has_translations_locale").val()+' .'+$(this).attr("name").split("_")[2]).val($(this).val())
+      })
+    })
+  </script>
+<% end %>

data/app/views/lolita/has_translations/_tab.html.erb

@@ -0,0 +1,78 @@
+<% if @object.new_record? %>
+  <p>Tulkošana iespējama tikai eksistējošiem ierakstiem.</p>
+<% else %>
+  <div class="managed-create-line">
+    <span class="brick"><%= t "fields.language" %></span>
+    <div class="fl">
+      <%= select_tag :has_translations_locale, options_for_select([""] + I18n.available_locales.clone.delete_if{|l| l == I18n.default_locale}), :onchange => "switch_has_translations_language($(this))" %>
+    </div>
+  </div>
+  <div id="has_translations_fields" style="display: none">
+    <% @object.class.columns_has_translations.each do |column| %>
+      <div class="managed-create-line">
+        <span class="brick"><%= @object.class.human_attribute_name(column.name) %></span>
+        <div class="fl">
+          <% if column.type == :string %>
+            <%= text_field_tag 'has_translations_' + column.name, nil, :class => 'txt' %>
+          <% elsif column.type == :text %>
+            <%= text_area_tag 'has_translations_' + column.name, nil, :class => "textarea" %>
+            <script type="text/javascript">
+              tinyMCE.execCommand('mceRemoveControl', false,'has_translations_<%= column.name %>');
+              tinyMCE.execCommand('mceAddControl', false,'has_translations_<%= column.name %>');
+            </script>
+            <br /><br />
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+  <div class="clear"></div>
+  <div></div>
+  <% @object.build_nested_translations %>
+  <% object_form.fields_for :translations do |tf| %>
+    <div id="object_translation_fields_<%= tf.object.locale %>">
+      <% @object.class.columns_has_translations.each do |column| %>
+        <%= tf.hidden_field column.name, :class => column.name %>
+      <% end %>
+      <%= tf.hidden_field :id, :class => "id" %>
+      <%= tf.hidden_field tf.object.class.master_id, :value => @object.id %>
+      <%= tf.hidden_field :locale, :class => "locale" %>
+    </div>
+  <% end %>
+  <script type="text/javascript">
+    var columns = <%= @object.class.columns_has_translations.map(&:name).inspect %>;
+    var blur = false;
+    function switch_has_translations_language(select){
+      var locale = select.val();
+      if(locale == ""){
+        $('#has_translations_fields').hide()
+      }else{
+        $.each(columns,function(i,column){
+          var content = $('#object_translation_fields_'+locale+' .'+column).val();
+          $('#has_translations_'+column).val(content);
+          if($('#has_translations_'+column).get(0).tagName == 'TEXTAREA'){
+            tinymce.EditorManager.getInstanceById('has_translations_'+column).setContent(content);
+          }
+        });
+        $('#has_translations_fields').show()
+      }
+      if(!blur){
+        $.each($('#has_translations_fields textarea'), function(i,area){
+          var item = $(area);
+          var tiny_editor = tinymce.EditorManager.getInstanceById(item.attr("id"));
+          tinymce.dom.Event.add(tiny_editor.getWin(), "blur", function(){
+            var textarea = $(tinymce.EditorManager.getInstanceById(item.attr("id")).getElement());
+            tiny_editor.save();
+            textarea.blur();
+          });
+        });
+        blur = true;
+      }
+    }
+    $.each(columns,function(i,column){
+      $('#has_translations_'+column).blur(function(){
+        $('#object_translation_fields_'+$("#has_translations_locale").val()+' .'+$(this).attr("name").split("_")[2]).val($(this).val())
+      })
+    })
+  </script>
+<% end %>

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  lolita:
+    tabs:
+      titles:
+        translation: Translation
+      translation:
+        fields:
+          language: Language

data/lib/generators/lolita_translation/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    ./script/generate has_translations Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/lolita_translation/has_translations_generator.rb

@@ -0,0 +1,8 @@
+class HasTranslationsGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # m.directory "lib"
+      # m.template 'README', "README"
+    end
+  end
+end

data/lib/lolita-translation/configuration/tab/translation.rb

@@ -0,0 +1,14 @@
+module Lolita
+  module Configuration
+    module Tab
+      class Translation < Lolita::Configuration::Tab::Base
+
+        def initialize(dbi,*args,&block)
+          @type=:translation
+          super
+        end
+        
+      end
+    end
+  end
+end

data/lib/lolita-translation/has_translations.rb

@@ -0,0 +1,295 @@
+require 'stringio'
+
+class ActiveRecord::Base
+  # Provides ability to add the translations for the model using delegate pattern.
+  # Uses has_many association to the ModelNameTranslation.
+  #
+  # For example you have model Article with attributes title and text.
+  # You want that attributes title and text to be translated.
+  # For this reason you need to generate new model ArticleTranslation.
+  # In migration you need to add:
+  #
+  #   create_table :article_translations do |t|
+  #     t.references :article, :null => false
+  #     t.string :locale, :length => 2, :null => false
+  #     t.string :name, :null => false
+  #   end
+  #
+  #   add_index :articles, [:article_id, :locale], :unique => true, :name => 'unique_locale_for_article_id'
+  #
+  # And in the Article model:
+  #
+  #   translations :title, :text
+  #
+  # This will adds:
+  #
+  # * named_scope (translated) and has_many association to the Article model
+  # * locale presence validation to the ArticleTranslation model.
+  #
+  # Notice: if you want to have validates_presence_of :article, you should use :inverse_of.
+  # Support this by yourself. Better is always to use artile.translations.build() method.
+  #
+  # For more information please read API. Feel free to write me an email to:
+  # dmitry.polushkin@gmail.com.
+  #
+  # ===
+  #
+  # You also can pass attributes and options to the translations class method:
+  #
+  #   translations :title, :text, :fallback => true, :writer => true, :nil => nil
+  #
+  # ===
+  #
+  # Configuration options:
+  # 
+  # * <tt>:fallback</tt> - if translation for the current locale not found.
+  #   By default true.
+  #   Uses algorithm of fallback:
+  #   0) current translation (using I18n.locale);
+  #   1) default locale (using I18n.default_locale);
+  #   2) :nil value (see <tt>:nil</tt> configuration option)
+  # * <tt>:reader</tt> - add reader attributes to the model and delegate them
+  #   to the translation model columns. Add's fallback if it is set to true.
+  # * <tt>:writer</tt> - add writer attributes to the model and assign them
+  #   to the translation model attributes.
+  # * <tt>:nil</tt> - when reader cant find string, it returns by default an
+  #   empty string. If you want to change this setting for example to nil,
+  #   add :nil => nil
+  #
+  # ===
+  #
+  # When you are using <tt>:writer</tt> option, you can create translations using
+  # update_attributes method. For example:
+  #
+  #   Article.create!
+  #   Article.update_attributes(:title => 'title', :text => 'text')
+  #
+  # ===
+  #
+  # <tt>translated</tt> named_scope is useful when you want to find only those
+  # records that are translated to a specific locale.
+  # For example if you want to find all Articles that is translated to an english
+  # language, you can write: Article.translated(:en)
+  #
+  # <tt>has_translation?(locale)</tt> method, that returns true if object's model
+  # have a translation for a specified locale
+  #
+  # <tt>translation(locale)</tt> method finds translation with specified locale.
+  #
+  # <tt>all_translations</tt> method that returns all possible translations in
+  # ordered hash (useful when creating forms with nested attributes).
+  def self.translations(*attrs)
+    options = {
+      :fallback => true,
+      :reader => true,
+      :writer => false,
+      :nil => ''
+    }.merge(attrs.extract_options!)
+    options.assert_valid_keys([:fallback, :reader, :writer, :nil])
+    
+    class << self
+      # adds :translations to :includes if current locale differs from default
+      #FIXME is this enough with find or need to create chain for find_last, find_first and others?
+      alias_method(:find_without_translations, :find) unless method_defined?(:find_without_translations)
+      def find(*args)
+        if args[0].kind_of?(Hash)
+          args[0][:include] ||= []
+          args[0][:include] << :translations
+        end unless I18n.locale == I18n.default_locale
+        find_without_translations(*args)
+      end
+      # Defines given class recursively
+      # Example:
+      # create_class('Cms::Text::Page', Object, ActiveRecord::Base)
+      # => Cms::Text::Page
+      def create_class(class_name, parent, superclass, &block)
+        first,*other = class_name.split("::")
+        if other.empty?
+          klass = Class.new superclass, &block
+          parent.const_set(first, klass)
+        else
+          klass = Class.new
+          parent = unless parent.const_defined?(first)
+            parent.const_set(first, klass)
+          else
+            first.constantize
+          end
+          create_class(other.join('::'), parent, superclass, &block)
+        end
+      end
+      # defines "ModelNameTranslation" if it's not defined manualy
+      def define_translation_class name, attrs
+        klass = name.constantize rescue nil
+        unless klass
+          klass = create_class(name, Object, ActiveRecord::Base) do
+            # set's real table name
+            set_table_name name.sub('Translation','').constantize.table_name.singularize + "_translations"
+            cattr_accessor :translate_attrs, :master_id
+            # override validate to vaidate only translate fields from master Class
+            def validate
+              item = self.class.name.sub('Translation','').constantize.new(self.attributes.clone.delete_if{|k,_| !self.class.translate_attrs.include?(k.to_sym)})
+              was_table_name = item.class.table_name
+              item.class.set_table_name self.class.table_name
+              item.valid? rescue
+              self.class.translate_attrs.each do |attr|
+                errors_on_attr = item.errors.on(attr)
+                self.errors.add(attr,errors_on_attr) if errors_on_attr
+              end
+              item.class.set_table_name was_table_name
+            end
+            extend TranslationClassMethods
+          end
+          klass.translate_attrs = attrs
+        else
+          unless klass.respond_to?(:translate_attrs)
+            klass.send(:cattr_accessor, :translate_attrs, :master_id)
+            klass.send(:extend,TranslationClassMethods)
+            klass.translate_attrs = attrs            
+          end
+        end
+        
+        klass.extract_master_id(name)
+        klass
+      end
+      # creates translation table and adds missing fields
+      # So at first add the "translations :name, :desc" in your model
+      # then put YourModel.sync_translation_table! in db/seed.rb and run "rake db:seed"
+      # Later adding more fields in translations array, just run agin "rake db:seed"
+      # If you want to remove fields do it manualy, it's safer
+      def sync_translation_table!
+        out = StringIO.new
+        $stdout = out
+        translations_class = reflections[:translations].class_name.constantize
+        translations_table = translations_class.table_name
+        unless ActiveRecord::Migration::table_exists?(translations_table)
+          ActiveRecord::Migration.create_table translations_table do |t|
+            t.integer translations_class.master_id, :null => false
+            t.string :locale, :null => false, :limit => 5
+            columns_has_translations.each do |col|
+              t.send(col.type,col.name)
+            end
+          end
+          ActiveRecord::Migration.add_index translations_table, [translations_class.master_id, :locale], :unique => true
+          translations_class.reset_column_information
+        else
+          changes = false
+          columns_has_translations.each do |col|
+            unless translations_class.columns_hash.has_key?(col.name)
+              ActiveRecord::Migration.add_column(translations_table, col.name, col.type)
+              changes = true
+            end
+          end
+          translations_class.reset_column_information if changes
+        end
+        $stdout = STDOUT
+      end
+    end
+
+    translation_class_name = "#{self.name}Translation"
+    translation_class = self.define_translation_class(translation_class_name, attrs)
+    belongs_to = self.name.demodulize.underscore.to_sym
+
+    write_inheritable_attribute :has_translations_options, options
+    class_inheritable_reader :has_translations_options
+
+    write_inheritable_attribute :columns_has_translations, (columns rescue []).collect{|col| col if attrs.include?(col.name.to_sym)}.compact
+    class_inheritable_reader :columns_has_translations
+
+    # forces given locale
+    # I18n.locale = :lv
+    # a = Article.find 18
+    # a.title
+    # => "LV title"
+    # a.in(:en).title
+    # => "EN title"
+    def in locale
+      locale.to_sym == I18n.default_locale ? self : find_translation(locale)
+    end
+    
+    def find_or_build_translation(*args)
+      locale = args.first.to_s
+      build = args.second.present?
+      find_translation(locale) || (build ? self.translations.build(:locale => locale) : self.translations.new(:locale => locale))
+    end
+
+    def translation(locale)
+      find_translation(locale.to_s)
+    end
+
+    def all_translations
+      t = I18n.available_locales.map do |locale|
+        [locale, find_or_build_translation(locale)]
+      end
+      ActiveSupport::OrderedHash[t]
+    end
+
+    def has_translation?(locale)
+      return true if locale == I18n.default_locale
+      find_translation(locale).present?
+    end
+
+    # if object is new, then nested slaves ar built for all available locales
+    def build_nested_translations
+      if (I18n.available_locales.size - 1) > self.translations.size
+        I18n.available_locales.clone.delete_if{|l| l == I18n.default_locale}.each do |l|
+          options = {:locale => l.to_s}
+          options[self.class.reflections[:translations].class_name.constantize.master_id] = self.id unless self.new_record?
+          self.translations.build(options) unless self.translations.map(&:locale).include?(l.to_s)
+        end
+      end
+    end
+
+    if options[:reader]
+      attrs.each do |name|
+        send :define_method, name do
+          unless I18n.default_locale == I18n.locale
+            translation = self.translation(I18n.locale)
+            if translation.nil?
+              if has_translations_options[:fallback]
+                (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)
+              else
+                has_translations_options[:nil]
+              end
+            else
+              if @return_raw_data
+                (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)
+              else
+                value = translation.send(name) and value.set_origins(self,name)
+              end
+            end
+          else
+            (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)
+          end
+        end
+      end
+    end
+
+    has_many :translations, :class_name => translation_class_name, :foreign_key => translation_class.master_id, :dependent => :destroy
+    accepts_nested_attributes_for :translations, :allow_destroy => true, :reject_if => proc { |attributes| columns_has_translations.collect{|col| attributes[col.name].blank? ? nil : 1}.compact.empty? }
+    translation_class.belongs_to belongs_to
+    translation_class.validates_presence_of :locale
+    translation_class.validates_uniqueness_of :locale, :scope => translation_class.master_id
+
+    # Workaround to support Rails 2
+    scope_method = if ActiveRecord::VERSION::MAJOR < 3 then :named_scope else :scope end
+
+    send scope_method, :translated, lambda { |locale| {:conditions => ["#{translation_class.table_name}.locale = ?", locale.to_s], :joins => :translations} }
+
+    #private is no good
+
+    def find_translation(locale)
+      locale = locale.to_s
+      translations.detect { |t| t.locale == locale }
+    end
+  end
+end
+
+module TranslationClassMethods
+  # sets real master_id it's aware of STI
+  def extract_master_id name
+    master_class = name.sub('Translation','').constantize
+    #FIXME why need to check superclass ?
+    class_name = master_class.name #!master_class.superclass.abstract_class? ? master_class.superclass.name : master_class.name
+    self.master_id = :"#{class_name.demodulize.underscore}_id"
+  end
+end

data/lib/lolita-translation/rails.rb

@@ -0,0 +1,5 @@
+module LolitaHasTranslation
+  class Engine < Rails::Engine
+
+  end
+end

data/lib/lolita-translation/string.rb

@@ -0,0 +1,19 @@
+class String
+  attr_accessor :origin_model, :origin_name
+  def set_origins obj, name
+    self.origin_model = obj
+    self.origin_name = name
+    self
+  end
+  # forces given locale
+  # I18n.locale = :lv
+  # a = Article.find 18
+  # a.title
+  # => "LV title"
+  # a.title.in(:en)
+  # => "EN title"
+  def in locale
+    return self unless self.origin_model
+    translation = self.origin_model.in(locale) and translation.send(self.origin_name)
+  end
+end

data/lib/lolita-translation.rb

@@ -0,0 +1,12 @@
+
+require 'lolita-translation/string.rb'
+require 'lolita-translation/has_translations.rb'
+require 'lolita-translation/rails'
+
+module Lolita
+  module Configuration
+    module Tab
+      autoload :Translation, "lolita-translation/configuration/tab/translation"
+    end
+  end
+end

data/lib/tasks/has_translations_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :has_translations do
+#   # Task goes here
+# end

data/lolita-translation.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lolita-translation}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
+  s.date = %q{2011-08-01}
+  s.description = %q{Translates models in Lolita}
+  s.email = %q{support@ithouse.lv}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "app/views/components/lolita/configuration/tab/translation/_display.html.erb",
+    "app/views/lolita/has_translations/_tab.html.erb",
+    "config/locales/en.yml",
+    "lib/generators/lolita_translation/USAGE",
+    "lib/generators/lolita_translation/has_translations_generator.rb",
+    "lib/lolita-translation.rb",
+    "lib/lolita-translation/configuration/tab/translation.rb",
+    "lib/lolita-translation/has_translations.rb",
+    "lib/lolita-translation/rails.rb",
+    "lib/lolita-translation/string.rb",
+    "lib/tasks/has_translations_tasks.rake",
+    "lolita-translation.gemspec",
+    "lolita-translations.gemspec",
+    "spec/has_translations_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ithouse/lolita-translations}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Lolita models translation plugin}
+  s.test_files = [
+    "spec/has_translations_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 3.0.0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lolita-translations.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lolita-translations}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
+  s.date = %q{2011-08-01}
+  s.description = %q{Translates models in Lolita}
+  s.email = %q{support@ithouse.lv}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "Rakefile",
+    "VERSION"
+  ]
+  s.homepage = %q{http://github.com/ithouse/lolita-translations}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Lolita models translation plugin}
+  s.test_files = [
+    "spec/has_translations_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 3.0.0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/has_translations_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'HasTranslations' do
+  it "should switch locales" do
+    g = Group.create!(:name => "Sport")
+    c = Category.create!(:name => "Golf", :groups => [g])
+    z = News.create!(:title => "Tiger Woods sucks", :body => Faker::Lorem::paragraphs(10).join, :category_id => c.id)
+    # translate
+    g.translations.create!(:locale => 'lv', :name => "Sports")
+    c.translations.create!(:locale => 'lv', :name => "Golfs")
+    z.translations.create!(:locale => 'lv', :title => "Taigers Vuds nekam neder")
+    
+    g.name.should == "Sport"
+    c.name.should == "Golf"
+    z.title.should == "Tiger Woods sucks"
+
+    I18n.locale = :lv
+    
+    g.name.should == "Sports"
+    c.name.should == "Golfs"
+    z.title.should == "Taigers Vuds nekam neder"
+
+    z.category.name.should == "Golfs"
+    z.category.groups.first.name.should == "Sports"
+
+    z.destroy
+    c.destroy
+    g.destroy
+    #--------------------------------
+    I18n.locale = I18n.default_locale
+  end
+
+  it "should load requested locale with 'in' method" do
+    g = Group.create!(:name => "Sport")
+    g.translations.create!(:locale => 'lv', :name => "Sports")
+
+    g = Group.find_by_name "Sport"    
+    g.name.should == "Sport"
+    g.name.in(:lv).should == "Sports"
+    g.name.should == "Sport"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require 'rubygems'
+gem 'rails', '~>2.3'
+require 'i18n'
+require 'active_record'
+require 'spec'
+require 'faker'
+
+require 'ruby-debug'    
+
+require File.dirname(__FILE__)+'/../init.rb'
+ActiveRecord::Base.logger = Logger.new(File.open("#{File.dirname(__FILE__)}/database.log", 'w+'))
+ActiveRecord::Base.establish_connection({ :database => ":memory:", :adapter => 'sqlite3', :timeout => 500 })
+
+# setup I18n
+I18n.available_locales = [:en,:lv,:ru,:fr]
+I18n.default_locale = :en
+I18n.locale = :en
+
+# Add models
+ActiveRecord::Schema.define do
+  create_table :news, :force => true do |t|
+    t.string :title
+    t.string :slug
+    t.text :body
+    t.integer :category_id
+    t.integer :trx_id
+  end
+  create_table :categories, :force => true do |t|
+    t.string :name
+    t.string :desc
+    t.integer :trx_id
+  end
+  create_table :groups, :force => true do |t|
+    t.string :name
+  end
+  create_table :categories_groups, :force => true, :id => false do |t|
+    t.integer :category_id
+    t.integer :group_id
+  end
+  create_table :meta_datas, :force => true do |t|
+    t.string :title
+    t.string :url
+    t.string :keywords
+    t.text :description
+    t.string :metaable_type
+    t.integer :metaable_id
+  end
+end
+
+class News < ActiveRecord::Base
+  belongs_to :category, :dependent => :destroy
+  has_one :meta_data, :as => :metaable, :dependent => :destroy
+  translations :title, :body
+end
+
+class Category < ActiveRecord::Base
+  has_many :news
+  has_and_belongs_to_many :groups
+  translations :name
+end
+
+class Group < ActiveRecord::Base
+  has_and_belongs_to_many :categories
+  translations :name
+end
+
+class MetaData < ActiveRecord::Base
+  belongs_to :metaable, :polymorphic => true
+  translations :title, :url, :keywords, :description
+end
+
+# build translation tables
+
+News.sync_translation_table!
+Category.sync_translation_table!
+Group.sync_translation_table!
+MetaData.sync_translation_table!
+
+# this is included in Lolita by default
+class ::Hash
+  # converts all keys to symbols, but RECURSIVE
+  def symbolize_keys!
+    each do |k,v|
+      sym = k.respond_to?(:to_sym) ? k.to_sym : k
+      self[sym] = Hash === v ? v.symbolize_keys! : v
+      delete(k) unless k == sym
+    end
+    self
+  end
+end
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    News.delete_all
+    Category.delete_all
+    MetaData.delete_all
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: lolita-translation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ITHouse
+- Gatis Tomsons
+- Arturs Meisters
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-01 00:00:00.000000000 +03:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &74136740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *74136740
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &74136150 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *74136150
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &74135560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *74135560
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &74118460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *74118460
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &74117810 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *74117810
+description: Translates models in Lolita
+email: support@ithouse.lv
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- app/views/components/lolita/configuration/tab/translation/_display.html.erb
+- app/views/lolita/has_translations/_tab.html.erb
+- config/locales/en.yml
+- lib/generators/lolita_translation/USAGE
+- lib/generators/lolita_translation/has_translations_generator.rb
+- lib/lolita-translation.rb
+- lib/lolita-translation/configuration/tab/translation.rb
+- lib/lolita-translation/has_translations.rb
+- lib/lolita-translation/rails.rb
+- lib/lolita-translation/string.rb
+- lib/tasks/has_translations_tasks.rake
+- lolita-translation.gemspec
+- lolita-translations.gemspec
+- spec/has_translations_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/ithouse/lolita-translations
+licenses:
+- MIT
+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: 283995089
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Lolita models translation plugin
+test_files:
+- spec/has_translations_spec.rb
+- spec/spec_helper.rb