translatable 0.3.1 → 1.2.2

data/VERSION

@@ -1 +1 @@
-0.3.1
+1.2.2

data/lib/generators/translatable/model_generator.rb

@@ -27,18 +27,22 @@ module Translatable
       def generate_translatable_block
         block = "  translatable do"
         attributes.each do |attr|
-          block << "\n    translatable :#{attr.name}, :presence => true#, :uniqueness => true"
+          block << "\n    field :#{attr.name}, :presence => true#, :uniqueness => true"
         end
         block << (options[:translated_model].nil? ?
-            "\n    #translatable_model 'Translated#{class_name}'" :
-            "\n    translatable_model '#{options[:translated_model]}'")
+            "\n    #class_name 'Translated#{class_name}'" :
+            "\n    class_name '#{options[:translated_model]}'")
         block << (options[:origin].nil? ?
-            "\n    #translatable_origin :#{singular_table_name}" :
-            "\n    translatable_origin :#{options[:origin]}")
+            "\n    #reflection_name :#{singular_table_name}" :
+            "\n    reflection_name :#{options[:origin]}")
+        block << "\n    #foreign_key :origin_id" 
         block << (options[:locale].nil? ?
-            "\n    #translatable_locale :locale" :
-            "\n    translatable_locale :#{options[:locale]}")
+            "\n    #locale_key :locale" :
+            "\n    locale_key :#{options[:locale]}")
         block << "\n  end\n"
+
+        block << "\n  #accepts_nested_attributes_for :translations, :current_translation"
+        block << "\n  #attr_accessible :translations_attributes, :current_translation_attributes\n"
       end
     end
   end

data/lib/generators/translatable/translation_generator.rb

@@ -7,7 +7,7 @@ module Translatable
 
       desc "Creates ActiveRecord for translation"
 
-      class_option :prefix, :type => :string, :default => "translatable", :desc => "Specifies the prefix to used tof translation dealer (Default: translatable)"
+      class_option :prefix, :type => :string, :default => "translated", :desc => "Specifies the prefix to used tof translation dealer (Default: translatable)"
       class_option :origin, :type => :string, :default => "origin",       :desc => "Specifies the association name to be use for origin (Default: origin)"
       class_option :locale, :type => :string, :default => "locale",       :desc => "Specifies the column to be use for locale (Default: locale)"
 

data/lib/translatable.rb

@@ -1,18 +1,20 @@
-require 'translatable/active_record'
-  
-if defined?(Rails)
+module Translatable
+end
+
+require "translatable/base"
+
+unless Gem::Specification.find_all_by_name("rails").empty?
   require 'translatable/engine'
 
   ActiveSupport.on_load(:active_record) do
-    ActiveRecord::Base.extend Translatable::ActiveRecord if defined?(I18n)
+    require 'translatable/orm/active_record'
+    ActiveRecord::Base.extend Translatable::ActiveRecord 
   end
 else
-  begin 
+  if Gem::Specification.find_by_name("active_record")
     require 'active_record'
-    require 'i18n'
-      
+    require 'translatable/orm/active_record'
+    
     ActiveRecord::Base.extend Translatable::ActiveRecord
-  rescue LoadError
-    $stderr.puts "Warning: Translatable is not loaded"
   end
-end
+end

data/lib/translatable/base.rb

@@ -0,0 +1,74 @@
+module Translatable
+  class Base
+    attr_reader :fields, :translation_model, :origin_key, :origin_reflection_name
+
+    def initialize origin_model
+      @origin_model = origin_model
+    end
+
+    # API 
+    def field(*args)
+      (@fields ||= []) << set_mapping(*args)
+    end
+
+    def class_name(model_name)
+      @translation_model = prepare_model model_name
+    end
+
+    def foreign_key(key_name)
+      @origin_key = key_name.to_sym
+    end
+
+    def reflection_name(reflection)
+      @origin_reflection_name = reflection.to_sym
+    end
+
+    def locale_key(key_name, opts = {})
+      set_mapping key_name, opts
+      @locale_column = key_name.to_sym
+    end
+
+    # ACCESS
+    def translation_model
+      @translation_model || (@translation_model = prepare_model)
+    end
+    alias_method :t_model, :translation_model
+
+    def origin_key
+      @origin_key || (@origin_key = :origin_id)
+    end
+
+    def origin_reflection_name
+      @origin_reflection_name || (@origin_reflection_name = :origin)
+    end
+    alias_method :or_name, :origin_reflection_name
+
+    def locale_column
+      @locale_column || (@locale_column = :locale)
+    end
+
+    def mapping
+      unless @mapping_defined
+        (@mapping ||= {})[locale_column] ||= :locale
+        @mapping_defined = true
+      end
+      @mapping || {}
+    end
+
+    protected
+
+    def set_mapping attribute, options = {}
+      (@mapping ||= {})[attribute.to_sym] = options.delete(:as) || attribute rescue attribute
+      return attribute, options
+    end
+
+    def origin_class_name
+      @origin_model.name
+    end
+
+    def prepare_model(model_name = nil)
+      model_constant = model_name ? model_name.to_s.camelize : "Translated#{origin_class_name}"
+      model_constant.constantize
+    end
+  end
+end

data/lib/translatable/orm/active_record.rb

@@ -0,0 +1,156 @@
+module Translatable
+  ###
+  # In order to made the model Translatable, an additional fields should
+  # should be added first to it. Here is an example of it might be implemented:
+  # 
+  # Examples:
+  #
+  #   class Author < ActiveRecord::Base
+  #     validates :name, :presence => true
+  #   end
+  #
+  #   class TranslatedNews < ActiveRecord::Base  #
+  #     attr_accessible :title, :content
+  #   end
+  #
+  #   class News < ActiveRecord::Base
+  #
+  #     belongs_to  :author
+  #
+  #     translatable do
+  #       field  :title, :presence => true, :uniqueness => true
+  #       field  :content, :presence => true
+  #       class_name "TranslatedNews"
+  #       foreign_key :origin_id
+  #     end
+  #
+  #     accepts_nested_attributes_for :translations, :current_translation
+  #     attr_accessible :translations_attributes, :current_translation_attributes
+  #     attr_accessible :author_id, :author
+  #   end
+  #
+  # An example of application:
+  #
+  #   news = News.create :translations_attributes => [{title: "Resent News", content: "That is where the text goes", locale: "en"}]
+  #   news.translations.create title: "Заголовок", content: "Содержание",locale: "ru"
+  #
+  #   news.content
+  #   # => "That is where the text goes"
+  #
+  #   news.set_current_translation :ru
+  #   news.content
+  #   # => "Сюди идет текст"
+  #
+  #   news.set_current_translation :de
+  #   news.content
+  #   # => nil
+  #
+  #   news.set_current_translation
+  #   news.content
+  #   # => "That is where the text goes"
+  #
+  module ActiveRecord
+
+    def translatable(&block)
+      extend Translatable::ActiveRecord::ClassMethods
+      include Translatable::ActiveRecord::InstanceMethods
+
+      @translatable_base = Translatable::Base.new(self)
+
+      @translatable_base.instance_eval(&block)
+      t_register_origin
+      t_register_translations
+      t_register_locale
+    end
+
+    module ClassMethods
+
+      protected
+
+      ###
+      # Handle the routine to define all th required stuff on the original maodel
+      def t_register_origin
+        has_many :translations, 
+          :class_name => @translatable_base.translation_model.to_s, 
+          :foreign_key => @translatable_base.origin_key,
+          :inverse_of =>  @translatable_base.or_name,
+          :dependent => :destroy
+
+        class_eval <<-EOS
+          has_one :current_translation, -> { where("#{reflection_locale}" => ::I18n.locale) }, 
+            :class_name => @translatable_base.translation_model.to_s, 
+            :foreign_key => @translatable_base.origin_key
+        EOS
+      end
+
+      def t_register_translations
+        @translatable_base.tap do |t|
+          t.t_model.validates t.locale_column, :presence => true
+          t.t_model.validates t.locale_column, :uniqueness => { :scope => t.origin_key }
+          t.t_model.validates t.locale_column, :format => {:with => /[a-z]{2}/}, :unless => Proc.new {
+            |record| record.public_send(t.locale_column).blank?
+          }
+
+          t.t_model.belongs_to t.or_name, :class_name => self.name, :inverse_of => :translations
+
+          t.fields.each do |f|
+            t.t_model.validates(f.first, f.last) unless f[1].blank?
+          end
+        end
+      end
+
+      def t_register_locale
+        @translatable_base.mapping.each_pair do |attr, attr_alias| 
+          self.instance_eval do
+            define_method attr_alias do 
+              current_translation.try(attr)
+            end
+          end
+        end
+      end
+
+      def reflection_locale
+        @translatable_base.locale_column
+      end
+    end
+
+    module InstanceMethods
+      def other_translations(reload = false)
+        @other_translations = nil if reload
+        @other_translations ||= begin 
+          unless association(:current_translation).loaded?
+            translations.to_a.reject {|t|t.send(t_locale_column) == ::I18n.locale.to_s}
+          else
+            translations - [current_translation]
+          end
+        end
+      end
+
+      def t(locale)
+        translations.select { |t| t.send(t_locale_column) == locale.to_s }.first
+      end
+
+      def with_locale(locale, &block)
+        begin
+          set_current_translation locale.to_sym
+          result = block.arity > 0 ? block.call(self) : yield
+        ensure
+          set_current_translation
+        end
+        result
+      end
+
+      def t_set_current(locale = ::I18n.locale)
+        translations.load_target unless translations.loaded?
+        association(:current_translation).target = t(locale.to_s)
+      end
+      alias_method :set_current_translation, :t_set_current
+
+      protected
+
+      def t_locale_column
+        self.class.send(:reflection_locale)
+      end
+    end
+  end
+end

data/test/cases/{translatable_test.rb → active_record_test.rb}

@@ -1,70 +1,98 @@
 # encoding: utf-8
+require 'active_record'
 require 'test_helper'
 require 'support/models/news'
 require 'support/models/posts'
 require 'support/models/messages'
 
-class TranslatableTest < Test::Unit::TestCase
-    teardown do
-      ::I18n.locale = ::I18n.default_locale
-    end
+class InstanceActiveRecordTest < Test::Unit::TestCase
+  teardown do
+    ::I18n.locale = ::I18n.default_locale
+  end
 
-  context "Translatable hash" do
-    should "Define default" do
-      th = News.instance_variable_get :@translatable
+  #context "Instance" do
+    test "should Respond to translatable methods" do
+      news = News.new
 
-      assert_kind_of Hash, th
-      assert th.has_key?(:properties)
+      assert news.respond_to?(:title), "title methods is missing for News instance"
+      assert news.respond_to?(:content), "content methods is missing for News instance"
+      assert news.respond_to?(:locale), "locale methods is missing for News instance"
     end
 
-    should "Has dafault model" do
-      assert_equal ::TranslatableNews, News.send(:translatable_model_prepared, 'TranslatableNews')
-    end
-  end
+    test "should Creates without translation" do
+      news = News.create
 
-  context "Translatable model preparation" do
-    should "Accept constant" do
-      assert_equal ::TranslatableNews, News.send(:translatable_model_prepared, ::TranslatableNews)
+      assert news.persisted?
+      assert_nil TranslatedNews.last
     end
 
-    should "Accept string" do
-      assert_equal ::TranslatableNews, News.send(:translatable_model_prepared, "TranslatableNews")
-    end
+    test "should Change current translation" do
+      news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
+        {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
-    should "Accept symbol" do
-      assert_equal ::TranslatableNews, News.send(:translatable_model_prepared, :TranslatableNews)
+      assert news.persisted?
+      assert_equal TranslatedNews.last, news.current_translation
+      assert_equal "en", news.current_translation.locale
+      
+      news.set_current_translation :ru
+      assert_equal TranslatedNews.first, news.current_translation
+      assert_equal "ru", news.current_translation.locale
     end
-  end
 
-  context "Instance" do
-    should "Respond to translatable methods" do
-      news = News.new
+    test "should Evaluate under translation" do
+      test_runner = self
+      news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
+        {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
-      assert news.respond_to?(:title), "title methods is missing for News instance"
-      assert news.respond_to?(:content), "content methods is missing for News instance"
+      assert_equal "en", news.current_translation.locale
+
+      news.with_locale(:ru) do
+        test_runner.assert_equal "ru", news.current_translation.locale
+      end
+      assert_equal "en", news.current_translation.locale
+
+      news.with_locale(:ru) do |n|
+        test_runner.assert_equal "ru", n.current_translation.locale
+      end
+      assert_equal "en", news.current_translation.locale
     end
 
-    should "Creates without translation" do
-      news = News.create
+    test "should Shortcut translation" do
+      news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
+        {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
-      assert news.persisted?
-      assert_nil TranslatableNews.last
+      assert_equal TranslatedNews.last, news.t(:en)
+      assert_equal "en", news.t(:en).locale
+
+      assert_equal TranslatedNews.first, news.t(:ru)
+      assert_equal "ru", news.t(:ru).locale
     end
 
-    should "Have no other translation" do
+    test "should Have no other translation" do
       news = News.create :translations_attributes => [{ :title => "Заголовок", :content => "Содержание", :locale => "ru"}]
 
       assert news.persisted?
 
-      t_news = TranslatableNews.last
+      t_news = TranslatedNews.last
       assert_equal [t_news], news.other_translations
       
       news.set_current_translation :ru
 
-      assert_equal [], news.other_translations
+      assert_equal [], news.other_translations(true)
+    end
+
+    test "should Have other translation" do
+      news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
+        {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
+
+      assert news.persisted?
+      assert_equal [TranslatedNews.first], news.other_translations
+      
+      news.set_current_translation :ru
+      assert_equal [TranslatedNews.last], news.other_translations(true)
     end
 
-    should "Provide errors on creation" do
+    test "should Provide errors on creation" do
       news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
         {:title => "Resent News", :content => "That is where the text goes", :locale => ""}]
 
@@ -76,73 +104,91 @@ class TranslatableTest < Test::Unit::TestCase
         assert t.new_record?
       end
     end
+  #end
+end
+
+class TranslatableInstanceActiveRecordTest < Test::Unit::TestCase
+  teardown do
+    ::I18n.locale = ::I18n.default_locale
   end
 
-  context "Translatable instance" do
-    should "Respond to translatable methods" do
-      news = TranslatableNews.new
+  #context "Translatable instance" do
+    test "should Respond to translatable methods" do
+      news = TranslatedNews.new
 
-      assert news.respond_to?(:title), "Title method is missing for TranslatableNews instance"
-      assert news.respond_to?(:content), "Content method is missing for TranslatableNews instance"
+      assert news.respond_to?(:title), "Title method is missing for TranslatedNews instance"
+      assert news.respond_to?(:content), "Content method is missing for TranslatedNews instance"
     end
 
-    should "Respond to methods related to origin" do
-      news = TranslatableNews.new
+    test "should Respond to methods related to origin" do
+      news = TranslatedNews.new
 
-      assert news.respond_to?(:locale), "Locale method is missing for TranslatableNews instance"
-      assert news.respond_to?(:origin_id), "Origin methods is missing for TranslatableNews instance"
-      assert news.respond_to?(:origin), "Origin methods is missing for TranslatableNews instance"
+      assert news.respond_to?(:locale), "Locale method is missing for TranslatedNews instance"
+      assert news.respond_to?(:origin_id), "Origin methods is missing for TranslatedNews instance"
+      assert news.respond_to?(:origin), "Origin methods is missing for TranslatedNews instance"
     end
-  end
+  #end
+end
 
-  context "Creation with translation" do
-    should "Assign to origin" do
+class CreationActiveRecordTest < Test::Unit::TestCase
+  teardown do
+    ::I18n.locale = ::I18n.default_locale
+  end
+  
+  #context "Creation with translation" do
+    test "should Assign to origin" do
       news = News.create
-      t_news = TranslatableNews.create :title => "Заголовок", :content => "Содержание", :locale => "ru", :origin_id => news.id
+      t_news = TranslatedNews.create :title => "Заголовок", :content => "Содержание", :locale => "ru", :origin_id => news.id
 
       assert t_news.persisted?
 
-      t_news = TranslatableNews.last
+      t_news = TranslatedNews.last
       assert_equal news.id, t_news.origin_id
       assert_equal "Заголовок", t_news.title
       assert_equal "Содержание", t_news.content
       assert_equal "ru", t_news.locale
     end
 
-    should "Create translation on origin creation" do
+    test "should Create translation on origin creation" do
       news = News.create :translations_attributes => [{ :title => "Заголовок", :content => "Содержание", :locale => "ru"}]
 
       assert news.persisted?
 
-      t_news = TranslatableNews.last
+      t_news = TranslatedNews.last
       assert_equal news.id, t_news.origin_id.to_i
       assert_equal "Заголовок", t_news.title
       assert_equal "Содержание", t_news.content
       assert_equal "ru", t_news.locale
     end
 
-    should "Create multiple translations" do
+    test "should Create multiple translations" do
       news = News.create :translations_attributes => [{ :title => "Заголовок", :content => "Содержание", :locale => "ru"},
         {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
       assert news.persisted?
 
-      t_news = TranslatableNews.first
+      t_news = TranslatedNews.first
       assert_equal news.id, t_news.origin_id.to_i
       assert_equal "Заголовок", t_news.title
       assert_equal "Содержание", t_news.content
       assert_equal "ru", t_news.locale
 
-      t_news = TranslatableNews.last
+      t_news = TranslatedNews.last
       assert_equal news.id, t_news.origin_id.to_i
       assert_equal "Resent News", t_news.title
       assert_equal "That is where the text goes", t_news.content
       assert_equal "en", t_news.locale
     end
+  #end
+end
+
+class CurrentTranslationActiveRecordTest < Test::Unit::TestCase
+  teardown do
+    ::I18n.locale = ::I18n.default_locale
   end
 
-  context "Current translation" do
-    should "Set default translation" do
+  #context "Current translation" do
+    test "should Set default translation" do
       news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
         {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
@@ -152,19 +198,19 @@ class TranslatableTest < Test::Unit::TestCase
       assert_equal "That is where the text goes", news.content
     end
     
-    should "Been set equal to current locale" do
+    test "should Been set equal to current locale" do
       news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
         {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
       assert news.persisted?
 
-      ::I18n.locale = :ru
+      news.set_current_translation :ru
 
       assert_equal "Заголовок", news.title
       assert_equal "Содержание", news.content
     end
     
-    should "Not been set if unavailable" do
+    test "should Not been set if unavailable" do
       news = News.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
         {:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
@@ -175,7 +221,7 @@ class TranslatableTest < Test::Unit::TestCase
       assert_nil news.content
     end
 
-    should "Be switched on locale switching" do
+    test "should Be switched on locale switching" do
       news = News.create :translations_attributes => [{:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
       assert news.persisted?
@@ -193,9 +239,9 @@ class TranslatableTest < Test::Unit::TestCase
       assert_equal "Заголовок", news.title
       assert_equal "Содержание", news.content
     end
-  end
+  #end
 
-  should "Add translation to existing record" do
+  test "should Add translation to existing record" do
     news = News.create :translations_attributes => [{:title => "Resent News", :content => "That is where the text goes", :locale => "en"}]
 
     assert news.persisted?
@@ -206,41 +252,41 @@ class TranslatableTest < Test::Unit::TestCase
     assert t_news.persisted?
   end
 
-  should "Define validations" do
-    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :locale => "ru"},
-      {:title => "Resent Post", :content => "That is where the text goes", :locale => "en"}]
+  test "should Define validations" do
+    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :language => "ru"},
+      {:title => "Resent Post", :content => "That is where the text goes", :language => "en"}]
     assert post.persisted?, "Message had errors: #{post.errors.inspect}"
 
-    post = Post.create :translations_attributes => [{:content => "Содержание", :locale => "ru"},
-      {:title => "Resent Post 2", :content => "That is where the text goes", :locale => "en"}]
+    post = Post.create :translations_attributes => [{:content => "Содержание", :language => "ru"},
+      {:title => "Resent Post 2", :content => "That is where the text goes", :language => "en"}]
     
     assert post.new_record?, "Message had errors: #{post.errors.full_messages.inspect}"
     assert_equal ["Translations title can't be blank"], post.errors.full_messages
 
-    post = Post.create :translations_attributes => [{:title => "Заголовок 2", :locale => "ru"},
-      {:title => "Resent Post 3", :content => "That is where the text goes", :locale => "en"}]
+    post = Post.create :translations_attributes => [{:title => "Заголовок 2", :language => "ru"},
+      {:title => "Resent Post 3", :content => "That is where the text goes", :language => "en"}]
 
     assert post.new_record?, "Message had errors: #{post.errors.full_messages.inspect}"
     assert_equal ["Translations content can't be blank"], post.errors.full_messages
 
-    post = Post.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :locale => "ru"},
-      {:title => "Resent Post 3", :content => "That is where the text goes", :locale => "en"}]
+    post = Post.create :translations_attributes => [{:title => "Заголовок", :content => "Содержание", :language => "ru"},
+      {:title => "Resent Post 3", :content => "That is where the text goes", :language => "en"}]
 
     assert post.new_record?, "Message had errors: #{post.errors.full_messages.inspect}"
     assert_equal ["Translations title has already been taken"], post.errors.full_messages
   end
 
   def test_origin_is_owerwrittent
-    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :locale => "ru"},
-      {:title => "Resent Post", :content => "That is where the text goes", :locale => "en"}]
+    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :language => "ru"},
+      {:title => "Resent Post", :content => "That is where the text goes", :language => "en"}]
     assert post.persisted?, "Message had errors: #{post.errors.inspect}"
 
-    assert_not_equal post.object_id, post.translations.first.post.object_id
+    assert_equal post.object_id, post.translations.first.post.object_id
   end
 
-  should "Accept aliases for fileds" do
-    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :locale => "ru"},
-      {:title => "Resent Post", :content => "That is where the text goes", :locale => "en"}]
+  test "should Accept aliases for fileds" do
+    post = Post.create :translations_attributes => [{:title => "Заголовок",:content => "Содержание", :language => "ru"},
+      {:title => "Resent Post", :content => "That is where the text goes", :language => "en"}]
     assert post.persisted?, "Message had errors: #{post.errors.inspect}"
 
     assert_equal "Resent Post", post.translated_title
@@ -249,10 +295,16 @@ class TranslatableTest < Test::Unit::TestCase
 
     assert_equal "Заголовок", post.translated_title
   end
+end
+
+class MassAssigmentActiveRecordTest < Test::Unit::TestCase
+  teardown do
+    ::I18n.locale = ::I18n.default_locale
+  end
 
-  context "Mass assigment" do
-    should "Be available to mass assigment by default" do
-      tp = TranslatableNews.new( :title => "Resent News", :content => "That is where the text goes", :locale => "en", :origin_id => 1)
+  #context "Mass assigment" do
+    test "should Be available to mass assigment by default" do
+      tp = TranslatedNews.new( :title => "Resent News", :content => "That is where the text goes", :locale => "en", :origin_id => 1)
 
       assert_equal "Resent News", tp.title
       assert_equal "That is where the text goes", tp.content
@@ -260,22 +312,22 @@ class TranslatableTest < Test::Unit::TestCase
       assert_equal 1, tp.origin_id
     end
 
-    should "Protect internal fields on desire" do
-      tm = TranslatedMessage.new( :title => "Resent Post", :content => "That is where the text goes", :locale => "en", :message_id => 1)
+    test "should Protect internal fields on desire" do
+      tm = MessageTranslation.new( :title => "Resent Message", :content => "That is where the text goes", :locale => "en", :message_id => 1)
 
-      assert_equal "Resent Post", tm.title
+      assert_equal "Resent Message", tm.title
       assert_equal "That is where the text goes", tm.content
       assert_equal nil, tm.locale
-      assert_equal nil, tm.message_id
+      assert_equal nil, tm.origin_id
     end
 
-    should "Allow multiple assigment rules" do
-      tm = TranslatedMessage.new( {:title => "Resent Post", :content => "That is where the text goes", :locale => "en", :message_id => 1}, :as => :editor)
+    test "should Allow multiple assigment rules" do
+      tm = MessageTranslation.new( {:title => "Resent Message", :content => "That is where the text goes", :locale => "en", :message_id => 1}, :as => :editor)
 
-      assert_equal "Resent Post", tm.title
+      assert_equal "Resent Message", tm.title
       assert_equal "That is where the text goes", tm.content
       assert_equal "en", tm.locale
-      assert_equal nil, tm.message_id
+      assert_equal nil, tm.origin_id
     end
-  end
+  #end
 end