env_parser 1.6.2 → 1.7.1

data/lib/env_parser.rb

@@ -339,9 +339,7 @@ class EnvParser
     def register_all(list)
       raise(ArgumentError, "invalid 'list' parameter type: #{list.class}") unless list.is_a? Hash
 
-      list.to_a.each_with_object({}) do |tuple, output|
-        output[tuple.first] = register(tuple.first, tuple.second)
-      end
+      list.to_h { |name, options| [name, register(name, options)] }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: env_parser
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.7.1
 platform: ruby
 authors:
 - Nestor Custodio
@@ -63,14 +63,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -188,11 +188,6 @@ files:
 - lib/env_parser/types/chronology_types.rb
 - lib/env_parser/types/internet_types.rb
 - lib/env_parser/version.rb
-- spec/env_parser/types/base_types_spec.rb
-- spec/env_parser/types/chronology_types_spec.rb
-- spec/env_parser/types/internet_types_spec.rb
-- spec/env_parser_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/nestor-custodio/env_parser
 licenses:
 - MIT
@@ -203,7 +198,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '3'
 required_rubygems_version: !ruby/object:Gem::Requirement

data/spec/env_parser/types/base_types_spec.rb

@@ -1,98 +0,0 @@
-RSpec.describe EnvParser::Types::BaseTypes do
-  it 'can parse strings' do
-    expect(EnvParser.parse(nil, as: :string)).to eq('')
-    expect(EnvParser.parse('', as: :string)).to eq('')
-
-    expect(EnvParser.parse('value', as: :string)).to eq('value')
-  end
-
-  it 'can parse symbols' do
-    expect(EnvParser.parse(nil, as: :symbol)).to eq(:'')
-    expect(EnvParser.parse('', as: :symbol)).to eq(:'')
-
-    expect(EnvParser.parse('value', as: :symbol)).to eq(:value)
-  end
-
-  it 'can parse booleans' do
-    expect(EnvParser.parse(nil, as: :boolean)).to eq(false)
-    expect(EnvParser.parse('', as: :boolean)).to eq(false)
-
-    expect(EnvParser.parse('0', as: :boolean)).to eq(false)
-    expect(EnvParser.parse('f', as: :boolean)).to eq(false)
-    expect(EnvParser.parse('false', as: :boolean)).to eq(false)
-
-    expect(EnvParser.parse('1', as: :boolean)).to eq(true)
-    expect(EnvParser.parse('t', as: :boolean)).to eq(true)
-    expect(EnvParser.parse('true', as: :boolean)).to eq(true)
-  end
-
-  it 'can parse integers' do
-    %i[int integer].each do |type|
-      expect(EnvParser.parse(nil, as: type)).to eq(0)
-      expect(EnvParser.parse('', as: type)).to eq(0)
-
-      expect(EnvParser.parse('-1.9', as: type)).to eq(-1)
-      expect(EnvParser.parse('-1.1', as: type)).to eq(-1)
-      expect(EnvParser.parse('-1', as: type)).to eq(-1)
-      expect(EnvParser.parse('0', as: type)).to eq(0)
-      expect(EnvParser.parse('1', as: type)).to eq(1)
-      expect(EnvParser.parse('1.1', as: type)).to eq(1)
-      expect(EnvParser.parse('1.9', as: type)).to eq(1)
-
-      expect(EnvParser.parse('non-numeric', as: type)).to eq(0)
-    end
-  end
-
-  it 'can parse floats' do
-    %i[float decimal number].each do |type|
-      expect(EnvParser.parse(nil, as: type)).to eq(0.0)
-      expect(EnvParser.parse('', as: type)).to eq(0.0)
-
-      expect(EnvParser.parse('-1.9', as: type)).to eq(-1.9)
-      expect(EnvParser.parse('-1.1', as: type)).to eq(-1.1)
-      expect(EnvParser.parse('-1', as: type)).to eq(-1.0)
-      expect(EnvParser.parse('0', as: type)).to eq(0.0)
-      expect(EnvParser.parse('1', as: type)).to eq(1.0)
-      expect(EnvParser.parse('1.1', as: type)).to eq(1.1)
-      expect(EnvParser.parse('1.9', as: type)).to eq(1.9)
-
-      expect(EnvParser.parse('non-numeric', as: type)).to eq(0.0)
-    end
-  end
-
-  it 'can parse json' do
-    expect(EnvParser.parse(nil, as: :json)).to eq(nil)
-    expect(EnvParser.parse('', as: :json)).to eq(nil)
-
-    expect { EnvParser.parse('non-json-parseable string', as: :json) }.to raise_error(JSON::ParserError)
-
-    expect(EnvParser.parse('null', as: :json)).to eq(nil)
-    expect(EnvParser.parse('true', as: :json)).to eq(true)
-    expect(EnvParser.parse('false', as: :json)).to eq(false)
-    expect(EnvParser.parse('1', as: :json)).to eq(1)
-    expect(EnvParser.parse('1.1', as: :json)).to eq(1.1)
-    expect(EnvParser.parse('"some string"', as: :json)).to eq('some string')
-    expect(EnvParser.parse('["one", 2, "three"]', as: :json)).to eq(['one', 2, 'three'])
-    expect(EnvParser.parse('{ "one": 1, "two": 2, "three": "three" }', as: :json)).to eq('one' => 1, 'two' => 2, 'three' => 'three')
-  end
-
-  it 'can parse arrays' do
-    expect(EnvParser.parse(nil, as: :array)).to eq([])
-    expect(EnvParser.parse('', as: :array)).to eq([])
-
-    expect { EnvParser.parse('non-json-parseable string', as: :array) }.to raise_error(JSON::ParserError)
-    expect { EnvParser.parse('"parseable json, but not an array"', as: :array) }.to raise_error(EnvParser::ValueNotConvertibleError)
-
-    expect(EnvParser.parse('["one", 2, "three"]', as: :array)).to eq(['one', 2, 'three'])
-  end
-
-  it 'can parse hashes' do
-    expect(EnvParser.parse(nil, as: :hash)).to eq({})
-    expect(EnvParser.parse('', as: :hash)).to eq({})
-
-    expect { EnvParser.parse('non-json-parseable string', as: :hash) }.to raise_error(JSON::ParserError)
-    expect { EnvParser.parse('"parseable json, but not a hash"', as: :hash) }.to raise_error(EnvParser::ValueNotConvertibleError)
-
-    expect(EnvParser.parse('{ "one": 1, "two": 2, "three": "three" }', as: :hash)).to eq('one' => 1, 'two' => 2, 'three' => 'three')
-  end
-end

data/spec/env_parser/types/chronology_types_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe EnvParser::Types::ChronologyTypes do
-  it 'can parse dates' do
-    expect(EnvParser.parse(nil, as: :date)).to eq(nil)
-    expect(EnvParser.parse('', as: :date)).to eq(nil)
-
-    expect(EnvParser.parse('11/05/1955 06:00', as: :date)).to eq(Date.new(1955, 11, 5))
-    expect(EnvParser.parse('11/12/1955 22:04', as: :date)).to eq(Date.new(1955, 11, 12))
-    expect(EnvParser.parse('1885-09-02 08:00', as: :date)).to eq(Date.new(1885, 9, 2))
-    expect(EnvParser.parse('1885-09-07', as: :date)).to eq(Date.new(1885, 9, 7))
-
-    expect(EnvParser.parse('tomorrow', as: :date)).to eq(Date.today + 1.day)
-
-    expect { EnvParser.parse('not a date', as: :date) }.to raise_error(EnvParser::ValueNotConvertibleError)
-    expect { EnvParser.parse('2018-02-29', as: :date) }.to raise_error(EnvParser::ValueNotConvertibleError)
-  end
-
-  it 'can parse times' do
-    %i[time datetime].each do |type|
-      expect(EnvParser.parse(nil, as: type)).to eq(nil)
-      expect(EnvParser.parse('', as: type)).to eq(nil)
-
-      expect(EnvParser.parse('11/05/1955 06:00', as: type)).to eq(Time.new(1955, 11, 5, 6, 0))
-      expect(EnvParser.parse('11/12/1955 22:04', as: type)).to eq(Time.new(1955, 11, 12, 22, 4))
-      expect(EnvParser.parse('1885-09-02 08:00', as: type)).to eq(Time.new(1885, 9, 2, 8, 0))
-      expect(EnvParser.parse('1885-09-07', as: type)).to eq(Time.new(1885, 9, 7))
-
-      expect(EnvParser.parse('today at 07:15', as: type)).to eq(Date.today + 7.hours + 15.minutes)
-
-      expect { EnvParser.parse('not a date/time', as: type) }.to raise_error(EnvParser::ValueNotConvertibleError)
-      expect { EnvParser.parse('today at 33:25', as: type) }.to raise_error(EnvParser::ValueNotConvertibleError)
-    end
-  end
-
-  it 'can parse durations' do
-    expect(EnvParser.parse(nil, as: :duration)).to eq(nil)
-    expect(EnvParser.parse('', as: :duration)).to eq(nil)
-
-    expect(EnvParser.parse('12 seconds', as: :duration)).to eq(12)
-    expect(EnvParser.parse('5 minutes', as: :duration)).to eq(5 * 60)
-    expect(EnvParser.parse('24 hours', as: :duration)).to eq(24 * 60 * 60)
-    expect(EnvParser.parse('1.5 days', as: :duration)).to eq(1.5 * 24 * 60 * 60)
-    expect(EnvParser.parse('1 day', as: :duration)).to eq(24 * 60 * 60)
-    expect(EnvParser.parse('2 weeks, 1 day', as: :duration)).to eq((2 * 7 * 24 * 60 * 60) + (24 * 60 * 60))
-    expect(EnvParser.parse('P2W1DT3H', as: :duration)).to eq((2 * 7 * 24 * 60 * 60) + (24 * 60 * 60) + (3 * 60 * 60))
-
-    expect { EnvParser.parse('not a duration', as: :duration) }.to raise_error(EnvParser::ValueNotConvertibleError)
-    expect { EnvParser.parse('37 dinglebops', as: :duration) }.to raise_error(EnvParser::ValueNotConvertibleError)
-  end
-end

data/spec/env_parser/types/internet_types_spec.rb

@@ -1,95 +0,0 @@
-RSpec.describe EnvParser::Types::InternetTypes do
-  it 'can parse ipv4 addresses' do
-    expect(EnvParser.parse(nil, as: :ipv4_address)).to eq(nil)
-    expect(EnvParser.parse('', as: :ipv4_address)).to eq(nil)
-
-    expect(EnvParser.parse('localhost', as: :ipv4_address)).to eq('127.0.0.1')
-    expect(EnvParser.parse('192.168.000.001', as: :ipv4_address)).to eq('192.168.0.1')
-
-    expect { EnvParser.parse('not an ip address', as: :ipv4_address) }.to raise_error(EnvParser::ValueNotConvertibleError)
-  end
-
-  it 'can parse ipv6 addresses' do
-    expect(EnvParser.parse(nil, as: :ipv6_address)).to eq(nil)
-    expect(EnvParser.parse('', as: :ipv6_address)).to eq(nil)
-
-    expect(EnvParser.parse('::', as: :ipv6_address)).to eq('::')
-    expect(EnvParser.parse('::1', as: :ipv6_address)).to eq('::1')
-    expect(EnvParser.parse('abcd::abcd:abcd', as: :ipv6_address)).to eq('abcd::abcd:abcd')
-
-    expect { EnvParser.parse('not an ip address', as: :ipv6_address) }.to raise_error(EnvParser::ValueNotConvertibleError)
-  end
-
-  it 'can parse network ports' do
-    %i[network_port port].each do |type|
-      expect(EnvParser.parse(nil, as: type)).to eq(nil)
-      expect(EnvParser.parse('', as: type)).to eq(nil)
-
-      expect(EnvParser.parse('80', as: type)).to eq(80)
-      expect(EnvParser.parse('8080', as: type)).to eq(8080)
-
-      expect { EnvParser.parse('99999999', as: type) }.to raise_error(EnvParser::ValueNotAllowedError)
-      expect { EnvParser.parse('not a port number', as: type) }.to raise_error(EnvParser::ValueNotConvertibleError)
-    end
-  end
-
-  it 'can parse email addresses' do
-    expect(EnvParser.parse(nil, as: :email_address)).to eq(nil)
-    expect(EnvParser.parse('', as: :email_address)).to eq(nil)
-
-    expect(EnvParser.parse('email@example.com', as: :email_address)).to eq('email@example.com')
-    expect(EnvParser.parse('some.user@gmail.com', as: :email_address)).to eq('some.user@gmail.com')
-
-    expect { EnvParser.parse('not an email address', as: :email_address) }.to raise_error(EnvParser::ValueNotConvertibleError)
-  end
-
-  it 'can parse version numbers' do
-    %i[version semver].each do |type|
-      expect(EnvParser.parse(nil, as: type)).to eq(nil)
-      expect(EnvParser.parse('', as: type)).to eq(nil)
-
-      # Our list of valid version strings is a subset of those in the official semver.org-provided regex suite.
-      # rubocop:disable Layout
-      #
-      valid_version_strings = {
-        '0.0.4'                 => { major: '0' , minor: '0', patch: '4', prerelease: nil           , buildmetadata: nil          },
-        '1.2.3'                 => { major: '1' , minor: '2', patch: '3', prerelease: nil           , buildmetadata: nil          },
-        '1.1.2-prerelease+meta' => { major: '1' , minor: '1', patch: '2', prerelease: 'prerelease'  , buildmetadata: 'meta'       },
-        '1.1.2+meta'            => { major: '1' , minor: '1', patch: '2', prerelease: nil           , buildmetadata: 'meta'       },
-        '1.1.2+meta-valid'      => { major: '1' , minor: '1', patch: '2', prerelease: nil           , buildmetadata: 'meta-valid' },
-        '1.0.0-alpha'           => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha'       , buildmetadata: nil          },
-        '1.0.0-beta'            => { major: '1' , minor: '0', patch: '0', prerelease: 'beta'        , buildmetadata: nil          },
-        '1.0.0-alpha.beta'      => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha.beta'  , buildmetadata: nil          },
-        '1.0.0-alpha.beta.1'    => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha.beta.1', buildmetadata: nil          },
-        '1.0.0-alpha.1'         => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha.1'     , buildmetadata: nil          },
-        '1.0.0-alpha0.valid'    => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha0.valid', buildmetadata: nil          },
-        '1.0.0-alpha.0valid'    => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha.0valid', buildmetadata: nil          },
-        '1.0.0-rc.1+build.1'    => { major: '1' , minor: '0', patch: '0', prerelease: 'rc.1'        , buildmetadata: 'build.1'    },
-        '2.0.0-rc.1+build.123'  => { major: '2' , minor: '0', patch: '0', prerelease: 'rc.1'        , buildmetadata: 'build.123'  },
-        '1.2.3-beta'            => { major: '1' , minor: '2', patch: '3', prerelease: 'beta'        , buildmetadata: nil          },
-        '10.2.3-DEV-SNAPSHOT'   => { major: '10', minor: '2', patch: '3', prerelease: 'DEV-SNAPSHOT', buildmetadata: nil          },
-        '1.2.3-SNAPSHOT-123'    => { major: '1' , minor: '2', patch: '3', prerelease: 'SNAPSHOT-123', buildmetadata: nil          },
-        '2.0.0+build.1848'      => { major: '2' , minor: '0', patch: '0', prerelease: nil           , buildmetadata: 'build.1848' },
-        '2.0.1-alpha.1227'      => { major: '2' , minor: '0', patch: '1', prerelease: 'alpha.1227'  , buildmetadata: nil          },
-        '1.0.0-alpha+beta'      => { major: '1' , minor: '0', patch: '0', prerelease: 'alpha'       , buildmetadata: 'beta'       },
-        '1.0.0-0A.is.legal'     => { major: '1' , minor: '0', patch: '0', prerelease: '0A.is.legal' , buildmetadata: nil          }
-      }
-      # rubocop:enable Layout
-
-      valid_version_strings.each do |version, expected_matches|
-        parsed_value = EnvParser.parse(version, as: type)
-
-        expect(parsed_value).to_not eq(nil)
-        expected_matches.each { |match_name, expected_value| expect(parsed_value[match_name]).to eq(expected_value) }
-      end
-
-      # Our list of invalid version strings is a subset of those in the official semver.org-provided regex suite.
-      #
-      invalid_version_strings = ['1', '1.2', '1.2.3-0123', '1.2.3-0123.0123', '1.1.2+.123', '+invalid', '-invalid', '-invalid+invalid',
-                                 '-invalid.01', 'alpha', 'alpha.1', 'alpha+beta', '1.0.0-alpha..', '1.0.0-alpha..1', '01.1.1', '1.01.1',
-                                 '1.1.01', '1.2.3.DEV', '1.2-SNAPSHOT', '+justmeta', '9.8.7+meta+meta', '9.8.7-whatever+meta+meta']
-
-      invalid_version_strings.each { |version| expect { EnvParser.parse(version, as: type) }.to raise_error(EnvParser::ValueNotConvertibleError) }
-    end
-  end
-end

data/spec/env_parser_spec.rb

@@ -1,214 +0,0 @@
-require 'tempfile'
-
-module Sample; end
-
-RSpec.describe EnvParser do
-  it 'has a version number' do
-    expect(EnvParser::VERSION).not_to be nil
-  end
-
-  describe 'EnvParser.define_type' do
-    it 'exists' do
-      expect(EnvParser).to respond_to(:define_type)
-    end
-
-    it 'can register new types' do
-      EnvParser.define_type(:thirty) { |_| 30 }
-      expect(EnvParser.parse('dummy value', as: :thirty)).to eq(30)
-    end
-  end
-
-  describe 'EnvParser.parse' do
-    it 'exists' do
-      expect(EnvParser).to respond_to(:parse)
-    end
-
-    it 'returns the requested default when necessary' do
-      expect(EnvParser.parse(nil, as: :integer, if_unset: 25)).to eq(25)
-      expect(EnvParser.parse('', as: :integer, if_unset: 25)).to eq(25)
-
-      expect(EnvParser.parse('99', as: :float, if_unset: 25.0)).to eq(99.0)
-    end
-
-    it 'only allows values from a limited set' do
-      expect(EnvParser.parse('25', as: :integer, from_set: [20, 25, 30])).to eq(25)
-      expect { EnvParser.parse('25', as: :integer, from_set: [1, 2, 3]) }.to raise_error(EnvParser::ValueNotAllowedError)
-
-      expect(EnvParser.parse(nil, as: :integer, if_unset: 9, from_set: [1, 2, 3])).to eq(9)
-    end
-
-    it 'only allows values that pass user-defined validation' do
-      expect(EnvParser.parse('abc', as: :string)).to eq('abc')
-      expect(EnvParser.parse('abc', as: :string) { |_| true }).to eq('abc')
-      expect { EnvParser.parse('abc', as: :string) { |_| false } }.to raise_error(EnvParser::ValueNotAllowedError)
-
-      expect(EnvParser.parse('abc', as: :string)).to eq('abc')
-      expect(EnvParser.parse('abc', as: :string, validated_by: ->(_) { true })).to eq('abc')
-      expect { EnvParser.parse('abc', as: :string, validated_by: ->(_) { false }) }.to raise_error(EnvParser::ValueNotAllowedError)
-    end
-  end
-
-  describe 'EnvParse.register' do
-    it 'exists' do
-      expect(EnvParser).to respond_to(:register)
-    end
-
-    it 'ceates global constants' do
-      source_hash = { ABC: '123' }
-      EnvParser.register(:ABC, from: source_hash, as: :integer)
-      expect(ABC).to eq(123)
-    end
-
-    it 'creates module constants' do
-      source_hash = { DEF: '456' }
-      EnvParser.register(:DEF, from: source_hash, as: :integer, within: Sample)
-      expect(Sample::DEF).to eq(456)
-    end
-
-    it 'creates named module constants' do
-      source_hash = { GHI: '789' }
-      EnvParser.register(:GHI, from: source_hash, as: :integer, named: :JKL, within: Sample)
-      expect { Sample::GHI }.to raise_error(NameError)
-      expect(Sample::JKL).to eq(789)
-    end
-
-    it 'will accept a hash keyed by variable names' do
-      source_hash = { FIRST: 'first', SECOND: '99', THIRD: 'third' }
-      EnvParser.register(
-        FIRST: { from: source_hash, as: :string, if_unset: 'no first' },
-        SECOND: { from: source_hash, as: :integer, if_unset: 'no second' },
-        THIRD: { from: source_hash, as: :string, if_unset: 'no third' },
-        FOURTH: { from: source_hash, as: :boolean, if_unset: 'no fourth' }
-      )
-
-      expect(FIRST).to eq('first')
-      expect(SECOND).to eq(99)
-      expect(THIRD).to eq('third')
-      expect(FOURTH).to eq('no fourth')
-    end
-  end
-
-  describe 'EnvParser.add_env_bindings' do
-    before(:context) { EnvParser.add_env_bindings }
-
-    it 'exists' do
-      expect(EnvParser).to respond_to(:add_env_bindings)
-    end
-
-    describe 'ENV.parse' do
-      it 'now exists' do
-        expect(ENV).to respond_to(:parse)
-      end
-
-      it 'interprets input values as ENV keys' do
-        ENV['ABC'] = '123'
-        expect(ENV.parse('ABC', as: :integer)).to eq(123)
-        expect(ENV.parse(:ABC, as: :integer)).to eq(123)
-      end
-    end
-
-    describe 'ENV.register' do
-      it 'now exists' do
-        expect(ENV).to respond_to(:register)
-      end
-
-      it 'ceates global constants' do
-        ENV['ABCD'] = '1234'
-        ENV.register(:ABCD, as: :integer)
-        expect(ABCD).to eq(1234)
-      end
-
-      it 'creates module constants' do
-        ENV['WXYZ'] = '5678'
-        ENV.register(:WXYZ, as: :integer, within: Sample)
-        expect(Sample::WXYZ).to eq(5678)
-      end
-
-      it 'creates module constants' do
-        ENV['ORIGINAL_NAME'] = '9999'
-        ENV.register(:ORIGINAL_NAME, as: :integer, named: :DIFFERENT_NAME, within: Sample)
-        expect { Sample::ORIGINAL_NAME }.to raise_error(NameError)
-        expect(Sample::DIFFERENT_NAME).to eq(9999)
-      end
-
-      it 'will accept a hash keyed by variable names' do
-        ENV['FIFTH'] = 'fifth'
-        ENV['SIXTH'] = '99'
-        ENV['SEVENTH'] = 'seventh'
-
-        ENV.register(
-          FIFTH: { as: :string, if_unset: 'no fifth' },
-          SIXTH: { as: :integer, if_unset: 'no sixth' },
-          SEVENTH: { as: :string, if_unset: 'no seventh' },
-          EIGHTH: { as: :boolean, if_unset: 'no eighth' }
-        )
-
-        expect(FIFTH).to eq('fifth')
-        expect(SIXTH).to eq(99)
-        expect(SEVENTH).to eq('seventh')
-        expect(EIGHTH).to eq('no eighth')
-      end
-    end
-  end
-
-  describe 'EnvParser.autoregister' do
-    it 'exists' do
-      expect(EnvParser).to respond_to(:autoregister)
-    end
-
-    it 'can autoregister constants' do
-      filename = Tempfile.open('EnvParser.autoregister.') do |file|
-        file.write <<~YAML.chomp
-          SOME_INT:
-            as: :integer
-            if_unset: 25
-
-          SOME_STRING:
-            as: :string
-            if_unset: "unexpected"
-
-          CLASS_CONSTANT:
-            as: :string
-            within: String
-
-          NAMED_CLASS_CONSTANT:
-            as: :string
-            named: :OTHER_CLASS_CONSTANT
-            within: String
-        YAML
-
-        file.path
-      end
-
-      ENV['SOME_INT'] = '99'
-      ENV['SOME_STRING'] = 'twelve'
-      ENV['CLASS_CONSTANT'] = 'tricky'
-      ENV['NAMED_CLASS_CONSTANT'] = 'quizzical'
-      EnvParser.autoregister filename
-
-      expect(SOME_INT).to eq(99)
-      expect(SOME_STRING).to eq('twelve')
-      expect(String::CLASS_CONSTANT).to eq('tricky')
-      expect { String::NAMED_CLASS_CONSTANT }.to raise_error(NameError)
-      expect(String::OTHER_CLASS_CONSTANT).to eq('quizzical')
-    end
-
-    it 'properly handles file-not-found' do
-      expect { EnvParser.autoregister 'nonexistent filename' }.to raise_error(EnvParser::AutoregisterFileNotFound)
-    end
-
-    it 'properly handles unparseable YAML' do
-      filename = Tempfile.open('EnvParser.autoregister.') do |file|
-        file.write <<~MALFORMED_YAML.chomp
-          SOME_INT:
-            as:
-            hello
-        MALFORMED_YAML
-
-        file.path
-      end
-
-      expect { EnvParser.autoregister filename }.to raise_error(EnvParser::UnparseableAutoregisterSpec)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-require 'bundler/setup'
-require 'env_parser'
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = '.rspec_status'
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end