a9n 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f1aa00ff577227a9d07088e0053ea48814a8816
-  data.tar.gz: 932f917737c5c1c6cdb6919a9b16a1127a0a1c8f
+  metadata.gz: f02694ddef5b6bee722ffa1bc9fd625ca1ca471a
+  data.tar.gz: 49594a970d5088cc11229db97020b9756ae27792
 SHA512:
-  metadata.gz: 1e69852a57a9f29d640d4983dfec8406c7943b038d07a5b58a441461a2f2ae7df8cfc6489c3df784dcb1b698a1c66ad8aeb4519c21c9bf00218217cc6478a507
-  data.tar.gz: d578632bc24b83cbfcdc835f7a76f727ba850bd527134bdd08940823af9a49d3a6d9d9655401d3428e5fa115724bdbb8c45ec21caf11a47a3346ea014ff9acff
+  metadata.gz: c5795aa763517c51bb0edc2e78a8610bbc7e9c5c2c20c0031b79d0f15af1aaef4db1a6988cf4cdcb2ae899e61bc02c46f84def2ce70f11b65417b4b108adbbd4
+  data.tar.gz: 5f025caf0e34ef45490fa0b6d6b7daef9246cb01e658a02eecec7ac0198cf16aed33ee30e9ed4d69c736f2bdb8dd69f547f29c42f7b6f5b05a604cc515966ca8

data/a9n.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/a9n/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Krzysztof Knapik"]
   gem.email         = ["knapo@knapo.net"]
-  gem.description   = %q{a9n is a tool to keep ruby/rails apps extra configuration easily maintainable and verifiable}
+  gem.description   = %q{a9n - ruby/rails apps extra configuration manager}
   gem.summary       = %q{a9n is a tool to keep ruby/rails apps extra configuration easily maintainable and verifiable}
   gem.homepage      = "https://github.com/knapo/a9n"
   gem.license       = 'MIT'

data/lib/a9n/struct.rb

@@ -2,21 +2,9 @@ require 'ostruct'
 
 module A9n
   class Struct < OpenStruct
-    def empty?
-      @table.empty?
-    end
-
-    def keys
-      @table.keys
-    end
+    extend Forwardable
 
-    def fetch(name, default = nil)
-      @table.fetch(name.to_sym, default)
-    end
-
-    def key?(key)
-      to_h.key?(key)
-    end
+    def_delegators :@table, :empty?, :keys, :key?
 
     def merge(key_value)
       key_value.each_pair do |key, value|

data/lib/a9n/version.rb

@@ -1,3 +1,3 @@
 module A9n
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/spec/unit/a9n_spec.rb

@@ -3,182 +3,226 @@ require "spec_helper"
 describe A9n do
   subject { described_class }
 
-  after {
+  def clean_singleton(subject)
     subject.instance_variable_set(:@storage, nil)
     subject.instance_variable_set(:@env, nil)
     subject.root = nil
     subject.app = nil
-  }
+  end
+
+  before { clean_singleton(subject) }
+  after { clean_singleton(subject) }
 
   describe ".env" do
-    before {
+    before do
       subject.instance_variable_set(:@env, nil)
-    }
+    end
 
     context "app_env is set" do
-      before {
+      before do
         expect(subject).to receive(:app).and_return(double(env: "dwarf_env")).exactly(3).times
         expect(subject).to receive(:get_env_var).never
-      }
+      end
 
-      it { expect(subject.env).to eq("dwarf_env") }
+      it do
+        expect(subject.env).to eq("dwarf_env")
+      end
     end
 
     context "when APP_ENV is set" do
-      before {
+      before do
         expect(subject).to receive(:app_env).and_return(nil)
         expect(subject).to receive(:get_env_var).with("RAILS_ENV").and_return(nil)
         expect(subject).to receive(:get_env_var).with("RACK_ENV").and_return(nil)
         expect(subject).to receive(:get_env_var).with("APP_ENV").and_return("dwarf_env")
-      }
+      end
 
-      it { expect(subject.env).to eq("dwarf_env") }
+      it do
+        expect(subject.env).to eq("dwarf_env")
+      end
     end
   end
 
   describe ".app" do
     context "when rails not found" do
-      before {
+      before do
         expect(subject).to receive(:get_rails).and_return(nil)
-      }
-      specify {
+      end
+
+      it do
         expect(subject.app).to be_nil
-      }
+      end
     end
 
     context "when rails app is being used" do
       let(:app) { double(env: "test", root: "/apps/a9n") }
-      before {
+
+      before do
         expect(subject).to receive(:get_rails).and_return(app)
-      }
+      end
 
-      specify { expect(subject.app).to eq(app) }
+      it do
+        expect(subject.app).to eq(app)
+      end
     end
 
     context "when custom non-rails app is being used" do
       let(:app) { double(env: "test", root: "/apps/a9n") }
-      before { subject.app = app }
 
-      specify { expect(subject.app).to eq(app) }
+      before do
+        subject.app = app
+      end
+
+      it do
+        expect(subject.app).to eq(app)
+      end
     end
   end
 
   describe ".root" do
     let(:app) { double(env: "test", root: "/apps/a9n") }
-    before { subject.app = app }
+
+    before do
+      subject.app = app
+    end
 
     context "with custom path" do
-      before {
+      before do
         subject.root = "/home/knapo/workspace/a9n"
-      }
-      specify {
+      end
+
+      it do
         expect(subject.root).to eq(Pathname.new("/home/knapo/workspace/a9n"))
-      }
+      end
     end
 
     context "with local app path" do
-      specify {
+      it do
         expect(subject.root).to eq("/apps/a9n")
-      }
+      end
     end
   end
 
   describe ".get_rails" do
     context "when defined" do
-      before {
+      before do
         Object.const_set(:Rails, Module.new)
-      }
-      after {
+      end
+
+      after do
         Object.send(:remove_const, :Rails)
-      }
-      it {
+      end
+
+      it do
         expect(subject.get_rails).to be_kind_of(Module)
-      }
+      end
     end
+
     context "when not defined" do
-      it { expect(subject.get_rails).to be_nil }
+      it do
+        expect(subject.get_rails).to be_nil
+      end
     end
   end
 
   describe ".get_env_var" do
-    before { ENV["DWARF"] = "little dwarf" }
-    it { expect(subject.get_env_var("DWARF")).to eq("little dwarf")}
-    it { expect(subject.get_env_var("IS_DWARF")).to be_nil}
+    before do
+      ENV["DWARF"] = "little dwarf"
+    end
+
+    it do
+      expect(subject.get_env_var("DWARF")).to eq("little dwarf")
+    end
+
+    it do
+      expect(subject.get_env_var("IS_DWARF")).to be_nil
+    end
   end
 
   describe ".default_files" do
-    before {
+    before do
       subject.root = File.expand_path("../../../test_app", __FILE__)
-    }
-    it {
+    end
+
+    it do
       expect(subject.default_files[0]).to include("configuration.yml")
       expect(Pathname.new(subject.default_files[0])).to be_absolute
       expect(subject.default_files[1]).to include("a9n/mandrill.yml")
       expect(Pathname.new(subject.default_files[1])).to be_absolute
-    }
+    end
   end
 
   describe ".load" do
-    before {
+    before do
       expect(described_class).to receive(:env).exactly(2).times.and_return("dev")
       subject.root = "/apps/test_app"
       files.each do |f, cfg|
         expect(A9n::Loader).to receive(:new).with(f, "dev").and_return(double(get: cfg))
       end
-    }
+    end
+
     context "when no files given" do
-      let(:files) {
+      let(:files) do
         {
           "/apps/test_app/config/file1.yml" => { host: "host1.com" },
           "/apps/test_app/config/dir/file2.yml" => { host: "host2.com" }
         }
-      }
-      before {
+      end
+
+      before do
         expect(subject).to receive(:default_files).and_return(files.keys)
         expect(subject).to receive(:get_absolute_paths_for).never
-      }
-      it {
+      end
+
+      it do
         expect(subject.load).to eq(files.values)
-      }
+      end
     end
 
     context "when custom files given" do
-      let(:given_files) {
+      let(:given_files) do
         ["file3.yml", "/apps/test_app/config/dir/file4.yml"]
-      }
-      let(:files) {
+      end
+
+      let(:files) do
         {
           "/apps/test_app/config/file3.yml" => { host: "host3.com" },
           "/apps/test_app/config/dir/file4.yml" => { host: "host4.com" }
         }
-      }
-      before {
+      end
+
+      before do
         expect(subject).to receive(:default_files).never
         expect(subject).to receive(:get_absolute_paths_for).with(given_files).and_call_original
-      }
-      it {
+      end
+
+      it do
         expect(subject.load(*given_files)).to eq(files.values)
-      }
+      end
     end
   end
 
   describe ".method_missing" do
     context "when storage is empty" do
-      before { expect(subject).to receive(:load).once }
-      it {
+      before do
+        expect(subject).to receive(:load).once
+      end
+
+      it do
         expect(subject.storage).to be_empty
         expect { subject.whatever }.to raise_error(A9n::NoSuchConfigurationVariable)
-      }
+      end
     end
 
     context "when storage is not empty" do
-      before {
+      before do
         subject.storage[:whenever] = 'whenever'
         expect(subject).not_to receive(:load)
-      }
-      it {
+      end
+
+      it do
         expect { subject.whatever }.to raise_error(A9n::NoSuchConfigurationVariable)
-      }
+      end
     end
   end
 end

data/spec/unit/loader_spec.rb

@@ -30,6 +30,7 @@ describe A9n::Loader do
         expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(nil)
         expect(subject).to receive(:verify!).never
       end
+
       it "raises expection"  do
         expect {
           subject.load
@@ -48,9 +49,9 @@ describe A9n::Loader do
       it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
       it { expect(config.api_key).to eq("example1234") }
 
-      it {
+      it do
         expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariable)
-      }
+      end
     end
 
     context "when only local configuration file exists" do
@@ -60,12 +61,13 @@ describe A9n::Loader do
         expect(described_class).to receive(:verify!).never
         subject.load
       end
+
       it { expect(config.app_host).to eq("127.0.0.1:3000") }
       it { expect(config.api_key).to eq("local1234") }
 
-      it {
+      it do
         expect { config.app_url }.to raise_error(A9n::NoSuchConfigurationVariable)
-      }
+      end
     end
 
     context "when both local and base configuration file exists without defaults" do
@@ -79,9 +81,9 @@ describe A9n::Loader do
         it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
         it { expect(config.api_key).to eq("example1234") }
 
-        it {
+        it do
           expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariable)
-        }
+        end
       end
 
       context "with different data" do
@@ -95,7 +97,7 @@ describe A9n::Loader do
         it "raises expection with missing variables names"  do
           expect {
             subject.load
-          }.to raise_error(A9n::MissingConfigurationVariables, /#{missing_variables_names.join(', ')}/)
+          }.to raise_error(A9n::MissingConfigurationVariables, /#{missing_variables_names.join(", ")}/)
         end
       end
     end
@@ -119,11 +121,11 @@ describe A9n::Loader do
         end
       end
 
-      before {
+      before do
         ENV["DWARF"] = "erbized dwarf"
-      }
+      end
 
-      context 'when file has erb extension' do
+      context "when file has erb extension" do
         let(:file_path) { File.join(root, "config/a9n/cloud.yml.erb") }
 
         it_behaves_like "non-empty config file"

data/spec/unit/struct_spec.rb

@@ -1,108 +1,119 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe A9n::Struct do
   context "without any values" do
     subject { described_class.new }
 
-    it 'is empty' do
-      expect(subject).to be_empty
+    describe "#empty?" do
+      it { expect(subject).to be_empty }
     end
 
-    it 'raises error' do
+    describe "#keys" do
+      it { expect(subject.keys).to eq([]) }
+    end
+
+    describe "#key?" do
+      it { expect(subject.key?(:dwarf)).to eq(false) }
+    end
+
+    describe "#[]" do
+      it { expect(subject[:dwarf]).to be_nil }
+    end
+
+    it "raises error on accessin invalid attribute" do
       expect {
         subject.dwarf
-      }.to raise_error(A9n::NoSuchConfigurationVariable, 'dwarf')
+      }.to raise_error(A9n::NoSuchConfigurationVariable, "dwarf")
     end
   end
 
   context "with values" do
     subject {
       described_class.new({
-          non_empty_dwarf: 'dwarf',
+          non_empty_dwarf: "dwarf",
           nil_dwarf:   nil,
           false_dwarf: false,
           true_dwarf:  true,
-          hash_dwarf:  { dwarf: 'hello' }
+          hash_dwarf:  { dwarf: "hello" }
         })
     }
 
-    describe '#keys' do
-      subject { super().keys }
-
+    describe "#keys" do
       it do
-        expect(subject).to eq [:non_empty_dwarf, :nil_dwarf, :false_dwarf, :true_dwarf, :hash_dwarf]
+        expect(subject.keys).to eq [:non_empty_dwarf, :nil_dwarf, :false_dwarf, :true_dwarf, :hash_dwarf]
       end
     end
 
-    describe '#merge' do
+    describe "#key?" do
+      it { expect(subject.key?(:nil_dwarf)).to eq(true) }
+      it { expect(subject.key?(:unknown)).to eq(false) }
+    end
+
+    describe "#merge" do
       before { subject.merge(argument) }
 
-      context 'hash' do
-        let(:argument) { { non_empty_dwarf: 'hello dwarf' } }
+      context "hash" do
+        let(:argument) { { non_empty_dwarf: "hello dwarf" } }
 
         it do
-          expect(subject.non_empty_dwarf).to eq('hello dwarf')
+          expect(subject.non_empty_dwarf).to eq("hello dwarf")
         end
       end
 
-      context 'struct' do
-        let(:argument) { described_class.new(non_empty_dwarf: 'hello dwarf') }
+      context "struct" do
+        let(:argument) { described_class.new(non_empty_dwarf: "hello dwarf") }
 
         it do
-          expect(subject.non_empty_dwarf).to eq('hello dwarf')
+          expect(subject.non_empty_dwarf).to eq("hello dwarf")
         end
       end
     end
 
-    it 'is not empty' do
+    it "is not empty" do
       expect(subject).not_to be_empty
     end
 
-    it 'gets non-empty value' do
-      expect(subject.non_empty_dwarf).to eq('dwarf')
+    it "gets non-empty value" do
+      expect(subject.non_empty_dwarf).to eq("dwarf")
     end
 
-    it 'gets nil value' do
+    it "gets nil value" do
       expect(subject.nil_dwarf).to eq(nil)
     end
 
-    it 'gets true value' do
+    it "gets true value" do
       expect(subject.true_dwarf).to eq(true)
     end
 
-    it 'gets false value' do
+    it "gets false value" do
       expect(subject.false_dwarf).to eq(false)
     end
 
-    it 'gets hash value' do
+    it "gets hash value" do
       expect(subject.hash_dwarf).to be_kind_of(Hash)
     end
 
-    it 'raises exception when value not exists' do
+    it "raises exception when value not exists" do
       expect {
         subject.non_existing_dwarf
       }.to raise_error(A9n::NoSuchConfigurationVariable)
     end
 
-    describe '#fetch' do
-      it 'return non empty value' do
-        expect(subject.fetch(:non_empty_dwarf)).to eq('dwarf')
-      end
-
-      it 'return false value' do
-        expect(subject.fetch(:false_dwarf)).to eq(false)
+    describe "#[]" do
+      it "return non empty value" do
+        expect(subject[:non_empty_dwarf]).to eq("dwarf")
       end
 
-      it 'return nil value' do
-        expect(subject.fetch(:nil_dwarf)).to eq(nil)
+      it "return false value" do
+        expect(subject[:false_dwarf]).to eq(false)
       end
 
-      it 'return nil for non existing value' do
-        expect(subject.fetch(:non_existing_dwarf)).to eq(nil)
+      it "return nil value" do
+        expect(subject[:nil_dwarf]).to eq(nil)
       end
 
-      it 'return default for non existing value' do
-        expect(subject.fetch(:non_existing_dwarf, 'default')).to eq('default')
+      it "return nil for non existing value" do
+        expect(subject[:non_existing_dwarf]).to eq(nil)
       end
     end
   end

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: a9n
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Krzysztof Knapik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-17 00:00:00.000000000 Z
+date: 2015-02-18 00:00:00.000000000 Z
 dependencies: []
-description: a9n is a tool to keep ruby/rails apps extra configuration easily maintainable
-  and verifiable
+description: a9n - ruby/rails apps extra configuration manager
 email:
 - knapo@knapo.net
 executables: []