releaf-i18n_database 1.1.19 → 2.0.1

data/spec/fixtures/invalid.xls

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

data/spec/fixtures/invalid.xlsx

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

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

@@ -1,198 +0,0 @@
-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(I18n).to receive(:locale_available?).and_return(true)
-      expect(described_class.locales_pluralizations).to eq([:one, :other, :few, :many, :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
-
-    context "when database doesn't exists" do
-      it "returns an empty array" do
-        allow(Releaf::I18nDatabase::I18nEntry).to receive(:pluck).and_raise(ActiveRecord::NoDatabaseError.new("xxx"))
-        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-      end
-    end
-
-    context "when node table doesn't exist" do
-      it "returns an empty array" do
-        allow(Releaf::I18nDatabase::I18nEntry).to receive(:pluck).and_raise(ActiveRecord::StatementInvalid.new("xxx"))
-        expect(subject.lookup(:lv, "some.localization", "_scope_", separator: ":", a: "b")).to be nil
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::Configuration do
-  subject{ described_class.new(translation_auto_creation: true,
-                               translation_auto_creation_patterns: [1, 2],
-                               translation_auto_creation_exclusion_patterns: [3, 4]) }
-
-  it do
-    is_expected.to have_attributes(translation_auto_creation: true)
-    is_expected.to have_attributes(translation_auto_creation_patterns: [1, 2])
-    is_expected.to have_attributes(translation_auto_creation_exclusion_patterns: [3, 4])
-  end
-end

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

@@ -1,24 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::HumanizeMissingTranslations do
-  describe ".call" do
-    context "when key is present and exception is I18n::MissingTranslation" do
-      it "humanizes missing translations" do
-        expect(I18n.t("some.missing translation")).to eq("Missing translation")
-      end
-    end
-
-    context "when key is not present and exception is I18n::MissingTranslation" do
-      it "does not intercept it" do
-        expect(I18n.t(nil)).to eq("translation missing: en.no key")
-      end
-    end
-
-    context "when exception is not I18n::MissingTranslation" do
-      it "does not intercept it" do
-        allow(I18n::Backend::Transliterator).to receive(:get).and_raise(I18n::ArgumentError)
-        expect{I18n.transliterate("error?")}.to raise_error(I18n::ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,151 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::ParseSpreadsheetTranslations do
-  let(:translation){ Releaf::I18nDatabase::I18nEntry.new }
-  let(:fixture_path){ File.expand_path('../../../fixtures/translations_import.xlsx', __dir__) }
-  let(:error_message){ "Don't know how to open file #{fixture_path}" }
-  subject{ described_class.new(file_path: fixture_path, extension: "xlsx") }
-
-  describe "#call" do
-    it "returns translations" do
-      allow(subject).to receive(:translations).and_return("x")
-      expect(subject.call).to eq("x")
-    end
-  end
-
-  describe "#rows" do
-    let(:spreadsheet){ Roo::Spreadsheet.open(fixture_path) }
-
-    before do
-      allow(subject).to receive(:spreadsheet).and_return(spreadsheet)
-    end
-
-    it "returns speadsheet casted to array" do
-      allow(spreadsheet).to receive(:to_a).and_return([1, 2])
-      expect(subject.rows).to eq([1, 2])
-    end
-
-    it "caches casted array" do
-      expect(spreadsheet).to receive(:to_a).and_return([1, 2]).once
-      subject.rows
-      subject.rows
-    end
-  end
-
-  describe "#data_rows" do
-    it "returns all rows except first and one with empty first value (key)" do
-      allow(subject).to receive(:rows).and_return([[1, 2, 3], [:a, 2, 3], [nil, 2, 4], ["", 4, 1], [6, 2, ""]])
-      expect(subject.data_rows).to eq([[:a, 2, 3], [6, 2, ""]])
-    end
-  end
-
-  describe "#locales" do
-    it "returns all non blank values from first row" do
-      allow(subject).to receive(:rows).and_return([["lv", "", "de", nil, "en"], [:a, 2, 3], [6, 2, ""]])
-      expect(subject.locales).to eq(["lv", "de", "en"])
-    end
-
-    it "caches resolved values" do
-      expect(subject).to receive(:rows).and_return([["lv", "", "de", nil, "en"], [:a, 2, 3], [6, 2, ""]]).once
-      subject.locales
-      subject.locales
-    end
-  end
-
-  describe "#spreadsheet" do
-    it "returns Roo spreadsheet instance" do
-      allow(Roo::Spreadsheet).to receive(:open).with(fixture_path, extension: "xlsx", file_warning: :ignore).and_return("instance")
-      expect(subject.spreadsheet).to eq("instance")
-    end
-
-
-    context "when opening the file raises an unsupported content error" do
-      it "raises Releaf::TranslationsImporter::UnsupportedFileFormatError" do
-        error = ArgumentError.new("error message")
-        allow(Roo::Spreadsheet).to receive(:open).and_raise( error )
-        expect(subject).to receive(:file_format_error?).with( "ArgumentError", "error message").and_return true
-        expect{ subject.spreadsheet }.to raise_error(described_class::UnsupportedFileFormatError)
-      end
-    end
-
-    context "when opening the file raises any other error" do
-      it "raises Releaf::TranslationsImporter::UnsupportedFileFormatError" do
-        error = ArgumentError.new("error message")
-        allow(Roo::Spreadsheet).to receive(:open).and_raise( error )
-        expect(subject).to receive(:file_format_error?).with( "ArgumentError", "error message").and_return false
-        expect{ subject.spreadsheet }.to raise_error( error )
-      end
-    end
-
-  end
-
-  describe "#file_format_error?" do
-
-    context "when given error is an ArgumentError" do
-      context "when the message contains 'Don't know how to open file'" do
-        it "returns true" do
-          expect(subject.file_format_error?("ArgumentError", error_message)).to be true
-        end
-      end
-      context "when the message is different" do
-        it "returns false" do
-          expect(subject.file_format_error?("ArgumentError", "error message")).to be false
-        end
-      end
-    end
-
-    context "when the error is a Zip::ZipError" do
-      it "returns true" do
-        expect(subject.file_format_error?("Zip::ZipError", "error message")).to be true
-      end
-    end
-
-    context "when the error is a Ole::Storage::FormatError" do
-      it "returns true" do
-        expect(subject.file_format_error?("Ole::Storage::FormatError", "error message")).to be true
-      end
-    end
-
-
-  end
-
-
-  describe "#translations" do
-    it "returns array of processed `Releaf::I18nDatabase::Translation` instances" do
-      allow(subject).to receive(:data_rows).and_return([[1, 2, 3], [:a, nil, 3], [6, 2, ""]])
-      allow(subject).to receive(:translation_instance).with(1, ["2", "3"]).and_return("t1")
-      allow(subject).to receive(:translation_instance).with(:a, ["", "3"]).and_return("t2")
-      allow(subject).to receive(:translation_instance).with(6, ["2", ""]).and_return("t3")
-      expect(subject.translations).to eq(["t1", "t2", "t3"])
-    end
-  end
-
-  describe "#translation_instance" do
-    it "returns first or initialized translation for given key and given localizations built" do
-      where_scope = Releaf::I18nDatabase::I18nEntry.where(key: ["sommmmquery"])
-      allow(Releaf::I18nDatabase::I18nEntry).to receive(:where).with(key: "as.ld").and_return(where_scope)
-      allow(where_scope).to receive(:first_or_initialize).and_return(translation)
-
-      expect(subject).to receive(:maintain_translation_locales).with(translation, ["x", "y"])
-      expect(subject.translation_instance("as.ld", ["x", "y"])).to eq(translation)
-    end
-  end
-
-  describe "#maintain_translation_locales" do
-    before do
-      allow(subject).to receive(:locales).and_return(["en", "de", "ge", "lv"])
-      translation.i18n_entry_translation.build(locale: "de", text: "po")
-      translation.i18n_entry_translation.build(locale: "ge", text: "x")
-    end
-
-    it "builds translation data for all missing locales" do
-      expect{ subject.maintain_translation_locales(translation, ["ent", "det", "get", "lvt"]) }
-        .to change{ translation.i18n_entry_translation.map{|td| td.locale } }.from(["de", "ge"]).to(["de", "ge", "en", "lv"])
-    end
-
-    it "overwrites existing translation data localizations only if new localizations is not empty" do
-      expect{ subject.maintain_translation_locales(translation, ["ent", "", "get", "lvt"]) }
-        .to change{ translation.i18n_entry_translation.map{|td| [td.locale, td.text] } }.to([["de", "po"], ["ge", "get"], ["en", "ent"], ["lv", "lvt"]])
-    end
-  end
-end

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

@@ -1,530 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::TranslationsStore do
-  describe "#initialize" do
-    it "assigns updated at from `Releaf::I18nDatabase::Backend` last updated at timestamp" do
-      allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return("x")
-      expect(subject.updated_at).to eq("x")
-    end
-
-    it "assigns empty hash to missing keys" do
-      expect(subject.missing_keys).to eq({})
-    end
-  end
-
-  describe "#config" do
-    it "returns Releaf.application.config" do
-      allow(Releaf.application).to receive(:config).and_return(:x)
-      expect(subject.config).to eq(:x)
-    end
-  end
-
-  describe "#expired?" do
-    context "when last translation update differs from last cache load" do
-      it "returns true" do
-        allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return(1)
-        subject.updated_at = 2
-        expect(subject.expired?).to be true
-      end
-    end
-
-    context "when last translation update does not differ from last cache load" do
-      it "returns false" do
-        allow(Releaf::I18nDatabase::Backend).to receive(:translations_updated_at).and_return(1)
-        subject.updated_at = 1
-        expect(subject.expired?).to be false
-      end
-    end
-  end
-
-  describe "#exist?" do
-    context "when given key exists within stored keys hash" do
-      it "returns true" do
-        allow(subject).to receive(:stored_keys).and_return("asd.xxx" => true)
-        expect(subject.exist?("asd.xxx")).to be true
-      end
-    end
-
-    context "when given key does not exist within keys hash" do
-      it "returns false" do
-        allow(subject).to receive(:stored_keys).and_return("asd.xxyy" => true)
-        expect(subject.exist?("asd.xxx")).to be false
-      end
-    end
-  end
-
-  describe "#lookup" do
-    it "returns first valid and returnable result" do
-      allow(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["admin", "menu", "translations"], true, count: 23).and_return("x1")
-      allow(subject).to receive(:returnable_result?)
-        .with("x1", count: 23).and_return(false)
-
-      allow(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["admin", "translations"], false, count: 23).and_return("x2")
-      allow(subject).to receive(:returnable_result?)
-        .with("x2", count: 23).and_return(true)
-
-      expect(subject.lookup(:ru, "admin.menu.translations", count: 23)).to eq("x2")
-    end
-
-    it "iterates throught all translation scopes until last key" do
-      expect(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["admin", "menu", "another", "translations"], true, count: 23).and_return(nil)
-      expect(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["admin", "menu", "translations"], false, count: 23).and_return(nil)
-      expect(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["admin", "translations"], false, count: 23).and_return(nil)
-      expect(subject).to receive(:dig_valid_translation)
-        .with(:ru, ["translations"], false, count: 23).and_return("x1")
-
-      subject.lookup(:ru, "admin.menu.another.translations", count: 23)
-    end
-
-    context "when no matches found" do
-      it "returns nil" do
-        allow(subject).to receive(:dig_valid_translation).and_return(nil)
-        expect(subject.lookup(:ru, "admin.menu.translations", count: 23)).to be nil
-      end
-    end
-  end
-
-  describe "#dig_translation" do
-    before do
-      allow(subject).to receive(:stored_translations).and_return(
-        lv: {
-          admin: {
-            some_scope: {
-              save: "Saglabāt"
-            }
-          }
-        },
-        lt: {
-          public: {
-            another_scope: {
-              email: "E-pastas"
-            }
-          }
-        }
-      )
-    end
-
-    it "dig given locale prefixed keys hash against stored translations and returns matched value (String or Hash)" do
-      expect(subject.dig_translation(:lv, [:admin, :some_scope, :save])).to eq("Saglabāt")
-      expect(subject.dig_translation(:lt, [:public, :another_scope, :email])).to eq("E-pastas")
-      expect(subject.dig_translation(:lt, [:public, :another_scope])).to eq(email: "E-pastas")
-    end
-
-    context "when no match found" do
-      it "returns nil" do
-        expect(subject.dig_translation(:lt, [:admin, :some_scope, :save])).to be nil
-        expect(subject.dig_translation(:lt, [:public, :email])).to be nil
-        expect(subject.dig_translation(:ge, [:public, :email])).to be nil
-      end
-    end
-  end
-
-  describe "#dig_valid_translation" do
-    before do
-      allow(subject).to receive(:dig_translation).with(:de, [:admin, :save]).and_return("translated_value")
-    end
-
-    context "when digged translation has valid result" do
-      it "returns digged translation result" do
-        allow(subject).to receive(:invalid_result?).with(:de, "translated_value", true, a: :b).and_return(false)
-        expect(subject.dig_valid_translation(:de, [:admin, :save], true, a: :b)).to eq("translated_value")
-      end
-    end
-
-    context "when digged translation has invalid result" do
-      it "returns nil" do
-        allow(subject).to receive(:invalid_result?).with(:de, "translated_value", true, a: :b).and_return(true)
-        expect(subject.dig_valid_translation(:de, [:admin, :save], true, a: :b)).to be nil
-      end
-    end
-  end
-
-  describe "#invalid_result?" do
-    before do
-      allow(subject).to receive(:invalid_nonpluralized_result?).with("xx", true, a: :b).and_return(false)
-      allow(subject).to receive(:invalid_pluralized_result?).with(:ge, "xx", a: :b).and_return(false)
-    end
-
-    context "when invalid nonplurarized result" do
-      it "returns true" do
-        allow(subject).to receive(:invalid_nonpluralized_result?).with("xx", true, a: :b).and_return(true)
-        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be true
-      end
-    end
-
-    context "when invalid plurarized result" do
-      it "returns true" do
-        allow(subject).to receive(:invalid_pluralized_result?).with(:ge, "xx", a: :b).and_return(true)
-        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be true
-      end
-    end
-
-    context "when no invalid nonplurarized or pluralized result" do
-      it "returns false" do
-        expect(subject.invalid_result?(:ge, "xx", true, a: :b)).to be false
-      end
-    end
-  end
-
-  describe "#invalid_nonpluralized_result?" do
-    context "when hash result, not first lookup and options without count" do
-      it "returns true" do
-        expect(subject.invalid_nonpluralized_result?({a: :b}, false, scope: "xxx")).to be true
-      end
-    end
-
-    context "when hash result, first lookup and options without count" do
-      it "returns false" do
-        expect(subject.invalid_nonpluralized_result?({a: :b}, true, scope: "xxx")).to be false
-      end
-    end
-
-    context "when hash result, not first lookup and options with count" do
-      it "returns false" do
-        expect(subject.invalid_nonpluralized_result?({a: :b}, false, count: 43, scope: "xxx")).to be false
-      end
-    end
-
-    context "when non hash result, not first lookup and options without count" do
-      it "returns false" do
-        expect(subject.invalid_nonpluralized_result?("x", false, scope: "xxx")).to be false
-      end
-    end
-  end
-
-  describe "#invalid_pluralized_result?" do
-    before do
-      allow(subject).to receive(:valid_pluralized_result?).with(:ge, 12, a: :b).and_return(false)
-    end
-
-    context "when hash result, options has count and invalid pluralized result" do
-      it "returns true" do
-        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {count: 12})).to be true
-      end
-    end
-
-    context "when non hash result, options has count and invalid pluralized result" do
-      it "returns false" do
-        expect(subject.invalid_pluralized_result?(:ge, "X", {count: 12})).to be false
-      end
-    end
-
-    context "when hash result, options has no count value and invalid pluralized result" do
-      it "returns false" do
-        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {scope: "xx.xx"})).to be false
-      end
-    end
-
-    context "when hash result, options has count and valid pluralized result" do
-      it "returns false" do
-        allow(subject).to receive(:valid_pluralized_result?).with(:ge, 12, a: :b).and_return(true)
-        expect(subject.invalid_pluralized_result?(:ge, {a: :b}, {count: 12})).to be false
-      end
-    end
-  end
-
-  describe "#valid_pluralized_result?" do
-    context "when given hash contains valid result for given locale and count" do
-      it "return true" do
-        expect(subject.valid_pluralized_result?(:lv, 2, one: "x", other: "y")).to be true
-      end
-    end
-
-    context "when given hash contains invalid result for given locale and count" do
-      it "return false" do
-        expect(subject.valid_pluralized_result?(:lv, 2, one: "x", few: "y")).to be false
-      end
-    end
-  end
-
-  describe "#returnable_result?" do
-    context "when given result is not blank" do
-      it "returns true" do
-        expect(subject.returnable_result?("x", a: "b")).to be true
-      end
-    end
-
-    context "when `inherit_scopes` option value is boolean `false`" do
-      it "returns true" do
-        expect(subject.returnable_result?(nil, inherit_scopes: false)).to be true
-      end
-    end
-
-    context "when given result is blank and `inherit_scopes` option value is not boolean `false`" do
-      it "returns false" do
-        expect(subject.returnable_result?(nil, inherit_scopes: true)).to be false
-        expect(subject.returnable_result?(nil, a: "b")).to be false
-      end
-    end
-  end
-
-  describe "#localization_data" do
-    it "returns hash with all non empty translations with locale prefixed key and localization as value" do
-      i18n_entry_1 = Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
-      i18n_entry_1.i18n_entry_translation.create(locale: "lv", text: "suņi")
-      i18n_entry_1.i18n_entry_translation.create(locale: "en", text: "dogs")
-
-      i18n_entry_2 = Releaf::I18nDatabase::I18nEntry.create(key: "some.good")
-      i18n_entry_2.i18n_entry_translation.create(locale: "lv", text: "xx")
-      i18n_entry_2.i18n_entry_translation.create(locale: "en", text: "")
-
-      expect(subject.localization_data).to eq("lv.some.food" => "suņi", "en.some.food" => "dogs",
-                                              "lv.some.good" => "xx")
-    end
-
-    it "has cached method result" do
-      expect(described_class).to cache_instance_method(:localization_data)
-    end
-  end
-
-  describe "#stored_keys" do
-    it "returns hash with existing translation keys" do
-      Releaf::I18nDatabase::I18nEntry.create(key: "some.food")
-      Releaf::I18nDatabase::I18nEntry.create(key: "some.good")
-      expect(subject.stored_keys).to eq("some.food" => true, "some.good" => true)
-    end
-
-    it "has cached method result" do
-      expect(described_class).to cache_instance_method(:stored_keys)
-    end
-  end
-
-  describe "#stored_translations" do
-    it "returns deep merged hash from all key translation hashes" do
-      allow(subject).to receive(:stored_keys).and_return("some.food" => true, "some.good" => true)
-      allow(subject).to receive(:key_hash).with("some.food").and_return(lv: {a: "a1"}, en: {d: {e: "ee"}})
-      allow(subject).to receive(:key_hash).with("some.good").and_return(lv: {b: "b2"}, en: {d: {u: "ll"}})
-      expect(subject.stored_translations).to eq(lv: {a: "a1", b: "b2"}, en: {d: {e: "ee", u: "ll"}})
-    end
-
-    context "when no keys exists" do
-      it "returns empty hash" do
-        allow(subject).to receive(:stored_keys).and_return({})
-        expect(subject.stored_translations).to eq({})
-      end
-    end
-
-    it "has cached method result" do
-      expect(described_class).to cache_instance_method(:stored_translations)
-    end
-  end
-
-  describe "#key_hash" do
-    it "build stored translation hash with keys and translated values for given key" do
-      allow(subject.config).to receive(:all_locales).and_return([:ge, :de])
-      allow(subject).to receive(:localization_data).and_return(
-        "lv.admin.releaf_i18n_database_translations.Save" => "zc",
-        "ge.admin.Save" => "asdasd",
-        "de.admin.releaf_i18n_database_translations.Save" => "Seiv",
-        "de.admin.releaf_i18n_database_translations.Cancel" => "dCancel",
-        "ge.admin.releaf_i18n_database_translations.Cancel" => "gCancel",
-      )
-
-      expect(subject.key_hash("admin.releaf_i18n_database_translations.Save")).to eq(
-        ge: {
-          admin: {
-            releaf_i18n_database_translations: {
-              Save: nil
-            }
-          }
-        },
-        de: {
-          admin: {
-            releaf_i18n_database_translations: {
-              Save: "Seiv"
-            }
-          }
-        }
-      )
-
-      expect(subject.key_hash("admin.releaf_i18n_database_translations.Cancel")).to eq(
-        ge: {
-          admin: {
-            releaf_i18n_database_translations: {
-              Cancel: "gCancel"
-            }
-          }
-        },
-        de: {
-          admin: {
-            releaf_i18n_database_translations: {
-              Cancel: "dCancel"
-            }
-          }
-        }
-      )
-    end
-  end
-
-  describe "#missing?" do
-    context "when given locale and key combination exists within missing keys hash" do
-      it "returns true" do
-        allow(subject).to receive(:missing_keys).and_return("lv.asd.xxx" => true)
-        expect(subject.missing?(:lv, "asd.xxx")).to be true
-      end
-    end
-
-    context "when given locale and key combination does not exist missing keys hash" do
-      it "returns false" do
-        allow(subject).to receive(:missing_keys).and_return("en.asd.xxx" => true)
-        expect(subject.missing?(:lv, "asd.xxx")).to be false
-      end
-    end
-  end
-
-  describe "#missing" do
-    it "adds given locale and key combination as missing" do
-      expect{ subject.missing(:de, "as.pasd", a: "x") }.to change { subject.missing_keys["de.as.pasd"] }
-        .from(nil).to(true)
-    end
-
-    context "when missing translation creation is available for given key and options" do
-      it "creates missing translation" do
-        allow(subject).to receive(:auto_create?).with("ps.asda", a: "x").and_return(true)
-        expect(subject).to receive(:auto_create).with("ps.asda", a: "x")
-        subject.missing(:de, "ps.asda", a: "x")
-      end
-    end
-
-    context "when missing translation creation is not available for given key and options" do
-      it "does not create missing translation" do
-        allow(subject).to receive(:auto_create?).with("ps.asda", a: "x").and_return(false)
-        expect(subject).to_not receive(:auto_create)
-        subject.missing(:de, "ps.asda", a: "x")
-      end
-    end
-  end
-
-  describe "#auto_create?" do
-    before do
-      allow(subject.config.i18n_database ).to receive(:translation_auto_creation).and_return(true)
-      allow(subject).to receive(:stored_keys).and_return("xxxome.save" => "xxxome.save")
-      allow(subject).to receive(:auto_creation_inclusion?).with("some.save").and_return(true)
-      allow(subject).to receive(:auto_creation_exception?).with("some.save").and_return(false)
-    end
-
-    context "when missing translation creation is enabled globally by i18n config and not disabled by `auto_create` option" do
-      it "returns true" do
-        expect(subject.auto_create?("some.save", {})).to be true
-        expect(subject.auto_create?("some.save", auto_create: true)).to be true
-        expect(subject.auto_create?("some.save", auto_create: nil)).to be true
-      end
-    end
-
-    context "when no auto creation inclusion" do
-      it "returns false" do
-        allow(subject).to receive(:auto_creation_inclusion?).with("some.save").and_return(false)
-        expect(subject.auto_create?("some.save", {})).to be false
-      end
-    end
-
-    context "when auto creation exception" do
-      it "returns false" do
-        allow(subject).to receive(:auto_creation_exception?).with("some.save").and_return(true)
-        expect(subject.auto_create?("some.save", {})).to be false
-      end
-    end
-
-    context "when missing translation creation is disabled globally by i18n config" do
-      it "returns false" do
-        allow(subject.config.i18n_database ).to receive(:translation_auto_creation).and_return(false)
-        expect(subject.auto_create?("some.save", {})).to be false
-      end
-    end
-
-    context "when missing translation creation is disabled by `auto_create` option" do
-      it "returns false" do
-        expect(subject.auto_create?("some.save", auto_create: false)).to be false
-      end
-    end
-
-    context "when key already exists within stored keys hash" do
-      it "returns false" do
-        allow(subject).to receive(:stored_keys).and_return("some.save" => "some.save")
-        expect(subject.auto_create?("some.save", {})).to be false
-      end
-    end
-  end
-
-  describe "#auto_creation_inclusion?" do
-    context "when given key matches any auto creation pattern" do
-      it "returns true" do
-        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_patterns).and_return([/^another\./, /^some\./])
-        expect(subject.auto_creation_inclusion?("some.save")).to be true
-      end
-    end
-
-    context "when given key matches no auto creation pattern" do
-      it "returns false" do
-        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_patterns).and_return([/^another\./, /^foo\./])
-        expect(subject.auto_creation_inclusion?("some.save")).to be false
-      end
-    end
-  end
-
-  describe "#auto_creation_exception?" do
-    context "when given key matches any auto creation exception pattern" do
-      it "returns true" do
-        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_exclusion_patterns).and_return([/^another\./, /^some\./])
-        expect(subject.auto_creation_exception?("some.save")).to be true
-      end
-    end
-
-    context "when given key matches no auto creation exception pattern" do
-      it "returns false" do
-        allow(subject.config.i18n_database ).to receive(:translation_auto_creation_exclusion_patterns).and_return([/^another\./, /^foo\./])
-        expect(subject.auto_creation_exception?("some.save")).to be false
-      end
-    end
-  end
-
-  describe "#auto_create" do
-    before do
-      allow(Releaf::I18nDatabase::Backend).to receive(:locales_pluralizations).and_return([:one, :many, :other])
-    end
-
-    context "when pluralizable translation given" do
-      it "creates translation for each pluralization form" do
-        allow(subject).to receive(:pluralizable_translation?).with(a: "b").and_return(true)
-        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.one")
-        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.many")
-        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd.other")
-        subject.auto_create("aasd.oihgja.sd", a: "b")
-      end
-    end
-
-    context "when non pluralizable translation given" do
-      it "creates translation" do
-        allow(subject).to receive(:pluralizable_translation?).with(a: "b").and_return(false)
-        expect(Releaf::I18nDatabase::I18nEntry).to receive(:create).with(key: "aasd.oihgja.sd")
-        subject.auto_create("aasd.oihgja.sd", a: "b")
-      end
-    end
-  end
-
-  describe "#pluralizable_translation?" do
-    context "when given options has count key and `create_plurals` key is true" do
-      it "returns true" do
-        expect(subject.pluralizable_translation?(count: 3, create_plurals: true)).to be true
-      end
-    end
-
-    context "when given options has count key and `create_plurals` key is not true" do
-      it "returns false" do
-        expect(subject.pluralizable_translation?(count: 3, create_plurals: false)).to be false
-        expect(subject.pluralizable_translation?(count: 3)).to be false
-      end
-    end
-
-    context "when given options has no count key and `create_plurals` key is true" do
-      it "returns false" do
-        expect(subject.pluralizable_translation?(create_plurals: true)).to be false
-      end
-    end
-  end
-end