lolita-translation 0.1.4 → 0.2.0

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 
-gem "rails", ">=3.0.0"
-gem "lolita", "~> 3.1.15"
+gem "rails", "~> 3.1.0"
+gem "lolita", "~> 3.2.0.rc1"
 group :development do
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.0"

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/lib/lolita-translation.rb

@@ -5,6 +5,11 @@ require 'lolita-translation/rails'
 
 module Lolita
   module Translation
+
+    def self.included(base_class)
+      base_class.extend(Lolita::Translation::SingletonMethods)
+    end
+
     class << self
       def translatable?(tab)
         fields = tab.fields.reject{|field|
@@ -23,7 +28,7 @@ module Lolita
         fields = tab.fields.reject{|field|
           !resource.class.translation_attrs.include?(field.name.to_sym)
         }
-        fields << Lolita::Configuration::Field.add(nested_form.dbi,:locale,:hidden)
+        fields << Lolita::Configuration::Factory::Field.add(nested_form.dbi,:locale,:hidden)
         nested_form.fields=fields
         nested_form
       end

data/lib/lolita-translation/has_translations.rb

@@ -1,111 +1,186 @@
 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
+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])
+        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)
+          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?
-      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
+      # 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)
+      def create_class(class_name, parent, superclass=nil, &block)
         first,*other = class_name.split("::")
         if other.empty?
-          klass = Class.new superclass, &block
+          klass = superclass ? Class.new(superclass, &block) : Class.new(&block)
           parent.const_set(first, klass)
         else
           klass = Class.new
@@ -117,27 +192,39 @@ class ActiveRecord::Base
           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
+        adapter = Lolita::DBI::Base.create(self)
+
         unless klass
-          klass = create_class(name, Object, ActiveRecord::Base) do
+          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
-            set_table_name name.sub('Translation','').constantize.table_name.singularize + "_translations"
+            translation_adapter = Lolita::DBI::Base.create(self)
+            translation_adapter.collection_name = adapter.collection_name.to_s.singularize + "_translation"
+           
             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_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.class.set_table_name was_table_name
+              item_adapter.collection_name = was_table_name
             end
-            extend TranslationClassMethods
+            extend Lolita::TranslationClassMethods
+
           end
           klass.translate_attrs = attrs
         else
@@ -151,6 +238,10 @@ class ActiveRecord::Base
         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"
@@ -159,141 +250,126 @@ class ActiveRecord::Base
       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
+        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|
-              t.send(col.type,col.name)
+              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
-          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
+        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
-          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
+    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)]
+      # 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
-      ActiveSupport::OrderedHash[t]
-    end
 
-    def has_translation?(locale)
-      return true if locale == I18n.default_locale
-      find_translation(locale).present?
-    end
+      def translation(locale)
+        find_translation(locale.to_s)
+      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)
+      def all_translations
+        t = I18n.available_locales.map do |locale|
+          [locale, find_or_build_translation(locale)]
         end
+        ActiveSupport::OrderedHash[t]
       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)
+      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
-    end
-
-    @translation_attrs = attrs
-    def self.translation_attrs
-      @translation_attrs
-    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
 
-    #private is no good
+      def find_translation(locale)
+        locale = locale.to_s
+        translations.detect { |t| t.locale == locale }
+      end
+    end
+  end
 
-    def find_translation(locale)
-      locale = locale.to_s
-      translations.detect { |t| t.locale == locale }
+  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
 
-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/lolita-translation.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{lolita-translation}
-  s.version = "0.1.4"
+  s.name = "lolita-translation"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{ITHouse}, %q{Gatis Tomsons}, %q{Arturs Meisters}]
-  s.date = %q{2011-09-01}
-  s.description = %q{Translates models in Lolita}
-  s.email = %q{support@ithouse.lv}
+  s.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
+  s.date = "2011-09-05"
+  s.description = "Translates models in Lolita"
+  s.email = "support@ithouse.lv"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md"
@@ -23,32 +23,32 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
+    "app/assets/.gitkeep",
+    "app/assets/javascripts/.gitkeep",
+    "app/assets/javascripts/lolita/translation.js",
+    "app/assets/stylesheets/lolita/translation.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",
     "config/locales/en.yml",
     "config/locales/lv.yml",
     "lib/generators/lolita_translation/USAGE",
-    "lib/generators/lolita_translation/assets_generator.rb",
     "lib/generators/lolita_translation/has_translations_generator.rb",
-    "lib/generators/lolita_translation/install_generator.rb",
     "lib/lolita-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",
-    "public/javascripts/lolita/translation.js",
-    "public/stylesheets/lolita/translation.css",
     "spec/has_translations_spec.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb"
   ]
-  s.homepage = %q{http://github.com/ithouse/lolita-translations}
-  s.licenses = [%q{MIT}]
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.8}
-  s.summary = %q{Lolita models translation plugin}
+  s.homepage = "http://github.com/ithouse/lolita-translations"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Lolita models translation plugin"
   s.test_files = [
     "spec/has_translations_spec.rb",
     "spec/spec_helper.rb"
@@ -58,23 +58,23 @@ 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<rails>, [">= 3.0.0"])
-      s.add_runtime_dependency(%q<lolita>, ["~> 3.1.15"])
+      s.add_runtime_dependency(%q<rails>, ["~> 3.1.0"])
+      s.add_runtime_dependency(%q<lolita>, ["~> 3.2.0.rc1"])
       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<lolita>, ["~> 3.1.15"])
+      s.add_dependency(%q<rails>, ["~> 3.1.0"])
+      s.add_dependency(%q<lolita>, ["~> 3.2.0.rc1"])
       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<lolita>, ["~> 3.1.15"])
+    s.add_dependency(%q<rails>, ["~> 3.1.0"])
+    s.add_dependency(%q<lolita>, ["~> 3.2.0.rc1"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lolita-translation
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,33 +11,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-01 00:00:00.000000000Z
+date: 2011-09-05 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &76701810 !ruby/object:Gem::Requirement
+  requirement: &73080930 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *76701810
+  version_requirements: *73080930
 - !ruby/object:Gem::Dependency
   name: lolita
-  requirement: &76701530 !ruby/object:Gem::Requirement
+  requirement: &73080430 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.1.15
+        version: 3.2.0.rc1
   type: :runtime
   prerelease: false
-  version_requirements: *76701530
+  version_requirements: *73080430
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &76701180 !ruby/object:Gem::Requirement
+  requirement: &73079880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *76701180
+  version_requirements: *73079880
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &76700740 !ruby/object:Gem::Requirement
+  requirement: &73079300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -56,10 +56,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *76700740
+  version_requirements: *73079300
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &76700100 !ruby/object:Gem::Requirement
+  requirement: &73078900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -67,10 +67,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *76700100
+  version_requirements: *73078900
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &76699310 !ruby/object:Gem::Requirement
+  requirement: &73078470 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -78,7 +78,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *76699310
+  version_requirements: *73078470
 description: Translates models in Lolita
 email: support@ithouse.lv
 executables: []
@@ -93,23 +93,23 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- app/assets/.gitkeep
+- app/assets/javascripts/.gitkeep
+- app/assets/javascripts/lolita/translation.js
+- app/assets/stylesheets/lolita/translation.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
 - config/locales/en.yml
 - config/locales/lv.yml
 - lib/generators/lolita_translation/USAGE
-- lib/generators/lolita_translation/assets_generator.rb
 - lib/generators/lolita_translation/has_translations_generator.rb
-- lib/generators/lolita_translation/install_generator.rb
 - lib/lolita-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
-- public/javascripts/lolita/translation.js
-- public/stylesheets/lolita/translation.css
 - spec/has_translations_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -128,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1053853743
+      hash: 735045519
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Lolita models translation plugin

data/lib/generators/lolita_translation/assets_generator.rb

@@ -1,13 +0,0 @@
-require 'generators/helpers/file_helper'
-module LolitaTranslation
-  module Generators
-    class AssetsGenerator < Rails::Generators::Base
-      include Lolita::Generators::FileHelper
-      desc "Copy all from public directory to project public directory."
-      def copy_all
-        root=File.expand_path("../../../../",__FILE__)
-        copy_dir("public",:root=>root)
-      end      
-    end
-  end
-end

data/lib/generators/lolita_translation/install_generator.rb

@@ -1,13 +0,0 @@
-require 'rails/generators'   
-module LolitaMenu
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      desc "Copy assets."
-
-      def copy_assets
-        generate("lolita_menu:assets")
-      end
-
-    end
-  end
-end