confection 0.2.0 → 0.2.1

data/.ruby

@@ -47,7 +47,7 @@ revision: 0
 created: '2011-11-06'
 summary: Multi-tenant configuration for Ruby
 title: Confection
-version: 0.2.0
+version: 0.2.1
 name: confection
 description: Confection is a multi-tenant configuration system for Ruby projects.
 organization: Rubyworks

data/Confile.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+#
+# QED test coverage report using SimpleCov.
+#
+# coverage_folder - the directory in which to store coverage report
+#                   this defaults to `log/coverage`.
+#
+config :qed, :cov do
+  require 'simplecov'
+
+  dir = $properties.coverage_folder
+
+  SimpleCov.start do
+    coverage_dir(dir || 'log/coverage')
+    #add_group "Label", "lib/qed/directory"
+  end
+end
+
+#
+# Example configuration.
+#
+config :example do
+  puts "Configuration Example!"
+end
+
+#
+# Detroit assembly.
+#
+config :detroit do
+  email do
+    mailto 'ruby-talk@ruby-lang.org', 'rubyworks-mailinglist@googlegroups.com'
+  end
+
+  gem do
+    active true
+  end
+
+  github do
+    folder 'web'
+  end
+
+  dnote do
+    title  'Source Notes'
+    output 'log/notes.html'
+  end
+
+  locat do
+    output 'log/locat.html'
+  end
+
+  vclog do
+    output 'log/history.html',
+           'log/changes.html'
+  end
+end
+

data/lib/confection/core_ext.rb

@@ -0,0 +1,14 @@
+# All core extensions come from Ruby Facets to maintain high standard for
+# careful core extensions.
+
+require 'facets/string/tabto'
+require 'facets/to_hash'
+
+#require 'facets/ostruct/to_h'  # TODO: Newer version of facets.
+require 'ostruct'
+class OpenStruct
+  def to_h
+    @table.dup
+  end
+end
+

data/lib/confection/current.rb

@@ -0,0 +1,79 @@
+module Confection
+
+  #
+  # Global properties is set for parsing project configuration.
+  # It is *always* the properties of the current project.
+  #
+  $properties = nil
+
+  # Current mixin extends the Confection module. Primarily is provides
+  # class methods for working with the current project's configurations.
+  #
+  module Current
+
+    #
+    def controller(scope, tool, *options)
+      params = (Hash === options.last ? options.pop : {})
+      params[:profile] = options.shift unless options.empty?
+
+      if from = params[:from]
+        projects[from] ||= Project.load(from)
+        projects[from].controller(scope, tool, params)
+      else
+        bootstrap if $properties.nil?  # TODO: better way to go about this?
+        current_project.controller(scope, tool, params)
+      end
+    end
+
+    #
+    def bootstrap
+      $properties = current_project.properties
+    end
+
+    #
+    def projects
+      @projects ||= {}
+    end
+
+    #
+    def current_directory
+      @current_directory ||= Dir.pwd
+    end
+
+    #
+    def current_project
+      projects[current_directory] ||= Project.lookup(current_directory)
+    end
+
+    #
+    def clear!
+      current_project.store.clear!
+    end
+
+    #
+    def profiles(tool)
+      current_project.profiles(tool)
+    end
+
+    #
+    def each(&block)
+      current_project.each(&block)
+    end
+
+    #
+    def size
+      current_project.size
+    end
+
+    #
+    # Project properties.
+    #
+    def properties
+      current_project.properties
+    end
+
+  end
+
+  extend Current
+
+end

data/lib/confection/hash_builder.rb

@@ -0,0 +1,48 @@
+module Confection
+
+  # HashBuilder takes a procedure and builds a Hash out of it.
+  #
+  # The procedure must conform to a set of rules to be useful in this respect.
+  # They must either take an argument and use that argument to set values, or
+  # if no argument is taken then `#instance_eval` is used to evaluate the
+  # procedure such that each method represents a key.
+  #
+  class HashBuilder < BasicObject
+
+    #
+    def initialize(hash={}, &block)
+      @hash = hash
+      case block.arity
+      when 0
+        instance_eval(&block)
+      else
+        block.call(self)
+      end
+    end
+
+    #
+    def to_h
+      @hash
+    end
+
+    #
+    def method_missing(s, *a, &b)
+      m = s.to_s
+      if a.empty? && !b
+        @hash[m.to_sym]
+      else
+        if b
+          @hash[m.chomp('=').to_sym] = HashBuilder.new(&b).to_h
+        else
+          if a.size > 1
+            @hash[m.chomp('=').to_sym] = a
+          else
+            @hash[m.chomp('=').to_sym] = a.first
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/confection/project.rb

@@ -0,0 +1,161 @@
+module Confection
+
+  # Project configuration.
+  #
+  # @todo Rename to `ProjectConfig` or ?
+  #
+  class Project
+
+    include Enumerable
+
+    #
+    # Configuration file pattern.
+    #
+    PATTERN = '{.,}confile{.rb,}'
+
+    #
+    # Per library cache.
+    #
+    def self.cache
+      @cache ||= {}
+    end
+
+    #
+    # Get project configuration from another library.
+    #
+    # This method uses the Finder gem.
+    #
+    # @param [String] lib
+    #   Library name.
+    #
+    # @return [Project,nil] Located project.
+    #
+    def self.load(lib=nil)
+      if lib
+        lib = lib.to_s
+        return cache[lib] if cache.key?(lib)
+        cache[lib] ||= (
+          config_path = Find.path(PATTERN, :from=>lib).first
+          config_path ? new(File.dirname(config_path)) : nil
+        )
+      else
+        lookup
+      end
+    end
+
+    #
+    # Lookup configuation file.
+    #
+    # @param dir [String]
+    #   Optional directory to begin search.
+    #
+    # @return [String] file path
+    #
+    def self.lookup(dir=nil)
+      dir = dir || Dir.pwd
+      home = File.expand_path('~')
+      while dir != '/' && dir != home
+        if file = Dir.glob(File.join(dir, PATTERN), File::FNM_CASEFOLD).first
+          return new(File.dirname(file))
+        end
+        dir = File.dirname(dir)
+      end
+      return nil
+    end
+
+    #
+    # Initialize new ProjectConfig.
+    #
+    # @param [String] root
+    #   Project root directory.
+    #
+    def initialize(root)
+      @root  = root
+    end
+
+    #
+    # Project root directory.
+    #
+    # @return [String] project's root directory
+    #
+    attr :root
+
+    #
+    # Alias for #root.
+    #
+    alias :directory :root
+
+    #
+    # Configuration store tracks a project's confirguration entries.
+    #
+    def store
+      @store ||= Store.new(*source)
+    end
+
+    #
+    # The file path of the project's configuration file.
+    #
+    # @return [String] path to configuration file
+    #
+    def source
+      Dir.glob(File.join(root, PATTERN), File::FNM_CASEFOLD)
+    end
+
+    #
+    # List of configuration profiles.
+    #
+    # @return [Array] profile names
+    #
+    def profiles(tool)
+      store.profiles(tool)
+    end
+
+    #
+    # Project properties.
+    #
+    # @todo Use cascading class, e.g. Confstruct.
+    #
+    def properties
+      dotruby = File.join(directory,'.ruby')
+      if File.exist?(dotruby)
+        data = YAML.load_file(dotruby)
+        OpenStruct.new(data)
+      else
+        OpenStruct.new
+      end
+    end
+
+    #
+    # Create a configuration controller.
+    #
+    # @param [Object] scope
+    #   Context for which controller is being created.
+    #
+    # @param [Symbol] tool
+    #   The tool of the configuration to select.
+    #
+    def controller(scope, tool, options={})
+      profile = options[:profile]
+      configs = store.lookup(tool, profile)
+      Controller.new(scope, *configs)
+    end
+
+    #
+    # Iterate over each configurations.
+    #
+    def each(&block)
+      store.each(&block)
+    end
+
+    #
+    # The number of configurations.
+    #
+    # @return [Fixnum] config count
+    #
+    def size
+      store.size
+    end
+
+  end
+
+end

data/lib/confection/store.rb

@@ -0,0 +1,182 @@
+module Confection
+
+  class Store
+
+    include Enumerable
+
+=begin
+    #
+    # Bootstrap the system, loading current configurations.
+    #
+    def bootstrap
+      if file
+        @config[root] = []
+        begin
+          DSL.load_file(file)
+        rescue => e
+          raise e if $DEBUG
+          warn e.message
+        end
+      end
+      @config[root]
+    end
+=end
+
+    #
+    def initialize(*sources)
+      @sources = sources
+
+      @list = []
+
+      sources.each do |source|
+        if File.file?(source)
+          parse(source)
+        else
+          # ignore directories
+        end
+      end
+    end
+
+    #
+    attr :sources
+
+    #
+    def parse(file)
+      DSL.parse(self, file)
+    end
+
+    #
+    # Iterate over each configurations.
+    #
+    def each(&block)
+      @list.each(&block)
+    end
+
+    #
+    # The number of configurations.
+    #
+    # @return [Fixnum] config count
+    #
+    def size
+      @list.size
+    end
+
+    #
+    # Add as configuratio to the store.
+    #
+    def <<(conf)
+      raise TypeError, "not a configuration instance -- `#{conf}'" unless Config === conf
+      @list << conf
+    end
+
+    #
+    # Add a list of configs.
+    #
+    def concat(configs)
+      configs.each{ |c| self << c }
+    end
+
+    #
+    # Lookup configuration by tool and profile name.
+    #
+    # @todo Future versions should allow this to handle regex and fnmatches.
+    #
+    def lookup(tool, profile=nil)
+      if profile == '*'
+        select do |c|
+          c.tool.to_sym == tool.to_sym
+        end
+      else
+        profile = profile.to_sym if profile
+
+        select do |c|
+          c.tool.to_sym == tool.to_sym && c.profile == profile
+        end
+      end
+    end
+
+    #
+    # Returns list of profiles collected from all configs.
+    #
+    def profiles(tool)
+      names = []
+      each do |c|
+        names << c.profile if c.tool == tool.to_sym
+      end
+      names.uniq
+    end
+
+    #
+    # Clear configs.
+    #
+    def clear!
+      @list = []
+    end
+
+    #
+    def first
+      @list.first
+    end
+
+    #
+    def last
+      @list.last
+    end
+
+    #
+    #def config(*args, &block)
+    #  dsl.config(*args, &block)
+    #end
+
+    #
+    #def controller(scope, name, profile=nil)
+    #  configs = lookup(name, profile)
+    #  Controller.new(scope, *configs)
+    #end
+
+    #
+    # Import configuration from another project.
+    #
+    def import(tool, profile, options, &block)
+      from_tool    = options[:tool]    || tool
+      from_profile = options[:profile] || profile
+
+      case from = options[:from]
+      when String, Symbol
+        project = Project.load(from.to_s)
+        store   = project ? project.store : nil
+      else
+        from  = '(self)'
+        store = self
+      end
+
+      raise "no configuration found in `#{from}'" unless store
+
+      configs = store.lookup(from_tool, from_profile)
+
+      configs.each do |config|
+        new_config = config.copy(:tool=>tool, :profile=>profile)
+
+        #new_options = @_options.dup
+        #new_options[:tool]    = tool
+        #new_options[:profile] = profile
+        #new_options[:block]   = config.block
+        #new_options[:text]    = config.text
+
+        # not so sure about this one
+        if String === new_config.value
+          new_config.value += ("\n" + options[:text].to_s) if options[:text]
+        end
+
+        self << new_config
+      end
+
+      #if block
+      #  self << Config::Block.new(tool, profile, nil, &block)
+      #end
+    end
+
+  end
+
+end
+

data/spec/00_concept.md

@@ -0,0 +1,33 @@
+= Confection
+
+The idea of confection is a unified configuration management across multiple
+tools for Ruby. The structure of a confection configuration file is very simple.
+It is a ruby script sectioned into named blocks:
+
+  config :rake do
+    # ... rake tasks ...
+  end
+
+  config :vclog do
+    # ... configure vclog ...
+  end
+
+Utilization of the these configurations is strictly up to the consuming 
+application. For example, save native support in Rake itself, we can add
+to a Rakefile:
+
+  require 'confection'
+
+  confection('rake').call
+
+ANALYSIS:
+
+  config :qed, :coverage, -> do
+    name 'Tommy'
+    age 42
+  end
+
+  config :qed, :coverage do
+    puts "Scripted"
+  end
+

data/spec/01_dsl.md

@@ -0,0 +1,69 @@
+# DSL
+
+The DSL class handle evaluation of a project configuration file.
+
+   store = Confection::Store.new
+
+   dsl = Confection::DSL.new(store)
+
+The DSL instance will have a cached binding.
+
+   #dsl.__binding__ == dsl.__binding__
+
+We can use the `#instance_eval` method to evaluate a configuration for our
+demonstration.
+
+    dsl.instance_eval(<<-HERE)
+      config :sample1 do
+        "block code"
+      end
+    HERE
+
+Evaluation of a configuration file, populate the Confection.config instance.
+
+    sample = store.last
+    sample.tool     #=> :sample1
+    sample.profile  #=> nil
+    sample.class    #=> Confection::Config
+
+A profile can be used as a means fo defining multiple configuration options
+for a single tool. This can be done by setting the second argument to a Symbol.
+
+    dsl.instance_eval(<<-HERE)
+      config :sample2, :opt1 do
+        "block code"
+      end
+    HERE
+
+    sample = store.last
+    sample.tool     #=> :sample2
+    sample.profile  #=> :opt1
+
+Or it can be done by using a `profile` block.
+
+    dsl.instance_eval(<<-HERE)
+      profile :opt1 do
+        config :sample2 do
+          "block code"
+        end
+      end
+    HERE
+
+    sample = store.last
+    sample.tool     #=> :sample2
+    sample.profile  #=> :opt1
+
+Different types of configuration can be defined. For instance, if a multi-line
+string is passed to the `config` method will be a text-based configuration.
+
+    dsl.instance_eval(<<-HERE)
+      config :sample3, %{
+        text config
+      }
+    HERE
+
+    sample = store.last
+    sample.tool        #=> :sample3
+    sample.profile     #=> nil
+    sample.to_s.strip.assert == "text config"
+

data/spec/02_import.md

@@ -0,0 +1,52 @@
+# Importing
+ 
+## Configuration Importing
+
+Configurations can be imported from another project
+using the `:from` option.
+
+    store = Confection::Store.new
+
+    dsl = Confection::DSL.new(store)
+
+    dsl.config :qed, :profile=>'example', :from=>'qed'
+
+    store.size.assert == 1
+
+The configuration can also be imported from a different profile.
+
+    dsl.config :qed, :coverage, :from=>'qed', :profile=>:simplecov
+
+    store.size.assert == 2
+
+Although it will rarely be useful, it may also be imported from another tool.
+
+    dsl.config :example, :from=>'qed', :tool=>:sample
+
+Imported configurations can also be augmented via a block.
+
+    store = Confection::Store.new
+
+    dsl = Confection::DSL.new(store)
+
+    dsl.config :qed, :from=>'qed', :profile=>:simplecov do
+      # additional code here
+    end
+
+    store.size.assert == 2
+
+Technically this last form just creates two configurations for the same
+tool and profile, but the ultimate effect is the same.
+
+## Script Importing
+
+Library files can be imported directly into configuration blocks via the
+`#import` method.
+
+    dsl.config :example do
+      import "fruitbasket/example.rb"
+    end
+
+This looks up the file via the `finder` gem and then evals it in the context
+of the config block.
+

data/spec/03_store.md

@@ -0,0 +1,20 @@
+## Store
+
+A Confection::Store encapsulates the list of configurations that belong
+to a project.
+
+    store = Confection::Store.new
+
+Only Config instance can be added to a store. Any other type of object
+will raise an error.
+
+    expect TypeError do
+      store << 1
+    end
+
+We can get a list of profiles for a given tool.
+
+    profiles = store.profiles(:text)
+
+    profiles.assert == []
+

data/spec/04_controller.md

@@ -0,0 +1,68 @@
+# Controller
+
+When working with configurations, Confection wraps configurations in a
+Controller instance.
+
+An empty controller can be made simply enough.
+
+    Confection::Controller.new(self, *[])
+
+The #confection method simple calls this with the configs it finds.
+
+    ctrl = config(:block)
+
+    Confection::Controller.assert === ctrl
+
+A controller will most oftern encapsulate just a sigle configuration,
+but it may contain more if the search parameters used to create it
+returned more than one matching configuration. We can see how many
+configurations the controller is harnessing using the `#size` method.
+
+    ctrl.size.assert == 1
+
+With the controller, we can utilize the configuration(s) it encapsulates
+through the handful of methods it provides for doing so. Probably the 
+most useful, which applies to Ruby-based configurations is the `#call`
+methods. This will execute the configuration script in the context
+in which it was defined.
+
+    result = ctrl.call
+
+    result.assert == "example block config"
+
+Instead of being executed in the context in which a configuration was
+defined, it can be executed in the current scope using the #exec method.
+
+    result = ctrl.exec
+
+    result.assert == "example block config"
+
+Of course, as this example only outputs a string, we won't notice any
+difference here.
+
+Lastly, script based configurations can be executed in the TOPLEVEL 
+context by using `#main_exec`, or its alias `#load`.
+
+    result = ctrl.main_exec
+
+    result.assert == "example block config"
+
+The controller can be converted to a Proc object, in which case the
+underlying execution is equivalent to using `#exec`. This allows 
+the procedure to be evaluated in other bindings as needed.
+
+    proc = ctrl.to_proc
+
+    result = proc.call
+
+    result.assert == "example block config"
+
+For text configuration, the controller will concat each configuration's 
+content.
+
+    ctrl = config(:text)
+
+    text = ctrl.to_s
+
+    text.strip.assert == 'example text config'
+

data/spec/05_config.md

@@ -0,0 +1,99 @@
+# Config Classes
+
+There are three classes of configuration: test, data and block. Block
+configurations encapsulate a block of Ruby code. Text configurations
+simply contain a text string --whatever that string may represent.
+Data configuration contantain a table of key-value pairs.
+
+## Block Configuration
+
+File configuration come from separate files rather then from definitions
+in a project's master configuration file.
+
+    config = confection(:block).first
+
+    Confection::Config.assert === config
+
+A Ruby-based configuration file, like our example, can be called via the `#call`
+method. This evaluates the code at the TOPLEVEL, like standard `Kernel.load`
+would.
+
+    result = config.call
+
+    result.assert == "example block config"
+
+The call can also be converted into a Proc object via `#to_proc`. This uses
+`instance_eval` internally, so that the Proc object can be evaluated in
+any context it may be needed.
+
+    proc = config.to_proc
+
+    Proc.assert === proc
+
+    result = proc.call
+
+    result.strip.assert == "example block config"
+
+
+## Text Configuraiton
+
+Text-based configurations
+
+    config = confection(:text).first
+
+    Confection::Config.assert === config
+
+    result = config.to_s
+
+    result.strip.assert == "example text config"
+
+For a text-based configuration `#call` does the same thing as `#to_s`.
+
+    result = config.call
+
+    result.strip.assert == "example text config"
+
+As with the other configuration classes, we may also convert this call
+into a Proc instance.
+
+    proc = config.to_proc
+
+    Proc.assert === proc
+
+The configuration object can be copied, with a special `#copy` method
+that accepts option parameters for changing the tool or profile of the copy.
+
+    alt = config.copy(:profile=>:alt)
+
+    alt.profile.assert == :alt
+
+
+## Data Configuration
+
+Data-based configuration.
+
+    config = confection(:example, :data).first
+
+    Confection::Config.assert === config
+
+    result = config.to_h
+
+    result.assert == {:name=>'Tommy', :age=>42 }
+
+For a Data-based configuration `#call` does the same thing as `#to_data`.
+
+    data = OpenStruct.new
+
+    result = config.call(data)
+
+    data.to_h.assert == {:name=>'Tommy', :age=>42 }
+
+As with the other configuration classes, we may also convert this call
+into a Proc instance.
+
+    proc = config.to_proc
+
+    Proc.assert === proc
+
+This just encapsulates the `#to_data` call in a lambda.
+

data/spec/06_manage.md

@@ -0,0 +1,38 @@
+# Manage
+
+The Confection module has some convenice class methods for working
+with the configuration of the *current* project --the one relative
+to the current working directory.
+
+The current project root directory can be had via the `current_directory`
+method.
+
+    Confection.current_directory
+
+The Project instance can be had via the `current_project` method.
+
+    project = Confection.current_project
+
+    Confection::Project.assert === project
+
+The configuration properties of the current project can be
+had via the `properties` method.
+
+    Confection.properties
+
+The profile names can be looked up for any given tool via the `profiles`
+method.
+
+    Confection.profiles(:file)
+
+The number of configurations in the current project can be had via
+the `size` method. (This is the number of configurations we have
+defined in our test fixture.)
+
+    Confection.size.assert == 3
+
+And we can loop through each configuration via the `each` method.
+
+    Confection.each{ |c| c }
+
+

data/spec/applique/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/spec/applique/file.rb

@@ -0,0 +1,8 @@
+require 'confection'
+
+When 'configuration file `(((\S+)))` containing' do |slots, text|
+  Confection.clear!
+  fname = [slots].flatten.first  # temporary transition to new QED
+  File.open(fname, 'w'){ |f| f << text }
+end
+

data/spec/applique/fixture.rb

@@ -0,0 +1,10 @@
+# Setup the fixtures.
+
+dir = File.dirname(__FILE__) + '/fixture'
+Dir.entries(dir).each do |file|
+  next if file == '.' or file == '..'
+  path = File.join(dir, file)
+  next if File.directory?(path)
+  FileUtils.install(path, Dir.pwd)
+end
+

data/spec/applique/fixture/confile.rb

@@ -0,0 +1,15 @@
+# exmaple configuration file
+
+config :block do
+  "example block config"
+end
+
+config :text do
+  "example text config"
+end
+
+config :example, :data do |ex|
+  ex.name = 'Tommy'
+  ex.age  = 42
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: confection
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: finder
-  requirement: &70312239870960 !ruby/object:Gem::Requirement
+  requirement: &69827679742240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70312239870960
+  version_requirements: *69827679742240
 - !ruby/object:Gem::Dependency
   name: facets
-  requirement: &70312239886780 !ruby/object:Gem::Requirement
+  requirement: &69827679741700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70312239886780
+  version_requirements: *69827679741700
 - !ruby/object:Gem::Dependency
   name: blankslate
-  requirement: &70312239886280 !ruby/object:Gem::Requirement
+  requirement: &69827679741200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70312239886280
+  version_requirements: *69827679741200
 - !ruby/object:Gem::Dependency
   name: detroit
-  requirement: &70312239885780 !ruby/object:Gem::Requirement
+  requirement: &69827679740700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70312239885780
+  version_requirements: *69827679740700
 - !ruby/object:Gem::Dependency
   name: qed
-  requirement: &70312239885280 !ruby/object:Gem::Requirement
+  requirement: &69827679740200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70312239885280
+  version_requirements: *69827679740200
 - !ruby/object:Gem::Dependency
   name: ae
-  requirement: &70312239884780 !ruby/object:Gem::Requirement
+  requirement: &69827679739700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70312239884780
+  version_requirements: *69827679739700
 description: Confection is a multi-tenant configuration system for Ruby projects.
 email:
 - transfire@gmail.com
@@ -92,11 +92,28 @@ files:
 - lib/confection/basic_object.rb
 - lib/confection/config.rb
 - lib/confection/controller.rb
+- lib/confection/core_ext.rb
+- lib/confection/current.rb
 - lib/confection/dsl.rb
+- lib/confection/hash_builder.rb
+- lib/confection/project.rb
+- lib/confection/store.rb
 - lib/confection.rb
+- spec/00_concept.md
+- spec/01_dsl.md
+- spec/02_import.md
+- spec/03_store.md
+- spec/04_controller.md
+- spec/05_config.md
+- spec/06_manage.md
+- spec/applique/ae.rb
+- spec/applique/file.rb
+- spec/applique/fixture/confile.rb
+- spec/applique/fixture.rb
 - LICENSE.txt
 - HISTORY.md
 - README.md
+- Confile.rb
 homepage: http://rubyworks.github.com/confection
 licenses:
 - BSD-2-Clause