i18n-js 2.1.2 → 3.0.11

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

@@ -0,0 +1,157 @@
+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(:js_extend)  { nil }
+  let(:sort_translation_keys){ nil }
+  let(:options)     { { namespace: namespace,
+                        pretty_print: pretty_print,
+                        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
+      subject.file.should eql("tmp/i18n-js/segment.js")
+    end
+
+    it "should persist the translations variable" do
+      subject.translations.should eql(translations)
+    end
+
+    it "should persist the namespace variable" do
+      subject.namespace.should eql("MyNamespace")
+    end
+
+    context "when namespace is nil" do
+      let(:namespace){ nil }
+
+      it "should default namespace to `I18n`" do
+        subject.namespace.should 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
+        subject.namespace.should eql("I18n")
+      end
+    end
+
+    context "when pretty_print is nil" do
+      it "should set pretty_print to false" do
+        subject.pretty_print.should be false
+      end
+    end
+
+    context "when pretty_print is truthy" do
+      let(:pretty_print){ 1 }
+
+      it "should set pretty_print to true" do
+        subject.pretty_print.should be true
+      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"
+
+        File.open(File.join(temp_path, "segment.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), {"test":"Test"});
+MyNamespace.translations["fr"] = I18n.extend((MyNamespace.translations["fr"] || {}), {"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"
+
+        File.open(File.join(temp_path, "en.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), {"test":"Test"});
+        EOF
+
+        File.open(File.join(temp_path, "fr.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["fr"] = I18n.extend((MyNamespace.translations["fr"] || {}), {"test":"Test2"});
+        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"
+
+        File.open(File.join(temp_path, "segment.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), {"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"
+
+        File.open(File.join(temp_path, "segment.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = {"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"
+
+        File.open(File.join(temp_path, "segment.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), {"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"
+
+        File.open(File.join(temp_path, "segment.js")){|f| f.read}.should eql <<-EOF
+MyNamespace.translations || (MyNamespace.translations = {});
+MyNamespace.translations["en"] = I18n.extend((MyNamespace.translations["en"] || {}), {"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}})
+
+      result[:a].should 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}})
+
+      target[:a].should 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 }
+
+      result.should 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 }
+
+      result.should 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 }
+
+      result.should eql({:a => {:c => 2}})
+      hash.should 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}})
+      unsorted_hash.should 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
+      described_class.scopes_match?([:a, :b], [:a, :b, :c]).should_not eql true
+      described_class.scopes_match?([:a, :b, :c], [:a, :b, :c]).should eql true
+      described_class.scopes_match?([:a, :b, :c], [:a, :b, :d]).should_not eql true
+    end
+
+    it "performs a comparison of wildcard scopes" do
+      described_class.scopes_match?([:a, '*'], [:a, :b, :c]).should_not eql true
+      described_class.scopes_match?([:a, '*', :c], [:a, :b, :c]).should eql true
+      described_class.scopes_match?([:a, :b, :c], [:a, '*', :c]).should eql true
+      described_class.scopes_match?([:a, :b, :c], [:a, '*', '*']).should eql true
+    end
+  end
+end