envied 0.9.1 → 0.9.2.rc1

data/lib/envied/env_proxy.rb

@@ -2,8 +2,9 @@ class ENVied
   # Responsible for anything related to the ENV.
   class EnvProxy
     attr_reader :config, :coercer, :groups
+    private :config, :coercer, :groups
 
-    def initialize(config, options = {})
+    def initialize(config, **options)
       @config = config
       @coercer = options.fetch(:coercer, ENVied::Coercer.new)
       @groups = options.fetch(:groups, [])
@@ -17,16 +18,6 @@ class ENVied
       variables.reject(&method(:coerced?)).reject(&method(:coercible?))
     end
 
-    def variables
-      @variables ||= begin
-        config.variables.select {|v| groups.include?(v.group) }
-      end
-    end
-
-    def variables_by_name
-      Hash[variables.map {|v| [v.name, v] }]
-    end
-
     def [](name)
       coerce(variables_by_name[name.to_sym])
     end
@@ -35,35 +26,45 @@ class ENVied
       variables_by_name[name.to_sym]
     end
 
-    def env_value_of(var)
-      ENV[var.name.to_s]
-    end
-
-    def default_value_of(var)
-      var.default_value(ENVied, var)
-    end
-
     def value_to_coerce(var)
       return env_value_of(var) unless env_value_of(var).nil?
       config.defaults_enabled? ? default_value_of(var) : nil
     end
 
+    private
+
     def coerce(var)
       coerced?(var) ?
         value_to_coerce(var) :
         coercer.coerce(value_to_coerce(var), var.type)
     end
 
+    def coerced?(var)
+      coercer.coerced?(value_to_coerce(var))
+    end
+
     def coercible?(var)
       coercer.coercible?(value_to_coerce(var), var.type)
     end
 
+    def default_value_of(var)
+      var.default_value(ENVied, var)
+    end
+
+    def env_value_of(var)
+      ENV[var.name.to_s]
+    end
+
     def missing?(var)
       value_to_coerce(var).nil?
     end
 
-    def coerced?(var)
-      coercer.coerced?(value_to_coerce(var))
+    def variables
+      @variables ||= config.variables.select {|v| groups.include?(v.group) }
+    end
+
+    def variables_by_name
+      @variables_by_name ||= variables.map {|v| [v.name, v] }.to_h
     end
   end
 end

data/lib/envied/env_var_extractor.rb

@@ -15,12 +15,12 @@ class ENVied
 
     attr_reader :globs, :extensions
 
-    def initialize(options = {})
+    def initialize(**options)
       @globs = options.fetch(:globs, self.defaults[:globs])
       @extensions = options.fetch(:extensions, self.defaults[:extensions])
     end
 
-    def self.extract_from(globs, options = {})
+    def self.extract_from(globs, **options)
       new(options.merge(globs: Array(globs))).extract
     end
 

data/lib/envied/variable.rb

@@ -1,7 +1,7 @@
 class ENVied::Variable
   attr_reader :name, :type, :group, :default
 
-  def initialize(name, type, options = {})
+  def initialize(name, type, **options)
     @name = name.to_sym
     @type = type.to_sym
     @group = options.fetch(:group, :default).to_sym

data/lib/envied/version.rb

@@ -1,3 +1,3 @@
 class ENVied
-  VERSION = '0.9.1'
+  VERSION = '0.9.2.rc1'
 end

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