configurate 0.1.0 → 0.5.0

data/spec/configurate/provider/dynamic_spec.rb

@@ -1,16 +1,18 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Configurate::Provider::Dynamic do
   subject { described_class.new }
   describe "#lookup_path" do
     it "returns nil if the setting was never set" do
-      expect(subject.lookup_path Configurate::SettingPath.new(["not_me"]) ).to be_nil
+      expect(subject.lookup_path(Configurate::SettingPath.new(["not_me"]))).to be_nil
     end
 
     it "remembers the setting if it ends with =" do
       subject.lookup_path Configurate::SettingPath.new(["find_me", "later="]), "there"
 
-      expect(subject.lookup_path Configurate::SettingPath.new(["find_me", "later"]) ).to eq "there"
+      expect(subject.lookup_path(Configurate::SettingPath.new(%w[find_me later]))).to eq "there"
     end
 
     it "calls .get on the argument if a proxy object is given" do
@@ -20,8 +22,14 @@ describe Configurate::Provider::Dynamic do
     end
 
     it "resolves nested calls after group assignment" do
-      subject.lookup_path Configurate::SettingPath.new(["find_me", "later="]), {"a" => "b"}
-      expect(subject.lookup_path Configurate::SettingPath.new(["find_me", "later", "a"])).to eq "b"
+      subject.lookup_path Configurate::SettingPath.new(%w[find_me later=]), "a" => "b"
+      expect(subject.lookup_path(Configurate::SettingPath.new(%w[find_me later a]))).to eq "b"
+    end
+
+    it "clears out all overrides on reset_dynamic!" do
+      subject.lookup_path Configurate::SettingPath.new(["find_me", "later="]), "there"
+      expect(subject.lookup_path(Configurate::SettingPath.new(["reset_dynamic!"]))).to eq true
+      expect(subject.lookup_path(Configurate::SettingPath.new(%w[find_me later]))).to_not eq "there"
     end
   end
 end

data/spec/configurate/provider/env_spec.rb

@@ -1,32 +1,34 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Configurate::Provider::Env do
   subject { described_class.new }
-  let(:existing_path) { ['existing', 'setting']}
-  let(:not_existing_path) { ['not', 'existing', 'path']}
-  let(:array_path) { ['array'] }
+  let(:existing_path) { %w[existing setting] }
+  let(:not_existing_path) { %w[not existing path] }
+  let(:array_path) { ["array"] }
   before(:all) do
-    ENV['EXISTING_SETTING'] = "there"
-    ENV['ARRAY'] = "foo,bar,baz"
+    ENV["EXISTING_SETTING"] = "there"
+    ENV["ARRAY"] = "foo,bar,baz"
   end
 
   after(:all) do
-    ENV['EXISTING_SETTING'] = nil
-    ENV['ARRAY'] = nil
+    ENV["EXISTING_SETTING"] = nil
+    ENV["ARRAY"] = nil
   end
 
-  describe '#lookup_path' do
+  describe "#lookup_path" do
     it "joins and upcases the path" do
       expect(ENV).to receive(:[]).with("EXISTING_SETTING")
       subject.lookup_path existing_path
     end
 
     it "returns nil if the setting isn't available" do
-      expect(subject.lookup_path not_existing_path).to be_nil
+      expect(subject.lookup_path(not_existing_path)).to be_nil
     end
 
     it "makes an array out of comma separated values" do
-      expect(subject.lookup_path array_path).to eq ["foo", "bar", "baz"]
+      expect(subject.lookup_path(array_path)).to eq %w[foo bar baz]
     end
 
     it "returns a unfrozen string" do

data/spec/configurate/provider/string_hash_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Configurate::Provider::StringHash do
+  let(:settings) {
+    {
+      "toplevel" => "bar",
+      "some"     => {
+        "nested" => {"some" => "lala", "setting" => "foo"}
+      }
+    }
+  }
+
+  describe "#initialize" do
+    it "raises if the argument is not hash" do
+      expect {
+        described_class.new "foo"
+      }.to raise_error ArgumentError
+    end
+
+    context "with a namespace" do
+      it "looks in the hash for that namespace" do
+        namespace = "some.nested"
+        provider = described_class.new settings, namespace: namespace
+        expect(provider.instance_variable_get(:@settings)).to eq settings["some"]["nested"]
+      end
+
+      it "raises if the namespace isn't found" do
+        expect {
+          described_class.new({}, namespace: "bar")
+        }.to raise_error ArgumentError
+      end
+
+      it "works with an empty namespace in the file" do
+        expect {
+          described_class.new({"foo" => {"bar" => nil}}, namespace: "foo.bar")
+        }.to_not raise_error
+      end
+    end
+
+    context "with required set to false" do
+      it "doesn't raise if a namespace isn't found" do
+        expect {
+          silence_stderr do
+            described_class.new({}, namespace: "foo", required: false)
+          end
+        }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#lookup_path" do
+    before do
+      @provider = described_class.new settings
+    end
+
+    it "looks up the whole nesting" do
+      expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
+    end
+
+    it "returns nil if no setting is found" do
+      expect(@provider.lookup_path(["not_me"])).to be_nil
+    end
+
+    context "with raise_on_missing set to true" do
+      before do
+        @provider = described_class.new settings, raise_on_missing: true
+      end
+
+      it "looks up the whole nesting" do
+        expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
+      end
+
+      it "returns nil if no setting is found" do
+        expect {
+          @provider.lookup_path ["not_me"]
+        }.to raise_error Configurate::MissingSetting
+      end
+    end
+  end
+end

data/spec/configurate/provider/toml_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "configurate/provider/toml"
+
+describe Configurate::Provider::TOML do
+  PARSER = Configurate::Provider::TOML::PARSER
+
+  let(:settings) {
+    {
+      "toplevel" => "bar",
+      "some"     => {
+        "nested" => {"some" => "lala", "setting" => "foo"}
+      }
+    }
+  }
+
+  describe "#initialize" do
+    it "loads the file" do
+      file = "foobar.toml"
+      expect(PARSER).to receive(:load_file).with(file).and_return({})
+      described_class.new file
+    end
+
+    it "raises if the file is not found" do
+      allow(PARSER).to receive(:load_file).and_raise(Errno::ENOENT)
+      expect {
+        silence_stderr do
+          described_class.new "foo"
+        end
+      }.to raise_error Errno::ENOENT
+    end
+
+    context "with a namespace" do
+      it "looks in the file for that namespace" do
+        namespace = "some.nested"
+        allow(PARSER).to receive(:load_file).and_return(settings)
+        provider = described_class.new "bla", namespace: namespace
+        expect(provider.instance_variable_get(:@settings)).to eq settings["some"]["nested"]
+      end
+
+      it "raises if the namespace isn't found" do
+        allow(PARSER).to receive(:load_file).and_return({})
+        expect {
+          silence_stderr do
+            described_class.new "bla", namespace: "bar"
+          end
+        }.to raise_error ArgumentError
+      end
+
+      it "works with an empty namespace in the file" do
+        allow(PARSER).to receive(:load_file).and_return("foo" => {"bar" => nil})
+        expect {
+          silence_stderr do
+            described_class.new "bla", namespace: "foo.bar"
+          end
+        }.to_not raise_error
+      end
+    end
+
+    context "with required set to false" do
+      it "doesn't raise if a file isn't found" do
+        allow(PARSER).to receive(:load_file).and_raise(Errno::ENOENT)
+        expect {
+          silence_stderr do
+            described_class.new "not_me", required: false
+          end
+        }.not_to raise_error
+      end
+
+      it "doesn't raise if a namespace isn't found" do
+        allow(PARSER).to receive(:load_file).and_return({})
+        expect {
+          silence_stderr do
+            described_class.new "bla", namespace: "foo", required: false
+          end
+        }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#lookup_path" do
+    before do
+      allow(PARSER).to receive(:load_file).and_return(settings)
+      @provider = described_class.new "dummy"
+    end
+
+    it "looks up the whole nesting" do
+      expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
+    end
+
+    it "returns nil if no setting is found" do
+      expect(@provider.lookup_path(["not_me"])).to be_nil
+    end
+
+    context "with raise_on_missing set to true" do
+      before do
+        @provider = described_class.new "dummy", raise_on_missing: true
+      end
+
+      it "looks up the whole nesting" do
+        expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
+      end
+
+      it "returns nil if no setting is found" do
+        expect {
+          @provider.lookup_path ["not_me"]
+        }.to raise_error Configurate::MissingSetting
+      end
+    end
+  end
+end

data/spec/configurate/provider/yaml_spec.rb

@@ -1,11 +1,16 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Configurate::Provider::YAML do
-  let(:settings) { {"toplevel" => "bar",
-                    "some" => {
-                      "nested" => { "some" => "lala", "setting" => "foo"}
-                    }
-                   } }
+  let(:settings) {
+    {
+      "toplevel" => "bar",
+      "some"     => {
+        "nested" => {"some" => "lala", "setting" => "foo"}
+      }
+    }
+  }
 
   describe "#initialize" do
     it "loads the file" do
@@ -23,26 +28,25 @@ describe Configurate::Provider::YAML do
       }.to raise_error Errno::ENOENT
     end
 
-
     context "with a namespace" do
       it "looks in the file for that namespace" do
         namespace = "some.nested"
         allow(::YAML).to receive(:load_file).and_return(settings)
-        provider = described_class.new 'bla', namespace: namespace
-        expect(provider.instance_variable_get :@settings).to eq settings['some']['nested']
+        provider = described_class.new "bla", namespace: namespace
+        expect(provider.instance_variable_get(:@settings)).to eq settings["some"]["nested"]
       end
 
       it "raises if the namespace isn't found" do
         allow(::YAML).to receive(:load_file).and_return({})
         expect {
-          described_class.new 'bla', namespace: "bar"
-        }.to raise_error
+          described_class.new "bla", namespace: "bar"
+        }.to raise_error ArgumentError
       end
 
       it "works with an empty namespace in the file" do
-        allow(::YAML).to receive(:load_file).and_return({'foo' => {'bar' => nil}})
+        allow(::YAML).to receive(:load_file).and_return("foo" => {"bar" => nil})
         expect {
-          described_class.new 'bla', namespace: "foo.bar"
+          described_class.new "bla", namespace: "foo.bar"
         }.to_not raise_error
       end
     end
@@ -51,14 +55,18 @@ describe Configurate::Provider::YAML do
       it "doesn't raise if a file isn't found" do
         allow(::YAML).to receive(:load_file).and_raise(Errno::ENOENT)
         expect {
-          described_class.new "not_me", required: false
+          silence_stderr do
+            described_class.new "not_me", required: false
+          end
         }.not_to raise_error
       end
 
       it "doesn't raise if a namespace isn't found" do
         allow(::YAML).to receive(:load_file).and_return({})
         expect {
-          described_class.new 'bla', namespace: "foo", required: false
+          silence_stderr do
+            described_class.new "bla", namespace: "foo", required: false
+          end
         }.not_to raise_error
       end
     end
@@ -67,15 +75,31 @@ describe Configurate::Provider::YAML do
   describe "#lookup_path" do
     before do
       allow(::YAML).to receive(:load_file).and_return(settings)
-      @provider = described_class.new 'dummy'
+      @provider = described_class.new "dummy"
     end
 
     it "looks up the whole nesting" do
-      expect(@provider.lookup_path ["some", "nested", "some"]).to eq settings["some"]["nested"]["some"]
+      expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
     end
 
     it "returns nil if no setting is found" do
-      expect(@provider.lookup_path ["not_me"]).to be_nil
+      expect(@provider.lookup_path(["not_me"])).to be_nil
+    end
+
+    context "with raise_on_missing set to true" do
+      before do
+        @provider = described_class.new "dummy", raise_on_missing: true
+      end
+
+      it "looks up the whole nesting" do
+        expect(@provider.lookup_path(%w[some nested some])).to eq settings["some"]["nested"]["some"]
+      end
+
+      it "returns nil if no setting is found" do
+        expect {
+          @provider.lookup_path ["not_me"]
+        }.to raise_error Configurate::MissingSetting
+      end
     end
   end
 end

data/spec/configurate/provider_spec.rb

@@ -1,10 +1,12 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Configurate::Provider::Base do
   describe "#lookup" do
     subject { described_class.new }
     it "calls #lookup_path" do
-      path = Configurate::SettingPath.new(["foo", "bar"])
+      path = Configurate::SettingPath.new(%w[foo bar])
       expect(subject).to receive(:lookup_path).with(path).and_return("something")
       expect(subject.lookup(path)).to eq "something"
     end
@@ -16,4 +18,15 @@ describe Configurate::Provider::Base do
       }.to raise_error Configurate::SettingNotFoundError
     end
   end
+
+  describe "::lookup_in_hash" do
+    let(:hash) { {foo: {bar: nil}} }
+    it "returns nil if key is nil" do
+      expect(Configurate::Provider.lookup_in_hash(%i[foo bar], hash) { :fallback }).to be_nil
+    end
+
+    it "returns fallback for a non-existent key" do
+      expect(Configurate::Provider.lookup_in_hash(%i[foo bar baz], hash) { :fallback }).to eq :fallback
+    end
+  end
 end

data/spec/configurate/proxy_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Configurate::Proxy do
   let(:lookup_chain) { double(lookup: "something") }
@@ -6,12 +8,12 @@ describe Configurate::Proxy do
 
   describe "in case statements" do
     it "acts like the target" do
-      pending "If anyone knows a way to overwrite ===, please tell me :P"
+      pending "If anyone knows a sane way to overwrite Module#===, please tell me :P"
       result = case proxy
                when String
-                "string"
+                 "string"
                else
-                "wrong"
+                 "wrong"
                end
       expect(result).to eq "string"
     end
@@ -23,6 +25,11 @@ describe Configurate::Proxy do
       proxy.method_missing(:enable?)
     end
 
+    it "calls #target if the method ends with a !" do
+      expect(lookup_chain).to receive(:lookup).and_return(false)
+      proxy.method_missing(:do_it!)
+    end
+
     it "calls #target if the method ends with a =" do
       expect(lookup_chain).to receive(:lookup).and_return(false)
       proxy.method_missing(:url=)
@@ -49,9 +56,8 @@ describe Configurate::Proxy do
   end
 
   describe "#target" do
-    [:to_str, :to_s, :to_xml, :respond_to?, :present?, :!=, :eql?,
-     :each, :try, :size, :length, :count, :==, :=~, :gsub, :blank?, :chop,
-     :start_with?, :end_with?].each do |method|
+    %i[to_s to_xml respond_to? present? != eql? each try size length
+       count == =~ gsub blank? chop start_with? end_with?].each do |method|
       it "is called for accessing #{method} on the proxy" do
         target = double(respond_to?: true, _proxy?: false)
         allow(lookup_chain).to receive(:lookup).and_return(target)
@@ -72,5 +78,25 @@ describe Configurate::Proxy do
     it "returns nil if no setting is given" do
       expect(proxy.target).to be_nil
     end
+
+    it "converts to a string" do
+      allow(lookup_chain).to receive(:lookup).and_return("bar")
+      expect("foo#{proxy.something}").to eq "foobar"
+    end
+
+    it "converts to a number" do
+      allow(lookup_chain).to receive(:lookup).and_return(1)
+      expect(2 + proxy.something).to eq 3
+    end
+
+    it "converts to an array" do
+      allow(lookup_chain).to receive(:lookup).and_return([1, 2])
+      expect(%i[a b].zip(proxy.something)).to eq [[:a, 1], [:b, 2]]
+    end
+
+    it "converts to a hash" do
+      allow(lookup_chain).to receive(:lookup).and_return(a: :b)
+      expect({c: :d}.merge(proxy.something)).to eq a: :b, c: :d
+    end
   end
 end