env_parser 1.3.0 → 1.3.2

data/spec/env_parser/types/base_types_spec.rb

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,45 @@
+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
+end

data/spec/env_parser_spec.rb

@@ -0,0 +1,192 @@
+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 = { XYZ: '456' }
+      EnvParser.register(:XYZ, from: source_hash, as: :integer, within: Sample)
+      expect(Sample::XYZ).to eq(456)
+    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 '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
+        YAML
+
+        file.path
+      end
+
+      ENV['SOME_INT'] = '99'
+      ENV['SOME_STRING'] = 'twelve'
+      ENV['CLASS_CONSTANT'] = 'tricky'
+      EnvParser.autoregister filename
+
+      expect(SOME_INT).to eq(99)
+      expect(SOME_STRING).to eq('twelve')
+      expect(String::CLASS_CONSTANT).to eq('tricky')
+    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

@@ -0,0 +1,14 @@
+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

metadata

@@ -1,73 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: env_parser
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Nestor Custodio
-autorequire: 
-bindir: exe
+autorequire:
+bindir: bin
 cert_chain: []
-date: 2019-11-04 00:00:00.000000000 Z
+date: 2022-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
+        version: 6.1.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: chronic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: chronic_duration
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,41 +81,41 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: chronic
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -123,20 +123,20 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: chronic_duration
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - sakimorix@gmail.com
 executables: []
@@ -148,7 +148,6 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
-- ".travis.yml"
 - ".yardopts"
 - Gemfile
 - Gemfile.lock
@@ -199,28 +198,33 @@ 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
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: A tool for painless parsing and validation of environment variables.
 test_files: []

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.4.2
-before_install: gem install bundler -v 1.16.0