envied 0.9.1 → 0.9.3

data/lib/envied.rb

@@ -12,8 +12,7 @@ class ENVied
     alias_method :required?, :env
   end
 
-  def self.require(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
+  def self.require(*args, **options)
     requested_groups = (args && !args.empty?) ? args : ENV['ENVIED_GROUPS']
     env!(requested_groups, options)
     error_on_missing_variables!(options)
@@ -22,26 +21,23 @@ class ENVied
     ensure_spring_after_fork_require(args, options)
   end
 
-  def self.env!(requested_groups, options = {})
-    @env = begin
-      @config = options.fetch(:config) { Configuration.load }
-      groups = required_groups(*requested_groups)
-      EnvProxy.new(@config, groups: groups)
-    end
+  def self.env!(requested_groups, **options)
+    @config = options.fetch(:config) { Configuration.load }
+    @env = EnvProxy.new(@config, groups: required_groups(*requested_groups))
   end
 
-  def self.error_on_missing_variables!(options = {})
+  def self.error_on_missing_variables!(**options)
     names = env.missing_variables.map(&:name)
     if names.any?
-      msg = "The following environment variables should be set: #{names * ', '}."
+      msg = "The following environment variables should be set: #{names.join(', ')}."
       msg << "\nPlease make sure to stop Spring before retrying." if spring_enabled? && !options[:via_spring]
       raise msg
     end
   end
 
-  def self.error_on_uncoercible_variables!(options = {})
+  def self.error_on_uncoercible_variables!(**options)
     errors = env.uncoercible_variables.map do |v|
-      "%{name} ('%{value}' can't be coerced to %{type})" % {name: v.name, value: env.value_to_coerce(v), type: v.type }
+      format("%{name} with %{value} (%{type})", name: v.name, value: env.value_to_coerce(v).inspect, type: v.type)
     end
     if errors.any?
       msg = "The following environment variables are not coercible: #{errors.join(", ")}."
@@ -56,17 +52,18 @@ class ENVied
     result.any? ? result.map(&:to_sym) : [:default]
   end
 
-  def self.ensure_spring_after_fork_require(args, options = {})
+  def self.ensure_spring_after_fork_require(args, **options)
     if spring_enabled? && !options[:via_spring]
-      Spring.after_fork { ENVied.require(args, options.merge(:via_spring => true)) }
+      Spring.after_fork { ENVied.require(args, options.merge(via_spring: true)) }
     end
   end
 
   def self.springify(&block)
     if defined?(ActiveSupport::Deprecation.warn) && !required?
-      ActiveSupport::Deprecation.warn(<<-MSG)
-It's no longer recommended to `ENVied.require` within ENVied.springify's block. Please re-run `envied init:rails` to upgrade.
-MSG
+      ActiveSupport::Deprecation.warn(<<~MSG)
+        It's no longer recommended to `ENVied.require` within ENVied.springify's
+        block. Please re-run `envied init:rails` to upgrade.
+      MSG
     end
     if spring_enabled?
       Spring.after_fork(&block)

data/spec/coercer_spec.rb

@@ -1,121 +1,273 @@
-require 'spec_helper'
-
-describe ENVied::Coercer do
+RSpec.describe ENVied::Coercer do
   it { is_expected.to respond_to :coerce }
+  it { is_expected.to respond_to :coerced? }
+  it { is_expected.to respond_to :coercible? }
+  it { is_expected.to respond_to :supported_types }
+  it { is_expected.to respond_to :supported_type? }
+
+  describe '.supported_types' do
+    it 'returns a sorted set of supported types' do
+      expect(described_class.supported_types).to eq %i(array boolean date float hash integer string symbol time uri)
+    end
+  end
+
+  describe '.supported_type?' do
+    it 'returns true for supported type' do
+      %i(array boolean date float hash integer string symbol time uri).each do |type|
+        expect(described_class.supported_type?(type)).to eq true
+      end
+    end
+
+    it 'returns false for unsupported type' do
+      expect(described_class.supported_type?(:fixnum)).to eq false
+    end
+  end
+
+  describe '#supported_types' do
+    it 'calls class method implementation' do
+      expect(described_class).to receive(:supported_types).and_call_original
+      described_class.new.supported_types
+    end
+  end
+
+  describe '#supported_type?' do
+    it 'calls class method implementation' do
+      expect(described_class).to receive(:supported_type?).with(:string).and_call_original
+      described_class.new.supported_type?(:string)
+    end
+  end
+
+  describe '#coerced?' do
+    let(:coercer) { described_class.new }
+
+    it 'returns true if value has been coerced (not a string)' do
+      expect(coercer.coerced?(1)).to eq true
+    end
+
+    it 'returns false if value is not a string' do
+      expect(coercer.coerced?('1')).to eq false
+    end
+  end
+
+  describe '#coercible?' do
+    let(:coercer) { described_class.new }
+
+    it 'returns false for unsupported type' do
+      expect(coercer.coercible?('value', :invalid_type)).to eq false
+    end
+
+    it 'returns false for a failed coercion' do
+      expect(coercer.coercible?('value', :boolean)).to eq false
+    end
+
+    it 'returns true for a coercible value' do
+      expect(coercer.coercible?('value', :string)).to eq true
+    end
+  end
 
   describe '#coerce' do
     let(:coercer){ described_class.new }
 
-    def coerce_to(type)
-      ->(str){ coercer.coerce(str, type) }
+    def coerce(str, type)
+      coercer.coerce(str, type)
+    end
+
+    it 'fails with an invalid type' do
+      expect { coerce('', :fixnum) }.to raise_error(ArgumentError, "The type `:fixnum` is not supported.")
     end
 
     describe 'to string' do
-      let(:coerce){ coerce_to(:string) }
+      it 'returns the input untouched' do
+        expect(coerce('1', :string)).to eq '1'
+        expect(coerce(' 1', :string)).to eq ' 1'
+      end
 
-      it 'yields the input untouched' do
-        expect(coerce['1']).to eq '1'
-        expect(coerce[' 1']).to eq ' 1'
+      it 'fails when the value does not respond to #to_str' do
+        value = Object.new
+        expect { coerce(value, :string) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to integer' do
-      let(:coerce){ coerce_to(:integer) }
+      {
+        '1' => 1,
+        '+1' => 1,
+        '-1' => -1,
+        '10' => 10,
+        '100_00' => 100_00,
+        '1_000_00' => 1_000_00
+      }.each do |value, integer|
+        it "converts #{value.inspect} to an integer" do
+          expect(coerce(value, :integer)).to be_kind_of(Integer)
+          expect(coerce(value, :integer)).to eq integer
+        end
+      end
 
-      it 'converts strings to integers' do
-        expect(coerce['1']).to eq 1
-        expect(coerce['-1']).to eq(-1)
+      it 'fails with an invalid string' do
+        expect { coerce('non-integer', :integer) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
 
-      it 'fails for float' do
-        expect {
-          coerce['1.23']
-        }.to raise_error(Coercible::UnsupportedCoercion)
+      it 'fails with a float' do
+        expect { coerce('1.23', :integer) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to float' do
-      let(:coerce){ coerce_to(:float) }
+      {
+        '1' => 1.0,
+        '+1' => 1.0,
+        '-1' => -1.0,
+        '1_000.0' => 1_000.0,
+        '10_000.23' => 10_000.23,
+        '1_000_000.0' => 1_000_000.0,
+        '1.0' => 1.0,
+        '1.234' => 1.234,
+        '1.0e+1' => 10.0,
+        '1.0e-1' => 0.1,
+        '1.0E+1' => 10.0,
+        '1.0E-1' => 0.1,
+        '+1.0' => 1.0,
+        '+1.0e+1' => 10.0,
+        '+1.0e-1' => 0.1,
+        '+1.0E+1' => 10.0,
+        '+1.0E-1' => 0.1,
+        '-1.0' => -1.0,
+        '-1.234' => -1.234,
+        '-1.0e+1' => -10.0,
+        '-1.0e-1' => -0.1,
+        '-1.0E+1' => -10.0,
+        '-1.0E-1' => -0.1,
+        '.1' => 0.1,
+        '.1e+1' => 1.0,
+        '.1e-1' => 0.01,
+        '.1E+1' => 1.0,
+        '.1E-1' => 0.01,
+        '1e1' => 10.0,
+        '1E+1' => 10.0,
+        '+1e-1' => 0.1,
+        '-1E1' => -10.0,
+        '-1e-1' => -0.1,
+      }.each do |value, float|
+        it "converts #{value.inspect} to a float" do
+          expect(coerce(value, :float)).to be_kind_of(Float)
+          expect(coerce(value, :float)).to eq float
+        end
+      end
+
+      it 'fails with an invalid string' do
+        expect { coerce('non-float', :float) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
+      end
 
-      it 'converts strings to floats' do
-        expect(coerce['1.05']).to eq 1.05
-        expect(coerce['-1.234']).to eq(-1.234)
+      it 'fails when string starts with e' do
+        expect { coerce('e1', :float) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to boolean' do
-      let(:coerce){ coerce_to(:boolean) }
+      %w[ 1 on ON t true T TRUE y yes Y YES ].each do |value|
+        it "converts #{value.inspect} to `true`" do
+          expect(coerce(value, :boolean)).to eq true
+        end
+      end
 
-      it "converts 'true' and 'false'" do
-        expect(coerce['true']).to eq true
-        expect(coerce['false']).to eq false
+      %w[ 0 off OFF f false F FALSE n no N NO ].each do |value|
+        it "converts #{value.inspect} to `false`" do
+          expect(coerce(value, :boolean)).to eq false
+        end
       end
 
-      it "converts '1' and '0'" do
-        expect(coerce['1']).to eq true
-        expect(coerce['0']).to eq false
+      it 'fails with an invalid boolean string' do
+        expect { coerce('non-boolean', :boolean) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to symbol' do
-      let(:coerce){ coerce_to(:symbol) }
-
       it 'converts strings to symbols' do
-        expect(coerce['a']).to eq :a
-        expect(coerce['nice_symbol']).to eq :nice_symbol
+        expect(coerce('a', :symbol)).to eq :a
+        expect(coerce('nice_symbol', :symbol)).to eq :nice_symbol
       end
     end
 
     describe 'to date' do
-      let(:coerce){ coerce_to(:date) }
+      it 'converts string to date' do
+        date = coerce('2019-03-22', :date)
+
+        expect(date).to be_instance_of(Date)
+        expect(date.year).to eq 2019
+        expect(date.month).to eq 3
+        expect(date.day).to eq 22
+      end
 
-      it 'converts strings to date' do
-        expect(coerce['2014-12-25']).to eq Date.parse('2014-12-25')
+      it 'converts other string formats to date' do
+        expect(coerce('March 22nd, 2019', :date)).to eq Date.parse('2019-03-22')
+        expect(coerce('Sat, March 23rd, 2019', :date)).to eq Date.parse('2019-03-23')
+      end
+
+      it 'fails with an invalid string' do
+        expect { coerce('non-date', :date) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to time' do
-      let(:coerce){ coerce_to(:time) }
+      it 'converts string to time without time part' do
+        time = coerce("2019-03-22", :time)
 
-      it 'converts strings to time' do
-        expect(coerce['4:00']).to eq Time.parse('4:00')
+        expect(time).to be_instance_of(Time)
+        expect(time.year).to eq 2019
+        expect(time.month).to eq 3
+        expect(time.day).to eq 22
+        expect(time.hour).to eq 0
+        expect(time.min).to eq 0
+        expect(time.sec).to eq 0
+      end
+
+      it 'converts string to time with time portion' do
+        time = coerce("March 22nd, 2019 9:30:55", :time)
+
+        expect(time).to be_instance_of(Time)
+        expect(time.year).to eq 2019
+        expect(time.month).to eq 3
+        expect(time.day).to eq 22
+        expect(time.hour).to eq 9
+        expect(time.min).to eq 30
+        expect(time.sec).to eq 55
+      end
+
+      it 'fails with an invalid string' do
+        expect { coerce('2999', :time) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
       end
     end
 
     describe 'to array' do
-      let(:coerce){ coerce_to(:array) }
-
       it 'converts strings to array' do
         {
           'a,b' => ['a','b'],
           ' a, b' => [' a',' b'],
           'apples,and\, of course\, pears' => ['apples','and, of course, pears'],
-        }.each do |i, o|
-          expect(coerce[i]).to eq o
+        }.each do |value, array|
+          expect(coerce(value, :array)).to eq array
         end
       end
     end
 
     describe 'to hash' do
-      let(:coerce){ coerce_to(:hash) }
-
       it 'converts strings to hashes' do
         {
           'a=1' => {'a' => '1'},
           'a=1&b=2' => {'a' => '1', 'b' => '2'},
           'a=&b=2' => {'a' => '', 'b' => '2'},
           'a&b=2' => {'a' => nil, 'b' => '2'},
-        }.each do |i, o|
-          expect(coerce[i]).to eq o
+        }.each do |value, hash|
+          expect(coerce(value, :hash)).to eq hash
         end
       end
     end
 
     describe 'to uri' do
-      let(:coerce){ coerce_to(:uri) }
-
       it 'converts strings to uris' do
-        expect(coerce['http://www.google.com']).to be_a(URI)
+        expect(coerce('https://www.google.com', :uri)).to be_a(URI)
+        expect(coerce('https://www.google.com', :uri).scheme).to eq 'https'
+        expect(coerce('https://www.google.com', :uri).host).to eq 'www.google.com'
       end
     end
   end

data/spec/configuration_spec.rb

@@ -1,49 +1,112 @@
-require 'spec_helper'
-
-describe ENVied::Configuration do
+RSpec.describe ENVied::Configuration do
   it { is_expected.to respond_to :variable }
+  it { is_expected.to respond_to :group }
   it { is_expected.to respond_to :enable_defaults! }
   it { is_expected.to respond_to :defaults_enabled? }
 
-  describe '#variable' do
-    def with_envfile(&block)
-      @config = described_class.new(&block)
-    end
-    attr_reader :config
+  def with_envfile(**options, &block)
+    @config = ENVied::Configuration.new(options, &block)
+  end
+  attr_reader :config
 
+  describe 'variables' do
     it 'results in an added variable' do
       with_envfile do
         variable :foo, :boolean
       end
 
-      expect(config.variables).to include ENVied::Variable.new(:foo, :boolean)
+      expect(config.variables).to include ENVied::Variable.new(:foo, :boolean, group: :default)
+    end
+
+    it 'sets string as default type when no type is given' do
+      with_envfile do
+        variable :bar
+      end
+
+      expect(config.variables).to include ENVied::Variable.new(:bar, :string, default: nil, group: :default)
     end
 
-    it 'sets string as type when no type is given' do
+    it 'sets a default value when specified' do
       with_envfile do
         variable :bar, default: 'bar'
       end
 
-      expect(config.variables).to include ENVied::Variable.new(:bar, :string, default: 'bar')
+      expect(config.variables).to include ENVied::Variable.new(:bar, :string, default: 'bar', group: :default)
+    end
+
+    it 'sets specific group for variable' do
+      with_envfile do
+        group :production do
+          variable :SECRET_KEY_BASE
+        end
+      end
+
+      expect(config.variables).to include ENVied::Variable.new(:SECRET_KEY_BASE, :string, group: :production)
+    end
+
+    it 'sets the same variable for multiple groups' do
+      with_envfile do
+        group :development, :test do
+          variable :DISABLE_PRY, :boolean, default: 'false'
+        end
+      end
+
+      expect(config.variables).to eq [
+        ENVied::Variable.new(:DISABLE_PRY, :boolean, default: 'false', group: :development),
+        ENVied::Variable.new(:DISABLE_PRY, :boolean, default: 'false', group: :test)
+      ]
     end
   end
 
   describe 'defaults' do
     it 'is disabled by default' do
-      expect(subject.defaults_enabled?).to_not be
+      expect(subject.defaults_enabled?).to eq false
+    end
+
+    it 'can be enabled with an ENV variable' do
+      allow(ENV).to receive(:[]).with("ENVIED_ENABLE_DEFAULTS").and_return("true")
+      expect(subject.defaults_enabled?).to eq true
+    end
+
+    it 'can be enabled through a config option' do
+      with_envfile(enable_defaults: true) { }
+
+      expect(config.defaults_enabled?).to eq true
     end
 
     describe '#enable_defaults!' do
-      it 'can be passed a value' do
+      it 'can be enabled in a block by calling `enable_defaults!`' do
+        with_envfile do
+          enable_defaults!
+        end
+
+        expect(config.defaults_enabled?).to eq true
+      end
+
+      it 'can be enabled by calling `enable_defaults!` with a Proc' do
+        with_envfile do
+          enable_defaults! { true }
+        end
+
+        expect(config.defaults_enabled?).to eq true
+      end
+
+      it 'defaults to true with no arguments' do
+        expect {
+          subject.enable_defaults!
+        }.to change { subject.defaults_enabled? }.from(false).to(true)
+      end
+
+      it 'can be passed a boolean value' do
         expect {
           subject.enable_defaults!(true)
-        }.to change { subject.defaults_enabled? }
+        }.to change { subject.defaults_enabled? }.from(false).to(true)
       end
 
       it 'can be passed a block' do
         expect {
           subject.enable_defaults! { true }
-        }.to change { subject.defaults_enabled? }.to(true)
+        }.to change { subject.defaults_enabled? }.from(false).to(true)
       end
     end
   end

data/spec/env_var_extractor_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ENVied::EnvVarExtractor do
+RSpec.describe ENVied::EnvVarExtractor do
 
   describe "#capture_variables" do
     def capture_variables(text)