lolita-translation 0.2.9 → 0.2.18

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format d

data/Gemfile

@@ -1,9 +1,19 @@
 source "http://rubygems.org"
 
-gem "lolita", ">=3.2.0.rc.3"
+gem "lolita", "3.1.18"
 group :development do
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
   gem "rcov", ">= 0"
 end
+
+group :test do
+  gem "rails", "~>3.0.0"
+  gem "rspec","~>2.6.0"
+  gem "rspec-rails", "~>2.6.0"
+  gem "webmock", "~> 1.7.6"
+  gem "sqlite3"
+  gem "ffaker"
+  gem 'ruby-debug19', :require => 'ruby-debug'
+end

data/VERSION

@@ -1 +1 @@
-0.2.9
+0.2.18

data/lib/lolita-translation.rb

@@ -1,7 +1,12 @@
 
+require 'lolita'
 require 'lolita-translation/string.rb'
-require 'lolita-translation/has_translations.rb'
-require 'lolita-translation/rails'
+require 'lolita-translation/modules'
+require 'lolita-translation/model'
+require 'lolita-translation/configuration'
+if Lolita.rails3?
+  require 'lolita-translation/rails'
+end
 
 module Lolita
   module Translation
@@ -11,6 +16,7 @@ module Lolita
     end
 
     class << self
+      # Determine whether tab is translatable. When there is one or more fields in tab, that are defined with #translates.
       def translatable?(tab)
         fields = tab.fields.reject{|field|
           field.dbi!=tab.dbi
@@ -19,6 +25,7 @@ module Lolita
         tab.dbi.klass.respond_to?(:translations) && (fields.map(&:name) & tab.dbi.klass.translation_attrs).any?
       end
 
+      # Create nested form configuration for views.
       def create_translations_nested_form(resource,tab)
         resource.build_nested_translations 
         nested_form = Lolita::Configuration::NestedForm.new(tab,:translations) 
@@ -37,39 +44,3 @@ module Lolita
 end
 
 Lolita.add_module Lolita::Translation
-
-Lolita::Hooks.component(:"/lolita/configuration/tab/form").before do
-  tab = self.component_locals[:tab]
-  if Lolita::Translation.translatable?(tab)
-    self.send(:render_component,"lolita/translation",:switch, :tab => tab)
-  end
-end
-
-Lolita::Hooks.component(:"/lolita/configuration/tab/fields").after do
-  tab = self.component_locals[:tab]
-  if Lolita::Translation.translatable?(tab)
-    self.render_component Lolita::Translation.create_translations_nested_form(self.resource,tab)
-  end
-end
-
-Lolita::Hooks.component(:"/lolita/configuration/tab/fields").around do
-  tab = self.component_locals[:tab]
-  if Lolita::Translation.translatable?(tab)
-    self.send(:render_component,"lolita/translation",:language_wrap,:tab => tab, :content => let_content)
-  else
-    let_content
-  end
-end
-
-Lolita::Hooks.component(:"/lolita/configuration/nested_form/fields").around do
-  tab = self.component_locals[:nested_form].parent
-  if Lolita::Translation.translatable?(tab)
-    self.send(:render_component,"lolita/translation",:language_wrap, :tab => tab, :content => let_content)
-  else
-    let_content
-  end
-end
-
-Lolita::Hooks.component(:"/lolita/configuration/tabs/display").before do
-  self.render_component "lolita/translation", :assets
-end

data/lib/lolita-translation/configuration.rb

@@ -0,0 +1,192 @@
+module Lolita
+  module Translation
+
+    module SingletonMethods
+      # 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 translations *attrs
+        @translations_config ||= Lolita::Translation::Configuration.new(self,*attrs)
+        if block_given?
+          yield @translations_config
+        end
+        @translations_config
+      end
+    end
+
+    class Configuration
+
+      attr_reader :klass, :options, :translation_class_name, :translation_class,:attrs
+
+      def initialize(base_class, *attrs)
+        @klass = base_class
+        @attrs = attrs
+        initialize_options
+        include_modules
+        initialize_default_attributes
+        extend_klass
+        extend_translation_class
+      end
+
+      private
+
+      def extend_klass
+        config = self
+        @klass.class_eval do
+    
+          class_attribute :has_translations_options
+          self.has_translations_options = config.options
+
+          class_attribute :columns_has_translations
+          self.columns_has_translations = (columns rescue []).collect{|col| col if config.attrs.include?(col.name.to_sym)}.compact
+          
+          class_attribute :translation_attrs
+          self.translation_attrs = config.attrs
+
+          has_many :translations, :class_name => config.translation_class_name, :foreign_key => config.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? }
+          
+          scope :translated, lambda { |locale| 
+            where("#{translation_class.table_name}.locale = ?", locale.to_s).joins(:translations)
+          }
+
+          class << self
+            alias_method_chain :find, :translations
+          end
+        end
+        override_readers
+      end
+
+      def extend_translation_class
+        translation_class.belongs_to @klass.name.demodulize.underscore.to_sym
+        translation_class.validates_presence_of :locale
+        translation_class.validates_uniqueness_of :locale, :scope => translation_class.master_id
+      end
+
+      def override_readers
+        if options[:reader]
+          attrs.each do |name|
+            override_reader(name)
+          end
+        end
+      end
+
+      def override_reader(name)
+        @klass.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
+
+      def initialize_default_attributes
+        @translation_class_name = "#{@klass.name}Translation"
+        @translation_class = Lolita::Translation::TranslationModel.new(self).klass
+      end
+
+      def include_modules
+        @klass.send(:include, Lolita::Translation::InstanceMethods)
+        @klass.extend(Lolita::Translation::ClassMethods)
+      end
+
+      def initialize_options
+        @options = {
+          :fallback => true,
+          :reader => true,
+          :writer => false,
+          :nil => ''
+        }.merge(@attrs.extract_options!)
+        @options.assert_valid_keys([:fallback, :reader, :writer, :nil,:table_name])
+      end
+
+    end
+  end
+end

data/lib/lolita-translation/model.rb

@@ -0,0 +1,100 @@
+module Lolita
+  module Translation
+    class ClassFactory
+
+      def self.create(class_name, parent, superclass=nil, &block)
+        first,*other = class_name.split("::")
+        if other.empty?
+          klass = superclass ? Class.new(superclass, &block) : Class.new(&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
+          self.create(other.join('::'), parent, superclass, &block)
+        end
+      end
+    end
+
+    module ModelInstanceMethods
+      # 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)})
+        item_adapter =  Lolita::DBI::Base.create(item.class)
+        self_adapter =  Lolita::DBI::Base.create(self.class)
+        was_table_name = item_adapter.collection_name
+        item_adapter.collection_name = self_adapter.collection_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_adapter.collection_name = was_table_name
+      end
+    end
+
+    module ModelClassMethods
+      # 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
+
+    class TranslationModel
+
+      attr_reader :adapter,:klass
+
+      def initialize(config)
+        @config = config
+        @adapter =  Lolita::DBI::Base.create(@config.klass)
+        @klass = begin
+          @config.translation_class_name.constantize 
+        rescue
+          self.create
+        end
+        fix_class_attrs
+        @klass.extract_master_id(@config.translation_class_name)
+      end
+
+      def create
+        translation_model = self
+        config = @config
+        new_klass = Lolita::Translation::ClassFactory.create(@config.translation_class_name, Object, get_orm_class) do
+            if translation_model.adapter.dbi.adapter_name == :mongoid
+              include Mongoid::Document
+            end
+            # set's real table name
+            translation_adapter = Lolita::DBI::Base.create(self)
+            translation_adapter.collection_name = config.options[:table_name] || translation_model.adapter.collection_name.to_s + "_translations"
+           
+            cattr_accessor :translate_attrs, :master_id
+
+            include Lolita::Translation::ModelInstanceMethods
+            extend Lolita::Translation::ModelClassMethods
+        end
+        new_klass.translate_attrs = @config.attrs
+        new_klass
+      end
+
+      private
+
+      def get_orm_class()
+        @adapter.dbi.adapter_name == :active_record ?  ActiveRecord::Base : nil
+      end
+
+      def fix_class_attrs
+        unless @klass.respond_to?(:translate_attrs)
+          @klass.send(:cattr_accessor, :translate_attrs, :master_id)
+          @klass.send(:extend,Lolita::Translation::ModelClassMethods)
+          @klass.translate_attrs = @config.attrs            
+        end
+      end
+    end
+  end
+end

data/lib/lolita-translation/modules.rb

@@ -0,0 +1,130 @@
+module Lolita
+  module Translation
+    module ClassMethods
+      
+      def find_with_translations(*args,&block)
+        unless ::I18n.locale == ::I18n.default_locale
+          if args && args[0].kind_of?(Hash)
+            args[0][:include] ||=[]
+            args[0][:include] << :translations
+          end
+        end
+        find_without_translations *args, &block
+      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
+        self_adapter = Lolita::DBI::Base.create(self)
+        translations_class = self.reflect_on_association(:translations).klass
+        translations_adapter = Lolita::DBI::Base.create(translations_class)
+
+        if translations_adapter.dbi.adapter_name == :active_record
+          translations_table = translations_adapter.collection_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
+        elsif translations_adapter.dbi.adapter_name == :mongoid
+          unless translations_class.fields["locale"]
+            translations_class.class_eval do
+              field(self.master_id, :type => Integer)
+              field :locale, :type => String
+              columns_has_translations.each do |col|
+                field col.name, :type => col.type
+              end
+              index(
+                [
+                  [ self.master_id, Mongo::ASCENDING ],
+                  [ :locale, Mongo::ASCENDING ]
+                ],
+                unique: true
+              )
+            end
+          else
+            columns_has_translations.each do |col|
+              unless translations_class.fields[col.name.to_s]
+                translations_class.field(col.name,:type => col.type)
+              end
+            end
+          end
+        end
+        $stdout = STDOUT
+      end
+    end
+
+    module InstanceMethods
+
+      # 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}
+            self_adapter = Lolita::DBI::Base.create(self.class)
+            options[self_adapter.reflect_on_association(:translations).klass.master_id] = self.id unless self.new_record?
+            self.translations.build(options) unless self.translations.map(&:locale).include?(l.to_s)
+          end
+        end
+      end
+
+      def find_translation(locale)
+        locale = locale.to_s
+        translations.detect { |t| t.locale == locale }
+      end
+    end
+  end
+end

data/lib/lolita-translation/rails.rb

@@ -1,5 +1,41 @@
-module LolitaHasTranslation
+module LolitaTranslation
   class Engine < Rails::Engine
 
   end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tab/form").before do
+  tab = self.component_locals[:tab]
+  if Lolita::Translation.translatable?(tab)
+    self.send(:render_component,"lolita/translation",:switch, :tab => tab)
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tab/fields").after do
+  tab = self.component_locals[:tab]
+  if Lolita::Translation.translatable?(tab)
+    self.render_component Lolita::Translation.create_translations_nested_form(self.resource,tab)
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tab/fields").around do
+  tab = self.component_locals[:tab]
+  if Lolita::Translation.translatable?(tab)
+    self.send(:render_component,"lolita/translation",:language_wrap,:tab => tab, :content => let_content)
+  else
+    let_content
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/nested_form/fields").around do
+  tab = self.component_locals[:nested_form].parent
+  if Lolita::Translation.translatable?(tab)
+    self.send(:render_component,"lolita/translation",:language_wrap, :tab => tab, :content => let_content)
+  else
+    let_content
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tabs/display").before do
+  self.render_component "lolita/translation", :assets
 end

data/lolita-translation.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "lolita-translation"
-  s.version = "0.2.9"
+  s.version = "0.2.18"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
-  s.date = "2011-11-03"
+  s.date = "2011-12-13"
   s.description = "Translates models in Lolita"
   s.email = "support@ithouse.lv"
   s.extra_rdoc_files = [
@@ -18,15 +18,13 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    ".rspec",
     "Gemfile",
     "LICENSE.txt",
     "README.md",
     "Rakefile",
     "VERSION",
     "app/assets/.gitkeep",
-    "app/assets/javascripts/.gitkeep",
-    "app/assets/javascripts/lolita/translation/application.js",
-    "app/assets/stylesheets/lolita/translation/application.css",
     "app/views/components/lolita/translation/_assets.html.erb",
     "app/views/components/lolita/translation/_language_wrap.html.erb",
     "app/views/components/lolita/translation/_switch.html.erb",
@@ -35,19 +33,23 @@ Gem::Specification.new do |s|
     "lib/generators/lolita_translation/USAGE",
     "lib/generators/lolita_translation/has_translations_generator.rb",
     "lib/lolita-translation.rb",
-    "lib/lolita-translation/has_translations.rb",
+    "lib/lolita-translation/configuration.rb",
+    "lib/lolita-translation/model.rb",
+    "lib/lolita-translation/modules.rb",
     "lib/lolita-translation/rails.rb",
     "lib/lolita-translation/string.rb",
     "lib/tasks/has_translations_tasks.rake",
     "lolita-translation.gemspec",
+    "public/javascripts/.gitkeep",
+    "public/javascripts/lolita/translation/application.js",
+    "public/stylesheets/lolita/translation/application.css",
     "spec/has_translations_spec.rb",
-    "spec/spec.opts",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/ithouse/lolita-translations"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
+  s.rubygems_version = "1.8.11"
   s.summary = "Lolita models translation plugin"
   s.test_files = [
     "spec/has_translations_spec.rb",
@@ -58,20 +60,20 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<lolita>, [">= 3.2.0.rc.3"])
+      s.add_runtime_dependency(%q<lolita>, ["= 3.1.18"])
       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<lolita>, [">= 3.2.0.rc.3"])
+      s.add_dependency(%q<lolita>, ["= 3.1.18"])
       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<lolita>, [">= 3.2.0.rc.3"])
+    s.add_dependency(%q<lolita>, ["= 3.1.18"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])

data/spec/spec_helper.rb

@@ -1,14 +1,19 @@
 # encoding: utf-8
 require 'rubygems'
-gem 'rails', '~>2.3'
-require 'i18n'
+require 'bundler'
+begin
+  Bundler.setup(:default, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
 require 'active_record'
-require 'spec'
-require 'faker'
-
-require 'ruby-debug'    
+require 'active_support'
+require 'logger'
+require 'ffaker'
+require File.expand_path('lib/lolita-translation')
 
-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 })
 
@@ -49,23 +54,28 @@ ActiveRecord::Schema.define do
 end
 
 class News < ActiveRecord::Base
+  include Lolita::Translation
   belongs_to :category, :dependent => :destroy
   has_one :meta_data, :as => :metaable, :dependent => :destroy
   translations :title, :body
 end
 
 class Category < ActiveRecord::Base
+  include Lolita::Translation
   has_many :news
   has_and_belongs_to_many :groups
   translations :name
 end
 
 class Group < ActiveRecord::Base
+  include Lolita::Translation
   has_and_belongs_to_many :categories
   translations :name
 end
 
 class MetaData < ActiveRecord::Base
+  set_table_name :meta_datas
+  include Lolita::Translation
   belongs_to :metaable, :polymorphic => true
   translations :title, :url, :keywords, :description
 end
@@ -89,7 +99,7 @@ class ::Hash
     self
   end
 end
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.before(:each) do
     News.delete_all
     Category.delete_all

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lolita-translation
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.18
   prerelease: 
 platform: ruby
 authors:
@@ -11,22 +11,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-03 00:00:00.000000000Z
+date: 2011-12-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lolita
-  requirement: &84206130 !ruby/object:Gem::Requirement
+  requirement: &16064780 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - =
       - !ruby/object:Gem::Version
-        version: 3.2.0.rc.3
+        version: 3.1.18
   type: :runtime
   prerelease: false
-  version_requirements: *84206130
+  version_requirements: *16064780
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &84205770 !ruby/object:Gem::Requirement
+  requirement: &16063400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,10 +34,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *84205770
+  version_requirements: *16063400
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &84205350 !ruby/object:Gem::Requirement
+  requirement: &16062360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -45,10 +45,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *84205350
+  version_requirements: *16062360
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &84204930 !ruby/object:Gem::Requirement
+  requirement: &16061500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -56,10 +56,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *84204930
+  version_requirements: *16061500
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &84204370 !ruby/object:Gem::Requirement
+  requirement: &16060600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,7 +67,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *84204370
+  version_requirements: *16060600
 description: Translates models in Lolita
 email: support@ithouse.lv
 executables: []
@@ -77,15 +77,13 @@ extra_rdoc_files:
 - README.md
 files:
 - .document
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - VERSION
 - app/assets/.gitkeep
-- app/assets/javascripts/.gitkeep
-- app/assets/javascripts/lolita/translation/application.js
-- app/assets/stylesheets/lolita/translation/application.css
 - app/views/components/lolita/translation/_assets.html.erb
 - app/views/components/lolita/translation/_language_wrap.html.erb
 - app/views/components/lolita/translation/_switch.html.erb
@@ -94,13 +92,17 @@ files:
 - lib/generators/lolita_translation/USAGE
 - lib/generators/lolita_translation/has_translations_generator.rb
 - lib/lolita-translation.rb
-- lib/lolita-translation/has_translations.rb
+- lib/lolita-translation/configuration.rb
+- lib/lolita-translation/model.rb
+- lib/lolita-translation/modules.rb
 - lib/lolita-translation/rails.rb
 - lib/lolita-translation/string.rb
 - lib/tasks/has_translations_tasks.rake
 - lolita-translation.gemspec
+- public/javascripts/.gitkeep
+- public/javascripts/lolita/translation/application.js
+- public/stylesheets/lolita/translation/application.css
 - spec/has_translations_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 homepage: http://github.com/ithouse/lolita-translations
 licenses:
@@ -115,9 +117,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 941878035
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -126,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Lolita models translation plugin

data/lib/lolita-translation/has_translations.rb

@@ -1,387 +0,0 @@
-require 'stringio'
-
-module Lolita
-  module Translation
-    module SingletonMethods
-      # 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 translations *attrs
-        include Lolita::Translation::InstanceMethods
-        options = {
-          :fallback => true,
-          :reader => true,
-          :writer => false,
-          :nil => ''
-        }.merge(attrs.extract_options!)
-        options.assert_valid_keys([:fallback, :reader, :writer, :nil,:table_name])
-        self.extend(Lolita::Translation::ClassMethods)
-        self.class_eval do
-          translation_class_name = "#{self.name}Translation"
-          translation_class = self.define_translation_class(translation_class_name, attrs,options)
-          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
-          
-          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
-
-          @translation_attrs = attrs
-          def self.translation_attrs
-            @translation_attrs
-          end
-          #adapter = Lolita::DBI::Base.create(self)
-          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 =:scope 
-
-          send scope_method, :translated, lambda { |locale| 
-            where("#{translation_class.table_name}.locale = ?", locale.to_s).joins(:translations)
-          }
-
-          class << self
-
-            def find_with_translations(*args,&block)
-              unless ::I18n.locale == ::I18n.default_locale
-                if args && args[0].kind_of?(Hash)
-                  args[0][:include] ||=[]
-                  args[0][:include] << :translations
-                end
-              end
-              find_without_translations *args, &block
-            end
-            alias_method_chain :find, :translations
-          end
-
-        end
-      end
-    end
-
-    module ClassMethods
-      # 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?
-      # 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=nil, &block)
-        first,*other = class_name.split("::")
-        if other.empty?
-          klass = superclass ? Class.new(superclass, &block) : Class.new(&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, options = {}
-        klass = name.constantize rescue nil
-        adapter = Lolita::DBI::Base.create(self)
-        unless klass
-          klass = create_class(name, Object, get_orm_class(adapter)) do
-            if adapter.dbi.adapter_name == :mongoid
-              include Mongoid::Document
-            end
-            # set's real table name
-            translation_adapter = Lolita::DBI::Base.create(self)
-            translation_adapter.collection_name = options[:table_name] || adapter.collection_name.to_s.singularize + "_translation"
-           
-            cattr_accessor :translate_attrs, :master_id
-
-            # before friendly_id 4.x
-            if adapter.klass.respond_to?(:uses_friendly_id?) && adapter.klass.send(:uses_friendly_id?)
-              parent_config = adapter.klass.friendly_id_config
-          
-              has_friendly_id parent_config.method,
-                :allow_nil => parent_config.allow_nil,
-                :approximate_ascii => parent_config.approximate_ascii,
-                :ascii_approximation_options => [:russian],
-                :max_length => parent_config.max_length,
-                :reserved_words => parent_config.reserved_words,
-                :use_slug => parent_config.use_slug
-            end
-            
-            # 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)})
-              item_adapter = Lolita::DBI::Adapter.add(item.class)
-              self_adapter = Lolita::DBI::Adapter.add(self)
-              was_table_name = item_adapter.collection_name
-              item_adapter.collection_name = self_adapter.collection_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_adapter.collection_name = was_table_name
-            end
-            extend Lolita::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
-
-      def get_orm_class(adapter)
-        adapter.dbi.adapter_name == :active_record ?  ActiveRecord::Base : nil
-      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
-        self_adapter = Lolita::DBI::Base.create(self)
-        translations_class = self.reflect_on_association(:translations).klass
-        translations_adapter = Lolita::DBI::Base.create(translations_class)
-
-        if translations_adapter.dbi.adapter_name == :active_record
-          translations_table = translations_adapter.collection_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
-        elsif translations_adapter.dbi.adapter_name == :mongoid
-          unless translations_class.fields["locale"]
-            translations_class.class_eval do
-              field(self.master_id, :type => Integer)
-              field :locale, :type => String
-              columns_has_translations.each do |col|
-                field col.name, :type => col.type
-              end
-              index(
-                [
-                  [ self.master_id, Mongo::ASCENDING ],
-                  [ :locale, Mongo::ASCENDING ]
-                ],
-                unique: true
-              )
-            end
-          else
-            columns_has_translations.each do |col|
-              unless translations_class.fields[col.name.to_s]
-                translations_class.field(col.name,:type => col.type)
-              end
-            end
-          end
-        end
-        $stdout = STDOUT
-      end
-    end
-
-    module InstanceMethods
-
-      # 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}
-            self_adapter = Lolita::DBI::Base.create(self.class)
-            options[self_adapter.reflect_on_association(:translations).klass.master_id] = self.id unless self.new_record?
-            self.translations.build(options) unless self.translations.map(&:locale).include?(l.to_s)
-          end
-        end
-      end
-
-      
-      #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
-end
-

data/spec/spec.opts

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