lolita-translation 0.3.3 → 0.5.0

data/spec/lolita-translation/record_spec.rb

@@ -0,0 +1,112 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/record")
+
+describe Lolita::Translation::Record do 
+  let(:klass) { Lolita::Translation::Record }
+
+  describe Lolita::Translation::Record::AbstractRecord do 
+    let(:abr_klass){ Lolita::Translation::Record::AbstractRecord }
+    
+    it "should have orm_record attributes" do 
+      some_obj = double("some_obj")
+      rec = abr_klass.new(some_obj)
+      rec.orm_record.should eq(some_obj)
+    end
+
+    it "should have #locale" do 
+      rec = abr_klass.new(double)
+      rec.locale.should eq(::I18n.locale)
+    end
+  end
+
+  describe Lolita::Translation::Record::ARRecord do 
+    let(:ar_klass){ Lolita::Translation::Record::ARRecord }
+    before(:each) do 
+      ar_klass.any_instance.stub(:locale_field).and_return("default_locale")
+    end
+
+    it "should return default locale from db if there is field defined or system default locale" do 
+      ar_record = double("ar")
+      ar_class = double("AR")
+      ar_record.stub(:class).and_return(ar_class)
+      ar_class.stub(:column_names).and_return(["name","default_locale"])
+      ar_record.stub(:attributes).and_return({"default_locale" => :en})
+      rec = ar_klass.new(ar_record)
+      rec.locale.should eq(:en)
+    end
+
+    it "should use default locale when there isn't field for that" do 
+      I18n.default_locale = :lv
+      ar_record = double("ar")
+      ar_class = double("AR")
+      ar_record.stub(:class).and_return(ar_class)
+      ar_class.stub(:column_names).and_return(["name"])
+      ar_record.stub(:attributes).and_return({"name" => "Name"})
+      rec = ar_klass.new(ar_record)
+      rec.locale.should eq(:lv)
+    end
+
+    it "should retrun default locale when locale column is blank" do 
+      I18n.default_locale = :ru
+      ar_record = double("ar")
+      ar_class = double("AR")
+      ar_record.stub(:class).and_return(ar_class)
+      ar_class.stub(:column_names).and_return(["name"])
+      ar_record.stub(:attributes).and_return({"name" => "Name", "default_locale" => ""})
+      rec = ar_klass.new(ar_record)
+      rec.locale.should eq(:ru)
+    end
+  end
+
+  it "should have original record" do 
+    some_obj = double
+    klass.new(some_obj).original_record.should eq(some_obj)
+  end
+
+  it "should have default locale" do 
+    some_obj = double
+    klass.new(some_obj).default_locale.should eq(::I18n.locale)
+  end
+
+  it "should build nested translations" do 
+    ::I18n.available_locales = [:lv,:ru]
+    I18n.locale = :lv
+    rec = double("record")
+    rec.stub(:id).and_return(1)
+
+    translations = double("translations")
+    translations.should_receive(:build).with({:locale => "ru"})
+    rec.stub(:translations).and_return(translations)
+
+    obj = klass.new(rec)
+    obj.build_nested_translations
+  end
+
+  describe "#in" do 
+    let(:rec){double("record")}
+
+    before(:each) do 
+      ::I18n.available_locales = [:lv,:ru,:en]
+      I18n.locale = :lv
+    end
+
+    it "should switch record #defaut_locale to given value" do 
+      obj = klass.new(rec)
+      obj.orm_wrapper.should_receive(:attribute).with(:name)
+      obj.attribute(:name)
+      obj.in(:ru)
+      obj.orm_wrapper.should_receive(:translated_attribute).with(:name, :locale => :ru)
+      obj.attribute(:name)
+    end
+
+    it "should switch record locale within block and back after block" do 
+      obj = klass.new(rec)
+      obj.in(:ru) do 
+        obj.orm_wrapper.should_receive(:translated_attribute).with(:name, :locale => :ru)
+        obj.attribute(:name)
+      end
+      obj.orm_wrapper.should_receive(:attribute).with(:name)
+      obj.attribute(:name)
+    end
+  end
+end

data/spec/lolita-translation/translation_class_builder_spec.rb

@@ -0,0 +1,62 @@
+require 'header'
+require File.expand_path("lib/lolita-translation/translation_class_builder")
+require File.expand_path("lib/lolita-translation/errors")
+require 'ar_schema'
+
+describe Lolita::Translation::TranslationClassBuilder do 
+  let(:klass){ Lolita::Translation::TranslationClassBuilder }
+  let(:some_class){ Class.new }
+
+  it "should have @klass attribute" do 
+    klass.new(some_class).klass.should eq(some_class)
+  end
+
+  context "ActiveRecord" do 
+    let(:ar_klass){ Lolita::Translation::Builder::ActiveRecordBuilder }
+
+    def stub_create_klass
+      ar_klass.any_instance.stub(:create_klass).and_return(true)
+    end
+
+    it "should validate if there are concrete builder availabe" do 
+      klass.new(some_class).builder_available?.should be_false
+      klass.new(Class.new(ActiveRecord::Base)).builder_available?.should be_true
+    end
+
+    it "should have builder when there is builder class available" do 
+      stub_create_klass
+      klass.new(some_class).builder.should be_nil
+      klass.new(Class.new(ActiveRecord::Base)).builder.should be_kind_of(Lolita::Translation::Builder::ActiveRecordBuilder)
+    end
+
+    it "should raise error when #build_class is called for unsupported builder" do 
+      expect{
+        obj = klass.new(some_class)
+        obj.build_class
+      }.to raise_error(Lolita::Translation::NoBuilderForClassError)
+    end
+
+    it "should override attributes to base class" do 
+      stub_create_klass
+      obj = klass.new(Class.new(ActiveRecord::Base))
+      obj.builder.should_receive(:override_klass_attributes)
+      obj.override_attributes :name
+    end
+
+    it "should raise error when no builder to use for #override_attributes" do 
+      stub_create_klass
+      obj = klass.new(some_class)
+      expect{
+        obj.override_attributes :name
+      }.to raise_error(Lolita::Translation::NoBuilderForClassError)
+    end
+
+    it "should build concrete class when #build is called" do 
+      stub_create_klass
+      obj = klass.new(Class.new(ActiveRecord::Base))
+      obj.builder.should_receive(:build).and_return(true)
+      obj.build_class
+    end
+  end
+
+end

data/spec/lolita_translation_spec.rb

@@ -0,0 +1,16 @@
+require 'header'
+require File.expand_path("lib/lolita-translation")
+
+describe Lolita::Translation do 
+  it "configuration is loded" do 
+    defined?(Lolita::Translation::Configuration).should_not be_nil
+  end
+
+  it "translation class builder is loaded" do 
+    defined?(Lolita::Translation::TranslationClassBuilder).should_not be_nil
+  end
+
+  it "orm mixin is loaded" do 
+    defined?(Lolita::Translation::ORM).should_not be_nil
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,6 @@
+require 'rails'
+require File.expand_path("spec/test_app/config/enviroment")
+require "rspec/rails"
+require 'capybara/rails'
+require 'capybara/rspec'
+Capybara.default_driver = :webkit

data/spec/requests/record_language_switch_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+if USE_RAILS
+  describe "In order to translate resource As system user I want to switch from original resource to translations" do 
+
+    it "As user in resource create form I see language switch and current language is active and I can switch to other languages" do 
+      visit "/lolita/posts/new"
+      language_selector_text = page.find(".tab-language-switch").text
+      ::I18n.available_locales.each do |locale|
+        language_selector_text.should match(/#{locale.to_s.capitalize}/)
+      end
+     
+    end
+
+  end
+end

data/spec/requests/record_saving_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe "In order to internationalize all content I can enter information in any language and translate to any other language" do 
+  
+  def click_save_btn
+    save_btn = page.find("button[data-type='save&close']")
+    save_btn.click
+  end
+
+  def create_category options = {}
+    default_options = {:name => "name", :default_locale => ::I18n.locale}
+    Category.create!(default_options.merge(options))
+  end
+
+  it "As user I can enter information in same language as system uses and resource will be stored in that language" do 
+    visit "/lolita/posts/new"
+    fill_in "post_title", :with => "lv-title"
+    fill_in "post_body", :with => "lv-body"
+    click_save_btn
+    page.should have_content("lv-title")
+    page.should have_content("lv-body")
+  end
+
+  it "As user I can enter information in language that I am using currently and original resource will be save in that language" do 
+    visit "/lolita/posts/new?locale=ru"
+    fill_in "post_title", :with => "ru-title"
+    fill_in "post_body", :with => "ru-body"
+    click_save_btn
+    visit "/lolita/posts?locale=lv"
+    page.should have_content("ru-title")
+    page.should have_content("ru-body")
+  end
+
+  it "As user I can open previously saved resource, in different language than mine, and resource will be shown in resource original language and I will see that" do 
+    I18n.locale = :ru 
+    category = create_category(:name => "ru-name")
+    visit("/lolita/categories/#{category.id}/edit?locale=lv")
+    page.should have_selector(".tab-language-switch li.active", :text => "Ru")
+    ru_content = page.find(".language-wrap.active")
+    ru_content.should be_visible
+  end
+
+  it "As user I can open previously saved resource, in different language than mine, and change original information and that information will be save in original resource" do 
+    I18n.locale = :ru 
+    category = create_category(:name => "ru-name")
+    visit("/lolita/categories/#{category.id}/edit?locale=lv")
+    page.fill_in "category_name", :with => "changed-ru-name"
+    click_save_btn
+    visit("/lolita/categories/#{category.id}/edit?locale=en")
+    name_inp = page.find("#category_name")
+    name_inp.value.should eq("changed-ru-name")
+  end
+
+  it "As user I can open previously saved resource, in different language than mine, and change information for my language, and it will be saved as translation", :js => true do 
+    I18n.locale = :ru 
+    category = create_category(:name => "ru-name")
+    visit("/lolita/categories/#{category.id}/edit?locale=lv")
+    page.execute_script(%Q{$(".tab-language-switch li[data-locale='lv']").click()})
+    page.fill_in("Name",:with => "lv-name")
+    click_save_btn
+    page.should have_content("lv-name")
+  end
+end

data/spec/spec_helper.rb

@@ -1,108 +1,56 @@
 # encoding: utf-8
-require 'rubygems'
-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 'active_support'
-require 'logger'
-require 'ffaker'
-require File.expand_path('lib/lolita-translation')
+# Now there are support only for "active_record"
+ENV["ORM"] = "active_record"
+# Set this to true if you want to launch rails application
+USE_RAILS = true
+# Set this true to use debugger, if your  ruby version supports debugger.
+USE_DEBUGGER = true
+# Set this to true to see HTML code coverage report
+SHOW_REPORT = false
 
-ActiveRecord::Base.logger = Logger.new(File.open("#{File.dirname(__FILE__)}/database.log", 'w+'))
-ActiveRecord::Base.establish_connection({ :database => ":memory:", :adapter => 'sqlite3', :timeout => 500 })
-
-# setup I18n
-I18n.available_locales = [:en,:lv,:ru,:fr]
-I18n.default_locale = :en
-I18n.locale = :en
 
-# Add models
-ActiveRecord::Schema.define do
-  create_table :news, :force => true do |t|
-    t.string :title
-    t.string :slug
-    t.text :body
-    t.integer :category_id
-    t.integer :trx_id
-  end
-  create_table :categories, :force => true do |t|
-    t.string :name
-    t.string :desc
-    t.integer :trx_id
-  end
-  create_table :groups, :force => true do |t|
-    t.string :name
-  end
-  create_table :categories_groups, :force => true, :id => false do |t|
-    t.integer :category_id
-    t.integer :group_id
-  end
-  create_table :meta_datas, :force => true do |t|
-    t.string :title
-    t.string :url
-    t.string :keywords
-    t.text :description
-    t.string :metaable_type
-    t.integer :metaable_id
-  end
+require 'header'
+if USE_RAILS
+  require 'rails_helper'
 end
 
-class News < ActiveRecord::Base
-  include Lolita::Translation
-  belongs_to :category, :dependent => :destroy
-  has_one :meta_data, :as => :metaable, :dependent => :destroy
-  translations :title, :body
+if ENV["ORM"] == "active_record"
+  require 'ar_schema'
 end
 
-class Category < ActiveRecord::Base
-  include Lolita::Translation
-  has_many :news
-  has_and_belongs_to_many :groups
-  translations :name
+if USE_DEBUGGER
+  require 'debugger'
 end
 
-class Group < ActiveRecord::Base
-  include Lolita::Translation
-  has_and_belongs_to_many :categories
-  translations :name
-end
+require 'logger'
+require 'ffaker'
+require File.expand_path('lib/lolita-translation')
 
-class MetaData < ActiveRecord::Base
-  set_table_name :meta_datas
-  include Lolita::Translation
-  belongs_to :metaable, :polymorphic => true
-  translations :title, :url, :keywords, :description
-end
 
-# build translation tables
+# setup I18n
+I18n.available_locales = [:en,:lv,:ru,:fr]
+I18n.default_locale = :lv
+I18n.locale = :en
+Lolita.locales = I18n.available_locales
 
-News.sync_translation_table!
-Category.sync_translation_table!
-Group.sync_translation_table!
-MetaData.sync_translation_table!
 
-# this is included in Lolita by default
-class ::Hash
-  # converts all keys to symbols, but RECURSIVE
-  def symbolize_keys!
-    each do |k,v|
-      sym = k.respond_to?(:to_sym) ? k.to_sym : k
-      self[sym] = Hash === v ? v.symbolize_keys! : v
-      delete(k) unless k == sym
+RSpec.configure do |config|
+  config.before(:each) do
+    if ENV["ORM"] == "active_record"
+      ::ARSchema.clean!
     end
-    self
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.mock_with :rspec
   end
 end
-RSpec.configure do |config|
-  config.before(:each) do
-    News.delete_all
-    Category.delete_all
-    MetaData.delete_all
+
+at_exit do 
+  if ::USE_RAILS
+    if File.exist?(File.expand_path("spec/test_app/db/lolita-translation.db"))
+      File.delete(File.expand_path("spec/test_app/db/lolita-translation.db"))
+    end
+  end
+  if ::SHOW_REPORT
+    CoverMe.complete!
   end
 end

data/spec/tasks/lolita_translation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'ar_schema'
+ARSchema.connect!
+
+describe "lolita_translation:sync_tables" do 
+  def translations
+    ActiveRecord::Base.connection.tables.reject{|tn| !tn.match(/translations/)}.sort
+  end
+
+  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 translation tables for all lolita mappings" do 
+    translations.should eq(%w(categories_translations posts_translations products_translations).sort)
+    Lolita.mappings[:comment] = Lolita::Mapping.new(:comments)
+    load(File.expand_path("lib/tasks/lolita_translation.rake"))
+    Rake.application["lolita_translation:sync_tables"].invoke()
+    translations.should eq(%w(categories_translations posts_translations comments_translations products_translations).sort)
+  end
+end