figgy 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage
+tmp/

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-rc1@figgy --create

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

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

data/README

@@ -0,0 +1,21 @@
+In Gemfile:
+
+    gem 'figgy'
+
+Configure (say, in a Rails initializer):
+
+    APP_CONFIG = Figgy.build do |config|
+      config.root = Rails.root.join('etc')
+
+      # config.foo is read from etc/foo.yml
+      config.define_overlay :default, nil
+
+      # config.foo is then updated with values from etc/production/foo.yml
+      config.define_overlay(:environment) { Rails.env }
+    end
+
+Access it as a dottable, indifferent-access hash:
+
+    APP_CONFIG["foo"]["some_key"]
+    APP_CONFIG[:foo].some_key
+    APP_CONFIG.foo[:some_key]

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/figgy.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "figgy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "figgy"
+  s.version     = Figgy::VERSION
+  s.authors     = ["Kyle Hargraves"]
+  s.email       = ["pd@krh.me"]
+  s.homepage    = "http://github.com/pd/figgy"
+  s.summary     = %q{Configuration file reading}
+  s.description = %q{Access YAML, JSON (and ...) configuration files with ease}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "json"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "aruba"
+  s.add_development_dependency "heredoc_unindent"
+end

data/lib/figgy/configuration.rb

@@ -0,0 +1,85 @@
+class Figgy
+  class Configuration
+    attr_reader :root, :overlays
+    attr_accessor :always_reload, :preload, :freeze
+
+    def initialize
+      self.root = Dir.pwd
+      @handlers = []
+      @overlays = []
+      @always_reload = false
+      @preload = false
+      @freeze = false
+
+      define_handler 'yml', 'yaml' do |contents|
+        YAML.load(contents)
+      end
+
+      define_handler 'yml.erb', 'yaml.erb' do |contents|
+        erb = ERB.new(contents).result
+        YAML.load(erb)
+      end
+
+      define_handler 'json' do |contents|
+        JSON.parse(contents)
+      end
+    end
+
+    def root=(path)
+      @root = File.expand_path(path)
+    end
+
+    def always_reload?
+      !!@always_reload
+    end
+
+    def preload?
+      !!@preload
+    end
+
+    def freeze?
+      !!@freeze
+    end
+
+    def define_overlay(name, value = nil)
+      value = yield if block_given?
+      @overlays << [name, value]
+    end
+
+    def define_combined_overlay(*names)
+      combined_name = names.join("_").to_sym
+      value = names.map { |name| overlay_value(name) }.join("_")
+      @overlays << [combined_name, value]
+    end
+
+    def overlay_dirs
+      return [@root] if @overlays.empty?
+      overlay_values.map { |v| v ? File.join(@root, v) : @root }.uniq
+    end
+
+    def define_handler(*extensions, &block)
+      @handlers += extensions.map { |ext| [ext, block] }
+    end
+
+    def extensions
+      @handlers.map { |ext, handler| ext }
+    end
+
+    def handler_for(filename)
+      match = @handlers.find { |ext, handler| filename =~ /\.#{ext}$/ }
+      match && match.last
+    end
+
+    private
+
+    def overlay_value(name)
+      overlay = @overlays.find { |n, v| name == n }
+      raise "No such overlay: #{name.inspect}" unless overlay
+      overlay.last
+    end
+
+    def overlay_values
+      @overlays.map &:last
+    end
+  end
+end

data/lib/figgy/finder.rb

@@ -0,0 +1,71 @@
+class Figgy
+  class Finder
+    def initialize(config)
+      @config = config
+    end
+
+    def load(name)
+      result = files_for(name).reduce(nil) do |result, file|
+        object = @config.handler_for(file).call(File.read(file))
+        if result && result.respond_to?(:merge)
+          deep_merge(result, object)
+        else
+          object
+        end
+      end
+
+      raise(Figgy::FileNotFound, "Can't find config files for key: #{name.inspect}") unless result
+      deep_freeze(to_figgy_hash(result))
+    end
+
+    def files_for(name)
+      Dir[*file_globs(name)]
+    end
+
+    def all_key_names
+      Dir[*file_globs].map { |file| File.basename(file).sub(/\..+$/, '') }.uniq
+    end
+
+    private
+
+    def file_globs(name = '*')
+      globs = extension_globs(name)
+      @config.overlay_dirs.map { |dir|
+        globs.map { |glob| File.join(dir, glob) }
+      }.flatten
+    end
+
+    def extension_globs(name = '*')
+      @config.extensions.map { |ext| "#{name}.#{ext}" }
+    end
+
+    def to_figgy_hash(obj)
+      case obj
+      when ::Hash
+        obj.each_pair { |k, v| obj[k] = to_figgy_hash(v) }
+        Figgy::Hash.new(obj)
+      when Array
+        obj.map { |v| to_figgy_hash(v) }
+      else
+        obj
+      end
+    end
+
+    def deep_freeze(obj)
+      return obj unless @config.freeze?
+      case obj
+      when ::Hash
+        obj.each_pair { |k, v| obj[deep_freeze(k)] = deep_freeze(v) }
+      when Array
+        obj.map! { |v| deep_freeze(v) }
+      end
+      obj.freeze
+    end
+
+    def deep_merge(a, b)
+      a.merge(b) do |key, oldval, newval|
+        oldval.respond_to?(:merge) && newval.respond_to?(:merge) ? deep_merge(oldval, newval) : newval
+      end
+    end
+  end
+end

data/lib/figgy/hash.rb

@@ -0,0 +1,49 @@
+class Figgy
+  # Stolen from Thor::CoreExt::HashWithIndifferentAccess
+  # It's smaller and more grokkable than ActiveSupport's.
+  class Hash < ::Hash
+    def initialize(hash = {})
+      super()
+      hash.each do |key, value|
+        self[convert_key(key)] = value
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      other.each do |key, value|
+        self[convert_key(key)] = value
+      end
+      self
+    end
+
+    protected
+
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    def method_missing(m, *args, &block)
+      self[m]
+    end
+  end
+end

data/lib/figgy/store.rb

@@ -0,0 +1,19 @@
+class Figgy
+  class Store
+    def initialize(finder, config)
+      @finder = finder
+      @config = config
+      @cache  = {}
+    end
+
+    def get(key)
+      key = key.to_s
+      @cache.delete(key) if @config.always_reload?
+      if @cache.key?(key)
+        @cache[key]
+      else
+        @cache[key] = @finder.load(key)
+      end
+    end
+  end
+end

data/lib/figgy/version.rb

@@ -0,0 +1,3 @@
+class Figgy
+  VERSION = "0.0.1"
+end

data/lib/figgy.rb

@@ -0,0 +1,33 @@
+require "yaml"
+require "erb"
+require "json"
+
+require "figgy/version"
+require "figgy/configuration"
+require "figgy/hash"
+require "figgy/finder"
+require "figgy/store"
+
+class Figgy
+  FileNotFound = Class.new(StandardError)
+
+  def self.build(&block)
+    config = Configuration.new
+    block.call(config)
+    new(config)
+  end
+
+  def initialize(config)
+    @config = config
+    @finder = Finder.new(config)
+    @store  = Store.new(@finder, @config)
+
+    if @config.preload?
+      @finder.all_key_names.each { |key| @store.get(key) }
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    @store.get(m)
+  end
+end

data/spec/figgy_spec.rb

@@ -0,0 +1,322 @@
+require 'spec_helper'
+
+describe Figgy do
+  it "reads YAML config files" do
+    write_config 'values', <<-YML
+    foo: 1
+    bar: 2
+    YML
+
+    test_config.values.should == { "foo" => 1, "bar" => 2 }
+  end
+
+  it "raises an exception if the file can't be found" do
+    expect { test_config.values }.to raise_error(Figgy::FileNotFound)
+  end
+
+  context "multiple extensions" do
+    it "supports .yaml" do
+      write_config 'values.yaml', 'foo: 1'
+      test_config.values.foo.should == 1
+    end
+
+    it "supports .yml.erb and .yaml.erb" do
+      write_config 'values.yml.erb', '<%= "foo" %>: <%= 1 %>'
+      write_config 'values.yaml.erb', '<%= "foo" %>: <%= 2 %>'
+      test_config.values.foo.should == 2
+    end
+
+    it "supports .json" do
+      write_config "values.json", '{ "json": true }'
+      test_config.values.json.should be_true
+    end
+
+    it "loads in the order named" do
+      write_config 'values.yml', 'foo: 1'
+      write_config 'values.yaml', 'foo: 2'
+
+      config = test_config do |config|
+        config.define_handler('yml', 'yaml') { |body| YAML.load(body) }
+      end
+      config.values.foo.should == 2
+    end
+  end
+
+  context "hash contents" do
+    it "makes the hash result dottable and indifferent" do
+      write_config 'values', <<-YML
+      outer:
+        also: dottable
+      YML
+
+      config = test_config
+      config.values.outer.should == { "also" => "dottable" }
+      config.values["outer"].should == { "also" => "dottable" }
+      config.values[:outer].should == { "also" => "dottable" }
+    end
+
+    it "makes a hash inside the hash result dottable and indifferent" do
+      write_config 'values', <<-YML
+      outer:
+        also: dottable
+      YML
+
+      config = test_config
+      config.values.outer.also.should == "dottable"
+      config.values.outer["also"].should == "dottable"
+      config.values.outer[:also].should == "dottable"
+    end
+
+    it "makes a hash inside an array result dottable and indifferent" do
+      write_config 'values', <<-YML
+      outer:
+        - in: an
+          array: it is
+        - still: a dottable hash
+      YML
+
+      config = test_config
+      config.values.outer.size.should == 2
+      first, second = *config.values.outer
+
+      first.should == { "in" => "an", "array" => "it is" }
+      first[:in].should == "an"
+      first.array.should == "it is"
+
+      second.still.should == "a dottable hash"
+      second[:still].should == "a dottable hash"
+      second["still"].should == "a dottable hash"
+    end
+  end
+
+  context "overlays" do
+    it "defaults to no overlay, thus reading directly from the config root" do
+      write_config 'values', "foo: 1"
+      test_config.values.should == { "foo" => 1 }
+    end
+
+    it "interprets a nil overlay value as an indication to read from the config root" do
+      write_config 'values', "foo: 1"
+      config = test_config do |config|
+        config.define_overlay :default, nil
+      end
+      config.values.should == { "foo" => 1 }
+    end
+
+    it "allows the overlay's value to be the result of a block" do
+      write_config 'prod/values', "foo: 1"
+      config = test_config do |config|
+        config.define_overlay(:environment) { 'prod' }
+      end
+      config.values.should == { "foo" => 1 }
+    end
+
+    it "overwrites values if the config file does not define a hash" do
+      write_config 'some_string', "foo bar baz"
+      write_config 'prod/some_string', "foo bar baz quux"
+
+      config = test_config do |config|
+        config.define_overlay :default, nil
+        config.define_overlay :environment, 'prod'
+      end
+
+      config.some_string.should == "foo bar baz quux"
+    end
+
+    it "deep merges hash contents from overlays" do
+      write_config 'defaults/values', <<-YML
+      foo:
+        bar: 1
+        baz: 2
+      YML
+
+      write_config 'prod/values', <<-YML
+      foo:
+        baz: 3
+      quux: hi!
+      YML
+
+      config = test_config do |config|
+        config.define_overlay :default, 'defaults'
+        config.define_overlay :environment, 'prod'
+      end
+
+      config.values.should == { "foo" => { "bar" => 1, "baz" => 3 }, "quux" => "hi!" }
+    end
+
+    it "can use both a nil overlay and an overlay with a value" do
+      write_config 'values', "foo: 1\nbar: 2"
+      write_config 'prod/values', "foo: 2"
+      config = test_config do |config|
+        config.define_overlay :default, nil
+        config.define_overlay :environment, 'prod'
+      end
+      config.values.should == { "foo" => 2, "bar" => 2 }
+    end
+
+    it "reads from overlays in order of definition" do
+      write_config 'defaults/values', <<-YML
+      foo: 1
+      bar: 1
+      baz: 1
+      YML
+
+      write_config 'prod/values', <<-YML
+      bar: 2
+      baz: 2
+      YML
+
+      write_config 'local/values', <<-YML
+      baz: 3
+      YML
+
+      config = test_config do |config|
+        config.define_overlay :default, 'defaults'
+        config.define_overlay :environment, 'prod'
+        config.define_overlay :local, 'local'
+      end
+
+      config.values.should == { "foo" => 1, "bar" => 2, "baz" => 3 }
+    end
+  end
+
+  context "combined overlays" do
+    it "allows new overlays to be defined from the values of others" do
+      write_config 'keys', "foo: 1"
+      write_config 'prod/keys', "foo: 2"
+      write_config 'prod_US/keys', "foo: 3"
+
+      config = test_config do |config|
+        config.define_overlay :default, nil
+        config.define_overlay :environment, 'prod'
+        config.define_overlay :country, 'US'
+        config.define_combined_overlay :environment, :country
+      end
+
+      config.keys.should == { "foo" => 3 }
+    end
+  end
+
+  context "reloading" do
+    it "can reload on each access when config.always_reload = true" do
+      write_config 'values', 'foo: 1'
+      config = test_config do |config|
+        config.always_reload = true
+      end
+      config.values.should == { "foo" => 1 }
+
+      write_config 'values', 'foo: bar'
+      config.values.should == { "foo" => "bar" }
+    end
+
+    it "does not reload when config.always_reload = false" do
+      write_config 'values', 'foo: 1'
+      config = test_config do |config|
+        config.always_reload = false
+      end
+      config.values.should == { "foo" => 1 }
+
+      write_config 'values', 'foo: bar'
+      config.values.should == { "foo" => 1 }
+    end
+  end
+
+  context "preloading" do
+    it "can preload all available configs when config.preload = true" do
+      write_config 'values', 'foo: 1'
+      write_config 'prod/values', 'foo: 2'
+      write_config 'prod/prod_only', 'bar: baz'
+
+      config = test_config do |config|
+        config.define_overlay :default, nil
+        config.define_overlay :environment, 'prod'
+        config.preload = true
+      end
+
+      write_config 'prod/values', 'foo: 3'
+      write_config 'prod_only', 'bar: quux'
+
+      config.values['foo'].should == 2
+      config.prod_only['bar'].should == 'baz'
+    end
+
+    it "still works with multiple extension support" do
+      write_config 'values.yaml', 'foo: 1'
+      write_config 'values.json', '{ "foo": 2 }'
+      write_config 'prod/lonely.yml', 'only: yml'
+      write_config 'local/json_values.json', '{ "json": true }'
+
+      config = test_config do |config|
+        config.define_overlay :default, nil
+        config.define_overlay :environment, 'prod'
+        config.define_overlay :local, 'local'
+      end
+
+      finder = config.instance_variable_get(:@finder)
+      finder.all_key_names.should == ['values', 'lonely', 'json_values']
+    end
+
+    it "still supports reloading when preloading is enabled" do
+      write_config 'values', 'foo: 1'
+
+      config = test_config do |config|
+        config.preload = true
+        config.always_reload = true
+      end
+
+      config.values['foo'].should == 1
+
+      write_config 'values', 'foo: 2'
+      config.values['foo'].should == 2
+    end
+  end
+
+  context "freezing" do
+    it "leaves results unfrozen by default" do
+      write_config 'values', 'foo: 1'
+      test_config.values.foo.should_not be_frozen
+    end
+
+    it "freezes the results when config.freeze = true" do
+      write_config 'values', 'foo: 1'
+      config = test_config do |config|
+        config.freeze = true
+      end
+      config.values.should be_frozen
+    end
+
+    it "freezes all the way down" do
+      write_config 'values', <<-YML
+      outer:
+        key: value
+        array:
+          - some string
+          - another string
+          - and: an inner hash
+      YML
+
+      config = test_config do |config|
+        config.freeze = true
+      end
+
+      expect { config.values.outer.array[2]['and'] = 'foo' }.to raise_error(/can't modify frozen/)
+      assert_deeply_frozen(config.values)
+    end
+
+    def assert_deeply_frozen(obj)
+      obj.should be_frozen
+      case obj
+      when Hash then obj.each { |k, v| assert_deeply_frozen(k); assert_deeply_frozen(v) }
+      when Array then obj.each { |v| assert_deeply_frozen(v) }
+      end
+    end
+  end
+end
+
+describe Figgy do
+  describe 'CnuConfig drop-in compatibility' do
+    it "should maybe support path_formatter = some_proc.call(config_name, overlays)"
+    it "should support preload's all_key_names when using path_formatter"
+    it "should support preload's all_key_names when using path_formatter"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+
+SimpleCov.start
+
+require 'rspec'
+require 'figgy'
+require 'aruba/api'
+require 'heredoc_unindent'
+
+module Figgy::SpecHelpers
+  def test_config
+    Figgy.build do |config|
+      config.root = current_dir
+      yield config if block_given?
+    end
+  end
+
+  def write_config(filename, contents)
+    filename = "#{filename}.yml" unless filename =~ /\./
+    write_file(filename, contents.unindent)
+  end
+end
+
+RSpec.configure do |c|
+  c.include Aruba::Api
+  c.include Figgy::SpecHelpers
+
+  c.after { FileUtils.rm_rf(current_dir) }
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: figgy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kyle Hargraves
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70234275187800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234275187800
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70234275187060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234275187060
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70234275186200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234275186200
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70234275185340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234275185340
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: &70234275184520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234275184520
+- !ruby/object:Gem::Dependency
+  name: heredoc_unindent
+  requirement: &70234275177120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234275177120
+description: Access YAML, JSON (and ...) configuration files with ease
+email:
+- pd@krh.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- README
+- Rakefile
+- figgy.gemspec
+- lib/figgy.rb
+- lib/figgy/configuration.rb
+- lib/figgy/finder.rb
+- lib/figgy/hash.rb
+- lib/figgy/store.rb
+- lib/figgy/version.rb
+- spec/figgy_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/pd/figgy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Configuration file reading
+test_files:
+- spec/figgy_spec.rb
+- spec/spec_helper.rb