hashie 3.5.7 → 4.1.0

data/spec/hashie/parsers/yaml_erb_parser_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Parsers::YamlErbParser do
-  describe '.perform' do
-    context 'a file' do
-      let(:config) do
-        <<-EOF
----
-foo: verbatim
-bar: <%= "erb" %>
-baz: "<%= __FILE__ %>"
-        EOF
-      end
-      let(:path) { 'template.yml' }
-
-      subject { described_class.new(path).perform }
-
-      before do
-        expect(File).to receive(:read).with(path).and_return(config)
-      end
-
-      it { is_expected.to be_a(Hash) }
-
-      it 'parses YAML after interpolating ERB' do
-        expect(subject['foo']).to eq 'verbatim'
-        expect(subject['bar']).to eq 'erb'
-        expect(subject['baz']).to eq path
-      end
-    end
-
-    context 'Pathname' do
-      let(:tempfile) do
-        file = Tempfile.new(['foo', '.yml'])
-        file.write("---\nfoo: hello\n")
-        file.rewind
-        file
-      end
-
-      subject { described_class.new(Pathname tempfile.path) }
-
-      it '"#perform" can be done in case of path is a Pathname object.' do
-        expect(subject.perform).to eq 'foo' => 'hello'
-      end
-    end
-  end
-end

data/spec/hashie/rash_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Rash do
-  subject do
-    Hashie::Rash.new(
-      /hello/ => 'hello',
-      /world/ => 'world',
-      'other' => 'whee',
-      true    => false,
-      1       => 'awesome',
-      1..1000 => 'rangey',
-      /(bcd)/ => proc { |m| m[1] }
-    # /.+/ => "EVERYTHING"
-    )
-  end
-
-  it 'finds strings' do
-    expect(subject['other']).to eq 'whee'
-    expect(subject['well hello there']).to eq 'hello'
-    expect(subject['the world is round']).to eq 'world'
-    expect(subject.all('hello world').sort).to eq %w(hello world)
-  end
-
-  it 'finds regexps' do
-    expect(subject[/other/]).to eq 'whee'
-  end
-
-  it 'finds other objects' do
-    expect(subject[true]).to eq false
-    expect(subject[1]).to eq 'awesome'
-  end
-
-  it 'finds numbers from ranges' do
-    expect(subject[250]).to eq 'rangey'
-    expect(subject[999]).to eq 'rangey'
-    expect(subject[1000]).to eq 'rangey'
-    expect(subject[1001]).to be_nil
-  end
-
-  it 'finds floats from ranges' do
-    expect(subject[10.1]).to eq 'rangey'
-    expect(subject[1.0]).to eq 'rangey'
-    expect(subject[1000.1]).to be_nil
-  end
-
-  it 'evaluates proc values' do
-    expect(subject['abcdef']).to eq 'bcd'
-    expect(subject['ffffff']).to be_nil
-  end
-
-  it 'finds using the find method' do
-    expect(subject.fetch(10.1)).to eq 'rangey'
-    expect(subject.fetch(true)).to be false
-  end
-
-  it 'raises in find unless a key matches' do
-    expect { subject.fetch(1_000_000) }.to raise_error(KeyError)
-  end
-
-  it 'yields in find unless a key matches' do
-    expect { |y| subject.fetch(1_000_000, &y) }.to yield_control
-    expect { |y| subject.fetch(10.1, &y) }.to_not yield_control
-  end
-
-  it 'gives a default value' do
-    expect(subject.fetch(10.1, 'noop')).to eq 'rangey'
-    expect(subject.fetch(1_000_000, 'noop')).to eq 'noop'
-    expect(subject.fetch(1_000_000) { 'noop' }).to eq 'noop'
-    expect(subject.fetch(1_000_000) { |k| k }).to eq 1_000_000
-    expect(subject.fetch(1_000_000, 'noop') { 'op' }).to eq 'op'
-  end
-
-  it 'responds to hash methods' do
-    expect(subject.respond_to?(:to_a)).to be true
-    expect(subject.methods).to_not include(:to_a)
-  end
-
-  it 'does not lose keys' do
-    subject.optimize_every = 1
-    expect(subject['hello']).to eq('hello')
-    expect(subject['world']).to eq('world')
-  end
-end

data/spec/hashie/trash_spec.rb

@@ -1,268 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Trash do
-  class TrashTest < Hashie::Trash
-    property :first_name, from: :firstName
-  end
-
-  let(:trash) { TrashTest.new }
-
-  describe 'translating properties' do
-    it 'adds the property to the list' do
-      expect(TrashTest.properties).to include(:first_name)
-    end
-
-    it 'creates a method for reading the property' do
-      expect(trash).to respond_to(:first_name)
-    end
-
-    it 'creates a method for writing the property' do
-      expect(trash).to respond_to(:first_name=)
-    end
-
-    it 'creates a method for writing the translated property' do
-      expect(trash).to respond_to(:firstName=)
-    end
-
-    it 'does not create a method for reading the translated property' do
-      expect(trash).not_to respond_to(:firstName)
-    end
-
-    it 'maintains translations hash mapping from the original to the translated name' do
-      expect(TrashTest.translations[:firstName]).to eq(:first_name)
-    end
-
-    it 'maintains inverse translations hash mapping from the translated to the original name' do
-      expect(TrashTest.inverse_translations[:first_name]).to eq :firstName
-    end
-
-    it '#permitted_input_keys contain the :from key of properties with translations' do
-      expect(TrashTest.permitted_input_keys).to include :firstName
-    end
-  end
-
-  describe 'standard properties' do
-    class TrashTestPermitted < Hashie::Trash
-      property :id
-    end
-
-    it '#permitted_input_keys contain names of properties without translations' do
-      expect(TrashTestPermitted.permitted_input_keys).to include :id
-    end
-  end
-
-  describe 'writing to properties' do
-    it 'does not write to a non-existent property using []=' do
-      expect { trash['abc'] = 123 }.to raise_error(NoMethodError)
-    end
-
-    it 'writes to an existing property using []=' do
-      expect { trash[:first_name] = 'Bob' }.not_to raise_error
-      expect(trash.first_name).to eq('Bob')
-      expect { trash['first_name'] = 'John' }.to raise_error(NoMethodError)
-    end
-
-    it 'writes to a translated property using []=' do
-      expect { trash[:firstName] = 'Bob' }.not_to raise_error
-      expect { trash['firstName'] = 'Bob' }.to raise_error(NoMethodError)
-    end
-
-    it 'reads/writes to an existing property using a method call' do
-      trash.first_name = 'Franklin'
-      expect(trash.first_name).to eq 'Franklin'
-    end
-
-    it 'writes to an translated property using a method call' do
-      trash.firstName = 'Franklin'
-      expect(trash.first_name).to eq 'Franklin'
-    end
-
-    it 'writes to a translated property using #replace' do
-      trash.replace(firstName: 'Franklin')
-      expect(trash.first_name).to eq 'Franklin'
-    end
-
-    it 'writes to a non-translated property using #replace' do
-      trash.replace(first_name: 'Franklin')
-      expect(trash.first_name).to eq 'Franklin'
-    end
-  end
-
-  describe ' initializing with a Hash' do
-    it 'does not initialize non-existent properties' do
-      expect { TrashTest.new(bork: 'abc') }.to raise_error(NoMethodError)
-    end
-
-    it 'sets the desired properties' do
-      expect(TrashTest.new(first_name: 'Michael').first_name).to eq 'Michael'
-    end
-
-    context 'with both the translated property and the property' do
-      it 'sets the desired properties' do
-        expect(TrashTest.new(first_name: 'Michael', firstName: 'Maeve').first_name).to eq 'Michael'
-      end
-    end
-
-    it 'sets the translated properties' do
-      expect(TrashTest.new(firstName: 'Michael').first_name).to eq 'Michael'
-    end
-  end
-
-  describe 'translating properties using a proc' do
-    class TrashLambdaTest < Hashie::Trash
-      property :first_name, from: :firstName, with: ->(value) { value.reverse }
-    end
-
-    let(:lambda_trash) { TrashLambdaTest.new }
-
-    it 'translates the value given on initialization with the given lambda' do
-      expect(TrashLambdaTest.new(firstName: 'Michael').first_name).to eq 'Michael'.reverse
-    end
-
-    it 'does not translate the value if given with the right property' do
-      expect(TrashTest.new(first_name: 'Michael').first_name).to eq 'Michael'
-    end
-
-    it 'translates the value given as property with the given lambda' do
-      lambda_trash.firstName = 'Michael'
-      expect(lambda_trash.first_name).to eq 'Michael'.reverse
-    end
-
-    it 'does not translate the value given as right property' do
-      lambda_trash.first_name = 'Michael'
-      expect(lambda_trash.first_name).to eq 'Michael'
-    end
-  end
-
-  describe 'translating multiple properties using a proc' do
-    class SomeDataModel < Hashie::Trash
-      property :value_a, from: :config, with: ->(config) { config.a }
-      property :value_b, from: :config, with: ->(config) { config.b }
-    end
-
-    ConfigDataModel = Struct.new(:a, :b)
-
-    subject { SomeDataModel.new(config: ConfigDataModel.new('value in a', 'value in b')) }
-
-    it 'translates the first key' do
-      expect(subject.value_a).to eq 'value in a'
-    end
-
-    it 'translates the second key' do
-      expect(subject.value_b).to eq 'value in b'
-    end
-
-    it 'maintains translations hash mapping from the original to the translated name' do
-      expect(SomeDataModel.translations).to eq(config: [:value_a, :value_b])
-    end
-  end
-
-  describe 'uses with or transform_with interchangeably' do
-    class TrashLambdaTestTransformWith < Hashie::Trash
-      property :first_name, from: :firstName, transform_with: ->(value) { value.reverse }
-    end
-
-    let(:lambda_trash) { TrashLambdaTestTransformWith.new }
-
-    it 'translates the value given as property with the given lambda' do
-      lambda_trash.firstName = 'Michael'
-      expect(lambda_trash.first_name).to eq 'Michael'.reverse
-    end
-
-    it 'does not translate the value given as right property' do
-      lambda_trash.first_name = 'Michael'
-      expect(lambda_trash.first_name).to eq 'Michael'
-    end
-  end
-
-  describe 'translating properties without from option using a proc' do
-    class TrashLambdaTestWithProperties < Hashie::Trash
-      property :first_name, transform_with: ->(value) { value.reverse }
-    end
-
-    let(:lambda_trash) { TrashLambdaTestWithProperties.new }
-
-    it 'translates the value given as property with the given lambda' do
-      lambda_trash.first_name = 'Michael'
-      expect(lambda_trash.first_name).to eq 'Michael'.reverse
-    end
-
-    it 'transforms the value when given in constructor' do
-      expect(TrashLambdaTestWithProperties.new(first_name: 'Michael').first_name).to eq 'Michael'.reverse
-    end
-
-    context 'when :from option is given' do
-      class TrashLambdaTest3 < Hashie::Trash
-        property :first_name, from: :firstName, transform_with: ->(value) { value.reverse }
-      end
-
-      it 'does not override the :from option in the constructor' do
-        expect(TrashLambdaTest3.new(first_name: 'Michael').first_name).to eq 'Michael'
-      end
-
-      it 'does not override the :from option when given as property' do
-        t = TrashLambdaTest3.new
-        t.first_name = 'Michael'
-        expect(t.first_name).to eq 'Michael'
-      end
-    end
-  end
-
-  describe 'inheritable transforms' do
-    class TransformA < Hashie::Trash
-      property :some_value, transform_with: ->(v) { v.to_i }
-    end
-
-    class TransformB < TransformA
-      property :some_other_value, transform_with: ->(v) { v.to_i }
-    end
-
-    class TransformC < TransformB
-      property :some_value, transform_with: ->(v) { -v.to_i }
-    end
-
-    it 'inherit properties transforms' do
-      expect(TransformB.new(some_value: '123', some_other_value: '456').some_value).to eq(123)
-    end
-
-    it 'replaces property transform' do
-      expect(TransformC.new(some_value: '123', some_other_value: '456').some_value).to eq(-123)
-    end
-  end
-
-  describe 'inheritable translations' do
-    class TranslationA < Hashie::Trash
-      property :some_value, from: 'someValue', with: ->(v) { v.to_i }
-    end
-
-    class TranslationB < TranslationA
-      property :some_other_value, from: 'someOtherValue'
-    end
-
-    it 'inherit properties translations' do
-      expect(TranslationB.new('someValue' => '123').some_value).to eq(123)
-    end
-  end
-
-  it 'raises an error when :from have the same value as property' do
-    expect do
-      class WrongTrash < Hashie::Trash
-        property :first_name, from: :first_name
-      end
-    end.to raise_error(ArgumentError)
-  end
-
-  context 'when subclassing' do
-    class Person < Hashie::Trash
-      property :first_name, from: :firstName
-    end
-
-    class Hobbit < Person; end
-
-    subject { Hobbit.new(firstName: 'Frodo') }
-
-    it 'keeps translation definitions in subclasses' do
-      expect(subject.first_name).to eq('Frodo')
-    end
-  end
-end

data/spec/hashie/utils_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-def a_method_to_match_against
-  'Hello world!'
-end
-
-RSpec.describe Hashie::Utils do
-  describe '.method_information' do
-    it 'states the module or class that a native method was defined in' do
-      bound_method = method(:trust)
-
-      message = Hashie::Utils.method_information(bound_method)
-
-      expect(message).to match('Kernel')
-    end
-
-    it 'states the line a Ruby method was defined at' do
-      bound_method = method(:a_method_to_match_against)
-
-      message = Hashie::Utils.method_information(bound_method)
-
-      expect(message).to match('spec/hashie/utils_spec.rb')
-    end
-  end
-end

data/spec/hashie/version_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Hashie do
-  it 'has a version' do
-    expect(Hashie::VERSION).not_to be_nil
-  end
-end

data/spec/hashie_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hashie do
-  describe '.logger' do
-    include_context 'with a logger'
-
-    it 'is available via an accessor' do
-      Hashie.logger.info('Fee fi fo fum')
-
-      expect(logger_output).to match('Fee fi fo fum')
-    end
-  end
-end