env_bang 1.0.0.pre.rc.1 → 2.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9876284297bbe55660d78e4d62bb83ec54e40ec83ddc94ef56907020805945c1
-  data.tar.gz: 1ef016e91711a660eee17849a8ac28c1ba8d303e5d6a645415f66d51ab648fb6
+  metadata.gz: '094ce7c346a763599ef55ab0256e99cdbed2d4f3059782cb2078ce8f5ff42502'
+  data.tar.gz: 353125d00af13bcb825fba521115a53d414d78bfc2e80cc7c8573051ee7c45a7
 SHA512:
-  metadata.gz: aa240511a3e7a4b4ea6437ec61f35fadbea111bfb191eeda6d25eee91818380cfc99d36a22734b48a66f945e53c3710e2909c9d4e132f64fb7df4c83bad1cdfc
-  data.tar.gz: d67dc205e27c91f1abe43b43d1745b432b6dfb2d9c495800c23b06a3e3616a89dabdde5513ce66d796074e346963b9fedb03f387fbb061fcea5e077efd557934
+  metadata.gz: 878b656b6090bdbbca837f260032a99edb2a34a50890681d2d88f9ce0e071df2a9c860778288478b7f1627acee4ce7f38efe5f55f469da1806e5fe2ed1850090
+  data.tar.gz: c9045031fd3209dc99605ec3a59c67e579d937b658250e4dbd29b958ddd8ed0fe0483f1c850ae59f0cf93e558420674e10ed32bc506a122186978cdd10cddfa5

data/.circleci/config.yml

@@ -0,0 +1,39 @@
+# Use the latest 2.1 version of CircleCI pipeline process engine.
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+orbs:
+  ruby: circleci/ruby@2.0.0
+  coveralls: coveralls/coveralls@2.1.0
+
+# Define a job to be invoked later in a workflow.
+# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
+jobs:
+  test:
+    parameters:
+      ruby-version:
+        type: string
+    docker:
+      # replace with your preferred image
+      - image: cimg/ruby:<< parameters.ruby-version >>
+    resource_class: small
+    environment:
+      COVERAGE: Summary
+    steps:
+      - checkout
+      - run: bundle install
+      - run: bundle exec rake
+      - coveralls/upload:
+          coverage_file: coverage/lcov.info
+
+# Invoke jobs via workflows
+# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
+workflows:
+  buidle_and_test:
+    jobs:
+      - test:
+          matrix:
+            parameters:
+              # https://github.com/CircleCI-Public/cimg-ruby
+              # only supports the last three ruby versions
+              ruby-version: ["2.6", "2.7", "3.0", "3.2"]

data/Gemfile

@@ -2,6 +2,7 @@ source 'https://rubygems.org'
 
 gemspec name: 'env_bang'
 
-group :metrics do
-  gem 'coveralls', require: false
+group :test do
+  gem 'simplecov'
+  gem 'simplecov-lcov'
 end

data/README.md

@@ -1,19 +1,17 @@
 # ENV!
 
-Do a bang-up job managing your environment variables.
+Verify correctness of environment configuration at startup time.
 
-[![Gem Version](https://img.shields.io/gem/v/env_bang.svg?style=flat)](https://rubygems.org/gems/env_bang)
-[![Build Status](https://img.shields.io/travis/jcamenisch/ENV_BANG/master.svg?style=flat)](https://travis-ci.org/jcamenisch/ENV_BANG)
-[![Maintainability](https://api.codeclimate.com/v1/badges/58ba2167873ed46687f9/maintainability)](https://codeclimate.com/github/jcamenisch/ENV_BANG/maintainability)
-[![Coverage Status](https://img.shields.io/coveralls/jcamenisch/ENV_BANG/master.svg?style=flat)](https://coveralls.io/r/jcamenisch/ENV_BANG)
+[![Gem Version](https://img.shields.io/gem/v/env_bang?logo=rubygems)](https://rubygems.org/gems/env_bang)
+[![Build Status](https://img.shields.io/circleci/build/github/jcamenisch/ENV_BANG/main)](https://dl.circleci.com/status-badge/redirect/gh/jcamenisch/ENV_BANG/tree/main)
+[![Maintainability](https://img.shields.io/codeclimate/maintainability/jcamenisch/ENV_BANG?logo=codeclimate)](https://codeclimate.com/github/jcamenisch/ENV_BANG)
+[![Coverage Status](https://img.shields.io/coverallsCoverage/github/jcamenisch/ENV_BANG?logo=coveralls)](https://coveralls.io/r/jcamenisch/ENV_BANG)
 
 ENV! provides a thin wrapper around ENV to accomplish a few things:
 
 - Provide a central place to specify all your app’s environment variables.
-- Fail loudly and helpfully if any environment variables are missing.
-- Prevent an application from starting up with missing environment variables.
-  (This is especially helpful in environments like Heroku, as your app will
-  continue running the old code until the server is configured for a new revision.)
+- Fail loudly and helpfully if any environment variables are missing or invalid.
+- Prevent an application from starting up with invalid environment variables.
 
 ## Installation
 

data/lib/env_bang/version.rb

@@ -1,3 +1,3 @@
 class ENV_BANG
-  VERSION = "1.0.0-rc.1"
+  VERSION = "2.0.0.alpha.1"
 end

data/lib/env_bang.rb

@@ -1,9 +1,13 @@
 require "env_bang/version"
 require "env_bang/classes"
 require "env_bang/formatter"
+require "forwardable"
 
 class ENV_BANG
   class << self
+    extend Forwardable
+    include Enumerable
+
     def config(&block)
       instance_eval(&block)
     end
@@ -48,10 +52,6 @@ class ENV_BANG
       Classes.cast ENV[var], vars[var]
     end
 
-    def method_missing(method, *args, &block)
-      ENV.send(method, *args, &block)
-    end
-
     def add_class(klass, &block)
       Classes.send :define_singleton_method, klass.to_s, &block
     end
@@ -63,6 +63,36 @@ class ENV_BANG
         Classes.default_class
       end
     end
+
+    def to_h
+      keys.map { |k| [k, self[k]] }.to_h
+    end
+
+    alias to_hash to_h
+
+    ####################################
+    # Implement Hash-like read methods #
+    ####################################
+
+    def_delegators :to_h,
+      :each, :assoc, :each_pair, :each_value, :empty?, :fetch,
+      :invert, :key, :rassoc, :values_at
+
+    def_delegators :vars, :each_key, :has_key?, :key?, :length, :size
+
+    def slice(*requested_keys)
+      (requested_keys & keys).map { |k| [k, self[k]] }.to_h
+    end
+
+    def except(*exceptions)
+      slice(*(keys - exceptions))
+    end
+
+    def value?(value)
+      values.include?(value)
+    end
+
+    alias has_value? value?
   end
 end
 

data/test/env_bang_test.rb

@@ -8,13 +8,13 @@ describe ENV_BANG do
 
   it "Raises exception if unconfigured ENV var requested" do
     ENV['UNCONFIGURED'] = 'unconfigured'
-    proc { ENV!['UNCONFIGURED'] }.must_raise KeyError
+    _{ ENV!['UNCONFIGURED'] }.must_raise KeyError
   end
 
   it "Raises exception if configured ENV var is not present" do
     ENV.delete('NOT_PRESENT')
 
-    proc {
+    _{
       ENV!.config do
         use 'NOT_PRESENT'
       end
@@ -22,12 +22,12 @@ describe ENV_BANG do
   end
 
   it "Raises exception immediately if value is invalid for the required type" do
-    proc {
+    _{
       ENV['NOT_A_DATE'] = '2017-02-30'
       ENV!.use 'NOT_A_DATE', class: Date
     }.must_raise ArgumentError
 
-    proc {
+    _{
       ENV!.use 'NOT_A_DATE_DEFAULT', class: Date, default: '2017-02-31'
     }.must_raise ArgumentError
   end
@@ -38,7 +38,7 @@ describe ENV_BANG do
     ENV!.config do
       use 'WASNT_PRESENT', default: 'a default value'
     end
-    ENV!['WASNT_PRESENT'].must_equal 'a default value'
+    _(ENV!['WASNT_PRESENT']).must_equal 'a default value'
   end
 
   it "Returns actual value from ENV if present" do
@@ -47,7 +47,7 @@ describe ENV_BANG do
     ENV!.config do
       use 'PRESENT', default: "You won't need this."
     end
-    ENV!['PRESENT'].must_equal 'present in environment'
+    _(ENV!['PRESENT']).must_equal 'present in environment'
   end
 
   describe "Type casting" do
@@ -61,14 +61,14 @@ describe ENV_BANG do
       ENV['INTEGER'] = integer
       ENV!.use 'INTEGER', class: Integer
 
-      ENV!['INTEGER'].must_equal integer.to_i
+      _(ENV!['INTEGER']).must_equal integer.to_i
     end
 
     it "Casts Symbols" do
       ENV['SYMBOL'] = 'symbol'
       ENV!.use 'SYMBOL', class: Symbol
 
-      ENV!['SYMBOL'].must_equal :symbol
+      _(ENV!['SYMBOL']).must_equal :symbol
     end
 
     it "Casts Floats" do
@@ -76,29 +76,29 @@ describe ENV_BANG do
       ENV['FLOAT'] = float
       ENV!.use 'FLOAT', class: Float
 
-      ENV!['FLOAT'].must_equal float.to_f
-      ENV!['FLOAT'].class.must_equal Float
+      _(ENV!['FLOAT']).must_equal float.to_f
+      _(ENV!['FLOAT'].class).must_equal Float
     end
 
     it "Casts Arrays" do
       ENV['ARRAY'] = 'one,two , three, four'
       ENV!.use 'ARRAY', class: Array
 
-      ENV!['ARRAY'].must_equal %w[one two three four]
+      _(ENV!['ARRAY']).must_equal %w[one two three four]
     end
 
     it "Casts Arrays of Integers" do
       ENV['INTEGERS'] = integers.join(',')
       ENV!.use 'INTEGERS', class: Array, of: Integer
 
-      ENV!['INTEGERS'].must_equal integers.map(&:to_i)
+      _(ENV!['INTEGERS']).must_equal integers.map(&:to_i)
     end
 
     it "Casts Arrays of Floats" do
       ENV['FLOATS'] = floats.join(',')
       ENV!.use 'FLOATS', class: Array, of: Float
 
-      ENV!['FLOATS'].must_equal floats.map(&:to_f)
+      _(ENV!['FLOATS']).must_equal floats.map(&:to_f)
     end
 
     it "regression: Casting Array always returns Array" do
@@ -106,7 +106,7 @@ describe ENV_BANG do
       ENV!.use 'ARRAY', class: Array
 
       2.times do
-        ENV!['ARRAY'].must_equal %w[one two three four]
+        _(ENV!['ARRAY']).must_equal %w[one two three four]
       end
     end
 
@@ -114,80 +114,80 @@ describe ENV_BANG do
       ENV['HASH'] = 'one: two, three: http://four.com'
       ENV!.use 'HASH', class: Hash
 
-      ENV!['HASH'].must_equal({one: 'two', three: 'http://four.com'})
+      _(ENV!['HASH']).must_equal({one: 'two', three: 'http://four.com'})
     end
 
     it 'Casts Hashes of Integers' do
       ENV['INT_HASH'] = 'one: 111, two: 222'
       ENV!.use 'INT_HASH', class: Hash, of: Integer
 
-      ENV!['INT_HASH'].must_equal({one: 111, two: 222})
+      _(ENV!['INT_HASH']).must_equal({one: 111, two: 222})
     end
 
     it 'Casts Hashes with String keys' do
       ENV['STRKEY_HASH'] = 'one: two, three: four'
       ENV!.use 'STRKEY_HASH', class: Hash, keys: String
 
-      ENV!['STRKEY_HASH'].must_equal({'one' => 'two', 'three' => 'four'})
+      _(ENV!['STRKEY_HASH']).must_equal({'one' => 'two', 'three' => 'four'})
     end
 
     it 'Casts Hashes with alternate separators' do
       ENV['ALT_HASH'] = 'one:two = three; four,five=six'
       ENV!.use 'ALT_HASH', class: Hash, sep: ';', val_sep: '='
 
-      ENV!['ALT_HASH'].must_equal({:'one:two' => 'three', :'four,five' => 'six'})
+      _(ENV!['ALT_HASH']).must_equal({:'one:two' => 'three', :'four,five' => 'six'})
     end
 
     it "Casts true" do
       ENV['TRUE'] = truthy_values.sample
       ENV!.use 'TRUE', class: :boolean
 
-      ENV!['TRUE'].must_equal true
+      _(ENV!['TRUE']).must_equal true
     end
 
     it "Casts false" do
       ENV['FALSE'] = falsey_values.sample
       ENV!.use 'FALSE', class: :boolean
 
-      ENV!['FALSE'].must_equal false
+      _(ENV!['FALSE']).must_equal false
     end
 
     it "converts falsey or empty string to false by default" do
       ENV['FALSE'] = falsey_values.sample
       ENV!.use 'FALSE'
 
-      ENV!['FALSE'].must_equal false
+      _(ENV!['FALSE']).must_equal false
     end
 
     it "leaves falsey string as string if specified" do
       ENV['FALSE'] = falsey_values.sample
       ENV!.use 'FALSE', class: String
 
-      ENV!['FALSE'].class.must_equal String
+      _(ENV!['FALSE'].class).must_equal String
     end
 
     it "casts Dates" do
       ENV['A_DATE'] = '2005-05-05'
       ENV!.use 'A_DATE', class: Date
 
-      ENV!['A_DATE'].class.must_equal Date
-      ENV!['A_DATE'].must_equal Date.new(2005, 5, 5)
+      _(ENV!['A_DATE'].class).must_equal Date
+      _(ENV!['A_DATE']).must_equal Date.new(2005, 5, 5)
     end
 
     it "casts DateTimes" do
       ENV['A_DATETIME'] = '2005-05-05 5:05pm'
       ENV!.use 'A_DATETIME', class: DateTime
 
-      ENV!['A_DATETIME'].class.must_equal DateTime
-      ENV!['A_DATETIME'].must_equal DateTime.new(2005, 5, 5, 17, 5)
+      _(ENV!['A_DATETIME'].class).must_equal DateTime
+      _(ENV!['A_DATETIME']).must_equal DateTime.new(2005, 5, 5, 17, 5)
     end
 
     it "casts Times" do
       ENV['A_TIME'] = '2005-05-05 5:05pm'
       ENV!.use 'A_TIME', class: Time
 
-      ENV!['A_TIME'].class.must_equal Time
-      ENV!['A_TIME'].must_equal Time.new(2005, 5, 5, 17, 5)
+      _(ENV!['A_TIME'].class).must_equal Time
+      _(ENV!['A_TIME']).must_equal Time.new(2005, 5, 5, 17, 5)
     end
 
     it "casts Regexps" do
@@ -195,51 +195,51 @@ describe ENV_BANG do
       ENV['A_REGEX'] = '^(this|is|a|[^tes.*\|]t.\.\*/\\\)$'
       ENV!.use 'A_REGEX', class: Regexp
 
-      ENV!['A_REGEX'].class.must_equal Regexp
-      ENV!['A_REGEX'].must_equal(/^(this|is|a|[^tes.*\|]t.\.\*\/\\)$/)
+      _(ENV!['A_REGEX'].class).must_equal Regexp
+      _(ENV!['A_REGEX']).must_equal(/^(this|is|a|[^tes.*\|]t.\.\*\/\\)$/)
     end
 
     it "casts inclusive Ranges of Integers by default" do
       ENV['A_RANGE'] = '1..100'
       ENV!.use 'A_RANGE', class: Range
 
-      ENV!['A_RANGE'].class.must_equal Range
-      ENV!['A_RANGE'].must_equal 1..100
+      _(ENV!['A_RANGE'].class).must_equal Range
+      _(ENV!['A_RANGE']).must_equal 1..100
     end
 
     it "casts exclusive Ranges as directed" do
       ENV['EXCLUSIVE_RANGE'] = '1..100'
       ENV!.use 'EXCLUSIVE_RANGE', class: Range, exclusive: true
 
-      ENV!['EXCLUSIVE_RANGE'].must_equal 1...100
+      _(ENV!['EXCLUSIVE_RANGE']).must_equal 1...100
 
       ENV['ANOTHER_EXCLUSIVE_RANGE'] = '1...100'
       ENV!.use 'ANOTHER_EXCLUSIVE_RANGE', class: Range, exclusive: true
 
-      ENV!['ANOTHER_EXCLUSIVE_RANGE'].must_equal 1...100
+      _(ENV!['ANOTHER_EXCLUSIVE_RANGE']).must_equal 1...100
     end
 
     it "casts Ranges of floats" do
       ENV['FLOAT_RANGE'] = '1.5..100.7'
       ENV!.use 'FLOAT_RANGE', class: Range, of: Float
 
-      ENV!['FLOAT_RANGE'].must_equal 1.5..100.7
+      _(ENV!['FLOAT_RANGE']).must_equal 1.5..100.7
     end
 
     it "casts Ranges of strings" do
       ENV['FLOAT_RANGE'] = 'az..za'
       ENV!.use 'FLOAT_RANGE', class: Range, of: String
 
-      ENV!['FLOAT_RANGE'].must_equal 'az'..'za'
+      _(ENV!['FLOAT_RANGE']).must_equal 'az'..'za'
     end
 
     it "allows default class to be overridden" do
-      ENV!.default_class.must_equal :StringUnlessFalsey
+      _(ENV!.default_class).must_equal :StringUnlessFalsey
       ENV!.config { default_class String }
       ENV['FALSE'] = falsey_values.sample
       ENV!.use 'FALSE', class: String
 
-      ENV!['FALSE'].class.must_equal String
+      _(ENV!['FALSE'].class).must_equal String
     end
 
     it "allows addition of custom types" do
@@ -254,7 +254,7 @@ describe ENV_BANG do
         use :NUMBER_SET, class: Set, of: Integer
       end
 
-      ENV!['NUMBER_SET'].must_equal Set.new [1, 3, 5, 7, 9]
+      _(ENV!['NUMBER_SET']).must_equal Set.new [1, 3, 5, 7, 9]
     end
 
     describe "Kernel casting delegators" do
@@ -262,53 +262,53 @@ describe ENV_BANG do
         ENV['A_INTEGER'] = '-123'
         ENV!.use 'A_INTEGER', class: Integer
 
-        ENV!['A_INTEGER'].must_equal(-123)
+        _(ENV!['A_INTEGER']).must_equal(-123)
       end
 
       it "casts Floats" do
         ENV['A_FLOAT'] = '123.456'
         ENV!.use 'A_FLOAT', class: Float
 
-        ENV!['A_FLOAT'].must_equal 123.456
+        _(ENV!['A_FLOAT']).must_equal 123.456
       end
 
       it "casts Strings" do
         ENV['A_STRING'] = 'What do I write here?'
         ENV!.use 'A_STRING', class: String
-        ENV!['A_STRING'].must_equal 'What do I write here?'
+        _(ENV!['A_STRING']).must_equal 'What do I write here?'
       end
 
       it "casts Rationals" do
         ENV['A_RATIONAL'] = '3/32'
         ENV!.use 'A_RATIONAL', class: Rational
 
-        ENV!['A_RATIONAL'].class.must_equal Rational
-        ENV!['A_RATIONAL'].must_equal 3.to_r/32
-        ENV!['A_RATIONAL'].to_s.must_equal '3/32'
+        _(ENV!['A_RATIONAL'].class).must_equal Rational
+        _(ENV!['A_RATIONAL']).must_equal 3.to_r/32
+        _(ENV!['A_RATIONAL'].to_s).must_equal '3/32'
       end
 
       it "casts Complexes" do
         ENV['A_COMPLEX'] = '123+4i'
         ENV!.use 'A_COMPLEX', class: Complex
 
-        ENV!['A_COMPLEX'].class.must_equal Complex
-        ENV!['A_COMPLEX'].to_s.must_equal '123+4i'
+        _(ENV!['A_COMPLEX'].class).must_equal Complex
+        _(ENV!['A_COMPLEX'].to_s).must_equal '123+4i'
       end
 
       it "casts Pathnames" do
         ENV['A_PATHNAME'] = '~/.git/config'
         ENV!.use 'A_PATHNAME', class: Pathname
 
-        ENV!['A_PATHNAME'].class.must_equal Pathname
-        ENV!['A_PATHNAME'].to_s.must_equal '~/.git/config'
+        _(ENV!['A_PATHNAME'].class).must_equal Pathname
+        _(ENV!['A_PATHNAME'].to_s).must_equal '~/.git/config'
       end
 
       it "casts URIs" do
         ENV['A_URI'] = 'http://www.example.com/path/to/nowhere'
         ENV!.use 'A_URI', class: URI
 
-        ENV!['A_URI'].class.must_equal URI::HTTP
-        ENV!['A_URI'].to_s.must_equal 'http://www.example.com/path/to/nowhere'
+        _(ENV!['A_URI'].class).must_equal URI::HTTP
+        _(ENV!['A_URI'].to_s).must_equal 'http://www.example.com/path/to/nowhere'
       end
     end
   end
@@ -320,7 +320,7 @@ describe ENV_BANG do
       ENV!.use 'VAR1'
       ENV!.use 'VAR2'
 
-      ENV!.keys.must_equal %w[VAR1 VAR2]
+      _(ENV!.keys).must_equal %w[VAR1 VAR2]
     end
 
     it "provides configured values" do
@@ -329,7 +329,7 @@ describe ENV_BANG do
       ENV!.use 'VAR1'
       ENV!.use 'VAR2'
 
-      ENV!.values.must_equal %w[something something\ else]
+      _(ENV!.values).must_equal %w[something something\ else]
     end
   end
 
@@ -337,18 +337,18 @@ describe ENV_BANG do
     it "Includes provided description in error message" do
       ENV.delete('NOT_PRESENT')
 
-      e = proc {
+      e = _{
         ENV!.config do
           use 'NOT_PRESENT', 'You need a NOT_PRESENT var in your ENV'
         end
       }.must_raise(KeyError)
-      e.message.must_include 'You need a NOT_PRESENT var in your ENV'
+      _(e.message).must_include 'You need a NOT_PRESENT var in your ENV'
     end
 
     it "Removes indentation from provided descriptions" do
       ENV.delete('NOT_PRESENT')
 
-      e = proc {
+      e = _{
         ENV!.config do
           use 'NOT_PRESENT', <<-DESC
             This multiline description
@@ -358,7 +358,7 @@ describe ENV_BANG do
           DESC
         end
       }.must_raise(KeyError)
-      e.message.must_include <<-UNINDENTED
+      _(e.message).must_include <<-UNINDENTED
     This multiline description
       has a lot of indentation
         varying from line to line
@@ -366,4 +366,173 @@ describe ENV_BANG do
       UNINDENTED
     end
   end
+
+  describe "Enumerable methods" do
+    before do
+      ENV['ONE'] = '1'
+      ENV['A'] = 'A'
+      ENV['INT_HASH'] = 'one: 1, two: 2'
+      ENV['FLOAT'] = '1.234'
+
+      ENV!.config do
+        use 'ONE', class: Integer
+        use 'A', class: String
+        use 'INT_HASH', class: Hash, of: Integer
+        use 'FLOAT', class: Float
+      end
+    end
+
+    it "converts keys and parsed values to a Hash" do
+      _(ENV!.to_h).must_equal({
+        'ONE'      => 1,
+        'A'        => 'A',
+        'INT_HASH' => { one: 1, two: 2 },
+        'FLOAT'    => 1.234,
+      })
+    end
+
+    it "Doesn't allow write access via the hash (It's not a reference to internal values)" do
+      h = ENV!.to_h
+      h['A'] = 'changed'
+      _(ENV!['A']).must_equal 'A'
+    end
+
+    it "returns an Array representation of the hash too" do
+      _(ENV!.to_a).must_equal [
+        ['ONE', 1],
+        ['A', 'A'],
+        ['INT_HASH', { one: 1, two: 2 }],
+        ['FLOAT', 1.234],
+      ]
+    end
+
+    it "implements other Enumerable methods too" do
+      _(ENV!.each.to_a).must_equal [
+        ['ONE', 1],
+        ['A', 'A'],
+        ['INT_HASH', { one: 1, two: 2 }],
+        ['FLOAT', 1.234],
+      ]
+
+      _(ENV!.to_enum.to_a).must_equal ENV!.to_a
+    end
+  end
+
+  describe "Hash-like read methods" do
+    before do
+      ENV['ONE'] = '1'
+      ENV['A'] = 'A'
+      ENV['INT_HASH'] = 'one: 1, two: 2'
+      ENV['FLOAT'] = '1.234'
+
+      ENV!.config do
+        use 'ONE', class: Integer
+        use 'A', class: String
+        use 'INT_HASH', class: Hash, of: Integer
+        use 'FLOAT', class: Float
+      end
+    end
+
+    it "implements .assoc and .rassoc correctly" do
+      _(ENV!.assoc('ONE')).must_equal ['ONE', 1]
+      _(ENV!.rassoc(1)).must_equal ['ONE', 1]
+    end
+
+    it "implements .each_key correctly" do
+      _(ENV!.each_key.to_a).must_equal(%w[ONE A INT_HASH FLOAT])
+      keys = []
+      ENV!.each_key do |key|
+        keys << key
+      end
+      _(keys).must_equal(%w[ONE A INT_HASH FLOAT])
+    end
+
+    it "implements .each_pair correctly" do
+      _(ENV!.each_pair.to_a).must_equal(ENV!.to_a)
+      pairs = []
+      ENV!.each_pair do |pair|
+        pairs << pair
+      end
+      _(pairs).must_equal(ENV!.to_a)
+    end
+
+    it "implements .each_value correctly" do
+      _(ENV!.each_value.to_a).must_equal [1, 'A', { one: 1, two: 2 }, 1.234]
+      values = []
+      ENV!.each_value do |value|
+        values << value
+      end
+      _(values).must_equal [1, 'A', { one: 1, two: 2 }, 1.234]
+    end
+
+    it "implements .empty? correctly" do
+      _(ENV!.empty?).must_equal(false)
+    end
+
+    it "implements .except correctly" do
+      _(ENV!.except('INT_HASH', 'FLOAT', 'NOTATHING')).must_equal({
+        'ONE' => 1,
+        'A'   => 'A',
+      })
+    end
+
+    it "implements .fetch correctly" do
+      _(ENV!.fetch('ONE')).must_equal 1
+      _{
+        ENV!.fetch('TWO')
+      }.must_raise KeyError
+      _(ENV!.fetch('TWO', 2)).must_equal 2
+      _(ENV!.fetch('TWO') { 22 }).must_equal 22
+    end
+
+    it "implements .invert correctly" do
+      _(ENV!.invert).must_equal({
+        1 => 'ONE',
+        'A' => 'A',
+        { one: 1, two: 2 } => 'INT_HASH',
+        1.234 => 'FLOAT',
+      })
+    end
+
+    it "implements .key correctly" do
+      _(ENV!.key(1)).must_equal 'ONE'
+    end
+
+    it "implements .key?/.has_key? correctly" do
+      _(ENV!.key?('ONE')).must_equal true
+      _(ENV!.has_key?('ONE')).must_equal true
+
+      _(ENV!.key?('TWO')).must_equal false
+      _(ENV!.has_key?('TWO')).must_equal false
+    end
+
+    it "implements .length correctly" do
+      _(ENV!.length).must_equal 4
+      _(ENV!.size).must_equal 4
+    end
+
+    it "implements .slice correctly" do
+      _(ENV!.slice('INT_HASH', 'FLOAT', 'NOTATHING')).must_equal({
+        'INT_HASH' => { one: 1, two: 2 },
+        'FLOAT'    => 1.234,
+      })
+    end
+
+    it "implements .to_hash correctly" do
+      _(ENV!.to_hash).must_equal ENV!.to_h
+    end
+
+    it "implements .value?/has_value? correctly" do
+      _(ENV!.value?(1)).must_equal true
+      _(ENV!.value?(2)).must_equal false
+      _(ENV!.has_value?(1)).must_equal true
+      _(ENV!.has_value?(2)).must_equal false
+    end
+
+    it "implements .values_at correctly" do
+      _(ENV!.values_at('INT_HASH', 'FLOAT', 'NOTATHING')).must_equal [
+        { one: 1, two: 2 }, 1.234, nil
+      ]
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,13 +1,21 @@
-require 'simplecov'
-require 'coveralls'
-
 require 'minitest/autorun'
 require 'minitest/spec'
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start
+require 'simplecov'
+
+SimpleCov.start 'rails' do
+  if ENV['CI']
+    require 'simplecov-lcov'
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
+
+  add_filter %w[version.rb initializer.rb]
+end
 
 require 'env_bang'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: env_bang
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc.1
+  version: 2.0.0.alpha.1
 platform: ruby
 authors:
 - Jonathan Camenisch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -46,8 +46,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-dist: trusty
-
-rvm:
-  - 2.0.0
-  - 2.3.3
-  - 2.4.0
-  - ruby-head
-  - rbx-3.69
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: rbx-3.69