hashie 3.6.0 → 5.0.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
-        <<-CONFIG
----
-foo: verbatim
-bar: <%= "erb" %>
-baz: "<%= __FILE__ %>"
-        CONFIG
-      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,328 +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: %i[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
-
-  context 'when copying properties from other properties' do
-    it 'retains the original and also sets the copy' do
-      simple = Class.new(Hashie::Trash) do
-        property :id
-        property :copy_of_id, from: :id
-      end
-
-      subject = simple.new(id: 1)
-
-      expect(subject.id).to eq(1)
-      expect(subject.copy_of_id).to eq(1)
-    end
-
-    it 'grabs the default for the original if it is not set' do
-      with_default = Class.new(Hashie::Trash) do
-        property :id, default: 0
-        property :copy_of_id, from: :id
-      end
-
-      subject = with_default.new
-
-      expect(subject.id).to eq(0)
-      expect(subject.copy_of_id).to eq(0)
-    end
-
-    it 'can be a required value' do
-      with_required = Class.new(Hashie::Trash) do
-        property :id
-        property :copy_of_id, from: :id, required: true, message: 'must be set'
-      end
-
-      expect { with_required.new }.to raise_error(ArgumentError, "The property 'copy_of_id' must be set")
-    end
-
-    it 'does not set properties that do not exist' do
-      from_non_property = Class.new(Hashie::Trash) do
-        property :copy_of_value, from: :value
-      end
-
-      subject = from_non_property.new(value: 0)
-
-      expect(subject).not_to respond_to(:value)
-      expect { subject[:value] }.to raise_error(NoMethodError, "The property 'value' is not defined for .")
-      expect(subject.to_h[:value]).to eq(nil)
-      expect(subject.copy_of_value).to eq(0)
-    end
-
-    it 'is not order-dependent in definition' do
-      simple = Class.new(Hashie::Trash) do
-        property :copy_of_id, from: :id
-        property :id
-      end
-
-      subject = simple.new(id: 1)
-
-      expect(subject.id).to eq(1)
-      expect(subject.copy_of_id).to eq(1)
-    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

data/spec/integration/elasticsearch/integration_spec.rb

@@ -1,40 +0,0 @@
-require 'elasticsearch/model'
-require 'hashie'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expect|
-    expect.syntax = :expect
-  end
-end
-
-class MyModel < Hashie::Mash
-  include Elasticsearch::Model
-
-  disable_warnings
-
-  index_name 'model'
-  document_type 'model'
-end
-
-RSpec.describe 'elaasticsearch-model' do
-  # See https://github.com/intridea/hashie/issues/354#issuecomment-363306114
-  # for the reason why this doesn't work as you would expect
-  it 'raises an error when the model does has an id' do
-    object = MyModel.new
-    stub_elasticsearch_client
-
-    expect { object.__elasticsearch__.index_document }.to raise_error(NoMethodError)
-  end
-
-  it 'does not raise an error when the model has an id' do
-    object = MyModel.new(id: 123)
-    stub_elasticsearch_client
-
-    expect { object.__elasticsearch__.index_document }.not_to raise_error
-  end
-
-  def stub_elasticsearch_client
-    response = double('Response', body: '{}')
-    allow_any_instance_of(Elasticsearch::Transport::Client).to receive(:perform_request) { response }
-  end
-end

data/spec/integration/omniauth/app.rb

@@ -1,11 +0,0 @@
-require 'sinatra'
-require 'omniauth'
-
-class MyApplication < Sinatra::Base
-  use Rack::Session::Cookie, secret: 'hashie integration tests'
-  use OmniAuth::Strategies::Developer
-
-  get '/' do
-    'Hello World'
-  end
-end

data/spec/integration/omniauth/integration_spec.rb

@@ -1,38 +0,0 @@
-ENV['RACK_ENV'] = 'test'
-
-require 'rspec/core'
-require 'rack/test'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expect|
-    expect.syntax = :expect
-  end
-end
-
-RSpec.describe 'omniauth' do
-  include Rack::Test::Methods
-
-  def app
-    MyApplication
-  end
-
-  let(:stdout) { StringIO.new }
-
-  around(:each) do |example|
-    original_stdout = $stdout
-    $stdout = stdout
-    require_relative 'app'
-    example.run
-    $stdout = original_stdout
-  end
-
-  it 'does not log anything to STDOUT when initializing' do
-    expect(stdout.string).to eq('')
-  end
-
-  it 'works' do
-    get '/'
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq 'Hello World'
-  end
-end

data/spec/integration/omniauth-oauth2/app.rb

@@ -1,52 +0,0 @@
-require 'action_controller/railtie'
-require 'action_view/railtie'
-require 'action_view/testing/resolvers'
-require 'rails/test_unit/railtie'
-require_relative 'some_site'
-
-module RailsApp
-  class Application < ::Rails::Application
-    config.eager_load      = false
-    config.secret_key_base = 'hashieintegrationtest'
-
-    config.middleware.use OmniAuth::Builder do
-      provider :some_site
-    end
-
-    routes.append do
-      get '/' => 'application#index'
-    end
-  end
-end
-
-LAYOUT = <<-HTML.freeze
-<!DOCTYPE html>
-<html>
-<head>
-  <title>TestApp</title>
-  <%= csrf_meta_tags %>
-</head>
-<body>
-<%= yield %>
-</body>
-</html>
-HTML
-
-INDEX = '<h1>Hello, world!</h1>'.freeze
-
-class ApplicationController < ActionController::Base
-  include Rails.application.routes.url_helpers
-
-  layout 'application'
-
-  self.view_paths = [ActionView::FixtureResolver.new(
-    'layouts/application.html.erb' => LAYOUT,
-    'application/index.html.erb'   => INDEX
-  )]
-
-  def index; end
-end
-
-Bundler.require(:default, Rails.env)
-
-RailsApp::Application.initialize!

data/spec/integration/omniauth-oauth2/integration_spec.rb

@@ -1,26 +0,0 @@
-ENV['RAILS_ENV'] = 'test'
-
-require 'rspec/core'
-
-RSpec.describe 'omniauth-oauth2 inside of rails', type: :request do
-  let(:stdout) { StringIO.new }
-
-  around(:each) do |example|
-    original_stdout = $stdout
-    $stdout = stdout
-    require_relative 'app'
-    require 'rspec/rails'
-    example.run
-    $stdout = original_stdout
-  end
-
-  it 'does not log anything to STDOUT when initializing a Rails app and is set to Rails logger' do
-    expect(stdout.string).to eq('')
-    expect(Hashie.logger).to eq(Rails.logger)
-  end
-
-  it 'works' do
-    get '/'
-    assert_select 'h1', 'Hello, world!'
-  end
-end