lolita-translation 0.3.3 → 0.5.0

data/spec/lolita-translation/builder/abstract_builder_spec.rb

@@ -0,0 +1,67 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/builder/abstract_builder")
+
+describe Lolita::Translation::Builder::AbstractBuilder do 
+  let(:klass){ Lolita::Translation::Builder::AbstractBuilder }
+  let(:some_class){ Class.new }
+
+  def set_class_name(klass, name = "SomeClass") 
+    klass.singleton_class.instance_eval do 
+      define_method(:to_s) do 
+        name
+      end
+    end
+  end
+
+  it "should have @base_klass attribute" do 
+    set_class_name(some_class)
+    klass.new(some_class).base_klass.should eq(some_class)
+  end
+
+  it "should return new class name like <ClassName>Translation for class named 'ClassName' " do 
+    set_class_name(some_class)
+    klass.new(some_class).class_name.should eq("SomeClassTranslation")
+  end
+
+  it "should return class name like <Scoped::ClassName>Translation for class name 'Scoped::ClassName'" do 
+    begin
+      Object.const_set(:Scoped,Class.new)
+      set_class_name(some_class,"Scoped::ClassName")
+      klass.new(some_class).class_name.should eq("Scoped::ClassNameTranslation")
+    ensure
+      Object.send(:remove_const, :Scoped)
+    end
+  end
+
+  it "should create class with scoped name" do 
+    begin
+      Object.const_set(:Scoped,Class.new)
+      set_class_name(some_class,"Scoped::OtherClassName")
+      klass.new(some_class).klass.name.should eq("Scoped::OtherClassNameTranslation")
+    ensure
+      Object.send(:remove_const, :Scoped)
+    end
+  end
+
+  it "should show warning when method that should be implemented in concrete builder is not implemented yet" do 
+    set_class_name(some_class)
+    ab_builder = klass.new(some_class)
+    expect{
+      ab_builder.build
+    }.not_to raise_error
+    ab_builder.should_receive(:implementation_warn).once
+    ab_builder.build
+  end
+
+  it "should create new class on initialization" do 
+    set_class_name(some_class)
+    klass.new(some_class).klass.to_s.should eq("SomeClassTranslation")
+  end
+
+  it "should accept superclass as third argument for new" do
+    set_class_name(some_class)
+    superclass = Class.new
+    builder = klass.new(some_class,nil,superclass)
+    builder.klass.superclass.should eq(superclass)
+  end
+end

data/spec/lolita-translation/builder/active_record_builder_spec.rb

@@ -0,0 +1,40 @@
+require 'header'
+require 'ar_schema'
+require File.expand_path("lib/lolita-translation/builder/active_record_builder")
+require File.expand_path("lib/lolita-translation/configuration")
+ARSchema.connect!
+
+describe Lolita::Translation::Builder::ActiveRecordBuilder do 
+  let(:klass) { Lolita::Translation::Builder::ActiveRecordBuilder }
+  let(:config){ Lolita::Translation::Configuration.new(Product) }
+  before(:each) do 
+    Object.send(:remove_const, :Product) if Object.const_defined?(:Product)
+    a_klass = Class.new(ActiveRecord::Base)
+    Object.const_set(:Product, a_klass)
+  end
+
+  after(:each) do 
+    Object.send(:remove_const, :Product) rescue nil
+  end
+
+ 
+  it "should build class with ActiveRecord::Base as superclass" do 
+    obj = klass.new(Product)
+    obj.build
+    obj.klass.superclass.should eq(ActiveRecord::Base)
+  end
+
+  it "should call class methods on klass" do 
+    obj = klass.new(Product, config)
+    obj.stub(:association_name).and_return(:product)
+    obj.build
+    obj.klass.reflections.keys.should include(:product)
+  end
+
+  it "should update base class" do
+    obj = klass.new(Product,config)
+    obj.stub(:translations_association_name).and_return(:translations)
+    obj.build
+    Product.reflections.keys.should include(:translations)
+  end 
+end

data/spec/lolita-translation/configuration_spec.rb

@@ -0,0 +1,72 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/configuration")
+require File.expand_path("lib/lolita-translation/translation_class_builder")
+require File.expand_path("lib/lolita-translation/errors")
+
+describe Lolita::Translation::Configuration do 
+  let(:klass){Lolita::Translation::Configuration}
+  let(:some_class) do 
+    Class.new do 
+      class << self
+        def table_exists?
+          true
+        end
+      end
+    end
+  end
+
+  before(:each) do 
+    Lolita::Translation::TranslationClassBuilder.any_instance.stub(:build_class).and_return("builder")
+    Lolita::Translation::TranslationClassBuilder.any_instance.stub(:override_attributes).and_return("attributes")
+  end
+
+  it "should have @klass attribute" do 
+    klass.new(some_class).klass.should eq(some_class)
+  end
+
+  it "should have @attributes attribute" do 
+    klass.new(some_class, :name, :body).attributes.sort.should eq([:name,:body].sort)
+  end
+
+  it "should have @translation_class attribute" do 
+    Object.const_set(:Product,some_class)
+    klass.new(some_class).translation_class.should eq("builder")
+  end
+
+  describe "locales" do 
+    before(:each) do 
+      Object.const_set(:Product,some_class)
+    end
+
+    after(:each) do 
+      Lolita::Translation.send(:remove_const,:Locales) rescue nil
+    end
+    it "can be received as option" do 
+      Lolita::Translation.const_set(:Locales, Class.new)
+      Lolita::Translation::Locales.should_receive(:new).with([:en,:ru]).and_return([:en,:ru])
+      config = klass.new(some_class, :locales => [:en, :ru])
+      config.locales.should == [:en,:ru]
+    end
+
+    it "should fall back to Lolita::Translation.locales when no locales are passed" do 
+      config = klass.new(some_class)
+      Lolita::Translation.stub(:locales).and_return([:lv,:ru])
+      config.locales.should eq(Lolita::Translation.locales)
+    end
+
+    it "can be as anonymous method" do 
+      Lolita::Translation.const_set(:Locales, Class.new)
+      Lolita::Translation::Locales.should_receive(:new).and_return(Proc.new{ [:lv,:ru] })
+      config = klass.new(some_class, :locales => Proc.new{ [:lv,:ru] })
+      config.locales.should eq([:lv,:ru])
+    end
+  end
+
+  it "should yield block with self when called with block" do 
+    block_called = nil
+    translation_conf = klass.new(some_class) do |conf|
+      block_called = conf
+    end
+    block_called.should eq(translation_conf)
+  end
+end

data/spec/lolita-translation/locale_spec.rb

@@ -0,0 +1,25 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/locale")
+
+describe Lolita::Translation::Locale do 
+  let(:klass){ Lolita::Translation::Locale }
+
+  it "should create new with given locale name" do 
+    obj = klass.new(:lv)
+    obj.name.should eq(:lv)
+    obj.short_name.should eq(:lv)
+  end
+
+  it "should have humanized name" do 
+    obj = klass.new(:lv)
+    obj.humanized_short_name.should eq("Lv")
+  end
+
+  it "should detect locale is active" do 
+    obj = klass.new(:lv)
+    I18n.locale = :en 
+    obj.should_not be_active
+    I18n.locale = :lv 
+    obj.should be_active
+  end
+end

data/spec/lolita-translation/locales_spec.rb

@@ -0,0 +1,31 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/locales")
+
+describe Lolita::Translation::Locales do 
+  let(:klass){ Lolita::Translation::Locales }
+
+  it "should create new with given locales names" do 
+    obj = klass.new([:lv,:en,:ru])
+    obj.locale_names.should eq([:en,:lv,:ru])
+  end
+
+  it "should implement Enumerable and each element should be Locale" do 
+    obj = klass.new([:lv,:en,:ru])
+    obj.first.should be_kind_of(Lolita::Translation::Locale)
+  end
+
+  it "should return locales in order where first is locale that belongs to record" do 
+    obj = klass.new([:lv,:en,:ru])
+    resource = double("resource")
+    transl_rec = double("transl-rec")
+    resource.stub(:translation_record).and_return(transl_rec)
+    transl_rec.stub(:default_locale).and_return(:ru)
+    obj.by_resource_locale(resource).map{|r| r.name}.should eq([:ru,:en,:lv])
+  end
+
+  it "should return active locale" do 
+    obj = klass.new([:lv,:en,:ru])
+    I18n.locale = :ru
+    obj.active.name.should eq(:ru)
+  end
+end

data/spec/lolita-translation/lolita/tab_extension_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+ARSchema.connect!
+
+describe "Lolita tab extension" do 
+  let(:some_class) do 
+    Class.new do 
+      class << self
+        def table_exists?
+          true
+        end 
+      end
+    end
+  end
+
+  let(:dbi) do 
+    tdbi = double("dbi") 
+    tdbi.stub(:klass).and_return(some_class)
+    tdbi
+  end
+
+  it "should provide tab with #translatable? method" do 
+    Lolita::Translation::Configuration.any_instance.stub(:build_translation_class).and_return(true)
+    tab = Lolita::Configuration::Tab::Base.new(dbi, :default)
+    tab.send(:translation_tab_extension).stub(:collect_possibly_translateble_fields).and_return([:name, :body])
+    tab.should_not be_translatable
+    some_class.class_eval do 
+      include Lolita::Translation
+      translate :name, :body
+    end
+    tab.should be_translatable
+  end
+
+  it "should provide tab with #build_translations_nested_form with resource" do 
+    c_class = Class.new(ActiveRecord::Base)
+    Object.const_set(:Product,c_class)
+    c_class.class_eval do 
+      include Lolita::Configuration
+      include Lolita::Translation
+      translate :name
+      lolita
+    end
+    tab = Lolita::Configuration::Tab::Base.new(Lolita::DBI::Base.create(Product), :default)
+    category = Product.new
+    form = tab.build_translations_nested_form(category)
+    category.translations.should have(I18n.available_locales.size - 1).items
+    form.fields.should have(1).item
+  end
+
+  it "should add #original_locale field to original tab" do 
+    c_class = Class.new(ActiveRecord::Base)
+    Object.const_set(:Product,c_class)
+    c_class.class_eval do 
+      include Lolita::Configuration
+      include Lolita::Translation
+      translate :name
+      lolita
+    end
+    tab = c_class.lolita.tabs.first
+    tab.fields.detect{|f| f.name == :original_locale}.should_not be_nil
+  end
+end 

data/spec/lolita-translation/migrator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Lolita::Translation::Migrator do 
+  let(:klass) { Lolita::Translation::Migrator }
+  
+  before(:each) do 
+    Object.send(:remove_const,:Comment) rescue nil
+    c_class = Class.new(ActiveRecord::Base)
+    Object.const_set(:Comment,c_class)
+    c_class.class_eval do 
+      include Lolita::Translation
+      translate :body
+    end
+  end
+
+  after(:each) do 
+    Object.send(:remove_const,:Comment) rescue nil
+  end
+
+  describe "Instance methods" do 
+
+    it "should have klass and config attributes" do 
+      migrator = klass.new(Comment)
+      migrator.klass.should eq(Comment)
+      migrator.config.should eq(Comment.translations_configuration)
+    end
+
+    it "should raise error when #migrate called" do 
+      migrator = klass.new(Comment)
+      expect{
+        migrator.migrate
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "Class methods" do 
+    it "should create concrete migrator for AR" do 
+      klass.create(Comment).should be_kind_of(Lolita::Translation::Migrators::ActiveRecordMigrator)
+    end
+  end
+
+end 

data/spec/lolita-translation/migrators/active_record_migrator_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'ar_schema'
+ARSchema.connect!
+
+describe Lolita::Translation::Migrators::ActiveRecordMigrator do 
+  let(:klass){ Lolita::Translation::Migrators::ActiveRecordMigrator }
+
+  before(:each) do 
+    Object.send(:remove_const,:Comment) rescue nil
+    c_class = Class.new(ActiveRecord::Base)
+    Object.const_set(:Comment,c_class)
+    c_class.class_eval do 
+      include Lolita::Translation
+      translate :body
+    end
+    ActiveRecord::Base.connection.execute("DROP TABLE comments_translations") rescue nil
+  end
+
+  after(:each) do 
+    Object.send(:remove_const,:Comment) rescue nil
+  end
+
+  it "should create new table for class" do 
+    migrator = klass.new(Comment)
+    ActiveRecord::Base.connection.tables.should_not include("comments_translations")
+    migrator.migrate
+    ActiveRecord::Base.connection.tables.should include("comments_translations")
+    CommentTranslation.column_names.sort.should eq(%w(body locale comment_id id).sort)
+  end
+
+  it "should add new column to table when one is added to configuration" do 
+    migrator = klass.new(Comment)
+    ActiveRecord::Base.connection.tables.should_not include("comments_translations")
+    migrator.migrate
+    CommentTranslation.column_names.sort.should eq(%w(body locale comment_id id).sort)
+    Comment.translations_configuration.attributes << :commenter
+    migrator.migrate
+    CommentTranslation.column_names.sort.should eq(%w(body locale comment_id id commenter).sort)
+  end
+
+  it "should remove column from table if it is removed from configuration" do 
+     migrator = klass.new(Comment)
+    Comment.translations_configuration.attributes << :commenter
+    migrator.migrate
+    CommentTranslation.column_names.sort.should eq(%w(body locale comment_id id commenter).sort)
+    Comment.translations_configuration.attributes.pop
+    migrator.migrate
+    CommentTranslation.column_names.sort.should eq(%w(body locale comment_id id).sort)
+  end
+end

data/spec/lolita-translation/orm/mixin_spec.rb

@@ -0,0 +1,52 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/orm/mixin")
+require File.expand_path("lib/lolita-translation/errors")
+
+describe Lolita::Translation::ORM do  
+  let(:klass){ Class.new }
+
+  before(:each) do 
+    klass.extend(Lolita::Translation::ORM::ClassMethods)
+    klass.class_eval do 
+      include Lolita::Translation::ORM::InstanceMethods
+    end
+  end
+
+  context "ClassMethods" do 
+
+    it "should provide #translate method to class" do 
+      klass.should respond_to(:translate)
+    end
+
+    it "should provide #translations_configuration for class" do 
+      klass.should respond_to(:translations_configuration)
+    end 
+
+    it "should raise error when configuration is requested before its initialization" do 
+      expect{
+        klass.translations_configuration
+      }.to raise_error(Lolita::Translation::ConfigurationNotInitializedError)
+    end 
+
+    it "should provide #sync_translation_table!" do 
+      klass.should respond_to(:sync_translation_table!)
+    end  
+  end
+
+  context "InstanceMethods" do 
+    it "should provide #translation_record to all instances of class" do 
+      obj = klass.new
+      obj.should respond_to(:translation_record)
+    end 
+
+    it "should provide #original_locale" do 
+      obj = klass.new
+      obj.should respond_to(:original_locale)
+    end
+
+    it "should provide #original_locale=" do 
+      obj = klass.new
+      obj.should respond_to(:original_locale=)
+    end
+  end
+end