configurative 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: efedb9a668b63966a08e43d75e84d3800e715ef0
+  data.tar.gz: f038eb86565e4fdbf2b08313da2f855e0b63bc6d
+SHA512:
+  metadata.gz: 0ed9f644507c27678bb7d7e0c3e2040ccfa61227d5dc3ed1bb5ac7300ce4119efe9c38ea7b3f556641c556a6263febd507c8b13b709ef4102e35a23203b087a7
+  data.tar.gz: 8ebfc35fbc8fb3c2191b18c1609e20d8c2b997cdb42d85a0fcac9b099ebd38203e7d4a46aae38793bebb38328739e008909f1522e3b2ec0e9579ef026b7a087b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in configurative.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Peter Wood
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,135 @@
+# Configurative
+
+Configurative is a library for handling basic configuration settings that was
+heavily inspired by the Settingslogic library. I found Settingslogic to be an
+excellent library but I just needed some extra capabilities...
+
+ * The library could use either YAML or JSON files as input.
+
+ * The library supported loading from a number of potential locations.
+
+ * The library was more accepting of failures (i.e. it would raise exceptions
+   in fewer cases).
+
+ * The library would allow configuration settings to be selected as a subset
+   of a larger file (i.e. the configuration settings could be tweaked to only
+   consist of the contents of a single section within a larger file).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'configurative'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install configurative
+
+## Usage
+
+The intended mechanism of usage is to derive a class from the
+```Configurative::Settings``` class. You can then customize this to have your
+configuration settings come from one of a specific set of files. A basic
+implementation therefore might look like this...
+
+    class Configuration < Configurative::Settings
+      files File.join(Dir.getwd, "config", "application.yml")
+    end
+
+The files line here can accept more than a single file path and will work
+through them in order until it finds a file that exists and that the code has
+permission to read. This will then be loaded and its contents will become the
+configuration settings.
+
+The library supports the use of files in either the JSON or YAML formats (note
+that the file extension should be either '.json' or '.yml'). The concept of
+environments is also supported, with "development" being the default environment
+used. You can support an alternative environment either by specifying it in
+an environment variable (the library checks RAILS_ENV then RACK_ENV in that
+order for the environment setting) or by specify it explicitly in the class
+definition like this...
+
+    class Configuration < Configurative::Settings
+      files File.join(Dir.getwd, "config", "application.yml")
+      environment ENV["MY_ENV"]
+    end
+
+If your configuration file is large and you really only want some of the
+settings it contains then you can specify a subsection in your class definition
+and the library will narrow the settings available to just those in the section
+specified. For example, if you had a configuration file like this...
+
+    database:
+      user_name: db_user
+      password: db_password
+    logging:
+      active: true
+      file: ./log/application.log
+
+Then you could extract only the entries in the logging section by defining your
+class as follows...
+
+    class Configuration < Configurative::Settings
+      files File.join(Dir.getwd, "config", "application.yml")
+      section "logging"
+    end
+
+Note that this setting can be used in conjunction with the environment setting
+but the environment setting takes precedence. So if you specify an environment
+setting of ```production``` and a section of ```logging``` then the production
+section would be extracted first and then the logging section extracted from
+what that returned. Note that for both the environment and section settings if
+a matching subsection is not found then the library simply assumes that its
+absence means that the relevant discrimator does not need to be applied.
+
+Once you've defined your configuration class then you can access the settings
+retrieved either directly through the class itself or by fetching an instance
+of that class. So if you defined a setting class called Configuration and loaded
+the following configuration settings...
+
+    one: 1
+    two: "Two"
+
+You could access the settings in all of the following ways...
+
+    Configuration.one            # = 1
+    Configuration[:one]          # = 1
+    Configuration.fetch(:one)    # = 1
+    Configuration.instance.two   # = "Two"
+    Configuration.instance[:two] # = "Two"
+
+If you request a setting that does not exist then the library returns ```nil```
+by default. If you want to fetch something with a viable alternative in case
+the original setting is not set then pass a second parameter to a call to the
+```#fetch()``` method. If you need to check whether a setting has been given a
+value then use the ```#include?()``` method and pass in the setting key. Finally
+if you want to check that you have at least some settings you can make a call
+to the ```#empty?()``` method to determine whether or not your settings class
+has anything in it.
+
+Note that, as part of the loading process, the library converts all Hashes into
+instances of the OpenStruct class and thus you can cascade down through a
+settings hierarchy using the ```.``` operator rather than a dereference call.
+So, for example, if you had this configuration...
+
+   one:
+     two:
+       three: 3
+
+You could access the value of three with a call such as this...
+
+    Configuration.one.two.three
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/configurative/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/configurative.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'configurative/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "configurative"
+  spec.version       = Configurative::VERSION
+  spec.authors       = ["Peter Wood"]
+  spec.email         = ["peter.wood@longboat.com"]
+  spec.summary       = %q{A library for handling Ruby configuration settings.}
+  spec.description   = %q{A library for handling Ruby configuration settings. Inspired by the Settingslogic library but providing some additional functionality.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+
+  spec.add_dependency "mime-types", "~> 2.6"
+end

data/lib/configurative.rb

@@ -0,0 +1,14 @@
+require "erb"
+require "json"
+require "mime/types"
+require "ostruct"
+require "yaml"
+require "configurative/version"
+require "configurative/exceptions"
+require "configurative/settings_parser"
+require "configurative/settings_loader"
+require "configurative/settings"
+
+module Configurative
+  # Your code goes here...
+end

data/lib/configurative/exceptions.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+#
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Configurative
+  class ConfigurationError < StandardError
+    def initialize(message, cause=nil)
+      super(message)
+      @cause = cause
+    end
+    attr_reader :cause
+  end
+end

data/lib/configurative/settings.rb

@@ -0,0 +1,166 @@
+#! /usr/bin/env ruby
+#
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Configurative
+  class Settings
+    @@options   = {}
+    @@instances = {}
+
+    def initialize(options={})
+      @settings = nil
+      self.class.options_for(self.class).merge!(options)
+    end
+
+    def self.instance
+      instance_for(self)
+    end
+
+    def [](key)
+      self.class[key]
+    end
+
+    def []=(key, value)
+      self.class[key] = value
+    end
+
+    def fetch(key, alternative=nil)
+      self.class.fetch(key, alternative)
+    end
+
+    def include?(key)
+      self.class.include?(key)
+    end
+
+    def empty?
+      self.class.empty?
+    end
+
+    def self.[](key)
+      instance_for(self)[key]
+    end
+
+    def self.[]=(key, value)
+      instance_for(self)[key] = value
+    end
+
+    def self.fetch(key, alternative=nil)
+      self[key] || alternative
+    end
+
+    def self.include?(key)
+      instance_for(self).include?(key)
+    end
+
+    def self.empty?
+      instance_for(self).empty?
+    end
+
+    def respond_to?(method_name, include_private=false)
+      self.class.instance_for?(self.class).include?(property_name(method_name)) || super
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      self.class.method_missing(method_name, *arguments, &block) || super
+    end
+
+    def self.reset(full=false)
+      @@instances = {}
+      @@options.delete(self) if full
+    end
+
+    def self.respond_to?(method_name, include_private=false)
+      instance_for(self).include?(property_name(method_name)) || super
+    end
+
+    def self.method_missing(method_name, *arguments, &block)
+      data = instance_for(self)
+      if method_name[-1,1] == "="
+        data[property_name(method_name)] = arguments.first
+      else
+        if data.include?(method_name)
+          data[method_name]
+        else
+          super
+        end
+      end
+    end
+
+    def self.files(*files)
+      options_for(self)[:files] = files
+    end
+
+    def self.sources(*files)
+      files(*files)
+    end
+
+    def self.environment(setting)
+      options_for(self)[:environment] = setting
+    end
+
+    def self.namespace(setting)
+      environment(setting)
+    end
+
+    def self.section(setting)
+      options_for(self)[:section] = setting
+    end
+
+    def self.load(*files)
+      settings = nil
+      path     = find_file(*files)
+      if path
+        begin
+          settings          = SettingsLoader.new(options).load!(path)
+          @@instances[self] = settings
+        rescue => error
+          # Deliberately ignored.
+        end
+      end
+      settings
+    end
+
+    def self.load!(*files)
+      settings = load(*files)
+      raise ConfigurationError, "Unable to locate an accessible configuration file." if settings.nil?
+      settings
+    end
+
+  private
+
+    def options
+      self.class.options
+    end
+
+    def self.options
+      options_for(self)
+    end
+
+    def self.find_file(*paths)
+      paths.find {|entry| File.exist?(entry) && File.file?(entry) && File.readable?(entry)}
+    end
+
+    def self.instance_for(klass, defaults={})
+      if !@@instances.include?(klass)
+        files             = options[:files] || []
+        settings          = load(*files)
+        parser            = SettingsParser.new(options_for(klass))
+        @@instances[klass] = settings.nil? ? parser.parse(defaults) : settings
+      end
+      @@instances[klass]
+    end
+
+    def self.options_for(klass)
+      if !@@options.include?(klass)
+        @@options[klass] = {environment: (ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"),
+                            section:     nil}
+      end
+      @@options[klass]
+    end
+
+    def self.property_name(name)
+      (name.to_s[-1, 1] == "=" ? name.to_s[0...-1] : name.to_s).to_sym
+    end
+  end
+end

data/lib/configurative/settings_loader.rb

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+#
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Configurative
+  class SettingsLoader
+    def initialize(options={})
+      @options = {}.merge(options)
+    end
+
+    def load!(path)
+      type = MIME::Types.type_for(path).first.content_type
+      case type
+        when "application/json"
+          load_json_file!(path)
+        when "text/x-yaml"
+          load_yaml_file!(path)
+        else
+          raise ConfigurationError, "Unsupported confguration file type '#{type}' encountered."
+      end
+    end
+
+  private
+
+    def environment
+      (@options[:environment] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
+    end
+
+    def section
+      (@options[:section] || nil)
+    end
+
+    def load_yaml_file!(path)
+      extract_settings(YAML.load(ERB.new(File.read(path)).result))
+    rescue => error
+      raise ConfigurationError.new("Exception caught loading the '#{path}' configuration file.", error)
+    end
+
+    def load_json_file!(path)
+      extract_settings(JSON.parse(ERB.new(File.read(path)).result))
+    rescue => error
+      raise ConfigurationError.new("Exception caught loading the '#{path}' configuration file.", error)
+    end
+
+    def extract_settings(input)
+      settings = {}.merge(input)
+      settings = settings[environment] if settings.include?(environment)
+      settings = settings[section] if section && settings.include?(section)
+      SettingsParser.new(@options).parse(settings)
+    end
+  end
+end

data/lib/configurative/settings_parser.rb

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+#
+# Copyright (c), 2015 Peter Wood
+# See the license.txt for details of the licensing of the code in this file.
+
+module Configurative
+  class SettingsParser
+    def initialize(options={})
+      @options = {}.merge(options)
+    end
+
+    def parse(content)
+      parse_hash(content)
+    end
+
+  private
+
+    def parse_hash(hash)
+      output = hash.inject(OpenStruct.new) do |object, entry|
+        object[entry[0].to_sym] = (entry[1].kind_of?(Hash) ? parse_hash(entry[1]) : entry[1])
+        object
+      end
+      output.define_singleton_method(:empty?) {output.to_h.empty?}
+      output.define_singleton_method(:include?) {|key| output.to_h.include?(key)}
+      output
+    end
+  end
+end

data/lib/configurative/version.rb

@@ -0,0 +1,3 @@
+module Configurative
+  VERSION = "0.1.0"
+end

data/spec/configurative/settings_loader_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+describe Configurative::SettingsParser do
+  subject {
+    Configurative::SettingsLoader.new
+  }
+
+  describe "#load!()" do
+    describe "when loading a YAML file" do
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "test.yml")
+      }
+
+      it "returns an OpenStruct containing the configuration data" do
+        output = subject.load!(path)
+        expect(output.class).to be(OpenStruct)
+        expect(output.one.two.three).to eq(3)
+      end
+    end
+
+    describe "when loading a JSON file" do
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "test.json")
+      }
+
+      it "returns an OpenStruct containing the configuration data" do
+        output = subject.load!(path)
+        expect(output.class).to be(OpenStruct)
+        expect(output.one.two.three).to eq(3)
+      end
+    end
+
+    describe "when an alternative environment setting is available" do
+      before do
+        ENV['RACK_ENV'] = "production"
+      end
+
+      after do
+        ENV['RACK_ENV'] = nil
+      end
+
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "environment_test.yml")
+      }
+
+      subject {
+        Configurative::SettingsLoader.new(section: "section2")
+      }
+
+      it "picks up the settings for the specified environment" do
+        output = subject.load!(path)
+        expect(output.one).to be_nil
+        expect(output.two).to be_nil
+        expect(output.three).to be_nil
+        expect(output.four).to eq(4)
+        expect(output.five).to eq(5)
+        expect(output.six).to eq(6)
+      end
+
+      it "still picks up the section setting" do
+        ENV['RACK_ENV'] = nil
+        output = subject.load!(path)
+        expect(output.one).to eq(1)
+        expect(output.two).to eq(2)
+        expect(output.three).to eq(3)
+      end
+
+      it "returns the entire file contents when an environment that doesn't exist is specified" do
+        ENV['RACK_ENV'] = "alternative"
+        output = subject.load!(path)
+        expect(output.development).not_to be_nil
+        expect(output.production).not_to be_nil
+      end
+    end
+
+    describe "when a section setting is specified" do
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "section_test.yml")
+      }
+
+      subject {
+        Configurative::SettingsLoader.new(section: "section2")
+      }
+
+      it "returns only the specified sections contents if it exists" do
+        output = subject.load!(path)
+        expect(output.one).to be_nil
+        expect(output.two).to be_nil
+        expect(output.three).to eq(3)
+        expect(output.four).to eq(4)
+        expect(output.five).to be_nil
+        expect(output.six).to be_nil
+      end
+
+      it "returns the entire contents if a matching section does not exist" do
+        output = Configurative::SettingsLoader.new(section: "blah").load!(path)
+        expect(output.section1).not_to be_nil
+        expect(output.section2).not_to be_nil
+        expect(output.section3).not_to be_nil
+      end
+    end
+
+    it "raises an exception if given a non-existent file name" do
+      expect {
+        subject.load!("blah.yml")
+      }.to raise_exception(Configurative::ConfigurationError,
+                           "Exception caught loading the 'blah.yml' configuration file.")
+    end
+
+    it "raises an exception if given an unsupported file type" do
+      expect {
+        subject.load!("blah.txt")
+      }.to raise_exception(Configurative::ConfigurationError,
+                           "Unsupported confguration file type 'text/plain' encountered.")
+    end
+  end
+
+  describe "templated source file" do
+    before do
+      ENV["TEST_VALUE"] = "Testing Value"
+    end
+
+    subject {
+      Configurative::SettingsLoader.new(section: "section2")
+    }
+
+    describe "from a YAML source" do
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "template_test.yml")
+      }
+
+      it "loads and parses the template correctly" do
+        output = subject.load!(path)
+        expect(output.setting).to eq("Testing Value")
+      end
+    end
+
+
+    describe "from a JSON source" do
+      let(:path) {
+        File.join(Dir.getwd, "spec", "data", "template_test.json")
+      }
+
+      it "loads and parses the template correctly" do
+        output = subject.load!(path)
+        expect(output.setting).to eq("Testing Value")
+      end
+    end
+  end
+end

data/spec/configurative/settings_parser_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Configurative::SettingsParser do
+  subject {
+    Configurative::SettingsParser.new
+  }
+
+  describe "#parse()" do
+    it "converts a Hash to an OpenStruct" do
+      output = subject.parse({"one" => 1, "two" => 2, "three" => 3})
+      expect(output.class).to eq(OpenStruct)
+      expect(output.one).to eq(1)
+      expect(output.two).to eq(2)
+      expect(output.three).to eq(3)
+    end
+
+    it "acts recursive on all Hashes contained within the specified one" do
+      output = subject.parse({one: {two: {three: 3}}})
+      expect(output.one.class).to eq(OpenStruct)
+      expect(output.one.two.class).to eq(OpenStruct)
+      expect(output.one.two.three).to eq(3)
+    end
+
+    it "adds an #empty?() method to the OpenStructs it generates" do
+      output = subject.parse({one: {two: {}}})
+      expect(output.one.empty?).to eq(false)
+      expect(output.one.two.empty?).to eq(true)
+    end
+
+    it "adds an #include?() method to the OpenStructs it generates" do
+      output = subject.parse({one: 1})
+      expect(output.include?(:one)).to eq(true)
+      expect(output.include?(:two)).to eq(false)
+    end
+  end
+end

data/spec/configurative/settings_spec.rb

@@ -0,0 +1,228 @@
+require "spec_helper"
+
+describe Configurative::Settings do
+  before do
+    Configurative::Settings.reset
+  end
+
+  describe "when a source file is available" do
+    subject {
+      Configurative::Settings.new(files: [File.join(Dir.getwd, "spec", "data", "environment_test.yml")])
+    }
+
+    it "autoloads the files contents" do
+      expect(subject[:section1].class).to eq(OpenStruct)
+      expect(subject[:section2].class).to eq(OpenStruct)
+      expect(subject[:section3].class).to eq(OpenStruct)
+    end
+  end
+
+  describe "#[]()" do
+    subject {
+      Configurative::Settings.new
+    }
+
+    before do
+      subject.one   = 1
+      subject.two   = "Two"
+      subject.three = 3
+    end
+
+    describe "at the instance level" do
+      it "returns the requested value if it exists" do
+        expect(subject[:one]).to eq(1)
+        expect(subject[:two]).to eq("Two")
+        expect(subject[:three]).to eq(3)
+      end
+
+      it "returns nil if the requested value does not exist" do
+        expect(subject[:non_existent]).to be_nil
+      end
+    end
+
+    describe "at the class level" do
+      it "returns the requested value if it exists" do
+        expect(Configurative::Settings[:one]).to eq(1)
+        expect(Configurative::Settings[:two]).to eq("Two")
+        expect(Configurative::Settings[:three]).to eq(3)
+      end
+
+      it "returns nil if the requested value does not exist" do
+        expect(Configurative::Settings[:non_existent]).to be_nil
+      end
+    end
+  end
+
+  describe "#[]=()" do
+    subject {
+      Configurative::Settings.new
+    }
+
+    describe "at the instance level" do
+      it "assigns a value to a key" do
+        subject[:value] = "Value"
+        expect(subject.value).to eq("Value")
+      end
+    end
+
+
+    describe "at the class level" do
+      it "assigns a value to a key" do
+        Configurative::Settings[:value] = "Value"
+        expect(Configurative::Settings.value).to eq("Value")
+      end
+    end
+  end
+
+  describe "#fetch()" do
+    subject {
+      Configurative::Settings.new
+    }
+
+    before do
+      subject.one   = 1
+      subject.two   = "Two"
+      subject.three = 3
+    end
+
+    describe "at the instance level" do
+      it "returns the requested value if it exists" do
+        expect(subject.fetch(:one)).to eq(1)
+        expect(subject.fetch(:two)).to eq("Two")
+        expect(subject.fetch(:three)).to eq(3)
+      end
+
+      it "returns the alternative value if the requested value does not exist" do
+        expect(subject.fetch(:non_existent)).to be_nil
+        expect(subject.fetch(:non_existent, "blah")).to eq("blah")
+      end
+    end
+
+    describe "at the class level" do
+      it "returns the requested value if it exists" do
+        expect(Configurative::Settings.fetch(:one)).to eq(1)
+        expect(Configurative::Settings.fetch(:two)).to eq("Two")
+        expect(Configurative::Settings.fetch(:three)).to eq(3)
+      end
+
+      it "returns the alternative value if the requested value does not exist" do
+        expect(Configurative::Settings.fetch(:non_existent)).to be_nil
+        expect(Configurative::Settings.fetch(:non_existent, "blah")).to eq("blah")
+      end
+    end
+  end
+
+  describe "#include?()" do
+    subject {
+      Configurative::Settings.new
+    }
+
+    before do
+      subject.one = 1
+    end
+
+    describe "at the instance level" do
+      it "returns true if the specified key exists" do
+        expect(subject.include?(:one)).to eq(true)
+      end
+
+      it "returns false if the specified key does not exist" do
+        expect(subject.include?(:blah)).to eq(false)
+      end
+    end
+
+    describe "at the class level" do
+      it "returns true if the specified key exists" do
+        expect(Configurative::Settings.include?(:one)).to eq(true)
+      end
+
+      it "returns false if the specified key does not exist" do
+        expect(Configurative::Settings.include?(:blah)).to eq(false)
+      end
+    end
+  end
+
+  describe "#empty?()" do
+    subject {
+      Configurative::Settings.new
+    }
+
+    before do
+      Configurative::Settings.reset(true)
+    end
+
+    describe "at the instance level" do
+      it "returns true if no values have been set" do
+        expect(subject.empty?).to eq(true)
+      end
+
+      it "returns false if at least one value has been set" do
+        subject.one = 1
+        expect(subject.empty?).to eq(false)
+      end
+    end
+
+    describe "at the class level" do
+      it "returns true if no values have been set" do
+        expect(Configurative::Settings.empty?).to eq(true)
+      end
+
+      it "returns false if at least one value has been set" do
+        Configurative::Settings.one = 1
+        expect(Configurative::Settings.empty?).to eq(false)
+      end
+    end
+  end
+
+  describe "derived classes" do
+    describe "using the files setting" do
+      class TestClass1 < Configurative::Settings
+        files File.join(Dir.getwd, "spec", "data", "non_existent.yml"),
+              File.join(Dir.getwd, "spec", "data", "test.yml")
+      end
+
+      subject {
+        TestClass1
+      }
+
+      it "loads data from the first matching, readable file it finds" do
+        expect(subject.empty?).to eq(false)
+        expect(subject.include?(:one)).to eq(true)
+      end
+    end
+
+    describe "using the environment setting" do
+      class TestClass2 < Configurative::Settings
+        files File.join(Dir.getwd, "spec", "data", "environment_test.yml")
+        environment "production"
+      end
+
+      subject {
+        TestClass2
+      }
+
+      it "loads data from the correct section of the configuration file" do
+        expect(subject.empty?).to eq(false)
+        expect(subject.include?(:section2)).to eq(true)
+      end
+    end
+
+    describe "using the section setting" do
+      class TestClass3 < Configurative::Settings
+        files File.join(Dir.getwd, "spec", "data", "section_test.yml")
+        section "section3"
+      end
+
+      subject {
+        TestClass3
+      }
+
+      it "loads data from the correct section of the configuration file" do
+        expect(subject.empty?).to eq(false)
+        expect(subject.instance.to_h.size).to eq(2)
+        expect(subject.include?(:five)).to eq(true)
+      expect(subject.include?(:six)).to eq(true)
+      end
+    end
+  end
+end

data/spec/data/environment_test.yml

@@ -0,0 +1,14 @@
+development:
+  section1:
+    blah: 25
+  section2:
+    one: 1
+    two: 2
+    three: 3
+  section3:
+    ningy: "pow"
+production:
+  section2:
+    four: 4
+    five: 5
+    six: 6

data/spec/data/section_test.yml

@@ -0,0 +1,9 @@
+section1:
+  one: 1
+  two: 2
+section2:
+  three: 3
+  four: 4
+section3:
+  five: 5
+  six: 6

data/spec/data/template_test.json

@@ -0,0 +1 @@
+{"setting":"<%= ENV["TEST_VALUE"] %>"}

data/spec/data/template_test.yml

@@ -0,0 +1 @@
+setting: <%= ENV["TEST_VALUE"] %>

data/spec/data/test.json

@@ -0,0 +1 @@
+{"one": {"two": {"three": 3}}}

data/spec/data/test.yml

@@ -0,0 +1,3 @@
+one:
+  two:
+    three: 3

data/spec/spec_helper.rb

@@ -0,0 +1,99 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "configurative"
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: configurative
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Wood
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: A library for handling Ruby configuration settings. Inspired by the Settingslogic
+  library but providing some additional functionality.
+email:
+- peter.wood@longboat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- configurative.gemspec
+- lib/configurative.rb
+- lib/configurative/exceptions.rb
+- lib/configurative/settings.rb
+- lib/configurative/settings_loader.rb
+- lib/configurative/settings_parser.rb
+- lib/configurative/version.rb
+- spec/configurative/settings_loader_spec.rb
+- spec/configurative/settings_parser_spec.rb
+- spec/configurative/settings_spec.rb
+- spec/data/environment_test.yml
+- spec/data/section_test.yml
+- spec/data/template_test.json
+- spec/data/template_test.yml
+- spec/data/test.json
+- spec/data/test.yml
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A library for handling Ruby configuration settings.
+test_files:
+- spec/configurative/settings_loader_spec.rb
+- spec/configurative/settings_parser_spec.rb
+- spec/configurative/settings_spec.rb
+- spec/data/environment_test.yml
+- spec/data/section_test.yml
+- spec/data/template_test.json
+- spec/data/template_test.yml
+- spec/data/test.json
+- spec/data/test.yml
+- spec/spec_helper.rb