bidu-core_ext 1.0.0

data/spec/support/shared_examples/clean.rb

@@ -0,0 +1,143 @@
+shared_examples 'a hash clean method' do |method|
+  context 'when hash has one level' do
+    let(:subject) do
+      { a: 1, b: nil, c: '', d: {} }
+    end
+
+    let(:expected) do
+      { a: 1 }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has two levels' do
+    let(:subject) do
+      { a: 1, c: '', d: { e: 1 }, f: { g: { b: nil } } }
+    end
+
+    let(:expected) do
+      { a: 1, d: { e: 1 } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has many levels' do
+    let(:subject) do
+      { a: 1, d: { e: { k: { l: { m: { n: 1 } } } } }, f: { g: { h: { i: { j: { c: '' } } } } } }
+    end
+
+    let(:expected) do
+      { a: 1, d: { e: { k: { l: { m: { n: 1 } } } } } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has one nil value and one valid value' do
+    let(:subject) do
+      { a: { b: 1, c: nil } }
+    end
+
+    let(:expected) do
+      { a: { b: 1 } }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays' do
+    let(:subject) do
+      { a: [] }
+    end
+
+    let(:expected) do
+      {}
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes' do
+    let(:subject) do
+      { a: [{ c: nil }] }
+    end
+
+    let(:expected) do
+      {}
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes with valid values' do
+    let(:subject) do
+      { a: [{ c: 1 }] }
+    end
+
+    let(:expected) do
+      { a: [{ c: 1 }] }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when hash has arrays with hashes with valid and invalid values' do
+    let(:subject) do
+      { a: [{ c: nil }, { d: 1 }] }
+    end
+
+    let(:expected) do
+      { a: [{ d: 1 }] }
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+end
+
+shared_examples 'an array clean method' do |method|
+  context 'when array has one level' do
+    let(:subject) do
+      [1, nil, '', {}, []]
+    end
+
+    let(:expected) do
+      [1]
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+
+  context 'when array has many levels' do
+    let(:subject) do
+      [1, nil, '', {}, [[[{ a: [[[[[[[]]]]]]] }]]], [[[[[[[2]]]]]]], [{ a: [2] }]]
+    end
+
+    let(:expected) do
+      [1, [[[[[[[2]]]]]]], [{ a: [2] }]]
+    end
+
+    it 'cleans the hash from empty and nil values' do
+      expect(subject.send(method)).to eq(expected)
+    end
+  end
+end

data/spec/support/shared_examples/hash_keys_changer.rb

@@ -0,0 +1,92 @@
+shared_examples 'a class with change_key method' do
+  let(:hash) do
+    { 'a' => 1, b: 2, c: { d: 3, e: 4 }, f: [{ g: 5 }, { h: 6 }] }
+  end
+
+  describe :change_keys do
+
+    it_behaves_like 'a method that is able to change keys', :change_keys
+    it 'does not affects the original hash' do
+      expect do
+        hash.change_keys(recursive: true) { |k| "foo_#{k}" }
+      end.not_to change { hash }
+    end
+  end
+
+  describe :change_keys! do
+    it_behaves_like 'a method that is able to change keys', :change_keys!
+
+    it 'affects the original hash' do
+      expect do
+        hash.change_keys!(recursive: true) { |k| "foo_#{k}" }
+      end.to change { hash }
+    end
+  end
+end
+
+shared_examples 'result is as expected' do
+  it 'is as expected' do
+    expect(result).to eq(expected)
+  end
+end
+
+shared_examples 'a method that is able to change keys' do |method|
+  let(:foo_sym_transformation) do
+    hash.public_send(method) { |k| "foo_#{k}".to_sym }
+  end
+
+  context 'with simple level hash' do
+    let(:hash) { { 'a' => 1, b: 2 } }
+
+    context 'with string transformation' do
+      let(:result) do
+        hash.public_send(method) { |k| "foo_#{k}" }
+      end
+      let(:expected) { { 'foo_a' => 1, 'foo_b' => 2 } }
+      it_behaves_like 'result is as expected'
+    end
+
+    context 'with symbol transformation' do
+      let(:result) { foo_sym_transformation }
+      let(:expected) { { foo_a: 1, foo_b: 2 } }
+      it_behaves_like 'result is as expected'
+    end
+  end
+
+  context 'with recursive hash' do
+    let(:hash) { { 'a' => 1, b:  { c: 3, 'd' => 4 } } }
+    let(:result) { hash.public_send(method, options) { |k| "foo_#{k}" } }
+    let(:expected) do
+      { 'foo_a' => 1, 'foo_b' =>  { 'foo_c' => 3, 'foo_d' => 4 } }
+    end
+
+    context 'when no options are given' do
+      let(:options) { {} }
+      it_behaves_like 'result is as expected'
+    end
+
+    context 'when options are given' do
+      let(:options) { { recursive: recursive } }
+
+      context 'with recursion' do
+        let(:recursive) { true }
+        it_behaves_like 'result is as expected'
+      end
+
+      context 'without recursion' do
+        let(:recursive) { false }
+        let(:expected) { { 'foo_a' => 1, 'foo_b' =>  { c: 3, 'd' => 4 } } }
+        it_behaves_like 'result is as expected'
+      end
+    end
+  end
+
+  context 'with many many levels' do
+    let(:hash) { { a: 1, b: { c: 2, d: { e: 3, f: 4 } } } }
+    let(:expected) do
+      { foo_a: 1, foo_b: { foo_c: 2, foo_d: { foo_e: 3, foo_f: 4 } } }
+    end
+    let(:result) { foo_sym_transformation }
+    it_behaves_like 'result is as expected'
+  end
+end

data/spec/support/shared_examples/keys_appender.rb

@@ -0,0 +1,43 @@
+shared_examples 'a class with append_keys method' do
+  describe :prepend_to_keys do
+    it 'accepts block to change the keys' do
+      expect({ a: 1, 'b' => 2 }.prepend_to_keys('foo_')).to eq(foo_a: 1, 'foo_b' => 2)
+    end
+    it 'applies the block recursively' do
+      expect({ 'a' => 1, b:  { c: 3, 'd' => 4 } }.prepend_to_keys('foo_')).to eq('foo_a' => 1, foo_b:  { foo_c: 3, 'foo_d' => 4 })
+    end
+    it 'changes type when type option is passed' do
+      expect({ 'a' => 1, b: 2 }.prepend_to_keys('foo_', type: :string)).to eq('foo_a' => 1, 'foo_b' => 2)
+    end
+    it 'changes type when type option is passed' do
+      expect({ 'a' => 1, b: 2 }.prepend_to_keys('foo_', type: :symbol)).to eq(foo_a: 1, foo_b: 2)
+    end
+    it 'keep type when type option is passed as keep' do
+      expect({ 'a' => 1, b: 2 }.prepend_to_keys('foo_', type: :keep)).to eq('foo_a' => 1, foo_b: 2)
+    end
+    it 'applies to array as well' do
+      expect({ 'a' => 1, b: [{ c: 2 }, { d: 3 }] }.prepend_to_keys('foo_', type: :keep)).to eq('foo_a' => 1, foo_b: [{ foo_c: 2 }, { foo_d: 3 }])
+    end
+  end
+
+  describe :append_to_keys do
+    it 'accepts block to change the keys' do
+      expect({ a: 1, 'b' => 2 }.append_to_keys('_bar')).to eq(a_bar: 1, 'b_bar' => 2)
+    end
+    it 'applies the block recursively' do
+      expect({ 'a' => 1, b:  { c: 3, 'd' => 4 } }.append_to_keys('_bar')).to eq('a_bar' => 1, b_bar:  { c_bar: 3, 'd_bar' => 4 })
+    end
+    it 'changes type when type option is passed' do
+      expect({ 'a' => 1, b: 2 }.append_to_keys('_bar', type: :string)).to eq('a_bar' => 1, 'b_bar' => 2)
+    end
+    it 'changes type when type option is passed' do
+      expect({ 'a' => 1, b: 2 }.append_to_keys('_bar', type: :symbol)).to eq(a_bar: 1, b_bar: 2)
+    end
+    it 'keep type when type option is passed as keep' do
+      expect({ 'a' => 1, b: 2 }.append_to_keys('_bar', type: :keep)).to eq('a_bar' => 1, b_bar: 2)
+    end
+    it 'applies to array as well' do
+      expect({ 'a' => 1, b: [{ c: 2 }, { d: 3 }] }.append_to_keys('_bar', type: :keep)).to eq('a_bar' => 1, b_bar: [{ c_bar: 2 }, { d_bar: 3 }])
+    end
+  end
+end

data/spec/support/shared_examples/keys_camelizer.rb

@@ -0,0 +1,285 @@
+shared_examples 'a class with camlize_keys method' do
+  describe :lower_camelize_keys do
+    let(:expected) { { inputKey: 'value' } }
+
+    context 'with underscore keys' do
+      let(:hash) { { input_key: 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+
+      it 'does not change original hash' do
+        expect { hash.lower_camelize_keys }.not_to change { hash }
+      end
+    end
+
+    context 'with camel case keys' do
+      let(:hash) { { InputKey: 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with string keys' do
+      let(:expected) { { 'inputKey' => 'value' } }
+      let(:hash) { { 'InputKey' => 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with deep keys change' do
+      let(:expected) { { inputKey: { innerKey: 'value' } } }
+      let(:hash) { { InputKey: { InnerKey: 'value' } } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with array keys change' do
+      let(:expected) { { inputKey: [{ innerKey: 'value' }] } }
+      let(:hash) { { InputKey: [{ InnerKey: 'value' }] } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'without recursive options' do
+      context 'with deep keys change' do
+        let(:expected) { { inputKey: { InnerKey: 'value' } } }
+        let(:hash) { { InputKey: { InnerKey: 'value' } } }
+
+        it 'converts the keys to lower camel case' do
+          expect(hash.lower_camelize_keys(recursive: false)).to eq(expected)
+        end
+      end
+
+      context 'with array keys change' do
+        let(:expected) { { inputKey: [{ InnerKey: 'value' }] } }
+        let(:hash) { { InputKey: [{ InnerKey: 'value' }] } }
+
+        it 'converts the keys to camle case' do
+          expect(hash.lower_camelize_keys(recursive: false)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe :lower_camelize_keys! do
+    let(:expected) { { inputKey: 'value' } }
+
+    context 'with underscore keys' do
+      let(:hash) { { input_key: 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys!).to eq(expected)
+      end
+
+      it 'does not change original hash' do
+        expect { hash.lower_camelize_keys! }.to change { hash }
+      end
+    end
+
+    context 'with camel case keys' do
+      let(:hash) { { InputKey: 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'with string keys' do
+      let(:expected) { { 'inputKey' => 'value' } }
+      let(:hash) { { 'InputKey' => 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with deep keys change' do
+      let(:expected) { { inputKey: { innerKey: 'value' } } }
+      let(:hash) { { InputKey: { InnerKey: 'value' } } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.lower_camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'with array keys change' do
+      let(:expected) { { inputKey: [{ innerKey: 'value' }] } }
+      let(:hash) { { InputKey: [{ InnerKey: 'value' }] } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.lower_camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'without recursive options' do
+      context 'with deep keys change' do
+        let(:expected) { { inputKey: { InnerKey: 'value' } } }
+        let(:hash) { { InputKey: { InnerKey: 'value' } } }
+
+        it 'converts the keys to lower camel case' do
+          expect(hash.lower_camelize_keys!(recursive: false)).to eq(expected)
+        end
+      end
+
+      context 'with array keys change' do
+        let(:expected) { { inputKey: [{ InnerKey: 'value' }] } }
+        let(:hash) { { InputKey: [{ InnerKey: 'value' }] } }
+
+        it 'converts the keys to camle case' do
+          expect(hash.lower_camelize_keys!(recursive: false)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe :camelize_keys do
+    let(:expected) { { InputKey: 'value' } }
+
+    context 'with underscore keys' do
+      let(:hash) { { input_key: 'value' } }
+
+      it 'converts the keys to camel case' do
+        expect(hash.camelize_keys).to eq(expected)
+      end
+
+      it 'does not change original hash' do
+        expect { hash.camelize_keys }.not_to change { hash }
+      end
+    end
+
+    context 'with lower camel case keys' do
+      let(:hash) { { inputKey: 'value' } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with string keys' do
+      let(:expected) { { 'InputKey' => 'value' } }
+      let(:hash) { { 'inputKey' => 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with deep keys change' do
+      let(:expected) { { InputKey: { InnerKey: 'value' } } }
+      let(:hash) { { inputKey: { innerKey: 'value' } } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'with array keys change' do
+      let(:expected) { { InputKey: [{ InnerKey: 'value' }] } }
+      let(:hash) { { inputKey: [{ innerKey: 'value' }] } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys).to eq(expected)
+      end
+    end
+
+    context 'without recursive options' do
+      context 'with deep keys change' do
+        let(:expected) { { InputKey: { InnerKey: 'value' } } }
+        let(:hash) { { inputKey: { InnerKey: 'value' } } }
+
+        it 'converts the keys to lower camel case' do
+          expect(hash.camelize_keys(recursive: false)).to eq(expected)
+        end
+      end
+
+      context 'with array keys change' do
+        let(:expected) { { InputKey: [{ InnerKey: 'value' }] } }
+        let(:hash) { { inputKey: [{ InnerKey: 'value' }] } }
+
+        it 'converts the keys to camle case' do
+          expect(hash.camelize_keys(recursive: false)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe :camelize_keys! do
+    let(:expected) { { InputKey: 'value' } }
+
+    context 'with underscore keys' do
+      let(:hash) { { input_key: 'value' } }
+
+      it 'converts the keys to camel case' do
+        expect(hash.camelize_keys!).to eq(expected)
+      end
+
+      it 'does not change original hash' do
+        expect { hash.camelize_keys! }.to change { hash }
+      end
+    end
+
+    context 'with lower camel case keys' do
+      let(:hash) { { inputKey: 'value' } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'with string keys' do
+      let(:expected) { { 'InputKey' => 'value' } }
+      let(:hash) { { 'inputKey' => 'value' } }
+
+      it 'converts the keys to lower camel case' do
+        expect(hash.camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'with deep keys change' do
+      let(:expected) { { InputKey: { InnerKey: 'value' } } }
+      let(:hash) { { inputKey: { innerKey: 'value' } } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'with array keys change' do
+      let(:expected) { { InputKey: [{ InnerKey: 'value' }] } }
+      let(:hash) { { inputKey: [{ innerKey: 'value' }] } }
+
+      it 'converts the keys to camle case' do
+        expect(hash.camelize_keys!).to eq(expected)
+      end
+    end
+
+    context 'without recursive options' do
+      context 'with deep keys change' do
+        let(:expected) { { InputKey: { InnerKey: 'value' } } }
+        let(:hash) { { inputKey: { InnerKey: 'value' } } }
+
+        it 'converts the keys to lower camel case' do
+          expect(hash.camelize_keys!(recursive: false)).to eq(expected)
+        end
+      end
+
+      context 'with array keys change' do
+        let(:hash) { { inputKey: [{ InnerKey: 'value' }] } }
+        let(:expected) { { InputKey: [{ InnerKey: 'value' }] } }
+
+        it 'converts the keys to camle case' do
+          expect(hash.camelize_keys!(recursive: false)).to eq(expected)
+        end
+      end
+    end
+  end
+end