releaf-i18n_database 0.2.1 → 1.0.3

data/app/models/releaf/i18n_database/translation.rb

@@ -1,17 +0,0 @@
-module Releaf::I18nDatabase
-  class Translation < ActiveRecord::Base
-    self.table_name = "releaf_translations"
-
-    validates_presence_of :key
-    validates_uniqueness_of :key
-    validates_length_of :key, maximum: 255
-
-    has_many :translation_data, dependent: :destroy, class_name: 'Releaf::I18nDatabase::TranslationData', inverse_of: :translation
-    accepts_nested_attributes_for :translation_data, allow_destroy: true
-
-    def locale_value(locale)
-      # search against all values to cache
-      translation_data.find{ |x| x.lang == locale.to_s }.try(:localization)
-    end
-  end
-end

data/app/models/releaf/i18n_database/translation_data.rb

@@ -1,11 +0,0 @@
-module Releaf::I18nDatabase
-  class TranslationData < ActiveRecord::Base
-    self.table_name = "releaf_translation_data"
-
-    validates_presence_of :translation, :lang
-    validates_uniqueness_of :translation_id, :scope => :lang
-    validates_length_of :lang, maximum: 5
-
-    belongs_to :translation, :inverse_of => :translation_data
-  end
-end

data/lib/releaf/i18n_database/builders_autoload.rb

@@ -1,10 +0,0 @@
-root_path = File.expand_path('../..', File.dirname(__dir__))
-files = %w(
-  builders_common
-  edit_builder
-  table_builder
-  index_builder
-)
-files.each do|file|
- require "#{root_path}/app/builders/releaf/i18n_database/translations/#{file}"
-end

data/releaf-i18n_database.gemspec

@@ -1,21 +0,0 @@
-require File.expand_path("../../releaf-core/lib/releaf/version.rb", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = "releaf-i18n_database"
-  s.version     = Releaf::VERSION
-
-  s.summary     = "i18n database gem for releaf"
-  s.description = "i18n database backend for releaf"
-  s.authors     = ["CubeSystems"]
-  s.email       = 'info@cubesystems.lv'
-  s.homepage    = 'https://github.com/cubesystems/releaf'
-
-  s.files             = `git ls-files`.split("\n")
-  s.test_files = Dir["spec/**/*"]
-
-  s.add_dependency 'releaf-core', Releaf::VERSION
-  s.add_dependency 'twitter_cldr'
-  s.add_dependency 'axlsx_rails', '>= 0.3.0'
-  s.add_dependency 'roo'
-
-end

data/spec/lib/i18n_database/backend_spec.rb

@@ -1,337 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::Backend do
-
-  before do
-    allow( Releaf::I18nDatabase ).to receive(:create_missing_translations).and_return(true)
-    allow( I18n.backend ).to receive(:reload_cache?).and_return(true)
-    I18n.backend.reload_cache
-  end
-
-  describe "#store_translations" do
-    it "merges given translations to cache" do
-      translation = FactoryGirl.create(:translation, key: "admin.content.save")
-      FactoryGirl.create(:translation_data, translation: translation, localization: "save", lang: "en")
-      FactoryGirl.create(:translation_data, translation: translation, localization: "saglabāt", lang: "lv")
-      I18n.backend.reload_cache
-      allow( I18n.backend ).to receive(:reload_cache?).and_return(false)
-
-      expect{ I18n.backend.store_translations(:en, {admin: {profile: "profils"}}) }.to change{ I18n.t("admin.profile") }.
-        from("Profile").to("profils")
-
-      expect(I18n.t("admin.content.save", locale: "lv")).to eq("saglabāt")
-    end
-  end
-
-  describe "#default" do
-    context "when `create_default: false` option exists" do
-      it "adds `create_default: true` option and remove `create_default` option" do
-        expect(subject).to receive(:resolve).with("en", "aa", "bb", count: 1, fallback: true, create_missing: false)
-        subject.send(:default, "en", "aa", "bb", count:1, default: "xxx", fallback: true, create_default: false, create_missing: false)
-      end
-
-      it "does not change given options" do
-        options = {count:1, default: "xxx", fallback: true, create_default: false}
-        expect{ subject.send(:default, "en", "aa", "bb", options) }.to_not change{ options }
-      end
-    end
-
-    context "when `create_default: false` option does not exists" do
-      it "does not modify options" do
-        expect(subject).to receive(:resolve).with("en", "aa", "bb", count: 1, fallback: true)
-        subject.send(:default, "en", "aa", "bb", count:1, default: "xxx", fallback: true)
-
-        expect(subject).to receive(:resolve).with("en", "aa", "bb", count: 1, fallback: true, create_default: true)
-        subject.send(:default, "en", "aa", "bb", count:1, default: "xxx", fallback: true, create_default: true)
-      end
-    end
-  end
-
-  describe "#create_missing_translation?" do
-    before do
-      Releaf::I18nDatabase.create_missing_translations = true
-    end
-
-    context "when missing translation creation is enabled globally by i18n config and not disabled by `create_missing` option" do
-      it "returns true" do
-        expect(subject.send(:create_missing_translation?, {})).to be true
-        expect(subject.send(:create_missing_translation?, create_missing: true)).to be true
-        expect(subject.send(:create_missing_translation?, create_missing: nil)).to be true
-      end
-    end
-
-    context "when missing translation creation is disabled globally by i18n config" do
-      it "returns false" do
-        allow( Releaf::I18nDatabase ).to receive(:create_missing_translations).and_return(false)
-        expect(subject.send(:create_missing_translation?, {})).to be false
-      end
-    end
-
-    context "when missing translation creation is disabled by `create_missing` option" do
-      it "returns false" do
-        expect(subject.send(:create_missing_translation?, create_missing: false)).to be false
-      end
-    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 "#reload_cache?" do
-    context "when last translation update differs from last cache load" do
-      it "returns true" do
-        allow(described_class).to receive(:translations_updated_at).and_return(1)
-        described_class::CACHE[:updated_at] = 2
-        expect(subject.reload_cache?).to be true
-      end
-    end
-
-    context "when last translation update differs from last cache load" do
-      it "returns false" do
-        allow(described_class).to receive(:translations_updated_at).and_return(1)
-        described_class::CACHE[:updated_at] = 1
-        expect(subject.reload_cache?).to be false
-      end
-    end
-  end
-
-  describe "#reload_cache" do
-    it "resets missing array" do
-      I18n.t("something")
-      expect{ I18n.backend.reload_cache }.to change{ described_class::CACHE[:missing].blank? }.from(false).to(true)
-    end
-
-    it "writes last translations update timestamp to cache" do
-      allow(described_class).to receive(:translations_updated_at).and_return("x")
-      expect{ I18n.backend.reload_cache }.to change{ described_class::CACHE[:updated_at] }.to("x")
-    end
-
-    it "loads all translated data to cache as hash" do
-      translation = FactoryGirl.create(:translation, key: "admin.xx.save")
-      FactoryGirl.create(:translation_data, translation: translation, localization: "saglabāt", lang: "lv")
-      FactoryGirl.create(:translation_data, translation: translation, localization: "save", lang: "en")
-
-      expect{ I18n.backend.reload_cache }.to change{ described_class::CACHE[:translations].blank? }.from(true).to(false)
-
-      expect(described_class::CACHE[:translations][:lv][:admin][:xx][:save]).to eq("saglabāt")
-      expect(described_class::CACHE[:translations][:en][:admin][:xx][:save]).to eq("save")
-    end
-  end
-
-  describe "#lookup" do
-    describe "cache reload" do
-      let(:timestamp){ Time.now }
-
-      context "when cache timestamp differs from translations update timestamp" do
-        it "reloads cache" do
-          described_class::CACHE[:updated_at] = timestamp
-          allow(described_class).to receive(:translations_updated_at).and_return(timestamp + 1.day)
-          expect(I18n.backend).to receive(:reload_cache)
-          I18n.t("cancel")
-        end
-      end
-
-      context "when cache timestamp is same as translations update timestamp" do
-        it "does not reload cache" do
-          allow( I18n.backend ).to receive(:reload_cache?).and_call_original
-          described_class::CACHE[:updated_at] = timestamp
-          allow(described_class).to receive(:translations_updated_at).and_return(timestamp)
-
-          expect(I18n.backend).to_not receive(:reload_cache)
-          I18n.t("cancel")
-        end
-      end
-    end
-
-    context "when translation exists within higher level key (instead of being scope)" do
-      it "returns nil (Humanize key)" do
-        translation = FactoryGirl.create(:translation, key: "some.food")
-        FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "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 = FactoryGirl.create(:translation, key: "dog.other")
-          FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "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 = FactoryGirl.create(:translation, key: "dog.food")
-          FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "suņi")
-          expect(I18n.t("dog", locale: "lv", count: 2)).to eq("Dog")
-        end
-      end
-    end
-
-    context "existing translation" do
-      context "when translation exists with different case" do
-        it "returns existing translation" do
-          translation = FactoryGirl.create(:translation, key: "Save")
-          FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "Saglabāt")
-          I18n.backend.reload_cache
-
-          expect(I18n.t("save", locale: "lv")).to eq("Saglabāt")
-          expect(I18n.t("Save", locale: "lv")).to eq("Saglabāt")
-        end
-      end
-
-      context "when translations hash exists in parent scope" do
-        before do
-          translation = FactoryGirl.create(:translation, key: "dog.other")
-          FactoryGirl.create(:translation_data, translation: translation, lang: "en", localization: "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 translation has default" do
-        context "when default creation is disabled" do
-          it "creates base translation" do
-            expect{ I18n.t("xxx.test.mest", default: :"xxx.mest", create_default: false) }.to change{ Releaf::I18nDatabase::Translation.pluck(:key) }
-              .to(["xxx.test.mest"])
-
-          end
-        end
-
-        context "when default creation is not disabled" do
-          it "creates base and default translations" do
-            expect{ I18n.t("xxx.test.mest", default: :"xxx.mest") }.to change{ Releaf::I18nDatabase::Translation.pluck(:key) }
-              .to(match_array(["xxx.mest", "xxx.test.mest"]))
-          end
-        end
-      end
-
-      context "in parent scope" do
-        context "nonexistent translation in given scope" do
-          it "uses parent scope" do
-            translation = FactoryGirl.create(:translation, key: "validation.admin.blank")
-            FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "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 = FactoryGirl.create(:translation, key: "validation.admin.blank")
-              FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "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
-            parent_translation = FactoryGirl.create(:translation, key: "validation.admin.blank")
-            FactoryGirl.create(:translation_data, translation: parent_translation, lang: "lv", localization: "Tukšs")
-
-            translation = FactoryGirl.create(:translation, key: "validation.admin.roles.blank")
-            FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "")
-
-            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
-            parent_translation = FactoryGirl.create(:translation, key: "validation.admin.blank")
-            FactoryGirl.create(:translation_data, translation: parent_translation, lang: "lv", localization: "Tukšs")
-
-            translation = FactoryGirl.create(:translation, key: "validation.admin.roles.blank")
-            FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "Tukša vērtība")
-
-            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 = FactoryGirl.create(:translation, key: "admin.content.cancel")
-          FactoryGirl.create(:translation_data, translation: translation, lang: "lv", localization: "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::Translation).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::Translation.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::Translation.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::Translation.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::Translation.pluck(:key).sort }.
-                from([]).to(result.sort)
-            end
-          end
-        end
-      end
-    end
-
-    context "when scope requested" do
-      it "returns all scope translations" do
-        translation1 = FactoryGirl.create(:translation, key: "admin.content.cancel")
-        FactoryGirl.create(:translation_data, translation: translation1, lang: "lv", localization: "Atlikt")
-        translation2 = FactoryGirl.create(:translation, key: "admin.content.save")
-        FactoryGirl.create(:translation_data, translation: translation2, lang: "lv", localization: "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/lib/i18n_database/translations_importer_spec.rb

@@ -1,17 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::TranslationsImporter do
-  describe "#initialize" do
-    context "when unsupported extension given" do
-      it "raises Releaf::TranslationsImporter::UnsupportedFileFormatError" do
-        expect{described_class.new("xx", "xx")}.to raise_error(described_class::UnsupportedFileFormatError)
-      end
-    end
-
-    context "when error raised from Roo" do
-      it "raises it" do
-        expect{described_class.new("xx", "xls")}.to raise_error(IOError)
-      end
-    end
-  end
-end

data/spec/models/i18n_database/translation_data_spec.rb

@@ -1,13 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::TranslationData do
-
-  it { is_expected.to validate_presence_of(:translation) }
-  it { is_expected.to validate_presence_of(:lang) }
-  it { is_expected.to validate_length_of(:lang).is_at_most(5) }
-  it {
-    FactoryGirl.create(:translation_data)
-    is_expected.to validate_uniqueness_of(:translation_id).scoped_to([:lang])
-  }
-  it { is_expected.to belong_to(:translation) }
-end

data/spec/models/i18n_database/translation_spec.rb

@@ -1,49 +0,0 @@
-require "rails_helper"
-
-describe Releaf::I18nDatabase::Translation do
-
-  it { is_expected.to validate_presence_of(:key) }
-  it { is_expected.to validate_length_of(:key).is_at_most(255) }
-  it do
-    FactoryGirl.create(:translation)
-    is_expected.to validate_uniqueness_of(:key)
-  end
-  it { is_expected.to have_many(:translation_data).dependent(:destroy) }
-  it { is_expected.to accept_nested_attributes_for(:translation_data).allow_destroy(true) }
-
-
-  before do
-    allow(Releaf.application.config).to receive(:available_locales) { ["de", "en"] }
-    allow(Releaf.application.config).to receive(:available_admin_locales) { ["lv"] }
-
-    @translation = FactoryGirl.create(:translation, :key => 'test.apple')
-    FactoryGirl.create(:translation_data, :localization => 'apple', :translation => @translation, :lang => "en")
-    FactoryGirl.create(:translation_data, :localization => 'apfel', :translation => @translation, :lang => "de")
-
-    I18n.backend.reload_cache
-  end
-
-  describe "translation" do
-    it "has relation to translation data" do
-      expect(@translation.translation_data.size).to eq(2)
-    end
-
-    it "destroys translation data when destroying translation itself" do
-      expect{ @translation.destroy }.to change{ Releaf::I18nDatabase::TranslationData.all.count }.from(2).to(0)
-    end
-  end
-
-  describe "#locale_value" do
-    it "returns translated value for given locale" do
-      expect(@translation.locale_value("en")).to eq("apple")
-      expect(@translation.locale_value("de")).to eq("apfel")
-      expect(@translation.locale_value("lt")).to eq(nil)
-    end
-
-    it "caches translated values with first call" do
-      expect(@translation.locale_value("en")).to eq("apple")
-      Releaf::I18nDatabase::TranslationData.destroy_all
-      expect(@translation.locale_value("de")).to eq("apfel")
-    end
-  end
-end