i18n-js 3.9.2 → 4.0.0.alpha3

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

@@ -1,84 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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
-
-    context "when translation entries contain procs" do
-      let(:translations) do
-        {
-          en: {
-            "test" => "Test",
-            "i18n" => {"plural" => {"rule" => proc {} }},
-          },
-          fr: {
-            "test" => "Test2",
-            "i18n" => {"plural" => {"rule" => proc {} }},
-          },
-        }
-      end
-
-      it "should write files without procs or their string representations" 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('{"i18n":{"plural":{}},"test":"Test"}'));
-MyNamespace.translations["fr"] = I18n.extend((MyNamespace.translations["fr"] || {}), JSON.parse('{"i18n":{"plural":{}},"test":"Test2"}'));
-        EOF
-      end
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-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
-
-  describe ".deep_remove_procs" do
-    let(:proc_obj) { proc {} }
-    let(:hash_with_proc) do
-      {
-        :a => :b,
-        :c => proc_obj,
-        :d => {
-          :e => proc_obj,
-          :f => :g,
-        }
-      }
-    end
-    subject { described_class.deep_remove_procs(hash_with_proc) }
-
-    it "performs a deep keys sort without changing the original hash" do
-      should eql({
-        :a => :b,
-        :d => {
-          :f => :g,
-        }
-      })
-      expect(hash_with_proc).to eql({
-        :a => :b,
-        :c => proc_obj,
-        :d => {
-          :e => proc_obj,
-          :f => :g,
-        }
-      })
-    end
-  end
-end