env_parser 1.6.2 → 1.7.2

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