i18n-js 2.1.2 → 3.8.3

data/spec/js/utility_functions.spec.js

@@ -0,0 +1,20 @@
+var I18n = require("../../app/assets/javascripts/i18n");
+
+describe("Utility Functions", function(){
+  beforeEach(function(){
+    I18n.reset();
+  });
+
+  describe("I18n.lookup", function() {
+    it("does not change locale on failed lookup", function(){
+      var fallback_locales = ['fallback1', 'fallback2'];
+
+      I18n.locales['lang'] = fallback_locales.slice();
+      expect(I18n.locales.lang).toEqual(fallback_locales);
+
+      I18n.lookup('anything', {locale: 'lang'})
+      expect(I18n.locales.lang).toEqual(fallback_locales);
+    });
+
+  })
+});

data/spec/ruby/i18n/js/fallback_locales_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe I18n::JS::FallbackLocales do
+  let(:locale) { :fr }
+  let(:default_locale) { :en }
+
+  describe "#locales" do
+    let(:fallbacks_locales) { described_class.new(fallbacks, locale) }
+    subject { fallbacks_locales.locales }
+
+    let(:fetching_locales) { proc do fallbacks_locales.locales end }
+
+    context "when given true as fallbacks" do
+      let(:fallbacks) { true }
+      it { should eq([default_locale]) }
+    end
+
+    context "when given false as fallbacks" do
+      let(:fallbacks) { false }
+      it { expect(fetching_locales).to raise_error(ArgumentError) }
+    end
+
+    context "when given a valid locale as fallbacks" do
+      let(:fallbacks) { :de }
+      it { should eq([:de]) }
+    end
+
+    context "when given a valid Array as fallbacks" do
+      let(:fallbacks) { [:de, :en] }
+      it { should eq([:de, :en]) }
+    end
+
+    context "when given a valid Hash with current locale as key as fallbacks" do
+      let(:fallbacks) do { :fr => [:de, :en] } end
+      it { should eq([:de, :en]) }
+    end
+
+    context "when given a valid Hash without current locale as key as fallbacks" do
+      let(:fallbacks) do { :de => [:fr, :en] } end
+      it { should eq([default_locale]) }
+    end
+
+    context "when given a invalid locale as fallbacks" do
+      let(:fallbacks) { :invalid_locale }
+      it { should eq([:invalid_locale]) }
+    end
+
+    context "when given a invalid type as fallbacks" do
+      let(:fallbacks) { 42 }
+      it { expect(fetching_locales).to raise_error(ArgumentError) }
+    end
+
+    # I18n::Backend::Fallbacks
+    context "when I18n::Backend::Fallbacks is used" do
+      let(:backend_with_fallbacks) { backend_class_with_fallbacks.new }
+
+      before do
+        I18n::JS.backend = backend_with_fallbacks
+        I18n.fallbacks[:fr] = [:de, :en]
+      end
+      after { I18n::JS.backend = I18n::Backend::Simple.new }
+
+      context "given true as fallbacks" do
+        let(:fallbacks) { true }
+        it { should eq([:de, :en]) }
+      end
+
+      context "given :default_locale as fallbacks" do
+        let(:fallbacks) { :default_locale }
+        it { should eq([:en]) }
+      end
+
+      context "given a Hash with current locale as fallbacks" do
+        let(:fallbacks) do { :fr => [:en] } end
+        it { should eq([:en]) }
+      end
+
+      context "given a Hash without current locale as fallbacks" do
+        let(:fallbacks) do { :de => [:en] } end
+        it { should eq([:de, :en]) }
+      end
+    end
+  end
+end

data/spec/ruby/i18n/js/segment_spec.rb

@@ -0,0 +1,261 @@
+require "spec_helper"
+
+describe I18n::JS::Segment do
+
+  let(:file)        { "tmp/i18n-js/segment.js" }
+  let(:translations){ { en: { "test" => "Test" }, fr: { "test" => "Test2" } } }
+  let(:namespace)   { "MyNamespace" }
+  let(:pretty_print){ nil }
+  let(:json_only)  { nil }
+  let(:js_extend)  { nil }
+  let(:sort_translation_keys){ nil }
+  let(:options)     { { namespace: namespace,
+                        pretty_print: pretty_print,
+                        json_only: json_only,
+                        js_extend: js_extend,
+                        sort_translation_keys: sort_translation_keys }.delete_if{|k,v| v.nil?} }
+  subject { I18n::JS::Segment.new(file, translations, options) }
+
+  describe ".new" do
+
+    it "should persist the file path variable" do
+      expect(subject.file).to eql("tmp/i18n-js/segment.js")
+    end
+
+    it "should persist the translations variable" do
+      expect(subject.translations).to eql(translations)
+    end
+
+    it "should persist the namespace variable" do
+      expect(subject.namespace).to eql("MyNamespace")
+    end
+
+    context "when namespace is nil" do
+      let(:namespace){ nil }
+
+      it "should default namespace to `I18n`" do
+        expect(subject.namespace).to eql("I18n")
+      end
+    end
+
+    context "when namespace is not set" do
+      subject { I18n::JS::Segment.new(file, translations) }
+
+      it "should default namespace to `I18n`" do
+        expect(subject.namespace).to eql("I18n")
+      end
+    end
+
+    context "when pretty_print is nil" do
+      it "should set pretty_print to false" do
+        expect(subject.pretty_print).to be false
+      end
+    end
+
+    context "when pretty_print is truthy" do
+      let(:pretty_print){ 1 }
+
+      it "should set pretty_print to true" do
+        expect(subject.pretty_print).to be true
+      end
+    end
+  end
+
+  describe "#saving!" do
+    before { allow(I18n::JS).to receive(:export_i18n_js_dir_path).and_return(temp_path) }
+
+    context "when json_only is true with locale" do
+      let(:file){ "tmp/i18n-js/%{locale}.js" }
+      let(:json_only){ true }
+
+      it 'should output JSON files per locale' do
+        subject.save!
+        file_should_exist "en.js"
+        file_should_exist "fr.js"
+
+        expect(File.read(File.join(temp_path, "en.js"))).to eql(
+          %Q({"en":{"test":"Test"}})
+        )
+
+        expect(File.read(File.join(temp_path, "fr.js"))).to eql(
+          %Q({"fr":{"test":"Test2"}})
+        )
+      end
+    end
+
+    context "when json_only is true without locale" do
+      let(:file){ "tmp/i18n-js/segment.js" }
+      let(:json_only){ true }
+
+      it 'should output one JSON file for all locales' do
+        subject.save!
+        file_should_exist "segment.js"
+
+        expect(File.read(File.join(temp_path, "segment.js"))).to eql(
+          %Q({"en":{"test":"Test"},"fr":{"test":"Test2"}})
+        )
+      end
+    end
+
+    context "when json_only and pretty print are true" do
+      let(:file){ "tmp/i18n-js/segment.js" }
+      let(:json_only){ true }
+      let(:pretty_print){ true }
+
+      it 'should output one JSON file for all locales' do
+        subject.save!
+        file_should_exist "segment.js"
+
+        expect(File.read(File.join(temp_path, "segment.js"))).to eql <<-EOS
+{
+  "en": {
+    "test": "Test"
+  },
+  "fr": {
+    "test": "Test2"
+  }
+}
+EOS
+.chomp
+      end
+    end
+  end
+
+  describe "#save!" do
+    before { allow(I18n::JS).to receive(:export_i18n_js_dir_path).and_return(temp_path) }
+    before { subject.save! }
+
+    context "when file does not include %{locale}" do
+      it "should write the file" do
+        file_should_exist "segment.js"
+
+        expect(File.open(File.join(temp_path, "segment.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"test":"Test"}'));
+MyNamespace.translations["fr"] = I18n.extend((MyNamespace.translations["fr"] || {}), JSON.parse('{"test":"Test2"}'));
+        EOF
+      end
+    end
+
+    context "when file includes %{locale}" do
+      let(:file){ "tmp/i18n-js/%{locale}.js" }
+
+      it "should write files" do
+        file_should_exist "en.js"
+        file_should_exist "fr.js"
+
+        expect(File.open(File.join(temp_path, "en.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"test":"Test"}'));
+        EOF
+
+        expect(File.open(File.join(temp_path, "fr.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["fr"] = I18n.extend((MyNamespace.translations["fr"] || {}), JSON.parse('{"test":"Test2"}'));
+        EOF
+      end
+    end
+
+    context "when file includes single quote" do
+      let(:file){ "tmp/i18n-js/%{locale}.js" }
+      let(:translations){ { en: { "a" => "Test's" } } }
+
+      it "should write files" do
+        file_should_exist "en.js"
+
+        expect(File.open(File.join(temp_path, "en.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"a":"Test\\'s"}'));
+        EOF
+      end
+    end
+
+    context "when file includes escaped double quote" do
+      let(:file){ "tmp/i18n-js/%{locale}.js" }
+      let(:translations){ { en: { "a" => 'say "hello"' } } }
+
+      it "should escape double quote" do
+        file_should_exist "en.js"
+
+        expect(File.open(File.join(temp_path, "en.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"a":"say \\\\"hello\\\\""}'));
+        EOF
+      end
+    end
+
+    context "when file includes backslash in double quote" do
+      let(:file){ "tmp/i18n-js/%{locale}.js" }
+      let(:translations){ { en: { "double-backslash-in-double-quote" => '"\\\\"' } } }
+
+      it "should escape backslash" do
+        file_should_exist "en.js"
+
+        expect(File.open(File.join(temp_path, "en.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"double-backslash-in-double-quote":"\\\\"\\\\\\\\\\\\\\\\\\\\""}'));
+        EOF
+      end
+    end
+
+    context "when js_extend is true" do
+      let(:js_extend){ true }
+
+      let(:translations){ { en: { "b" => "Test", "a" => "Test" } } }
+
+      it 'should output the keys as sorted' do
+        file_should_exist "segment.js"
+
+        expect(File.open(File.join(temp_path, "segment.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"a":"Test","b":"Test"}'));
+        EOF
+      end
+    end
+
+    context "when js_extend is false" do
+      let(:js_extend){ false }
+
+      let(:translations){ { en: { "b" => "Test", "a" => "Test" } } }
+
+      it 'should output the keys as sorted' do
+        file_should_exist "segment.js"
+
+        expect(File.open(File.join(temp_path, "segment.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = JSON.parse('{"a":"Test","b":"Test"}');
+        EOF
+      end
+    end
+
+    context "when sort_translation_keys is true" do
+      let(:sort_translation_keys){ true }
+
+      let(:translations){ { en: { "b" => "Test", "a" => "Test" } } }
+
+      it 'should output the keys as sorted' do
+        file_should_exist "segment.js"
+
+        expect(File.open(File.join(temp_path, "segment.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"a":"Test","b":"Test"}'));
+        EOF
+      end
+    end
+
+    context "when sort_translation_keys is false" do
+      let(:sort_translation_keys){ false }
+
+      let(:translations){ { en: { "b" => "Test", "a" => "Test" } } }
+
+      it 'should output the keys as sorted' do
+        file_should_exist "segment.js"
+
+        expect(File.open(File.join(temp_path, "segment.js")){|f| f.read}).to eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), JSON.parse('{"b":"Test","a":"Test"}'));
+        EOF
+      end
+    end
+  end
+end

data/spec/ruby/i18n/js/utils_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe I18n::JS::Utils do
+
+  describe ".strip_keys_with_nil_values" do
+    subject { described_class.strip_keys_with_nil_values(input_hash) }
+
+    context 'when input_hash does NOT contain nil value' do
+      let(:input_hash) { {a: 1, b: { c: 2 }} }
+      let(:expected_hash) { input_hash }
+
+      it 'returns the original input' do
+        is_expected.to eq expected_hash
+      end
+    end
+    context 'when input_hash does contain nil value' do
+      let(:input_hash) { {a: 1, b: { c: 2, d: nil }, e: { f: nil }} }
+      let(:expected_hash) { {a: 1, b: { c: 2 }, e: {}} }
+
+      it 'returns the original input with nil values removed' do
+        is_expected.to eq expected_hash
+      end
+    end
+  end
+
+  context "hash merging" do
+    it "performs a deep merge" do
+      target = {:a => {:b => 1}}
+      result = described_class.deep_merge(target, {:a => {:c => 2}})
+
+      expect(result[:a]).to eql({:b => 1, :c => 2})
+    end
+
+    it "performs a banged deep merge" do
+      target = {:a => {:b => 1}}
+      described_class.deep_merge!(target, {:a => {:c => 2}})
+
+      expect(target[:a]).to eql({:b => 1, :c => 2})
+    end
+  end
+
+  describe ".deep_reject" do
+    it "performs a deep keys rejection" do
+      hash = {:a => {:b => 1}}
+
+      result = described_class.deep_reject(hash) { |k, v| k == :b }
+
+      expect(result).to eql({:a => {}})
+    end
+
+    it "performs a deep keys rejection prunning the whole tree if necessary" do
+      hash = {:a => {:b => {:c => {:d => 1, :e => 2}}}}
+
+      result = described_class.deep_reject(hash) { |k, v| k == :b }
+
+      expect(result).to eql({:a => {}})
+    end
+
+
+    it "performs a deep keys rejection without changing the original hash" do
+      hash = {:a => {:b => 1, :c => 2}}
+
+      result = described_class.deep_reject(hash) { |k, v| k == :b }
+
+      expect(result).to eql({:a => {:c => 2}})
+      expect(hash).to eql({:a => {:b => 1, :c => 2}})
+    end
+  end
+
+  describe ".deep_key_sort" do
+    let(:unsorted_hash) { {:z => {:b => 1, :a => 2}, :y => 3} }
+    subject(:sorting) { described_class.deep_key_sort(unsorted_hash) }
+
+    it "performs a deep keys sort without changing the original hash" do
+      should eql({:y => 3, :z => {:a => 2, :b => 1}})
+      expect(unsorted_hash).to eql({:z => {:b => 1, :a => 2}, :y => 3})
+    end
+
+    # Idea from gem `rails_admin`
+    context "when hash contain non-Symbol as key" do
+      let(:unsorted_hash) { {:z => {1 => 1, true => 2}, :y => 3} }
+
+      it "performs a deep keys sort without error" do
+        expect{ sorting }.to_not raise_error
+      end
+      it "converts keys to symbols" do
+        should eql({:y => 3, :z => {1 => 1, true => 2}})
+      end
+    end
+  end
+
+  describe ".scopes_match?" do
+    it "performs a comparison of literal scopes" do
+      expect(described_class.scopes_match?([:a, :b], [:a, :b, :c])).to_not eql true
+      expect(described_class.scopes_match?([:a, :b, :c], [:a, :b, :c])).to eql true
+      expect(described_class.scopes_match?([:a, :b, :c], [:a, :b, :d])).to_not eql true
+    end
+
+    it "performs a comparison of wildcard scopes" do
+      expect(described_class.scopes_match?([:a, '*'], [:a, :b, :c])).to_not eql true
+      expect(described_class.scopes_match?([:a, '*', :c], [:a, :b, :c])).to eql true
+      expect(described_class.scopes_match?([:a, :b, :c], [:a, '*', :c])).to eql true
+      expect(described_class.scopes_match?([:a, :b, :c], [:a, '*', '*'])).to eql true
+    end
+  end
+end