castle-rb 5.0.0 → 6.0.0

data/lib/castle/review.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Castle
-  class Review
-    def self.retrieve(review_id)
-      Castle::API.request(
-        Castle::Commands::Review.build(review_id)
-      )
-    end
-  end
-end

data/lib/castle/utils.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Castle
-  module Utils
-    class << self
-      # Returns a new hash with all keys converted to symbols, as long as
-      # they respond to +to_sym+. This includes the keys from the root hash
-      # and from all nested hashes and arrays.
-      #
-      #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
-      #
-      #   Castle::Hash.deep_symbolize_keys(hash)
-      #   # => {:person=>{:name=>"Rob", :age=>"28"}}
-      def deep_symbolize_keys(object, &block)
-        case object
-        when Hash
-          object.each_with_object({}) do |(key, value), result|
-            result[key.to_sym] = deep_symbolize_keys(value, &block)
-          end
-        when Array
-          object.map { |e| deep_symbolize_keys(e, &block) }
-        else
-          object
-        end
-      end
-
-      def deep_symbolize_keys!(object, &block)
-        case object
-        when Hash
-          object.keys.each do |key|
-            value = object.delete(key)
-            object[key.to_sym] = deep_symbolize_keys!(value, &block)
-          end
-          object
-        when Array
-          object.map! { |e| deep_symbolize_keys!(e, &block) }
-        else
-          object
-        end
-      end
-
-      def replace_invalid_characters(arg)
-        if arg.is_a?(::String)
-          arg.encode('UTF-8', invalid: :replace, undef: :replace)
-        elsif arg.is_a?(::Hash)
-          arg.each_with_object({}) { |(k, v), h| h[k] = replace_invalid_characters(v) }
-        elsif arg.is_a?(::Array)
-          arg.map(&method(:replace_invalid_characters))
-        else
-          arg
-        end
-      end
-    end
-  end
-end

data/lib/castle/utils/cloner.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Castle
-  module Utils
-    class Cloner
-      def self.call(object)
-        Marshal.load(Marshal.dump(object))
-      end
-    end
-  end
-end

data/lib/castle/utils/timestamp.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Castle
-  module Utils
-    # generates proper timestamp
-    class Timestamp
-      def self.call
-        Time.now.utc.iso8601(3)
-      end
-    end
-  end
-end

data/spec/lib/castle/headers_formatter_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::HeadersFormatter do
-  subject(:formatter) { described_class }
-
-  it 'removes HTTP_' do
-    expect(formatter.call('HTTP_X_TEST')).to be_eql('X-Test')
-  end
-
-  it 'capitalizes header' do
-    expect(formatter.call('X_TEST')).to be_eql('X-Test')
-  end
-
-  it 'ignores letter case and -_ divider' do
-    expect(formatter.call('http-X_teST')).to be_eql('X-Test')
-  end
-
-  it 'does not remove http if there is no _- char' do
-    expect(formatter.call('httpX_teST')).to be_eql('Httpx-Test')
-  end
-
-  it 'capitalizes' do
-    expect(formatter.call(:clearance)).to be_eql('Clearance')
-  end
-end

data/spec/lib/castle/utils_spec.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-describe Castle::Utils do
-  let(:nested_strings) { { 'a' => { 'b' => { 'c' => 3 } } } }
-  let(:nested_symbols) { { a: { b: { c: 3 } } } }
-  let(:nested_mixed) { { 'a' => { b: { 'c' => 3 } } } }
-  let(:string_array_of_hashes) { { 'a' => [{ 'b' => 2 }, { 'c' => 3 }, 4] } }
-  let(:symbol_array_of_hashes) { { a: [{ b: 2 }, { c: 3 }, 4] } }
-  let(:mixed_array_of_hashes) { { a: [{ b: 2 }, { 'c' => 3 }, 4] } }
-
-  describe '#deep_symbolize_keys' do
-    subject { described_class.deep_symbolize_keys(hash) }
-
-    context 'when nested_symbols' do
-      let(:hash) { nested_symbols }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_strings' do
-      let(:hash) { nested_strings }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_mixed' do
-      let(:hash) { nested_mixed }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when string_array_of_hashes' do
-      let(:hash) { string_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when symbol_array_of_hashes' do
-      let(:hash) { symbol_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when mixed_array_of_hashes' do
-      let(:hash) { mixed_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-  end
-
-  describe '#cloner' do
-    subject { described_class.deep_symbolize_keys!(Castle::Utils::Cloner.call(hash)) }
-
-    context 'when nested_symbols' do
-      let(:hash) { nested_symbols }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_strings' do
-      let(:hash) { nested_strings }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when nested_mixed' do
-      let(:hash) { nested_mixed }
-
-      it { is_expected.to eq(nested_symbols) }
-    end
-
-    context 'when string_array_of_hashes' do
-      let(:hash) { string_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when symbol_array_of_hashes' do
-      let(:hash) { symbol_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-
-    context 'when mixed_array_of_hashes' do
-      let(:hash) { mixed_array_of_hashes }
-
-      it { is_expected.to eq(symbol_array_of_hashes) }
-    end
-  end
-
-  describe '::replace_invalid_characters' do
-    subject { described_class.replace_invalid_characters(input) }
-
-    context 'when input is a string' do
-      let(:input) { '1234' }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is an array' do
-      let(:input) { [1, 2, 3, '4'] }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is a hash' do
-      let(:input) { { user_id: 1 } }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is nil' do
-      let(:input) { nil }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'when input is a nested hash' do
-      let(:input) { { user: { id: 1 } } }
-
-      it { is_expected.to eq input }
-    end
-
-    context 'with invalid UTF-8 characters' do
-      context 'when input is a hash' do
-        let(:input) { { user_id: "inv\xC4lid" } }
-
-        it { is_expected.to eq(user_id: 'inv�lid') }
-      end
-
-      context 'when input is a nested hash' do
-        let(:input) { { user: { id: "inv\xC4lid" } } }
-
-        it { is_expected.to eq(user: { id: 'inv�lid' }) }
-      end
-
-      context 'when input is an array of hashes' do
-        let(:input) { [{ user: "inv\xC4lid" }] * 2 }
-
-        it { is_expected.to eq([{ user: 'inv�lid' }, { user: 'inv�lid' }]) }
-      end
-
-      context 'when input is an array' do
-        let(:input) { ["inv\xC4lid"] * 2 }
-
-        it { is_expected.to eq(['inv�lid', 'inv�lid']) }
-      end
-
-      context 'when input is a hash with array in key' do
-        let(:input) { { items: ["inv\xC4lid"] * 2 } }
-
-        it { is_expected.to eq(items: ['inv�lid', 'inv�lid']) }
-      end
-    end
-  end
-end