releaf-i18n_database 0.2.1 → 1.0.3

data/spec/features/translations_spec.rb

@@ -1,19 +1,19 @@
 require 'rails_helper'
 feature "Translations" do
-  background do
+  background(create_translations: true) do
     auth_as_user
 
-    t1 = create(:translation, key: 'test.key1')
-    t2 = create(:translation, key: 'great.stuff')
-    t3 = create(:translation, key: 'geek.stuff')
-    create(:translation_data, lang: 'en', localization: 'testa atslēga', translation_id: t1.id)
-    create(:translation_data, lang: 'en', localization: 'awesome stuff', translation_id: t2.id)
-    create(:translation_data, lang: 'lv', localization: 'lieliska manta', translation_id: t2.id)
-    create(:translation_data, lang: 'en', localization: 'geek stuff', translation_id: t3.id)
-    create(:translation_data, lang: 'lv', localization: 'nūģu lieta', translation_id: t3.id)
+    translation_1 = Releaf::I18nDatabase::I18nEntry.create(key: 'test.key1')
+    translation_2 = Releaf::I18nDatabase::I18nEntry.create(key: 'great.stuff')
+    translation_3 = Releaf::I18nDatabase::I18nEntry.create(key: 'geek.stuff')
+    translation_1.i18n_entry_translation.create(locale: 'en', text: 'testa atslēga')
+    translation_2.i18n_entry_translation.create(locale: 'en', text: 'awesome stuff')
+    translation_2.i18n_entry_translation.create(locale: 'lv', text: 'lieliska manta')
+    translation_3.i18n_entry_translation.create(locale: 'en', text: 'geek stuff')
+    translation_3.i18n_entry_translation.create(locale: 'lv', text: 'nūģu lieta')
   end
 
-  scenario "blank only filtering", js: true  do
+  scenario "blank only filtering", js: true, create_translations: true  do
     visit releaf_i18n_database_translations_path
     expect(page).to have_number_of_resources(3)
 
@@ -46,7 +46,7 @@ feature "Translations" do
     expect(page).to have_number_of_resources(3)
   end
 
-  scenario "index" do
+  scenario "index", create_translations: true do
     visit releaf_i18n_database_translations_path
     expect( page ).to have_content 'test.key1'
     expect( page ).to have_content 'great.stuff'
@@ -59,7 +59,7 @@ feature "Translations" do
     expect( page ).to have_content 'nūģu lieta'
   end
 
-  scenario "Editing", js: true do
+  scenario "Editing", js: true, create_translations: true do
     visit releaf_i18n_database_translations_path
 
     fill_in 'search', with: "stuff"
@@ -77,7 +77,7 @@ feature "Translations" do
     expect(page).to have_notification("Update failed", :error)
 
     within ".table tr.item:last-child" do
-      click_button "Remove item"
+      click_button "Remove"
     end
     expect(page).to have_css(".table tr.item", count: 1) # wait for fade out to complete
 
@@ -101,7 +101,15 @@ feature "Translations" do
     expect(page).to have_content 'en translation'
   end
 
-  scenario "Import excel file with translations", js: true do
+  scenario "Do not save empty translations", create_translations: true do
+    visit releaf_i18n_database_translations_path
+    click_link "Edit"
+    click_button "Save"
+
+    expect(Releaf::I18nDatabase::I18nEntryTranslation.where(text: "").count).to eq(0)
+  end
+
+  scenario "Import excel file with translations", js: true, create_translations: true do
     visit releaf_i18n_database_translations_path
     expect(page).to have_no_css(".table td span", text: "Eksports")
     expect(page).to have_no_css(".table td span", text: "Export")
@@ -129,7 +137,7 @@ feature "Translations" do
     expect(page).to have_css(".table td span", text: "jauns")
   end
 
-  scenario "Import unsupported file", js: true do
+  scenario "Import unsupported file", js: true, create_translations: true do
     visit releaf_i18n_database_translations_path
 
     script = "$('form.import').css({display: 'block'});"
@@ -144,7 +152,39 @@ feature "Translations" do
     expect(page).to have_notification("Unsupported file format", "error")
   end
 
-  scenario "Export translations" do
+  scenario "Import corrupt xls file", js: true, create_translations: true do
+    visit releaf_i18n_database_translations_path
+
+    script = "$('form.import').css({display: 'block'});"
+    page.execute_script(script)
+
+    fixture_path = File.expand_path('../fixtures/invalid.xls', __dir__)
+
+    within('form.import') do
+      attach_file(:import_file, fixture_path)
+    end
+
+    expect(page).to have_notification("Unsupported file format", "error")
+  end
+
+
+  scenario "Import corrupt xlsx file", js: true, create_translations: true do
+    visit releaf_i18n_database_translations_path
+
+    script = "$('form.import').css({display: 'block'});"
+    page.execute_script(script)
+
+    fixture_path = File.expand_path('../fixtures/invalid.xlsx', __dir__)
+
+    within('form.import') do
+      attach_file(:import_file, fixture_path)
+    end
+
+    expect(page).to have_notification("Unsupported file format", "error")
+  end
+
+
+  scenario "Export translations", create_translations: true do
     visit releaf_i18n_database_translations_path
     click_link "Export"
 
@@ -159,4 +199,183 @@ feature "Translations" do
 
     File.delete(tmp_file)
   end
+
+  describe "Lookup" do
+    background do
+      Releaf::I18nDatabase::Backend.reset_cache
+      allow( Releaf.application.config.i18n_database ).to receive(:translation_auto_creation).and_return(true)
+    end
+
+    context "when translation exists within higher level key (instead of being scope)" do
+      it "returns nil (Humanize key)" do
+        translation = Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
+        translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
+
+        expect(I18n.t("some.food", locale: "lv")).to eq("suņi")
+        expect(I18n.t("some.food.asd", locale: "lv")).to eq("Asd")
+      end
+    end
+
+    context "when pluralized translation requested" do
+      context "when valid pluralized data matched" do
+        it "returns pluralized translation" do
+          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.other")
+          translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
+
+          expect(I18n.t("dog", locale: "lv", count: 2)).to eq("suņi")
+        end
+      end
+
+      context "when invalid pluralized data matched" do
+        it "returns nil (Humanize key)" do
+          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.food")
+          translation.i18n_entry_translation.create(locale: "lv", text: "suņi")
+
+          expect(I18n.t("dog", locale: "lv", count: 2)).to eq("Dog")
+        end
+      end
+    end
+
+    context "when same translations with different cases exists" do
+      it "returns case sensitive translation" do
+        translation = Releaf::I18nDatabase::I18nEntry.create(key: "Save")
+        translation.i18n_entry_translation.create(locale: "lv", text: "Saglabāt")
+
+        expect(I18n.t("save", locale: "lv")).to eq("Save")
+        expect(I18n.t("Save", locale: "lv")).to eq("Saglabāt")
+      end
+    end
+
+    context "existing translation" do
+      context "when translations hash exists in parent scope" do
+        before do
+          translation = Releaf::I18nDatabase::I18nEntry.create(key: "dog.other")
+          translation.i18n_entry_translation.create(locale: "en", text: "dogs")
+        end
+
+        context "when pluralized translation requested" do
+          it "returns pluralized translation" do
+            expect(I18n.t("admin.controller.dog", count: 2)).to eq("dogs")
+          end
+        end
+
+        context "when non pluralized translation requested" do
+          it "returns nil" do
+            expect(I18n.t("admin.controller.dog")).to eq("Dog")
+          end
+        end
+      end
+
+      context "when ignorable pattern" do
+        it "does not auto create missing translation" do
+          expect{ I18n.t("attributes.title") }.to_not change{ Releaf::I18nDatabase::I18nEntry.count }
+        end
+      end
+
+      context "in parent scope" do
+        context "nonexistent translation in given scope" do
+          it "uses parent scope" do
+            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
+            translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
+            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukšs")
+          end
+
+          context "when `inherit_scopes` option is `false`" do
+            it "does not lookup upon higher level scopes" do
+              translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
+              translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
+              expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv", inherit_scopes: false)).to eq("Blank")
+            end
+          end
+        end
+
+        context "and empty translation value in given scope" do
+          it "uses parent scope" do
+            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.roles.blank")
+            translation.i18n_entry_translation.create(locale: "lv", text: "")
+
+            parent_translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
+            parent_translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
+
+            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukšs")
+          end
+        end
+
+        context "and existing translation value in given scope" do
+          it "uses given scope" do
+            translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.roles.blank")
+            translation.i18n_entry_translation.create(locale: "lv", text: "Tukša vērtība")
+
+            parent_translation = Releaf::I18nDatabase::I18nEntry.create(key: "validation.admin.blank")
+            parent_translation.i18n_entry_translation.create(locale: "lv", text: "Tukšs")
+
+            expect(I18n.t("blank", scope: "validation.admin.roles", locale: "lv")).to eq("Tukša vērtība")
+          end
+        end
+      end
+
+      context "when scope defined" do
+        it "uses given scope" do
+          translation = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.cancel")
+          translation.i18n_entry_translation.create(locale: "lv", text: "Atlikt")
+          expect(I18n.t("cancel", scope: "admin.content", locale: "lv")).to eq("Atlikt")
+        end
+      end
+    end
+
+    context "nonexistent translation" do
+      context "loading multiple times" do
+        it "queries db only for the first time" do
+          I18n.t("save", scope: "admin.xx")
+          expect(Releaf::I18nDatabase::I18nEntry).not_to receive(:where)
+          I18n.t("save", scope: "admin.xx")
+        end
+      end
+
+      context "with nonexistent translation" do
+        before do
+          allow(Releaf.application.config).to receive(:all_locales).and_return(["ru", "lv"])
+        end
+
+        it "creates empty translation" do
+          expect { I18n.t("save") }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "save").count }.by(1)
+        end
+
+        context "when count option passed" do
+          context "when create_plurals option not passed" do
+            it "creates empty translation" do
+              expect { I18n.t("animals.horse", count: 1) }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "animals.horse").count }.by(1)
+            end
+          end
+
+          context "when negative create_plurals option passed" do
+            it "creates empty translation" do
+              expect { I18n.t("animals.horse", create_plurals: false, count: 1) }.to change { Releaf::I18nDatabase::I18nEntry.where(key: "animals.horse").count }.by(1)
+            end
+          end
+
+          context "when positive create_plurals option passed" do
+            it "creates pluralized translations for all Releaf locales" do
+              result = ["animals.horse.few", "animals.horse.many", "animals.horse.one", "animals.horse.other", "animals.horse.zero"]
+              expect{ I18n.t("animals.horse", count: 1, create_plurals: true) }.to change{ Releaf::I18nDatabase::I18nEntry.pluck(:key).sort }.
+                from([]).to(result.sort)
+            end
+          end
+        end
+      end
+    end
+
+    context "when scope requested" do
+      it "returns all scope translations" do
+        translation_1 = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.cancel")
+        translation_1.i18n_entry_translation.create(locale: "lv", text: "Atlikt")
+
+        translation_2 = Releaf::I18nDatabase::I18nEntry.create(key: "admin.content.save")
+        translation_2.i18n_entry_translation.create(locale: "lv", text: "Saglabāt")
+
+        expect(I18n.t("admin.content", locale: "lv")).to eq(cancel: "Atlikt", save: "Saglabāt")
+        expect(I18n.t("admin.content", locale: "en")).to eq(cancel: nil, save: nil)
+      end
+    end
+  end
 end

data/spec/fixtures/invalid.xls

@@ -0,0 +1,3 @@
+NOT REALLY
+A SPREADSHEET
+FILE

data/spec/fixtures/invalid.xlsx

@@ -0,0 +1,3 @@
+NOT REALLY
+A SPREADSHEET
+FILE

data/spec/lib/releaf/i18n_database/backend_spec.rb

@@ -0,0 +1,192 @@
+require "rails_helper"
+
+describe Releaf::I18nDatabase::Backend do
+  let(:translations_store){ Releaf::I18nDatabase::TranslationsStore.new }
+
+  describe ".configure_component" do
+    it "adds new `Releaf::I18nDatabase::Configuration` configuration with default config" do
+      stub_const("Releaf::I18nDatabase::Backend::DEFAULT_CONFIG", a: :b)
+      allow(Releaf::I18nDatabase::Configuration).to receive(:new)
+        .with(a: :b).and_return("_new")
+      expect(Releaf.application.config).to receive(:add_configuration).with("_new")
+      described_class.configure_component
+    end
+  end
+
+  describe ".reset_cache" do
+    it "reset translations cache to backend instance" do
+      subject.translations_cache = :x
+      allow(described_class).to receive(:backend_instance).and_return(subject)
+      expect{ described_class.reset_cache }.to change{ subject.translations_cache }.to(nil)
+    end
+  end
+
+  describe ".backend_instance" do
+    context "when I18n backend has chained backends" do
+      it "returns Releaf::I18nDatabase::Backend instance" do
+        backends = I18n::Backend::Chain.new(subject, I18n::Backend::Simple.new)
+        allow(I18n).to receive(:backend).and_return(backends)
+        expect(described_class.backend_instance).to eq(subject)
+      end
+
+      it "returns nil when chain hasn't Releaf::I18nDatabase::Backend instance" do
+        backends = I18n::Backend::Chain.new(I18n::Backend::Simple.new)
+        allow(I18n).to receive(:backend).and_return(backends)
+        expect(described_class.backend_instance).to be nil
+      end
+    end
+
+    context "when I18n backend has single backend and it is instance of Releaf::I18nDatabase::Backend" do
+      it "returns Releaf::I18nDatabase::Backend instance" do
+        allow(I18n).to receive(:backend).and_return(subject)
+        expect(described_class.backend_instance).to eq(subject)
+      end
+    end
+
+    context "when I18n backend has single backend and it is not instance of Releaf::I18nDatabase::Backend" do
+      it "returns nil" do
+        allow(I18n).to receive(:backend).and_return(I18n::Backend::Simple.new)
+        expect(described_class.backend_instance).to be nil
+      end
+    end
+  end
+
+  describe ".initialize_component" do
+    it "adds itself as i18n backend as primary backend while keeping Rails default simple backend as secondary" do
+      allow(I18n).to receive(:backend).and_return(:current_backend)
+      allow(I18n::Backend::Chain).to receive(:new).with(:new_backend, :current_backend).and_return(:x)
+      allow(described_class).to receive(:new).and_return(:new_backend)
+      expect(I18n).to receive(:backend=).with(:x)
+      described_class.initialize_component
+    end
+  end
+
+  describe ".locales_pluralizations" do
+    it "returns array all pluralization forms for releaf locales" do
+      allow(Releaf.application.config).to receive(:all_locales).and_return([:de, :ru, :aasdsd])
+
+      allow(TwitterCldr).to receive(:supported_locale?).with(:de).and_return(true)
+      allow(TwitterCldr::Formatters::Plurals::Rules).to receive(:all_for).with(:de).and_return([:one, :other, :many])
+
+      allow(TwitterCldr).to receive(:supported_locale?).with(:ru).and_return(true)
+      allow(TwitterCldr::Formatters::Plurals::Rules).to receive(:all_for).with(:ru).and_return([:one, :other, :few, :zero])
+
+      allow(TwitterCldr).to receive(:supported_locale?).with(:aasdsd).and_return(false)
+
+      expect(described_class.locales_pluralizations).to eq([:one, :other, :many, :few, :zero])
+    end
+  end
+
+  describe "#translations" do
+    let(:another_translations_store){ Releaf::I18nDatabase::TranslationsStore.new }
+
+    context "when translations has been loaded and is not expired" do
+      it "returns assigned translations hash instance" do
+        subject.translations_cache = translations_store
+        allow(translations_store).to receive(:expired?).and_return(false)
+        expect(Releaf::I18nDatabase::TranslationsStore).to_not receive(:new)
+        expect(subject.translations).to eq(translations_store)
+      end
+    end
+
+    context "when translations has been loaded and is expired" do
+      it "initializes new `TranslationsStore`, cache and return it" do
+        subject.translations_cache = translations_store
+        allow(translations_store).to receive(:expired?).and_return(true)
+        expect(Releaf::I18nDatabase::TranslationsStore).to receive(:new).and_return(another_translations_store)
+        expect(subject.translations).to eq(another_translations_store)
+      end
+    end
+
+    context "when translations has not been loaded" do
+      it "initializes new `TranslationsStore`, cache and return it" do
+        subject.translations_cache = nil
+        expect(Releaf::I18nDatabase::TranslationsStore).to receive(:new).and_return(another_translations_store)
+        expect(subject.translations).to eq(another_translations_store)
+      end
+    end
+  end
+
+  describe "#store_translations" do
+    it "pass given translations to simple translation backend" do
+      simple_backend = I18n.backend.backends.last
+      expect(simple_backend).to receive(:store_translations).with(:lv, {a: "x"}, {c: "d"})
+      subject.store_translations(:lv, {a: "x"}, {c: "d"})
+    end
+  end
+
+  describe ".translations_updated_at" do
+    it "returns translations updated_at from cached settings" do
+      allow(Releaf::Settings).to receive(:[]).with(described_class::UPDATED_AT_KEY).and_return("x")
+      expect(described_class.translations_updated_at).to eq("x")
+    end
+  end
+
+  describe ".translations_updated_at=" do
+    it "stores translations updated_at to cached settings" do
+      expect(Releaf::Settings).to receive(:[]=).with(described_class::UPDATED_AT_KEY, "xx")
+      described_class.translations_updated_at = "xx"
+    end
+  end
+
+  describe "#lookup" do
+    before do
+      allow(subject).to receive(:translations).and_return(translations_store)
+      allow(subject).to receive(:normalize_flat_keys).with(:lv, "some.localization", "_scope_", ":")
+        .and_return("xx.s.loc")
+    end
+
+    it "flattens key before passing further" do
+      expect(translations_store).to receive(:missing?).with(:lv, "xx.s.loc")
+      expect(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b")
+      expect(translations_store).to receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
+
+      subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
+    end
+
+    context "when translation is known as missing" do
+      it "does not make lookup in translation hash, does not mark it as missing and return nil" do
+        allow(translations_store).to receive(:missing?).with(:lv, "xx.s.loc").and_return(true)
+        expect(translations_store).to_not receive(:lookup)
+        expect(translations_store).to_not receive(:missing)
+        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
+      end
+    end
+
+    context "when translation is not known as missing" do
+      before do
+        allow(translations_store).to receive(:missing?).with(:lv, "xx.s.loc").and_return(false)
+      end
+
+      context "when lookup result is not nil" do
+        before do
+          allow(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b").and_return("x")
+        end
+
+        it "returns lookup result" do
+          expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to eq("x")
+        end
+
+        it "does not mark translation as missing" do
+          expect(translations_store).to_not receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
+          subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
+        end
+      end
+
+      context "when lookup result is nil" do
+        before do
+          allow(translations_store).to receive(:lookup).with(:lv, "xx.s.loc", separator: ":", a: "b").and_return(nil)
+        end
+
+        it "returns nil" do
+          expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
+        end
+
+        it "marks translation as missing" do
+          expect(translations_store).to receive(:missing).with(:lv, "xx.s.loc", separator: ":", a: "b")
+          subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")
+        end
+      end
+    end
+  end
+end