envied 0.9.3 → 0.10.0.alpha1

data/spec/coercer_spec.rb

@@ -1,274 +0,0 @@
-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(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
-      it 'returns the input untouched' do
-        expect(coerce('1', :string)).to eq '1'
-        expect(coerce(' 1', :string)).to eq ' 1'
-      end
-
-      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
-      {
-        '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 'fails with an invalid string' do
-        expect { coerce('non-integer', :integer) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
-      end
-
-      it 'fails with a float' do
-        expect { coerce('1.23', :integer) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
-      end
-    end
-
-    describe 'to float' do
-      {
-        '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 'fails when string starts with e' do
-        expect { coerce('e1', :float) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
-      end
-    end
-
-    describe 'to boolean' do
-      %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
-
-      %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 'fails with an invalid boolean string' do
-        expect { coerce('non-boolean', :boolean) }.to raise_error(ENVied::Coercer::UnsupportedCoercion)
-      end
-    end
-
-    describe 'to symbol' do
-      it 'converts strings to symbols' do
-        expect(coerce('a', :symbol)).to eq :a
-        expect(coerce('nice_symbol', :symbol)).to eq :nice_symbol
-      end
-    end
-
-    describe 'to date' do
-      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 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
-      it 'converts string to time without time part' do
-        time = coerce("2019-03-22", :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 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
-      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 |value, array|
-          expect(coerce(value, :array)).to eq array
-        end
-      end
-    end
-
-    describe 'to hash' do
-      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 |value, hash|
-          expect(coerce(value, :hash)).to eq hash
-        end
-      end
-    end
-
-    describe 'to uri' do
-      it 'converts strings to uris' do
-        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
-end

data/spec/configuration_spec.rb

@@ -1,113 +0,0 @@
-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? }
-
-  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, 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 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', 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 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 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? }.from(false).to(true)
-      end
-
-      it 'can be passed a block' do
-        expect {
-          subject.enable_defaults! { true }
-        }.to change { subject.defaults_enabled? }.from(false).to(true)
-      end
-    end
-  end
-end

data/spec/env_var_extractor_spec.rb

@@ -1,22 +0,0 @@
-RSpec.describe ENVied::EnvVarExtractor do
-
-  describe "#capture_variables" do
-    def capture_variables(text)
-      described_class.new.capture_variables(text)
-    end
-
-    {
-      %{self.a = ENV['A']} => %w(A),
-      %{self.a = ENV["A"]} => %w(A),
-      %{self.a = ENV.fetch('A')]} => %w(A),
-      %{self.a = ENV.fetch("A")]} => %w(A),
-      %{# self.a = ENV["A"]} => %w(A),
-      %{self.a = ENV["A"] && self.b = ENV["B"]} => %w(A B),
-      %{self.a = ENV["A3"]} => %w(A3)
-    }.each do |line, expected|
-      it "captures #{expected} from #{line.inspect}" do
-        expect(capture_variables(line)).to contain_exactly(*expected)
-      end
-    end
-  end
-end

data/spec/envied_spec.rb

@@ -1,339 +0,0 @@
-RSpec.describe ENVied do
-  describe 'class' do
-    subject { described_class }
-    it { is_expected.to respond_to :require }
-  end
-
-  def reset_envied
-    ENVied.instance_eval do
-      @env = nil
-      @config = nil
-    end
-  end
-
-  context 'configured' do
-
-    before do
-      reset_envied
-    end
-
-    def set_ENV(env = {})
-      stub_const("ENV", env)
-    end
-
-    def configure(**options, &block)
-      @config = ENVied::Configuration.new(options, &block)
-    end
-
-    def configured_with(**hash)
-      @config = ENVied::Configuration.new.tap do |config|
-        hash.each do |name, type|
-          config.variable(name, type)
-        end
-      end
-    end
-
-    def envied_require(*args, **options)
-      options[:config] = @config || ENVied::Configuration.new # Prevent `Configuration.load` from being called
-      ENVied.require(*args, **options)
-    end
-
-    it 'does respond to configured variables' do
-      set_ENV('A' => '1')
-      configured_with(A: :integer)
-      envied_require
-
-      expect(described_class).to respond_to :A
-    end
-
-    it 'does not respond to unconfigured variables' do
-      set_ENV('A' => '1')
-      configured_with
-      envied_require
-
-      expect(described_class).to_not respond_to :B
-    end
-
-    it 'sets ENVied.config' do
-      set_ENV('A' => '1')
-      configured_with(A: :integer)
-      envied_require
-
-      expect(ENVied.config).to be_instance_of(ENVied::Configuration)
-    end
-
-    context 'ENV contains not all configured variables' do
-      before do
-        set_ENV
-        configured_with(A: :integer)
-      end
-
-      specify do
-        expect {
-          envied_require
-        }.to raise_error(RuntimeError, 'The following environment variables should be set: A.')
-      end
-    end
-
-    context 'ENV variables are not coercible' do
-      before do
-        set_ENV('A' => 'NaN', 'B' => 'invalid')
-        configured_with(A: :integer, B: :boolean)
-      end
-
-      specify do
-        expect {
-          envied_require
-        }.to raise_error(
-          RuntimeError,
-          'The following environment variables are not coercible: A with "NaN" (integer), B with "invalid" (boolean).'
-        )
-      end
-    end
-
-    context 'configuring' do
-      it 'raises error when configuring variable of unknown type' do
-        expect {
-          configured_with(A: :fixnum)
-        }.to raise_error(ArgumentError, ":fixnum is not a supported type. Should be one of #{ENVied::Coercer.supported_types}")
-      end
-    end
-
-    # TODO: review needed, doesn't make sense?
-    context 'bug: default value "false" is not coercible' do
-      before do
-        configure(enable_defaults: true) do
-          variable :FORCE_SSL, :boolean, default: true
-        end
-      end
-
-      specify do
-        expect {
-          envied_require
-        }.not_to raise_error
-      end
-    end
-
-    describe 'defaults' do
-      describe 'assigning' do
-        it 'sets a default value for ENV variable' do
-          configure(enable_defaults: true) do
-            variable :A, :integer, default: '1'
-          end
-          envied_require
-
-          expect(described_class.A).to eq 1
-        end
-
-        it 'sets a default value from calling a proc for ENV variable' do
-          configure(enable_defaults: true) do
-            variable :A, :integer, default: proc { "1" }
-          end
-          envied_require
-
-          expect(described_class.A).to eq 1
-        end
-
-        it 'ignores setting defaults if they are disabled' do
-          set_ENV
-          configure(enable_defaults: false) do
-            variable :A, :integer, default: "1"
-            variable :B, :integer, default: "1"
-          end
-
-          expect {
-            envied_require
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: A, B.')
-        end
-
-        it 'ignores a default value if ENV variable is already provided' do
-          set_ENV('A' => '2')
-          configure(enable_defaults: true) do
-            variable :A, :integer, default: "1"
-          end
-          envied_require
-
-          expect(described_class.A).to eq 2
-        end
-
-        it 'can set a default value via a proc that references another ENV variable' do
-          set_ENV('A' => '1')
-          configure(enable_defaults: true) do
-            variable :A, :integer
-            variable :B, :integer, default: proc {|env| env.A * 2 }
-          end
-          envied_require
-
-          expect(described_class.B).to eq 2
-        end
-      end
-    end
-
-    describe ".required?" do
-      # TODO: change to always return boolean
-      it 'returns true-ish if `ENVied.require` was called' do
-        expect {
-          envied_require
-        }.to change { ENVied.required? }.from(nil).to(anything)
-      end
-    end
-
-    describe "groups" do
-      context 'a variable in a group' do
-        before do
-          set_ENV
-          configure do
-            variable :MORE
-
-            group :foo do
-              variable :BAR
-            end
-            group :moo do
-              variable :BAT
-            end
-          end
-        end
-
-        it 'is required when requiring the groups passed as a delimited string' do
-          expect {
-            envied_require('foo,moo')
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR, BAT.')
-        end
-
-        it 'is required when requiring the group' do
-          [:foo, 'foo'].each do |group|
-            expect {
-              envied_require(group)
-            }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
-          end
-        end
-
-        it 'is not required when requiring another group' do
-          [:bat, 'bat'].each do |group|
-            expect {
-              envied_require(group)
-            }.to_not raise_error
-          end
-        end
-
-        it 'will not define variables not part of the default group' do
-          set_ENV('MORE' => 'yes')
-          envied_require(:default)
-
-          expect {
-            described_class.BAR
-          }.to raise_error(NoMethodError)
-        end
-
-        it 'takes ENV["ENVIED_GROUPS"] into account when nothing is passed to require' do
-          set_ENV('ENVIED_GROUPS' => 'foo')
-          expect {
-            envied_require
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
-        end
-
-        it 'will define variables in the default group when nothing is passed to require' do
-          set_ENV('MORE' => 'yes')
-          envied_require
-
-          expect(described_class.MORE).to eq 'yes'
-        end
-
-        it 'requires variables without a group when requiring the default group' do
-          [:default, 'default'].each do |group|
-            expect {
-              envied_require(group)
-            }.to raise_error(RuntimeError, 'The following environment variables should be set: MORE.')
-          end
-        end
-      end
-
-      context 'a variable in multiple groups' do
-        before do
-          set_ENV
-          configure do
-            variable :MORE
-
-            group :foo, :moo do
-              variable :BAR
-            end
-          end
-        end
-
-        it 'is required when requiring any of the groups' do
-          expect {
-            envied_require(:foo)
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
-
-          expect {
-            envied_require(:moo)
-          }.to raise_error(RuntimeError, 'The following environment variables should be set: BAR.')
-        end
-      end
-
-      describe 'Hashable' do
-        before do
-          set_ENV('FOO' => 'a=1&b=&c', 'BAR' => '')
-          configure do
-            variable :FOO, :hash
-            variable :BAR, :hash
-          end
-          envied_require
-        end
-
-        it 'yields hash from string' do
-          expect(ENVied.FOO).to eq({ 'a' => '1', 'b' => '', 'c' => nil })
-        end
-
-        it 'yields hash from an empty string' do
-          expect(ENVied.BAR).to eq({})
-        end
-
-        context 'with defaults enabled' do
-          before do
-            set_ENV
-            configure(enable_defaults: true) do
-              variable :BAZ, :hash
-            end
-          end
-
-          it 'has no default by default' do
-            # fixes a bug where variables of type :Hash had a default even
-            # when none was configured.
-            expect { envied_require }.to raise_error(RuntimeError, 'The following environment variables should be set: BAZ.')
-          end
-        end
-      end
-
-      describe 'Arrayable' do
-        before do
-          set_ENV('MORE' => 'a, b, and\, c')
-          configure do
-            variable :MORE, :array
-          end
-          envied_require
-        end
-
-        it 'yields array from string' do
-          expect(ENVied.MORE).to eq ['a',' b',' and, c']
-        end
-      end
-
-      describe 'URIable' do
-        before do
-          set_ENV('SITE_URL' => 'https://www.google.com')
-          configure do
-            variable :SITE_URL, :uri
-          end
-          envied_require
-        end
-
-        it 'yields a URI from string' do
-          expect(ENVied.SITE_URL).to be_a URI
-          expect(ENVied.SITE_URL.scheme).to eq 'https'
-          expect(ENVied.SITE_URL.host).to eq 'www.google.com'
-        end
-      end
-    end
-  end
-end