a9n 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1278accbf3b20ef8dcf2084995996dbaa1bdabda
-  data.tar.gz: d444fa5ca535f636c4d0eefb03895d3bf12813da
+  metadata.gz: e1fa842e61082deb4d82eb3059efed6cb0ce0e50
+  data.tar.gz: a3250f33bf6df0ae3b06de1bb30774acf958d65f
 SHA512:
-  metadata.gz: 71e3c6444b5418cf69547a9e81cd88dcefd6d346648268de14f2adf045f0920100865041cd0f7637c25f5d2fe376036b39c4b3be24df2ddb8729531bcee02d1b
-  data.tar.gz: 5b924cb72e0a6d6813056ab6ef43e1b3a07ac4eb5c3615ae74c26834b3bc8ce0938fabbe0d07eeeaf06a23b94708255cf8ad192114405d40c00458a7bd345090
+  metadata.gz: ca996bb79d7331734d27e51eb5b35c1759a95bc680056ca6a25c78ec138d2c6c2272e613cb2bbd18aa4cbb01155ef981d8fa4719f909239abfb3c15c273e9b2a
+  data.tar.gz: d9e4c62825e16d882d3f9dadb56e4689e64b7036a47b77557208ff9c89a2f5798992fde85eb77fbe26c97d310c35dfd8967b627135497fd18e0f6a1ad0e37841

data/README.md

@@ -10,8 +10,7 @@
 [codeclimate]: https://codeclimate.com/github/knapo/a9n
 [coveralls]: https://coveralls.io/r/knapo/a9n
 
-Simple tool for managing extra configuration in ruby/rails apps. Supports Rails 2.x, 3.x, 4.x and Ruby 1.9, 2.0.
-Ruby 1.8 is not supported in version 0.1.2 and higher.
+A9n is a simple tool for managing extra configuration in ruby/rails apps. It supports Rails 2.x, 3.x, 4.x and Ruby 1.9, 2.0. 2.1. Ruby 1.8 is not supported since version 0.1.2.
 
 ## Installation
 
@@ -37,15 +36,14 @@ after budler requires:
     A9n.root = File.expand_path('../..', __FILE__)
     A9n.load
 
-
 It works with `Rails` by default. If you want to use `A9n` with non-rails app
-you may need to tell it A9n:
+you may need to tell that to A9n by:
 
     A9n.local_app = MyApp
 
 ## Usage
 
-You can access any variable defined in configuration files but delegating it to
+You can access any variable defined in configuration files by delegating it to
 `A9n`. E.g:
 
     defaults:
@@ -58,21 +56,22 @@ You can access any variable defined in configuration files but delegating it to
 is accessible by:
 
     A9n.app_host   # => `knapo.net` in production and `localhost:3000` in development
-    A9n.email_from # => `no-reply@knapo.net` in all envs
+    A9n.email_from # => `no-reply@knapo.net` in both envs
 
 ## Custom and multiple configuration files
 
-If you need to load config from custom files (e.g `config/mongo.yml`, `config/other.yml` and `config/custom_dir/extra.yml`), add:
-
-    A9n.load('mongo.yml', 'other.yml', 'custom_dir/extra')
+If you want to scope configuration you may split to multiple files. All files from `config/a9n` are loaded by default, but you may pass custom paths as an argument to `A9n.load` e.g. `A9n.load('lib/facebook/api.yml', 'config/mongoid.yml')`. In such cases config items are accessialbe via scope consistient with the file name. 
 
-and the configuration is availble under `mongo`, `other` and `extra` scopes:
+E.g. if you have `config/a9n/mandrill.yml`:
+     
+     defaults:
+       username: "joe"
+       api_key: "1234asdf"
 
-    A9n.mongo.varname
+you can access it by:
 
-    A9n.other.varname
-
-    A9n.extra.varname
+     A9n.mandrill.username # => `joe`
+     A9n.mandrill.api_key # => `1234asdf`
 
 ## Contributing
 
@@ -82,7 +81,3 @@ and the configuration is availble under `mongo`, `other` and `extra` scopes:
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-### Contributors
-
-* [Grzegorz Świrski](https://github.com/sognat)
-* [Jakub Łopusiński](https://github.com/siemakuba)

data/lib/a9n.rb

@@ -1,6 +1,7 @@
 require "a9n/version"
 require "a9n/struct"
-require "a9n/core_ext/hash"
+require "a9n/ext/hash"
+require "a9n/loader"
 require "yaml"
 require "erb"
 
@@ -15,82 +16,63 @@ module A9n
 
   class << self
     def env
-      @env ||= local_app_env || get_env_var("RAILS_ENV") || get_env_var("RACK_ENV") || get_env_var("APP_ENV")
+      @env ||= app_env || get_env_var("RAILS_ENV") || get_env_var("RACK_ENV") || get_env_var("APP_ENV")
     end
 
-    def local_app_env
-      local_app.env if local_app && local_app.respond_to?(:env)
+    def app_env
+      app.env if app && app.respond_to?(:env)
     end
 
-    def local_app
-      @local_app ||= get_rails
+    def app
+      @app ||= get_rails
     end
 
-    def local_app=(local_app)
-      @local_app = local_app
+    def app=(app_instance)
+      @app = app_instance
     end
 
     def root
-      @root ||= local_app.root
+      @root ||= app.root
     end
 
     def root=(path)
-      path = path.to_s
-      @root = path.empty? ? nil : Pathname.new(path.to_s)
+      @root = path.to_s.empty? ? nil : Pathname.new(path.to_s)
     end
 
-    def scope(name)
-      instance_variable_get(var_name_for(name)) || (name == DEFAULT_SCOPE && load.first)
+    def get_rails
+      defined?(Rails) ? Rails : nil
     end
 
-    def load(*files)
-      files = [DEFAULT_FILE] if files.empty?
-      files.map do |file|
-        default_and_env_config = load_config(file)
-
-        instance_variable_set(var_name_for(file), A9n::Struct.new(default_and_env_config))
-      end
+    def get_env_var(name)
+      ENV[name]
     end
 
-    def load_config(file)
-      env_example      = load_yml("config/#{file}.example", env)
-      env_local        = load_yml("config/#{file}", env)
-      default_example  = load_yml("config/#{file}.example", "defaults")
-      default_local    = load_yml("config/#{file}", "defaults")
-
-      if env_example.nil? && env_local.nil? && default_example.nil? && default_local.nil?
-        raise MissingConfigurationData.new("Configuration data was not found in neither config/#{file}.example nor config/#{file}")
-      end
-
-      example = Hash.merge(default_example, env_example)
-      local = Hash.merge( default_local,env_local)
-
-      if !example.nil? && !local.nil?
-        verify!(example, local)
-      end
-
-      local || example
+    def fetch(*args)
+      scope(DEFAULT_SCOPE).fetch(*args)
     end
 
-    def load_yml(file, env)
-      path = File.join(self.root, file)
-      return nil unless File.exists?(path)
-      yml = YAML.load(ERB.new(File.read(path)).result)
+    def scope(name)
+      load unless instance_variable_defined?(var_name_for(name))
+      instance_variable_get(var_name_for(name))
+    end
 
-      if yml[env].is_a?(Hash)
-        return yml[env].deep_symbolize_keys
-      else
-        return nil
-      end
+    def var_name_for(file)
+      :"@#{File.basename(file.to_s, '.*')}"
     end
 
-    # Fixes rspec issue
-    def to_ary
-      nil
+    def default_files
+      [root.join("config/#{DEFAULT_SCOPE}.yml").to_s] + Dir[root.join("config/a9n/*.yml")]
     end
 
-    def fetch(*args)
-      scope(DEFAULT_SCOPE).fetch(*args)
+    def load(*files)
+      if files.empty?
+        files = default_files
+      else
+        files = get_absolute_paths_for(files)
+      end
+      files.map do |file|
+        instance_variable_set(var_name_for(file), A9n::Loader.new(file, env).get)
+      end
     end
 
     def method_missing(name, *args)
@@ -101,25 +83,10 @@ module A9n
       end
     end
 
-    def get_rails
-      defined?(Rails) ? Rails : nil
-    end
-
-    def get_env_var(name)
-      ENV[name]
-    end
-
-    def var_name_for(file)
-      :"@#{file.to_s.split('/').last.split('.').first}"
-    end
-
     private
 
-    def verify!(example, local)
-      missing_keys = example.keys - local.keys
-      if missing_keys.any?
-        raise MissingConfigurationVariables.new("Following variables are missing in your configuration file: #{missing_keys.join(",")}")
-      end
+    def get_absolute_paths_for(files)
+      files.map { |file| Pathname.new(file).absolute? ? file : self.root.join('config', file).to_s }
     end
   end
 end

data/lib/a9n/ext/hash.rb

@@ -0,0 +1,21 @@
+module A9n
+  class HashExt
+    class << self
+      # Hash#deep_symbolize_keys
+      # based on
+      # https://github.com/svenfuchs/i18n/blob/master/lib/i18n/core_ext/hash.rb
+      def deep_symbolize_keys(hash)
+        hash.inject({}) { |result, (key, value)|
+          value = deep_symbolize_keys(value) if value.is_a?(::Hash)
+          result[(key.to_sym rescue key) || key] = value
+          result
+        }
+      end
+
+      def merge(*items)
+        return nil if items.compact.empty?
+        items.compact.inject({}){|sum, item| sum.merge!(item)}
+      end
+    end
+  end
+end

data/lib/a9n/loader.rb

@@ -0,0 +1,57 @@
+require 'ostruct'
+
+module A9n
+  class Loader
+    attr_reader :env, :local_file, :example_file
+
+    def initialize(file_path, env)
+      @env = env.to_s
+      @local_file = file_path
+      @example_file = "#{file_path}.example"
+    end
+
+    def get
+      @struct ||= load
+    end
+
+    def load
+      env_example      = self.class.load_yml(example_file, env)
+      env_local        = self.class.load_yml(local_file, env)
+      default_example  = self.class.load_yml(example_file, "defaults")
+      default_local    = self.class.load_yml(local_file, "defaults")
+
+      if env_example.nil? && env_local.nil? && default_example.nil? && default_local.nil?
+        raise A9n::MissingConfigurationData.new("Configuration data for *#{env}* env was not found in neither *#{example_file}* nor *#{local_file}*")
+      end
+
+      example = A9n::HashExt.merge(default_example, env_example)
+      local   = A9n::HashExt.merge(default_local, env_local)
+
+      if !example.nil? && !local.nil?
+        verify!(example, local)
+      end
+
+      @struct = A9n::Struct.new(local || example)
+    end
+
+    def self.load_yml(file_path, env)
+      return nil unless File.exists?(file_path)
+      yml = YAML.load(ERB.new(File.read(file_path)).result)
+
+      if yml[env].is_a?(::Hash)
+        A9n::HashExt.deep_symbolize_keys(yml[env])
+      else
+        return nil
+      end
+    end
+
+    private
+
+    def verify!(example, local)
+      missing_keys = example.keys - local.keys
+      if missing_keys.any?
+        raise A9n::MissingConfigurationVariables.new("Following variables are missing in #{local_file} file: #{missing_keys.join(",")}")
+      end
+    end
+  end
+end

data/lib/a9n/struct.rb

@@ -7,7 +7,7 @@ module A9n
     end
 
     def fetch(name, default = nil)
-      @table[name.to_sym] || default
+      @table.fetch(name.to_sym, default)
     end
 
     def method_missing(name, *args)

data/lib/a9n/version.rb

@@ -1,3 +1,3 @@
 module A9n
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/spec/integration/a9n_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe A9n do
+  subject { described_class }
+
+  let(:env) { "test" }
+
+  before {
+    subject.app = double(env: env)
+    subject.root = File.expand_path("../../../test_app", __FILE__)
+  }
+
+  after {
+    subject.instance_variable_set(:@env, nil)
+    subject.root = nil
+    subject.app = nil
+  }
+
+  context "base config file" do
+    it {
+      expect(subject.default_dwarf).to eq("default dwarf")
+      expect(subject.overriden_dwarf).to eq("already overriden dwarf")
+    }
+  end
+
+  context "undefined env" do
+    let(:env) { "tropical" }
+    it {
+      expect(subject.default_dwarf).to eq("default dwarf")
+      expect(subject.overriden_dwarf).to eq("not yet overriden dwarf")
+    }
+  end
+
+  context "extra config file" do
+    it {
+      expect(subject.mandrill).to be_kind_of(A9n::Struct)
+      expect(subject.mandrill.username).to eq("joe")
+      expect(subject.mandrill.api_key).to eq("asdf1234")
+    }
+  end
+end

data/spec/spec_helper.rb

@@ -15,7 +15,8 @@ require 'bundler/setup'
 require 'a9n'
 
 RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.order = "random"
   config.color_enabled = true
   config.tty = true
-end
+end

data/spec/unit/a9n_spec.rb

@@ -0,0 +1,198 @@
+require "spec_helper"
+
+describe A9n do
+  subject { described_class }
+
+  after {
+    subject.instance_variable_set(:@env, nil)
+    subject.root = nil
+    subject.app = nil
+  }
+
+  describe ".env" do
+    before {
+      subject.instance_variable_set(:@env, nil)
+    }
+
+    context "app_env is set" do
+      before {
+        expect(subject).to receive(:app).and_return(double(env: "dwarf_env")).exactly(3).times
+        expect(subject).to receive(:get_env_var).never
+      }
+
+      it { expect(subject.env).to eq("dwarf_env") }
+    end
+
+    context "when APP_ENV is set" do
+      before {
+        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")
+      }
+
+      it { expect(subject.env).to eq("dwarf_env") }
+    end
+  end
+
+  describe ".app" do
+    context "when rails not found" do
+      before {
+        expect(subject).to receive(:get_rails).and_return(nil)
+      }
+      specify {
+        expect(subject.app).to be_nil
+      }
+    end
+
+    context "when rails app is being used" do
+      let(:app) { double(env: "test", root: "/apps/a9n") }
+      before {
+        expect(subject).to receive(:get_rails).and_return(app)
+      }
+
+      specify { expect(subject.app).to eq(app) }
+    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) }
+    end
+  end
+
+  describe ".root" do
+    let(:app) { double(env: "test", root: "/apps/a9n") }
+    before { subject.app = app }
+
+    context "with custom path" do
+      before {
+        subject.root = "/home/knapo/workspace/a9n"
+      }
+      specify {
+        expect(subject.root).to eq(Pathname.new("/home/knapo/workspace/a9n"))
+      }
+    end
+
+    context "with local app path" do
+      specify {
+        expect(subject.root).to eq("/apps/a9n")
+      }
+    end
+  end
+
+  describe ".get_rails" do
+    context "when defined" do
+      before {
+        Object.const_set(:Rails, Module.new)
+      }
+      after {
+        Object.send(:remove_const, :Rails)
+      }
+      it {
+        expect(subject.get_rails).to be_kind_of(Module)
+      }
+    end
+    context "when not defined" do
+      it { expect(subject.get_rails).to be_nil }
+    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}
+  end
+
+  describe ".var_name_for" do
+    it { expect(subject.var_name_for(:configuration)).to eq(:@configuration) }
+    it { expect(subject.var_name_for("configuration.yml")).to eq(:@configuration) }
+    it { expect(subject.var_name_for("custom_dir/extra.yml")).to eq(:@extra) }
+  end
+
+  describe ".fetch" do
+    let(:example_config) { A9n::Struct.new({hello: "world"}) }
+    before {
+      expect(subject).to receive(:scope).with(subject::DEFAULT_SCOPE).twice.and_return(example_config)
+    }
+    it {
+      expect(subject.fetch(:hello)).to eq("world")
+      expect(subject.fetch(:wold)).to eq(nil)
+    }
+  end
+
+  describe ".scope" do
+    context "when config has been loaded" do
+      before {
+        subject.instance_variable_set(:@custom1, { api_key: '1234asdf'})
+        expect(subject).to receive(:load).never
+      }
+      it {
+        expect(subject.scope(:custom1)).to eq({ api_key: '1234asdf'})
+      }
+    end
+    context "when config has not been loaded yet" do
+      it {
+        expect(subject).to receive(:load)
+        subject.scope(:custom2)
+      }
+    end
+  end
+
+  describe ".default_files" do
+    before {
+      subject.root = File.expand_path("../../../test_app", __FILE__)
+    }
+    it {
+      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
+
+  describe ".load" do
+    before {
+      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
+    }
+    context "when no files given" do
+      let(:files) {
+        {
+          "/apps/test_app/config/file1.yml" => { host: "host1.com" },
+          "/apps/test_app/config/dir/file2.yml" => { host: "host2.com" }
+        }
+      }
+      before {
+        expect(subject).to receive(:default_files).and_return(files.keys)
+        expect(subject).to receive(:get_absolute_paths_for).never
+      }
+      it {
+        expect(subject.load).to eq(files.values)
+      }
+    end
+
+    context "when custom files given" do
+      let(:given_files) {
+        ["file3.yml", "/apps/test_app/config/dir/file4.yml"]
+      }
+      let(:files) {
+        {
+          "/apps/test_app/config/file3.yml" => { host: "host3.com" },
+          "/apps/test_app/config/dir/file4.yml" => { host: "host4.com" }
+        }
+      }
+      before {
+        expect(subject).to receive(:default_files).never
+        expect(subject).to receive(:get_absolute_paths_for).with(given_files).and_call_original
+      }
+      it {
+        expect(subject.load(*given_files)).to eq(files.values)
+      }
+    end
+  end
+end

data/spec/unit/loader_spec.rb

@@ -0,0 +1,163 @@
+require "spec_helper"
+
+describe A9n::Loader do
+  let(:env) { "test" }
+  let(:root) { File.expand_path("../../../test_app", __FILE__) }
+  let(:file_path) { File.join(root, "config/configuration.yml") }
+  subject { described_class.new(file_path, env) }
+
+  describe "#intialize" do
+    it { expect(subject.env).to eq(env) }
+    it { expect(subject.local_file).to eq(file_path) }
+    it { expect(subject.example_file).to eq("#{file_path}.example") }
+  end
+
+  describe "#load" do
+    let(:example_env_config) {
+      { app_url: "http://127.0.0.1:3000", api_key: "base1234" }
+    }
+    let(:local_env_config) {
+      { app_host: "127.0.0.1:3000", api_key: "local1234" }
+    }
+    let(:example_default_config) {
+      { page_title: "Base Kielbasa", api_key: "example1234default"  }
+    }
+    let(:local_default_config) {
+      { page_title: "Local Kielbasa", api_key: "local1234default" }
+    }
+    let(:env){
+      "tropical"
+    }
+    let(:config) { subject.get }
+
+    context "when no configuration file exists" do
+      before do
+        expect(described_class).to receive(:load_yml).with(subject.example_file, env).and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.example_file, "defaults").and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, "defaults").and_return(nil)
+        expect(subject).to receive(:verify!).never
+      end
+      it "raises expection"  do
+        expect {
+          subject.load
+        }.to raise_error(A9n::MissingConfigurationData)
+      end
+    end
+
+    context "when example configuration file exists with defaults" do
+      before do
+        expect(described_class).to receive(:load_yml).with(subject.example_file, env).and_return(example_env_config)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.example_file, "defaults").and_return(example_default_config)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, "defaults").and_return(nil)
+
+        expect(described_class).to receive(:verify!).never
+        subject.load
+      end
+
+      it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
+      it { expect(config.page_title).to eq("Base Kielbasa") }
+      it { expect(config.api_key).to eq("base1234") }
+
+      it {
+        expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariable)
+      }
+    end
+
+    context "when local configuration file exists with defaults" do
+      before do
+        expect(described_class).to receive(:load_yml).with(subject.example_file, env).and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(local_env_config)
+        expect(described_class).to receive(:load_yml).with(subject.example_file, "defaults").and_return(nil)
+        expect(described_class).to receive(:load_yml).with(subject.local_file, "defaults").and_return(local_default_config)
+        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.page_title).to eq("Local Kielbasa") }
+      it { expect(config.api_key).to eq("local1234") }
+
+      it {
+        expect { config.app_url }.to raise_error(A9n::NoSuchConfigurationVariable)
+      }
+    end
+
+    context "when both local and base configuration file exists without defaults" do
+      context "with same data" do
+        before do
+          expect(described_class).to receive(:load_yml).with(subject.example_file, env).and_return(example_env_config)
+          expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(example_env_config)
+          expect(described_class).to receive(:load_yml).with(subject.example_file, "defaults").and_return(nil)
+          expect(described_class).to receive(:load_yml).with(subject.local_file, "defaults").and_return(nil)
+          subject.load
+        end
+
+        it { expect(config.app_url).to eq("http://127.0.0.1:3000") }
+        it { expect(config.api_key).to eq("base1234") }
+
+        it {
+          expect { config.page_title }.to raise_error(A9n::NoSuchConfigurationVariable)
+        }
+        it {
+          expect { config.app_host }.to raise_error(A9n::NoSuchConfigurationVariable)
+        }
+      end
+
+      context "with different data" do
+        before do
+          expect(described_class).to receive(:load_yml).with(subject.example_file, env).and_return(example_env_config)
+          expect(described_class).to receive(:load_yml).with(subject.local_file, env).and_return(local_env_config)
+          expect(described_class).to receive(:load_yml).with(subject.example_file, "defaults").and_return(nil)
+          expect(described_class).to receive(:load_yml).with(subject.local_file, "defaults").and_return(nil)
+        end
+        it "raises expection"  do
+          expect {
+            subject.load
+          }.to raise_error(A9n::MissingConfigurationVariables)
+        end
+      end
+    end
+  end
+
+  describe ".load_yml" do
+    let(:env) { "test" }
+    subject {  described_class.load_yml(file_path, env) }
+
+    context "when file not exists" do
+      let(:file_path) { "file_not_existing_in_universe.yml" }
+
+      it{ expect(subject).to be_nil }
+    end
+
+    context "when file exists" do
+      let(:file_path) { File.join(root, "config/configuration.yml") }
+
+      before {
+        ENV["DWARF"] = "erbized dwarf"
+      }
+
+      context "and has data" do
+        it "returns non-empty hash" do
+          expect(subject).to be_kind_of(Hash)
+          expect(subject.keys).to_not be_empty
+        end
+
+        it "has symbolized keys" do
+          expect(subject.keys.first).to be_kind_of(Symbol)
+          expect(subject[:hash_dwarf]).to be_kind_of(Hash)
+          expect(subject[:hash_dwarf].keys.first).to be_kind_of(Symbol)
+        end
+
+        it "parses erb" do
+          expect(subject[:erb_dwarf]).to eq("erbized dwarf")
+        end
+      end
+
+      context "and has no data" do
+        let(:env) { "production" }
+        it{ expect(subject).to be_nil }
+      end
+    end
+  end
+end

data/spec/{struct_spec.rb → unit/struct_spec.rb}

@@ -47,8 +47,20 @@ describe A9n::Struct do
       expect(subject.fetch(:non_empty_dwarf)).to eq('dwarf')
     end
 
-    it 'not returns nil for non existing value' do
+    it 'return false value' do
+      expect(subject.fetch(:false_dwarf)).to eq(false)
+    end
+
+    it 'return nil value' do
+      expect(subject.fetch(:nil_dwarf)).to eq(nil)
+    end
+
+    it 'return nil for non existing value' do
       expect(subject.fetch(:non_existing_dwarf)).to eq(nil)
     end
+
+    it 'return default for non existing value' do
+      expect(subject.fetch(:non_existing_dwarf, 'default')).to eq('default')
+    end
   end
 end

data/test_app/config/a9n/mandrill.yml

@@ -0,0 +1,3 @@
+defaults:
+  username: "joe"
+  api_key: "asdf1234"

data/{spec/fixtures → test_app/config}/configuration.yml

@@ -20,4 +20,4 @@ test:
   overriden_dwarf: "already overriden dwarf"
   hash_dwarf:
     dwarf_1: "hello 1"
-    dwarf_2: "hello 2"
+    dwarf_2: "hello 2"

data/test_app/config/configuration.yml.example

@@ -0,0 +1,23 @@
+defaults:
+  default_dwarf: "example default dwarf"
+  overriden_dwarf: "example not yet overriden dwarf"
+development:
+  nil_dwarf: ~
+  false_dwarf: false
+  true_dwarf: true
+  string_dwarf: "dwarf"
+  erb_dwarf: "<%= ENV['DWARF'] %>"
+  overriden_dwarf: "example already overriden dwarf"
+  hash_dwarf:
+    dwarf_1: "hello 1"
+    dwarf_2: "hello 2"
+test:
+  nil_dwarf: ~
+  false_dwarf: false
+  true_dwarf: true
+  string_dwarf: "dwarf"
+  erb_dwarf: "<%= ENV['DWARF'] %>"
+  overriden_dwarf: "example already overriden dwarf"
+  hash_dwarf:
+    dwarf_1: "hello 1"
+    dwarf_2: "hello 2"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: a9n
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Krzysztof Knapik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-16 00:00:00.000000000 Z
+date: 2014-05-29 00:00:00.000000000 Z
 dependencies: []
 description: Simple tool for managing extra configuration in ruby/rails apps
 email:
@@ -27,13 +27,18 @@ files:
 - a9n.gemspec
 - lib/a9n.rb
 - lib/a9n/capistrano.rb
-- lib/a9n/core_ext/hash.rb
+- lib/a9n/ext/hash.rb
+- lib/a9n/loader.rb
 - lib/a9n/struct.rb
 - lib/a9n/version.rb
-- spec/a9n_spec.rb
-- spec/fixtures/configuration.yml
+- spec/integration/a9n_spec.rb
 - spec/spec_helper.rb
-- spec/struct_spec.rb
+- spec/unit/a9n_spec.rb
+- spec/unit/loader_spec.rb
+- spec/unit/struct_spec.rb
+- test_app/config/a9n/mandrill.yml
+- test_app/config/configuration.yml
+- test_app/config/configuration.yml.example
 homepage: https://github.com/knapo/a9n
 licenses:
 - MIT
@@ -59,7 +64,8 @@ signing_key:
 specification_version: 4
 summary: a9n is a simple tool for managing extra configuration in ruby/rails apps
 test_files:
-- spec/a9n_spec.rb
-- spec/fixtures/configuration.yml
+- spec/integration/a9n_spec.rb
 - spec/spec_helper.rb
-- spec/struct_spec.rb
+- spec/unit/a9n_spec.rb
+- spec/unit/loader_spec.rb
+- spec/unit/struct_spec.rb

data/lib/a9n/core_ext/hash.rb

@@ -1,17 +0,0 @@
-class Hash
-  # Hash#deep_symbolize_keys
-  # based on
-  # https://github.com/svenfuchs/i18n/blob/master/lib/i18n/core_ext/hash.rb
-  def deep_symbolize_keys
-    inject({}) { |result, (key, value)|
-      value = value.deep_symbolize_keys if value.is_a?(self.class)
-      result[(key.to_sym rescue key) || key] = value
-      result
-    }
-  end unless self.method_defined?(:deep_symbolize_keys)
-
-  def self.merge(*items)
-    return nil if items.compact.empty?
-    items.compact.inject({}){|sum, item| sum.merge!(item)}
-  end
-end

data/spec/a9n_spec.rb

@@ -1,295 +0,0 @@
-require 'spec_helper'
-
-describe A9n do
-  describe '.local_app' do
-    context 'when rails not found' do
-      before {
-        expect(described_class).to receive(:get_rails).and_return(nil)
-      }
-      specify {
-        expect(described_class.local_app).to be_nil
-      }
-    end
-
-    context 'when custom non-rails app is being used' do
-      let(:local_app) { double(env: 'test', root: '/apps/a9n') }
-      before { described_class.local_app = local_app }
-
-      specify { expect(described_class.local_app).to eq(local_app) }
-    end
-
-    after { described_class.local_app = nil }
-  end
-
-  describe '.root' do
-    let(:local_app) { double(env: 'test', root: '/apps/a9n') }
-    before { described_class.local_app = local_app }
-
-    context 'with custom path' do
-      before {
-        described_class.root = '/home/knapo/workspace/a9n'
-      }
-      specify {
-        expect(described_class.root).to eq(Pathname.new('/home/knapo/workspace/a9n'))
-      }
-    end
-
-    context 'with local app path' do
-      specify {
-        expect(described_class.root).to eq('/apps/a9n')
-      }
-    end
-
-    after {
-      described_class.root = nil
-      described_class.local_app = nil
-    }
-  end
-
-  describe '.load' do
-    let(:base_file) { described_class::DEFAULT_FILE }
-    let(:extra_file) { 'mongo.yml' }
-    let(:base_sample_config){
-      { app_url: 'http://127.0.0.1:3000', api_key: 'base1234' }
-    }
-    let(:local_sample_config){
-      { app_host: '127.0.0.1:3000', api_key: 'local1234' }
-    }
-    let(:base_default_config){
-      { page_title: 'Base Kielbasa', api_key: 'base1234default'  }
-    }
-    let(:local_default_config){
-      { page_title: 'Local Kielbasa', api_key: 'local1234default' }
-    }
-    let(:env){
-      'tropical'
-    }
-    subject {
-      described_class
-    }
-    before do
-      allow(described_class).to receive(:env).and_return(env)
-    end
-
-    context 'when no configuration file exists' do
-      before do
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", 'defaults').and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", 'defaults').and_return(nil)
-        expect(described_class).to receive(:verify!).never
-      end
-      it 'raises expection'  do
-        expect {
-          described_class.load
-        }.to raise_error(described_class::MissingConfigurationData)
-      end
-    end
-
-    context 'when base configuration file exists with defaults' do
-      before do
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", env).and_return(base_sample_config)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", 'defaults').and_return(base_default_config)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", 'defaults').and_return(nil)
-
-        expect(described_class).to receive(:verify!).never
-        described_class.load
-      end
-
-      its(:app_url) { should_not be_nil }
-      its(:app_url) { should == subject.fetch(:app_url) }
-      its(:page_title) { should == 'Base Kielbasa' }
-      its(:api_key) { should == 'base1234' }
-      specify {
-        expect(subject.instance_variable_get("@configuration")).to be_kind_of(A9n::Struct)
-      }
-      specify {
-        expect { subject.app_host }.to raise_error(described_class::NoSuchConfigurationVariable)
-      }
-    end
-
-    context 'when local configuration file exists with defaults' do
-      before do
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", env).and_return(local_sample_config)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", 'defaults').and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{base_file}", 'defaults').and_return(local_default_config)
-        expect(described_class).to receive(:verify!).never
-        described_class.load
-      end
-
-      its(:app_host) { should_not be_nil }
-      its(:page_title) { should == 'Local Kielbasa' }
-      its(:api_key) { should == 'local1234' }
-      specify {
-        expect { subject.app_url }.to raise_error(described_class::NoSuchConfigurationVariable)
-      }
-    end
-
-    context 'when both local and base configuration file exists without defaults' do
-      context 'with same data' do
-        before do
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", env).and_return(base_sample_config)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}", env).and_return(base_sample_config)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", 'defaults').and_return(nil)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}", 'defaults').and_return(nil)
-          described_class.load
-        end
-
-        its(:app_url) { should_not be_nil }
-        its(:api_key) { should == 'base1234' }
-        specify {
-          expect { subject.page_title }.to raise_error(described_class::NoSuchConfigurationVariable)
-        }
-        specify {
-          expect { subject.app_host }.to raise_error(described_class::NoSuchConfigurationVariable)
-        }
-      end
-
-      context 'with different data' do
-        before do
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", env).and_return(base_sample_config)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}", env).and_return(local_sample_config)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}.example", 'defaults').and_return(nil)
-          expect(described_class).to receive(:load_yml).with("config/#{base_file}", 'defaults').and_return(nil)
-        end
-        it 'raises expection'  do
-          expect {
-            described_class.load
-          }.to raise_error(described_class::MissingConfigurationVariables)
-        end
-      end
-    end
-
-    context 'when extra file is loaded' do
-      before do
-        expect(described_class).to receive(:load_yml).with("config/#{extra_file}.example", env).and_return(base_sample_config)
-        expect(described_class).to receive(:load_yml).with("config/#{extra_file}", env).and_return(nil)
-        expect(described_class).to receive(:load_yml).with("config/#{extra_file}.example", 'defaults').and_return(base_default_config)
-        expect(described_class).to receive(:load_yml).with("config/#{extra_file}", 'defaults').and_return(nil)
-
-        expect(described_class).to receive(:verify!).never
-        described_class.load('mongo.yml')
-      end
-
-      it { expect(subject.mongo).to be_kind_of(A9n::Struct) }
-      it { expect(subject.instance_variable_get("@mongo")).to be_kind_of(A9n::Struct) }
-      it { expect(subject.mongo.app_url).to eq("http://127.0.0.1:3000") }
-      it { expect(subject.mongo.page_title).to eq('Base Kielbasa') }
-      it { expect(subject.mongo.api_key).to eq('base1234') }
-      specify {
-        expect { subject.mongo.app_host }.to raise_error(described_class::NoSuchConfigurationVariable)
-      }
-    end
-  end
-
-  describe '.load_yml' do
-    let(:root) { File.dirname(__FILE__) }
-    let(:env) { 'test' }
-    subject {  described_class.load_yml(file_path, env) }
-
-    before do
-      expect(described_class).to receive(:root).at_least(:once).and_return(root)
-      expect(described_class).to receive(:env).never
-    end
-
-    context 'when file not exists' do
-      let(:file_path) { 'file_not_existing_in_universe.yml' }
-
-      it 'returns nil' do
-        expect(subject).to be_nil
-      end
-    end
-
-    context 'when file exists' do
-      let(:file_path) { 'fixtures/configuration.yml'}
-      before {
-        ENV['DWARF'] = 'erbized dwarf'
-      }
-
-      context 'and has data' do
-        it 'returns non-empty hash' do
-          expect(subject).to be_kind_of(Hash)
-          expect(subject.keys).to_not be_empty
-        end
-
-        it 'has symbolized keys' do
-          expect(subject.keys.first).to be_kind_of(Symbol)
-          expect(subject[:hash_dwarf]).to be_kind_of(Hash)
-          expect(subject[:hash_dwarf].keys.first).to be_kind_of(Symbol)
-        end
-
-        it 'parses erb' do
-          expect(subject[:erb_dwarf]).to eq('erbized dwarf')
-        end
-      end
-
-      context 'and has no data' do
-        let(:env) { 'production' }
-        it { should be_nil }
-      end
-    end
-  end
-
-  describe '.env' do
-    before {
-      described_class.instance_variable_set(:@env, nil)
-    }
-
-    context 'local_app_env is set' do
-      before {
-        expect(described_class).to receive(:local_app).and_return(double(env: 'dwarf_env')).exactly(3).times
-        expect(described_class).to receive(:get_env_var).never
-      }
-
-      describe '#env' do
-        subject { super().env }
-        it { should == 'dwarf_env' }
-      end
-    end
-
-    context "when APP_ENV is set" do
-      before {
-        expect(described_class).to receive(:local_app_env).and_return(nil)
-        expect(described_class).to receive(:get_env_var).with('RAILS_ENV').and_return(nil)
-        expect(described_class).to receive(:get_env_var).with('RACK_ENV').and_return(nil)
-        expect(described_class).to receive(:get_env_var).with('APP_ENV').and_return('dwarf_env')
-      }
-
-      describe '#env' do
-        subject { super().env }
-        it { should == 'dwarf_env' }
-      end
-    end
-  end
-
-  describe '.get_env_var' do
-    before { ENV['DWARF'] = 'little dwarf' }
-    it { expect(described_class.get_env_var('DWARF')).to eq('little dwarf')}
-    it { expect(described_class.get_env_var('IS_DWARF')).to be_nil}
-  end
-
-  describe '.get_rails' do
-    context 'when defined' do
-      before {
-        Object.const_set(:Rails, Module.new)
-      }
-      after {
-        Object.send(:remove_const, :Rails)
-      }
-      it {
-        expect(described_class.get_rails).to be_kind_of(Module)
-      }
-    end
-    context 'when not defined' do
-      it { expect(described_class.get_rails).to be_nil }
-    end
-  end
-
-  describe '.var_name_for' do
-    it { expect(described_class.var_name_for(:configuration)).to eq(:@configuration) }
-    it { expect(described_class.var_name_for('configuration.yml')).to eq(:@configuration) }
-    it { expect(described_class.var_name_for('custom_dir/extra.yml')).to eq(:@extra) }
-  end
-end