configure_me 0.1.1

data/.gitignore

@@ -0,0 +1,21 @@
+pkg/*
+*.gem
+.bundle
+config/database.yml
+config/*.sphinx.conf
+*~
+*.cache
+*.log
+autotest
+*.pid
+tmp/**/*
+.DS_Store
+db/*.sqlite3
+doc/api
+doc/app
+doc/plugins
+doc/*.dot
+coverage/*
+*.sw?
+vendor/plugins/ns_web
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format progress
+--backtrace

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,112 @@
+## ConfigureMe
+
+A really simple gem for helping to manage dynamic application configuration.
+
+### Installation
+    gem "configure_me"
+
+### Usage
+Using ConfigureMe is easy.  First, derive a class from ConfigureMe::Base.  Then define your settings just as you would attributes.
+
+    class AppConfig < ConfigureMe::Base
+      setting :timeout
+      setting :max_items
+    end
+
+Settings can also be given default values:
+
+    class AppConfig < ConfigureMe::Base
+      setting :min_password_length, :default => 8
+    end
+
+To access the settings, just reference the class's *instance* method, followed by the name of the setting:
+
+    # AppConfig.instance.min_password_length
+    => 8
+
+Changes to the configuration are made the same way:
+
+    # AppConfig.instance.min_password_length = 6
+    => 6
+    # AppConfig.instance.min_password_length
+    => 6
+
+### Nesting
+You can also nest configuration classes.  To nest one config under another, just call *nest_me* from inside the nested class, passing it the class you would like to nest it under.  When an instance of the parent class is created, an instance of the nested class will be instantiated at the same time.
+
+    class MainConfig < ConfigureMe::Base
+      setting :site_name, :default => "Ninja Robot Monkeys"
+    end
+
+    class ExtensionConfig < ConfigureMe::Base
+      nest_me(MainConfig)
+      setting :secret_weapon, :default => "throwing star"
+    end
+
+    # MainConfig.instance.extension.secret_weapon
+    => "throwing star"
+
+The default behaviour when nesting is to use the name of the nested class (excluding "Config") to create the accessor method.  To override this behavior, just pass the alternate name to *nest_me*
+
+    class ExtensionConfig < ConfigureMe::Base
+      nest_me MainConfig, 'altextension'
+      ...
+    end
+
+    # AppConfig.instance.altextension.secret_weapon
+    => "throwing star"
+
+## Persisting
+An easily editable configuration doesn't do any good without persisting it.  To store our configuration settings in the database, we need to generate an ActiveRecord model to store our settings.
+
+    # rails g configure_me Setting
+
+This will create a model/migration, and an initializer to let ConfigureMe know what model it should use for persisting.  You can call the model whatever you want, so long as you pass the correct name in the initializer.  All that's left is to tell ConfigureMe to actually persist our configuration.  And its a one-liner:
+
+    class AppConfig < ConfigureMe::Base
+      ...
+      persist_me
+    end
+
+Now, when updating any setting, the new value will be written to the database as well as stored in memory.   Settings are converted to YAML before being written, so complex values can be stored.  When accessing a setting, the database is always consulted first, and if no value is stored, the default is returned or, if no default was specified, nil.
+
+## Caching
+To really crank up the performance, you can enable caching of values.  If you're paying attention, the method to enable this should be obvious.
+
+    class AppConfig < ConfigureMe::Base
+      cache_me
+    end
+
+Now, when values are accessed, the cache will be referenced before falling back to other means.  If combined with *persist_me*, this can make dealing with dynamic site configuration perform much better than a database only solution.
+
+## Putting it all together
+
+Here's a complete configuration example:
+
+    class MainConfig < ConfigureMe::Base
+      persist_me
+      cache_me
+
+      setting :site_name
+      setting :admin_email
+      setting :theme, :default => 'spacecadet'
+    end
+
+    class UserConfig < ConfigureMe::Base
+      nest_me(MainConfig)
+      persist_me
+      cache_me
+
+      setting :min_username, :default => 8
+      setting :min_password, :default => 8
+    end
+
+With this setup, we'll have access to a total of 5 configuration options:
+
+    AppConfig.instance.site_name
+    AppConfig.instance.admin_email
+    AppConfig.instance.theme
+    AppConfig.instance.user.min_username
+    AppConfig.instance.user.min_password
+
+All of which will be stored in the database when modified, and read from the cache when possible.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_opts =  %w{--text-report --sort coverage}
+    t.rcov_opts << %w{--exclude gems\/,spec\/}
+  end
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = 'features --format progress'
+end

data/configure_me.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "configure_me/version"
+
+Gem::Specification.new do |s|
+  s.name        = "configure_me"
+  s.version     = ConfigureMe::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Josh Williams"]
+  s.email       = ["theprime@codingprime.com"]
+  s.homepage    = "http://www.github.com/t3hpr1m3/configure_me"
+  s.summary     = %q{Simple configuration library}
+  s.description = %q{Simple gem to assist with persisting configuration data.}
+
+  s.rubyforge_project = "configure_me"
+
+  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 = %w(lib)
+
+  s.add_dependency 'activemodel',   '~> 3.0.1'
+  s.add_dependency 'activesupport', '~> 3.0.1'
+
+  s.add_development_dependency 'rspec',     '~> 2.0.1'
+  s.add_development_dependency 'rcov',      '~> 0.9.9'
+  s.add_development_dependency 'mocha',     '~> 0.9.8'
+  s.add_development_dependency 'cucumber',  '~> 0.9.4'
+  s.add_development_dependency 'activerecord',  '~> 3.0.1'
+end

data/features/memory.feature

@@ -0,0 +1,16 @@
+Feature: Store configuration in memory
+	In order to store configuration information
+	As a ruby developer
+	I want to create a configuration class that stores settings in memory
+
+	Scenario: Simple configuration object
+		Given a Configuration class that derives from ConfigureMe::Base
+		And I add a "color" setting with a type of "string" and a default of "red"
+		When I create an instance of the class
+		And I read the "color" setting
+		Then the result should be "red"
+
+		When I set the "color" setting to "blue"
+		And I read the "color" setting
+		Then the result should be "blue"
+

data/features/step_definitions/base_steps.rb

@@ -0,0 +1,33 @@
+require 'configure_me'
+
+Given /^a (.*) class that derives from ConfigureMe::Base$/ do |name|
+  @klass = Class.new(ConfigureMe::Base)
+end
+
+Given /^I add a "([^"]*)" setting with a type of "([^"]*)" and a default of "([^"]*)"$/ do |name, type, default|
+  @klass.send :setting, name.to_sym, type.to_sym, :default => default
+end
+
+When /^I create an instance of the class$/ do
+  @obj = @klass.new
+end
+
+When /^I create another instance of the class$/ do
+  @obj2 = @klass.new
+end
+
+When /^I read the "([^"]*)" setting$/ do |name|
+  @result = @obj.send name.to_sym
+end
+
+When /^I read the new class's "([^"]*)" setting$/ do |name|
+  @result = @obj2.send name.to_sym
+end
+
+When /^I set the "([^"]*)" setting to "([^"]*)"$/ do |name, value|
+  @obj.send "#{name}=".to_sym, value
+end
+
+Then /^the result should be "([^"]*)"$/ do |value|
+  @result.should eql(value)
+end

data/lib/configure_me.rb

@@ -0,0 +1,13 @@
+module ConfigureMe
+  class << self
+    def persist_with(klass)
+      @persistence_klass = klass
+    end
+
+    def persistence_klass
+      @persistence_klass ||= nil
+    end
+  end
+end
+require 'configure_me/setting'
+require 'configure_me/base'

data/lib/configure_me/base.rb

@@ -0,0 +1,40 @@
+require 'active_model'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'singleton'
+require 'configure_me/persistence'
+require 'configure_me/caching'
+require 'configure_me/settings'
+require 'configure_me/nesting'
+
+module ConfigureMe
+  class Base
+    include ActiveModel::AttributeMethods
+    include Settings
+    include Persistence
+    include Caching
+    include Nesting
+    include Singleton
+
+    class << self
+      def config_name
+        self.name.gsub(/^(.*)Config$/, '\1').downcase
+      end
+    end
+
+    def parent
+      @parent || nil
+    end
+
+    def parent=(parent)
+      @parent = parent
+    end
+
+    def initialize
+      @children = {}
+      @settings = settings_from_class_settings
+      self.class.nested.each do |klass|
+        nest(klass)
+      end
+    end
+  end
+end

data/lib/configure_me/caching.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+
+module ConfigureMe
+  module Caching
+    extend ActiveSupport::Concern
+
+    included do
+      @caching = false
+    end
+
+    module ClassMethods
+      def cache_me(caching_key = nil)
+        @caching = true
+      end
+
+      def caching?
+        @caching
+      end
+    end
+
+    def cache_key(name)
+      persistence_key(name)
+    end
+  end
+end

data/lib/configure_me/nesting.rb

@@ -0,0 +1,36 @@
+require 'active_support/concern'
+
+module ConfigureMe
+  module Nesting
+    extend ActiveSupport::Concern
+
+    included do
+      @@nested = []
+    end
+
+    module ClassMethods
+      def nest_me(klass, name = nil)
+        klass.nest(self)
+        @nested_name = name || klass.config_name
+      end
+
+      def nested
+        @nested ||= []
+      end
+
+      def nest(klass)
+        nested << klass
+      end
+    end
+
+    def nest(klass)
+      @children[klass.config_name] = klass.instance
+      klass.instance.parent = self
+      self.class_eval <<-EOF
+        def #{klass.config_name}
+          @children['#{klass.config_name}']
+        end
+      EOF
+    end
+  end
+end

data/lib/configure_me/persistence.rb

@@ -0,0 +1,34 @@
+require 'active_support/concern'
+
+module ConfigureMe
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      @persisting = false
+    end
+
+    module ClassMethods
+      def persist_me(persistence_key = nil)
+        if ConfigureMe.persistence_klass.nil?
+          raise ::RuntimeError, "configure_me - persistence_klass is not set.  Make sure you have an initializer to assign it."
+        end
+        @persisting = true
+      end
+
+      def persisting?
+        @persisting
+      end
+
+      def persistence_key
+        self.config_name
+      end
+    end
+
+    def persistence_key(name)
+      key = "#{self.class.persistence_key}_#{name.to_s}"
+      key = @parent.persistence_key(key) unless @parent.nil?
+      key
+    end
+  end
+end

data/lib/configure_me/setting.rb

@@ -0,0 +1,16 @@
+module ConfigureMe
+  class Setting
+    attr_reader :name, :default
+
+    def initialize(owner, name, *args)
+      options = args.extract_options!
+
+      @owner, @name = owner, name.to_s
+      @default = options.key?(:default) ? options[:default] : nil
+    end
+
+    def define_methods!
+      @owner.define_attribute_methods(true)
+    end
+  end
+end

data/lib/configure_me/settings.rb

@@ -0,0 +1,94 @@
+require 'active_support/concern'
+
+module ConfigureMe
+  module Settings
+    extend ActiveSupport::Concern
+
+    included do
+      attribute_method_suffix('', '=')
+    end
+
+    module ClassMethods
+      def setting(name, options = {})
+        new_setting = Setting.new(self, name, options)
+        class_settings[name] = new_setting
+        new_setting.define_methods!
+      end
+
+      def class_settings
+        @class_settings ||= {}.with_indifferent_access
+      end
+
+      def define_attribute_methods(force = false)
+        return unless class_settings
+        undefine_attribute_methods if force
+        super(class_settings.keys)
+      end
+    end
+
+    def settings_from_class_settings
+      self.class.class_settings.inject({}.with_indifferent_access) do |settings, (name, setting)|
+        settings[name] = setting.default
+        settings
+      end
+    end
+
+    def read_setting(name)
+      if self.class.caching?
+        setting = Rails.cache.read(cache_key(name))
+        return setting unless setting.nil?
+      end
+
+      if self.class.persisting?
+        setting = ConfigureMe.persistence_klass.find_by_key(persistence_key(name))
+        return YAML::load(setting.value) unless setting.nil?
+      end
+
+      @settings[name.to_sym]
+    end
+
+    def write_setting(name, value)
+      if self.class.class_settings[name]
+        @settings[name.to_sym]  = value
+      else
+        raise NoMethodError, "Unknown setting: #{name.inspect}"
+      end
+
+      if self.class.caching?
+        Rails.cache.write(cache_key(name), value)
+      end
+
+      if self.class.persisting?
+        setting = ConfigureMe.persistence_klass.find_or_create_by_key(persistence_key(name))
+        setting.value = value.to_yaml
+        setting.save!
+      end
+
+    end
+
+    protected
+
+    def attribute_method?(name)
+      self.class.class_settings.key?(name)
+    end
+
+    private
+
+    def settings=(new_settings)
+      return unless new_settings.is_a?(Hash)
+      settings = new_settings.stringify_keys
+
+      settings.each do |k, v|
+        respond_to?("#{k}=".to_sym) ? send("#{k}=".to_sym, v) : raise(UnknownMethodError, "Unknown setting: #{k}")
+      end
+    end
+
+    def attribute(name)
+      read_setting(name.to_sym)
+    end
+
+    def attribute=(name, value)
+      write_setting(name.to_sym, value)
+    end
+  end
+end

data/lib/configure_me/version.rb

@@ -0,0 +1,3 @@
+module ConfigureMe
+  VERSION = "0.1.1"
+end

data/lib/generators/configure_me_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators/active_record'
+
+class ConfigureMeGenerator < ActiveRecord::Generators::Base #Rails::Generators::NamedBase
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  def generate_model
+    template 'model.rb', "app/models/#{singular_name}.rb"
+  end
+
+  def generate_migration
+    migration_template 'migration.rb', "db/migrate/create_#{plural_name}.rb"
+  end
+
+  def generate_initializer
+    template 'initializer.rb', 'config/initializers/init_configure_me.rb'
+  end
+end

data/lib/generators/templates/initializer.rb

@@ -0,0 +1 @@
+ConfigureMe.persist_with <%= class_name %>

data/lib/generators/templates/migration.rb

@@ -0,0 +1,16 @@
+class Create<%= class_name.pluralize %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= plural_name %> do |t|
+      t.string  :key
+      t.text    :value
+
+      t.timestamps
+    end
+
+    add_index :<%= plural_name %>, :key,                :unique => true
+  end
+
+  def self.down
+    drop_table :<%= plural_name %>
+  end
+end

data/lib/generators/templates/model.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/spec/configure_me/base_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe ConfigureMe::Base do
+  class TestConfig < ConfigureMe::Base
+  end
+
+  it { TestConfig.should respond_to(:setting) }
+  it { TestConfig.instance.should respond_to(:read_setting) }
+  it { TestConfig.instance.should respond_to(:write_setting) }
+  it { TestConfig.send(:persisting?).should be_false }
+
+  describe 'with a "color" setting with a default of "red"' do
+    before(:each) do
+      @klass = Class.new(ConfigureMe::Base)
+      @klass.send :setting, :color, :default => 'red'
+    end
+
+    describe 'an instance ' do
+      it 'should respond to attribute_method?(:color) with true' do
+        @obj = @klass.instance
+        @obj.send(:attribute_method?, :color).should be_true
+      end
+
+      it 'should respond to attribute_method?(:size) with false' do
+        @obj = @klass.instance
+        @obj.send(:attribute_method?, :size).should be_false
+      end
+
+      it 'should respond to :color with "red"' do
+        @obj = @klass.instance
+        @obj.color.should eql('red')
+      end
+
+      it 'should store a new :color of "blue"' do
+        @obj = @klass.instance
+        @obj.color = 'blue'
+        @obj.color.should eql('blue')
+      end
+
+      it 'should raise error when setting an unknown attribute' do
+        @obj = @klass.instance
+        lambda { @obj.write_setting('size', 'big') }.should raise_error(NoMethodError)
+      end
+
+      it 'should assign from a hash' do
+        @obj = @klass.instance
+        @obj.send :settings=, {:color => 'blue'}
+        @obj.color.should eql('blue')
+      end
+    end
+  end
+
+  describe 'persisting' do
+    before(:each) do
+      @klass = TestConfig
+      @persistence = mock('PersistenceClass')
+      ConfigureMe.persist_with @persistence
+      @klass.send :setting, :color, :default => 'red'
+      @klass.send :persist_me
+    end
+
+    it { @klass.send(:persisting?).should be_true }
+    it { @klass.should respond_to(:persistence_key) }
+    it { @klass.persistence_key.should eql('test') }
+
+    describe 'with a non-persisted setting' do
+      before(:each) do
+        @obj = @klass.instance
+        @unpersisted = mock('UnpersistedSetting') do
+          stubs(:value=)
+        end
+        @persistence = mock('PersistenceClass')
+        ConfigureMe.persist_with @persistence
+      end
+
+      it { @obj.send(:persistence_key, :color).should eql('test_color') }
+
+      it 'should store updates to the database' do
+        @unpersisted = mock('UnpersistedSetting') do
+          expects(:value=)
+          expects(:save!)
+        end
+        @persistence.stubs(:find_or_create_by_key).returns(@unpersisted)
+        @obj.color = "blue"
+      end
+
+      it 'should return the default value' do
+        @persistence.stubs(:find_by_key).returns(nil)
+        @obj.color.should eql('red')
+      end
+    end
+
+    describe 'with a persisted setting' do
+      before(:each) do
+        @obj = @klass.instance
+        @persisted = mock('PersistedSetting') do
+          stubs(:value).returns("blue".to_yaml)
+        end
+        @persistence.stubs(:find_by_key).returns(@persisted)
+        ConfigureMe.persist_with @persistence
+      end
+      
+      it 'should return a valid value' do
+        @obj.color.should eql("blue")
+      end
+    end
+  end
+end

data/spec/configure_me/setting_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ConfigureMe::Setting do
+  before(:each) do
+    @owner = mock('owner') do
+      stubs(:define_attribute_methods)
+    end
+    @setting = ConfigureMe::Setting.new(@owner, :foo, :default => 'bar')
+  end
+
+  it { @setting.should respond_to(:name) }
+  it { @setting.name.should eql('foo') }
+  it { @setting.should respond_to(:default) }
+  it { @setting.default.should eql('bar') }
+
+  it "define_methods! should call the owner class's define_attribute_methods with false" do
+    owner = mock('owner') do
+      expects(:define_attribute_methods).with(true)
+    end
+    setting = ConfigureMe::Setting.new(owner, :foo, :default => 'bar')
+    setting.define_methods!
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default)
+require 'rspec/core'
+
+require 'configure_me'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification 
+name: configure_me
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Josh Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-27 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 9
+        - 4
+        version: 0.9.4
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :development
+  version_requirements: *id007
+description: Simple gem to assist with persisting configuration data.
+email: 
+- theprime@codingprime.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- configure_me.gemspec
+- features/memory.feature
+- features/step_definitions/base_steps.rb
+- lib/configure_me.rb
+- lib/configure_me/base.rb
+- lib/configure_me/caching.rb
+- lib/configure_me/nesting.rb
+- lib/configure_me/persistence.rb
+- lib/configure_me/setting.rb
+- lib/configure_me/settings.rb
+- lib/configure_me/version.rb
+- lib/generators/configure_me_generator.rb
+- lib/generators/templates/initializer.rb
+- lib/generators/templates/migration.rb
+- lib/generators/templates/model.rb
+- spec/configure_me/base_spec.rb
+- spec/configure_me/setting_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://www.github.com/t3hpr1m3/configure_me
+licenses: []
+
+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: configure_me
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple configuration library
+test_files: 
+- features/memory.feature
+- features/step_definitions/base_steps.rb
+- spec/configure_me/base_spec.rb
+- spec/configure_me/setting_spec.rb
+- spec/spec_helper.rb