confuse 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor

data/.ruby-version

@@ -0,0 +1 @@
+1.8.7-p370

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tom Chipchase
+
+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,29 @@
+# Configuration
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'configuration'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install configuration
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

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

data/TODO

@@ -0,0 +1,4 @@
+* Make the :type attriute for a config item actually do something. (e.g.some
+    basic type checking)
+* Write some more tests
+* Pick a good name that hasn't already been claimed on rubygems.

data/confuse.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'confuse/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'confuse'
+  spec.version       = Confuse::VERSION
+  spec.authors       = ['Tom Chipchase']
+  spec.email         = ['tom@mediasp.com']
+  spec.description   = %q{Add nested configuration to an application}
+  spec.summary       = %q{}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)/)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'inifile'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'minitest'
+end

data/example/001_simple_example.ini

@@ -0,0 +1,3 @@
+[default]
+foo = 10
+bar = 20

data/example/001_simple_example.rb

@@ -0,0 +1,18 @@
+require 'configuration/configurable'
+
+# An example of adding configuration options to a class.
+class SimpleExample
+  configurable
+
+  config_path 'example/001_simple_example.ini'
+
+  define :foo do
+    description   "How many Foo's are there?"
+    type          :integer
+    default       1
+  end
+
+end
+
+example = SimpleExample.new
+puts example.foo

data/example/002_namespace_example.rb

@@ -0,0 +1,29 @@
+require 'configuration/configurable'
+
+# An example of adding configuration options to a class, seperated by
+# namespaces.
+class NamespaceExample
+  configurable
+
+  config_path 'example/002_namespace_example.ini'
+
+  define :bar do
+    description 'foo_bar'
+    type :integer
+    default 1
+  end
+
+  namespace :foo do
+    define :bar do
+      description 'bar_foo'
+      type :string
+      default 'Hello, world!'
+    end
+  end
+end
+
+example = NamespaceExample.new
+puts example.config.inspect
+puts example.bar
+puts example.config[:foo_bar]
+puts example.foo[:bar]

data/example/003_config_subclass_instance_example.rb

@@ -0,0 +1,9 @@
+require 'configuration'
+
+class ExampleConfig < Configuration::ConfigBase
+  define :foo do
+    default 10
+  end
+end
+
+puts ExampleConfig.new.foo

data/example/004_configured_by.rb

@@ -0,0 +1,26 @@
+require 'configuration/configurable'
+
+module ExampleConfig
+  extend Configuration::ConfigMixin
+  extend Configuration::DSL
+
+  define :conf do
+    default 2
+  end
+end
+
+class Foo
+  configured_by ExampleConfig
+
+  default_namespace :foo
+
+  define :bar do
+    default 1
+  end
+
+end
+
+foo = Foo.new
+puts foo.config[:conf]
+puts foo.bar
+

data/lib/confuse/config.rb

@@ -0,0 +1,24 @@
+require 'confuse/config_mixin'
+require 'confuse/dsl'
+
+module Confuse
+  # The default module used for configuration.
+  module Config
+    extend ConfigMixin
+  end
+
+  # Super class for configuration in order to have multiple instances.
+  class ConfigBase
+    include ConfigMixin
+    extend DSL
+
+    def initialize
+      load_namespaces(self.class.namespaces)
+      read_files(self.class.config_path)
+    end
+
+    def config
+      self
+    end
+  end
+end

data/lib/confuse/config_item.rb

@@ -0,0 +1,33 @@
+module Confuse
+  # A {ConfigItem} is a class for storing a single piece of config. It has a
+  # key, a type, a description, and a default value.
+  class ConfigItem
+    attr_reader :key
+    attr_writer :value
+
+    def initialize(name, &block)
+      @key = name
+      instance_eval(&block)
+    end
+
+    def description(description = nil)
+      @description = description unless description.nil?
+      @description
+    end
+
+    def type(type = nil)
+      @type = type unless type.nil?
+      @type
+    end
+
+    def default(default = nil)
+      @default = default unless default.nil?
+      @default
+    end
+
+    def value
+      @value || @default
+    end
+  end
+end
+

data/lib/confuse/config_mixin.rb

@@ -0,0 +1,117 @@
+require 'confuse/namespace'
+require 'inifile'
+require 'yaml'
+
+module Confuse
+  # Mixin for configuration.
+  module ConfigMixin
+    def namespaces
+      @namespaces ||= {}
+    end
+
+    def load_namespaces(new_namespaces)
+      new_namespaces.each do |key, value|
+        existing = namespaces[key]
+        existing ? existing.merge!(value) : namespaces[key] = value
+      end
+    end
+
+    def read_files(file_paths)
+      Array(file_paths).map do |path|
+        if File.directory?(path)
+          load_config_dir(path)
+        elsif File.exists?(path)
+          load_config_file(path)
+        end
+      end.flatten.compact.each { |c| mixin_config!(c) }
+    end
+
+    def [](key)
+      namespace = find_namespace(key) || :default
+      rest_of_key = rest_of_key(key, namespace)
+      ns = namespaces[namespace]
+      return ns unless rest_of_key
+      ns[rest_of_key]
+    end
+
+    # We allow the namespace and the key to be concatenated with an '_', so this
+    # method is to search the possible substrings that could make up the
+    # namespace for a key.
+    #
+    # This does not guarentee that the suffix of the namespace that is found is
+    # a valid key in that namespace.
+    #
+    # @param [Symbol] key to search
+    def find_namespace(key)
+      until key.to_s.empty? || @namespaces[key.to_sym]
+        key = (s = key.to_s)[0, s.rindex('_') || 0]
+      end
+      key.to_s.empty? ? nil : key.to_sym
+    end
+
+    # Once we've found the namespace, we want to find the rest of the string
+    # to use as the rest of the key. If the namespace isn't a substring of the
+    # key (e.g. :default), we return the key unaltered.
+    #
+    # @param [Symbol] key The full key
+    # @param [Symbol] namespace The substring of the key that is the
+    # namespace.
+    def rest_of_key(key, namespace)
+      key_s = key.to_s
+      namespace_s = namespace.to_s
+      return nil if key_s == namespace_s
+      index = key_s.index(namespace_s) && (namespace_s.length + 1)
+      key_s[index || 0, key_s.length].to_sym
+    end
+
+    def load_config_dir(config_dir)
+      Dir[config_dir + '/*.{ini,conf,yaml}'].map do |conf_file|
+        load_config_file(conf_file)
+      end
+    end
+
+    def load_config_file(conf_file)
+      conf = load_ini(conf_file) || load_yaml(conf_file)
+      raise "Can't parse #{conf_file}" unless conf
+      conf
+    end
+
+    def mixin_config!(config)
+      config.each do |key, value|
+        namespace = @namespaces[find_namespace(key) || :default]
+        if value.respond_to? :keys
+          # if its a hash, set each key in the hash as a config item in the
+          # namespace
+          value.each do |k, v|
+            namespace[k] = v
+          end
+        else
+          # otherwise, set it directly in the namespace
+          namespace[key] = value
+        end
+      end
+    end
+
+    def load_ini(file)
+      begin
+        # make sure they keys are ruby symbols
+        symbolise_hash_keys(IniFile.load(file).to_h)
+      rescue IniFile::Error
+        nil
+      end
+    end
+
+    def symbolise_hash_keys(hash)
+      hash.reduce({}) do |memo, (key, val)|
+        memo[key.to_sym] =
+        val.respond_to?(:reduce) ? symbolise_hash_keys(val) : val
+      memo
+      end
+    end
+
+    def load_yaml(file)
+      YAML.load(File.read(file))
+    end
+
+  end
+end

data/lib/confuse/configurable.rb

@@ -0,0 +1,15 @@
+require 'configuration'
+
+# Monkey patch class to easily allow a class to be configurable.
+class Class
+  def configurable
+    extend Confuse::DSL
+    include Confuse::InstanceMethods
+  end
+
+  def configured_by(config)
+    configurable
+    @configured_by = config
+  end
+end
+

data/lib/confuse/dsl.rb

@@ -0,0 +1,68 @@
+require 'confuse/config'
+
+module Confuse
+  # DSL for setting up a configurable class
+  module DSL
+    attr_reader :configured_by
+
+    def configured_by(config = Config)
+      @configured_by ||= config
+    end
+
+    def default_namespace(namespace = :default)
+      @default_namespace ||= namespace
+    end
+
+    def config_path(*paths)
+      @config_path ||= []
+      @config_path.concat paths
+    end
+
+    def namespaces
+      @namespaces ||= {
+        default_namespace => Namespace.new(&(Proc.new { }))
+      }
+    end
+
+    def define(name, &block)
+      namespaces[default_namespace].define(name, &block)
+      getter(name, default_namespace)
+    end
+
+    def namespace(name, &block)
+      new_namespace = Namespace.new(&block)
+      if namespaces[name.to_sym]
+        namespaces[name.to_sym].merge! new_namespace
+      else
+        namespaces[name.to_sym] = new_namespace
+      end
+      getter(name)
+    end
+
+    def getter(name, namespace = nil)
+      class_eval do
+        if namespace.nil?
+          define_method(name) do
+            config[name]
+          end
+        else
+          define_method(name) do
+            config[namespace][name]
+          end
+        end
+      end
+    end
+
+  end
+
+  # Instance methods for getting the defined configuration from an instance of
+  # a configured class.
+  module InstanceMethods
+    # Lazilly create the config object when it is first requested.
+    def config
+      self.class.configured_by.load_namespaces(self.class.namespaces)
+      self.class.configured_by.read_files(self.class.config_path)
+      self.class.configured_by
+    end
+  end
+end

data/lib/confuse/namespace.rb

@@ -0,0 +1,56 @@
+require 'confuse/config_item'
+
+module Confuse
+  # A {Namespace} is a container to keep configuration data seperate from the
+  # rest of the config.
+  class Namespace
+
+    attr_reader :items, :supress_warnings_flag, :strict_flag
+
+    def initialize(&block)
+      @items = {}
+      @supress_warnings = false
+      @strict = false
+      instance_eval(&block)
+    end
+
+    def define(name, &block)
+      @items[name] = ConfigItem.new(name, &block)
+    end
+
+    def supress_warnings
+      @supress_warnings_flag = true
+    end
+
+    def strict
+      @strict_flag = true
+    end
+
+    def [](key)
+      (i = get_item(key)) && i.value
+    end
+
+    def []=(key, value)
+      item = get_item(key) || create_new_key(key, value)
+      item && item.value = value
+    end
+
+    def create_new_key(key, value)
+      if @supress_warnings_flag
+        puts "Warning: config includes unknown option '#{key}'"
+      end
+      @items[key] = ConfigItem.new(key, &(Proc.new {})) unless @strict_flag
+    end
+
+    def get_item(key)
+      @items[key]
+    end
+
+    def merge!(namespace)
+      @strict_flag = namespace.strict
+      @supress_warnings_flag = namespace.supress_warnings
+      @items.merge! namespace.items
+    end
+
+  end
+end

data/lib/confuse/version.rb

@@ -0,0 +1,3 @@
+module Confuse
+  VERSION = '0.0.1'
+end

data/lib/confuse.rb

@@ -0,0 +1,11 @@
+require 'confuse/version'
+
+require 'confuse/config'
+require 'confuse/config_item'
+require 'confuse/config_mixin'
+require 'confuse/dsl'
+require 'confuse/namespace'
+
+module Confuse
+end
+

data/test/test_config.rb

@@ -0,0 +1,50 @@
+require 'minitest/autorun'
+require 'confuse'
+
+# Test instance methods
+class TestConfig < MiniTest::Unit::TestCase
+  def setup
+    namespace = Confuse::Namespace.new do
+      define :baz do
+        default 1
+      end
+    end
+    @config = Confuse::Config
+    @config.load_namespaces({ :foo_bar => namespace })
+  end
+
+  def test_find_namespace
+    assert_equal :foo_bar, @config.find_namespace(:foo_bar_baz)
+  end
+
+  def test_fine_namespace_no_sub_key
+    assert_equal :foo_bar, @config.find_namespace(:foo_bar)
+  end
+
+  def test_find_namespace_doesnt_exist
+    assert_equal nil, @config.find_namespace(:bar)
+  end
+
+  def test_rest_of_key
+    assert_equal :bar, @config.rest_of_key(:foo_bar, :foo)
+  end
+
+  def test_rest_of_key_default_namespace
+    assert_equal :bar, @config.rest_of_key(:bar, :default)
+  end
+
+  def test_load_namespaces
+    namespace = Confuse::Namespace.new do
+      define :foo do
+        default 1
+      end
+    end
+
+    @config.load_namespaces({ :foo_bar => namespace })
+
+    assert @config[:foo_bar][:foo]
+    assert @config[:foo_bar][:baz]
+  end
+
+end
+

data/test/test_namespace.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'confuse'
+
+class TestNamespace < MiniTest::Unit::TestCase
+  def setup
+    @namespace = Confuse::Namespace.new do
+      define :foo do
+        default 1
+      end
+    end
+  end
+
+  def test_merge!
+    namespace = Confuse::Namespace.new do
+      define :bar do
+        default 1
+      end
+    end
+
+    @namespace.merge!(namespace)
+
+    assert @namespace[:foo]
+    assert @namespace[:bar]
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: confuse
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tom Chipchase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-10-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: inifile
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Add nested configuration to an application
+email: 
+- tom@mediasp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- confuse.gemspec
+- example/001_simple_example.ini
+- example/001_simple_example.rb
+- example/002_namespace_example.rb
+- example/003_config_subclass_instance_example.rb
+- example/004_configured_by.rb
+- lib/confuse.rb
+- lib/confuse/config.rb
+- lib/confuse/config_item.rb
+- lib/confuse/config_mixin.rb
+- lib/confuse/configurable.rb
+- lib/confuse/dsl.rb
+- lib/confuse/namespace.rb
+- lib/confuse/version.rb
+- test/test_config.rb
+- test/test_namespace.rb
+homepage: ""
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- test/test_config.rb
+- test/test_namespace.rb
+has_rdoc: