ficus 0.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e2f42373c4373ad219fa88df98d44ff83916f35
-  data.tar.gz: aec31ba49eb8074354256fec29d444d4aaa8612a
+  metadata.gz: 484115640e759fe32eeefa0d4ec9b65982ad3510
+  data.tar.gz: 88ec5550e290697fff154936d6fc1174955d305d
 SHA512:
-  metadata.gz: d6d56312dd96ae16ddad988fe555152c4c1361af4ab299495521f54da4dbb44d0af6fd77b53dcaa491fdd4c52108aa27da18f84df707402438968dd23ca37045
-  data.tar.gz: 1d237e3b1bb559029b6f415af05f4575c103faf664f42fc9e45a3a6c7cb28a65185ed8725b1a235433397b71bfe7e097e75c35cc22bdadeabdb820738379ad87
+  metadata.gz: 09fc932f9eee192ae7155b944512f74e7ed083e4d04df176f25bc1137685e6910a03b910ebf4504a23ba5dbeb273e2be5dfe10ff30729fca967ff6c77216af49
+  data.tar.gz: 0ef2a6d334d58e138cd5542c5e219775e32b5f1fc61d2580c13a33ed8997e02669f35001d0f927e0b6202d6d0b7caaaa9661677cd213e7a4dbd72bb758a06387

data/.gitignore

@@ -1,3 +1,4 @@
+.vendor
 .rspec
 vendor
 .idea

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.0
+  

data/README.md

@@ -1,10 +1,8 @@
 # Ficus
 
-A simple YAML configuration DSL that does runtime validation.
+[![Build Status](https://travis-ci.org/drewfradette/ruby-ficus.png?branch=master)](https://travis-ci.org/drewfradette/ruby-ficus)
 
-## Important Note
-This uses the [`recursive-open-struct`](https://github.com/aetherknight/recursive-open-struct) but due to gem missing a [crucial fix](https://github.com/aetherknight/recursive-open-struct/commit/0c16caa1b9a19d12e97829f02083f0b7d21f0100) 
-I have simply added the latest version with the fix to the `lib`. When it's fixed in rubygems, I will add it as a gem dependency.
+A simple YAML configuration DSL that does runtime validation.
 
 ## Installation
 
@@ -50,7 +48,9 @@ And now we can use Ficus to load the config and validate it at the same time.
 ```ruby
 require 'ficus'
 
-config = Ficus.load 'config.yml' do
+ficus = Ficus.load_file 'config.yml'
+
+ficus.validation do
   section 'section_1' do
     required 'key1'
     required 'key2'
@@ -75,13 +75,18 @@ config = Ficus.load 'config.yml' do
   end
 end
 
-config.section_1.key1         # value1
-config.section_1.key2         # value2
-config.section_1.key3         # value3
-config.section_2.key4         # value4
-config.not_defined            # nil
+if ficus.valid?
+  ficus.config['section_1']['key1']     # value1
+  ficus.config['section_1']['key2']     # value2
+  ficus.config['section_1']['key3']     # value3
+  ficus.config['section_2']['key4']     # value4
+else
+ ficus.errors.each { |err| puts err.to_s }
+end
 ```
 
+For more examples, see the `examples` directory.
+
 ## Contributing
 
 1. Fork it

data/Rakefile

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

data/examples/regexp/regexp.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'ficus'
+require 'pp'
+
+ficus = Ficus.load_file('sample.conf').validation do
+  section /^server\d?$/ do
+    required 'active'
+    optional 'state', 'pending'
+  end
+
+  section /^server[A-Z]?$/i do
+    required 'active'
+    optional 'state', 'running'
+  end
+end
+
+if ficus.valid?
+  pp ficus.config
+else
+  puts "Invalid Configuration:"
+  ficus.errors.each {|err| puts err.to_s}
+end

data/examples/regexp/sample.conf

@@ -0,0 +1,12 @@
+server1:
+  active: true
+
+server2:
+  active: false
+
+serverA:
+  active: false
+
+serverB:
+  active: false
+

data/examples/simple/sample.conf

@@ -0,0 +1,5 @@
+key1: value1
+key2: value2
+
+section1:
+  active: true

data/examples/simple/simple.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'ficus'
+require 'pp'
+
+ficus = Ficus.load_file('sample.conf').validation do
+
+  required 'key1'
+  required 'key2'
+
+  section 'section1' do
+    required 'active'
+    optional 'url', 'http://drewfradette.ca'
+  end
+
+  section 'section2', optional: true do
+    required 'key3'
+  end
+end
+
+if ficus.valid?
+  pp ficus.config
+else
+  ficus.errors.each {|err| puts err.to_s}
+end

data/examples/templates/sample.conf

@@ -0,0 +1,9 @@
+web:
+  ip_address: 127.0.0.1
+  state: running
+
+db:
+  ip_address: 127.0.0.2
+
+cache:
+  ip_address: 127.0.0.3

data/examples/templates/templates.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'ficus'
+require 'pp'
+
+ficus = Ficus.load_file('sample.conf').validation do
+  # Note: The DSL is evaluated in order so be sure to
+  #       declare your templates before you use them.
+  template :server do
+    required 'ip_address'
+    optional 'state', 'pending'
+  end
+
+  section 'web',   template: :server
+  section 'db',    template: :server
+  section 'cache', template: :server
+end
+
+if ficus.valid?
+  pp ficus.config
+else
+  ficus.errors.each {|err| puts err.to_s}
+end

data/examples/typechecking/sample.conf

@@ -0,0 +1,5 @@
+
+active: true
+size: 145
+name: example
+grep: Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit

data/examples/typechecking/typechecking.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'ficus'
+require 'pp'
+
+ficus = Ficus.load_file('sample.conf').validation do
+  required 'active', :boolean
+  required 'size',   :number
+  required 'name',   :string
+
+  optional 'grep', 'lorem ipsum', /est qui dolorem/
+end
+
+if ficus.valid?
+  pp ficus.config
+else
+  ficus.errors.each {|err| puts err.to_s}
+end

data/ficus.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "ficus"
-  spec.version       = '0.0.5'
+  spec.version       = '2.0.0'
   spec.authors       = ["Drew Fradette"]
   spec.email         = ["drew.fradette@gmail.com"]
   spec.description   = 'A runtime validation configuration DSL'
@@ -20,7 +20,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'simplecov' if RUBY_VERSION >= '1.9'
-
-  spec.add_dependency 'recursive-open-struct', '>= 0.4.5'
+  spec.add_development_dependency 'simplecov'
 end

data/lib/ficus.rb

@@ -1,7 +1,166 @@
 require 'yaml'
-require 'logger'
-require 'recursive-open-struct'
 
-require 'ficus/loader'
-require 'ficus/dsl'
-require 'ficus/exceptions'
+class Ficus
+  class MissingValidation < StandardError; end
+
+  class << self
+    def load_file(filename)
+      Ficus.load(YAML.load_file(filename))
+    end
+
+    def load(data)
+      Ficus.new data
+    end
+  end
+
+  attr_accessor :config, :errors, :opts, :schema, :templates
+
+  TYPES = {
+    string:  [String],
+    number:  [Fixnum, Float],
+    boolean: [TrueClass, FalseClass],
+    array:   [Array],
+    section: [Hash],
+  }
+
+  def initialize(config, opts = {})
+    self.config = config
+    self.opts = opts
+    self.templates = {}
+    self.errors = []
+  end
+
+  def validation(&block)
+    self.schema = block
+    return self
+  end
+
+  def valid?
+    raise MissingValidation.new('no validation block specified') if self.schema.nil?
+    self.errors = []
+    instance_eval(&self.schema)
+    return self.errors.empty?
+  end
+
+  def config
+    @config ||= {}
+  end
+
+  def template(name, &block)
+    self.templates[name] = block
+  end
+
+  def section(name, section_opts = {}, &block)
+    if sections(name).nil?
+      return if section_opts.fetch(:optional, false)
+      msg = (name.class == Regexp) ? "no matches in #{heritage}" : "undefined"
+      error heritage(name), msg
+      return
+    end
+
+    sections(name).each do |key|
+      # Ensure that the section is valid
+      if !self.valid_type?(self.get(key), :section)
+        error heritage(key), "must be section"
+        next
+      end
+
+      # Set the validation block
+      validation_block = block if block_given?
+      template_name = section_opts.fetch(:template, false)
+      if template_name
+        if !self.templates.key?(template_name)
+          error heritage(key), "undefined template #{template_name}"
+          next
+        end
+        validation_block = self.templates[template_name]
+      end
+
+      # Get to work
+      leaf = Ficus.new self.get(key), heritage: heritage(key)
+      leaf.validation(&validation_block) unless validation_block.nil?
+      if leaf.valid?
+        # Update the data for the leaf section as 'optional' can modify the data.
+        self.config[key] = leaf.config
+      else
+        # Update the errors raise by the leaf
+        self.errors += leaf.errors
+      end
+    end
+  end
+
+  def optional(name, default, type = nil)
+    value = exists?(name) ? get(name) : default
+    if !valid_type?(value, type)
+      error heritage(name), "must be #{type}"
+    else
+      self.config[name] = value
+    end
+  end
+
+  def required(name, type = nil)
+    if self.config.key?(name)
+      error heritage(name), "must be #{type}" unless self.valid_type? get(name), type
+    else
+      error heritage(name), "undefined"
+    end
+  end
+
+  protected
+
+  def error(name, message)
+    self.errors << Error.new(name, message)
+  end
+
+  def exists?(key)
+    self.config.key?(key)
+  end
+
+  def get(key)
+    self.config.fetch(key)
+  end
+
+  def heritage(postfix = nil)
+    if postfix.nil?
+      self.opts.fetch(:heritage, [])
+    else
+      self.opts.fetch(:heritage, []) + [postfix.to_s]
+    end
+  end
+
+  def sections(name)
+    # Collect the sections
+    if name == :all
+      self.config.keys
+    elsif name.class == Regexp
+      self.config.select{|k,v| k =~ name}.keys
+    elsif self.config.key?(name)
+      {name => self.config[name]}.keys
+    else
+      nil
+    end
+  end
+
+  # Ensure value is a valid type.
+  def valid_type?(value, type)
+    if type.nil?
+      return true
+    elsif type.class == Regexp
+      !!(type =~ value.to_s)
+    else
+      TYPES[type].include?(value.class)
+    end
+  end
+
+  class Error
+    attr_accessor :name, :message
+    def initialize(name, message)
+      self.name = name
+      self.message = message
+    end
+
+    def to_s
+      "#{name.join('.')}: #{message}"
+    end
+  end
+end

data/spec/ficus_spec.rb

@@ -1,145 +1,269 @@
 require 'spec_helper'
 require 'tempfile'
-require 'yaml'
+
 require 'ficus'
 
 describe Ficus do
-  before :each do
-    Ficus.logger = logger
-    @config = {
-      :general => {:key1=>'value1', :key2=>'value2', :key3=>'value3'},
-      :misc    => {
-        :key4 => 'value4',
-        :list => {:item1 => 'value1', :item2 => 'value2'}
-      }
+  def config
+    {
+      'general' => {'key1' => 'value1', 'key2' => 'value2', 'key3' =>'value3'},
+      'misc' => {'key4' => 'value4', 'list' => {
+        'item1' => 'value1',
+        'item2' => 'value2'
+      }}
     }
   end
 
-  it 'should load the config without any validation' do
-    config_file do |config|
-      config = Ficus.load(config)
-      config.to_h.should eq @config
+  it 'will load the config from a string' do
+    ficus = Ficus.load(config)
+    expect(ficus.config).to eq config
+  end
+
+  it 'will load the config from a file' do
+    Tempfile.open('config.yml') do |file|
+      file.write config.to_yaml
+      file.close
+
+      ficus = Ficus.load_file file.path
+      expect(ficus.config).to eq config
     end
   end
 
-  it 'should load the config with a warning about a missing section' do
-    config_file do |config|
-      config = Ficus.load(config) do
-        section 'not_real', :optional => true
+  it 'will validate the config with an optional missing section' do
+    Ficus.load(config).tap do |ficus|
+      ficus.validation do
+        section 'not_real', optional: true
       end
-      Ficus.warnings.size.should eq 1
+      expect(ficus.valid?).to eq true
     end
   end
 
-  it 'should load the config with a error about a missing section' do
-    config_file do |config|
-      expect do
-        config = Ficus.load(config) do
-          section 'not_real'
-        end
-      end.to raise_error Ficus::ConfigError
+  it 'will fail to validate the config due to a missing section' do
+    Ficus.load(config).tap do |ficus|
+      ficus.validation do
+        section 'not_real'
+      end
 
-      Ficus.errors.size.should eq 1
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/not_real/)
     end
   end
 
-  it 'should load the config but fail to validate' do
-    config_file do |config|
-      expect do
-        config = Ficus.load(config) do
-          section 'general', :optional => true do
-            required 'fake_param'
-          end
+  it 'will fail to validate the config due to a required parameter' do
+    Ficus.load(config).tap do |ficus|
+      ficus.validation do
+        section 'general', optional: true do
+          required 'fake_param'
         end
-      end.to raise_error Ficus::ConfigError
-      Ficus.errors.size.should eq 1
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/general.fake_param/)
     end
   end
 
-  it 'should load the config but fill in the optional value' do
-    config_file do |config|
-      config = Ficus.load(config) do
+  it 'will validate the config and fill in the optional value' do
+    Ficus.load(config).tap do |ficus|
+      ficus.validation do
         section 'general' do
           optional 'newparam', 'value2'
         end
       end
-      @config.fetch(:general).fetch('newparam', nil).should eq nil
-      config.general.newparam.should eq 'value2'
+
+      expect(ficus.valid?).to eq true
+      expect(ficus.config['general']['newparam']).to eq 'value2'
     end
   end
 
-  it 'should validate conformant subsections' do
-    hash = {
-        :subsections => {
-            :section1 => {:key1=>'value1'},
-            :section2 => {:key1=>'value1'},
-        }
-    }
+  it 'will validate conformant subsections' do
+    hash = {'subsections' => {'section1' => {'key1' => 'value1'}, 'section2' => {'key1' => 'value1'}}}
 
-    config_file(hash) do |config|
-      config = Ficus.load(config) do
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
         section 'subsections' do
           section /^section/ do
-            required :key1
+            required 'key1'
           end
         end
       end
-      config.subsections.section1.key1.should eq 'value1'
-      config.subsections.section2.key1.should eq 'value1'
+
+      expect(ficus.valid?).to eq true
+      expect(ficus.config['subsections']['section1']['key1']).to eq 'value1'
+      expect(ficus.config['subsections']['section2']['key1']).to eq 'value1'
     end
   end
 
-  it 'should invalidate nonconformant subsections' do
-    hash = {
-        :subsections => {
-            :section1 => {:key1=>'value1'},
-            :section2 => {},
-        }
-    }
+  it 'will fail to validate nonconformant subsections' do
+    hash = {'subsections' => {'section1' => {'key1' => 'value1'}, 'section2' => {}}}
 
-    config_file(hash) do |config|
-      expect do
-        Ficus.load(config) do
-          section 'subsections' do
-            section /^section/ do
-              required :key1
-            end
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        section 'subsections' do
+          section /^section/ do
+            required 'key1'
           end
         end
-      end.to raise_error Ficus::ConfigError
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/subsections.section2.key1/)
     end
   end
 
-  it 'should validate all subsections' do
-    hash = {
-        :subsections => {
-            :section1 => {:key1=>'value1'},
-            :section2 => {},
-        }
-    }
+  it 'will fail validate all subsections' do
+    hash = {'subsections' => {'section1' => {'key1' => 'value1'},'section2' => {}}}
 
-    config_file(hash) do |config|
-      expect do
-        Ficus.load(config) do
-          section 'subsections' do
-            section :all do
-              required :key1
-            end
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        section 'subsections' do
+          section :all do
+            required 'key1'
           end
         end
-      end.to raise_error Ficus::ConfigError
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/subsections.section2.key1/)
+    end
+  end
+
+  it 'will validate based on a template' do
+    hash = {'section1' => {'key1' => 'value1'}}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        template 'template1' do
+          required 'key1'
+        end
+        section 'section1', template: 'template1'
+      end
+      expect(ficus.valid?).to eq true
+      expect(ficus.config['section1']['key1']).to eq 'value1'
+    end
+  end
+
+  it 'will fail to validate due to failing to conform to a template' do
+    hash = {'section1' => {}}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        template 'template1' do
+          required 'key1'
+        end
+        section 'section1', :template=>'template1'
+      end
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/section1.key1/)
     end
   end
 
-  def config_file(hash=@config)
-    Tempfile.open('config.yml') do |config|
-      config.write hash.to_yaml
-      config.close
-      yield config.path
+  it 'will fail to validate a reference to an invalid template' do
+    hash = {'section1' => {}}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        section 'section1', template: 'template1'
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.first.to_s).to match(/undefined template template1/)
     end
   end
 
-  def logger
-    Logger.new(STDOUT).tap { |log| log.level = Logger::FATAL }
+  it 'will fail to validate due to a parameter definde as a section' do
+    hash = {'section1' => 'notarealsection'}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        section 'section1'
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 1
+      expect(ficus.errors.first.to_s).to match(/must be/i)
+    end
+  end
+
+  it 'will validate with type checking on optional parameters' do
+    hash = {'number' => 3}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        optional 'number', 1,     :number
+        optional 'bool',   true,  :boolean
+        optional 'name',  'drew', :string
+        optional 'matcher', 'server5', /server\d/
+      end
+
+      expect(ficus.valid?).to eq true
+    end
+  end
+
+  it 'will fail to validate with type checking on optional parameters' do
+    hash = {}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        optional 'number',  false,      :number
+        optional 'bool',    'drew',     :boolean
+        optional 'name',    123,        :string
+        optional 'matcher', 'server5',  /zzzserver\d/
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 4
+    end
+  end
+  it 'will validate with type checking on required parameters' do
+    hash = {'number' => 1, 'bool' => false,'name' => "drew"}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        required 'number', :number
+        required 'bool',   :boolean
+        required 'name',   :string
+      end
+
+      expect(ficus.valid?).to eq true
+    end
+  end
+
+  it 'will fail to validate due to type checking on required parameters' do
+    hash = {'number' => false, 'bool' => "nope",'name' => 1}
+
+    Ficus.load(hash).tap do |ficus|
+      ficus.validation do
+        required 'number', :number
+        required 'bool',   :boolean
+        required 'name',   :string
+      end
+
+      expect(ficus.valid?).to eq false
+      expect(ficus.errors.size).to eq 3
+      ficus.errors.each do |error|
+        expect(error.to_s).to match(/must be/)
+      end
+    end
+  end
+
+  it 'will raise an exception if no validation block is specified' do
+    Ficus.load({'key' => 'value'}).tap do |ficus|
+      expect(ficus.schema).to eq nil
+      expect{ficus.valid?}.to raise_error(::Ficus::MissingValidation)
+    end
+  end
+
+  it 'will allow you to chain the validation method' do
+    ficus = Ficus.load({'some' => 'data'}).validation do
+      required 'some', :string
+    end
+
+    expect(ficus.class).to eq Ficus
+    expect(ficus.schema).not_to be_nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ficus
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Drew Fradette
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-24 00:00:00.000000000 Z
+date: 2014-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,20 +66,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: recursive-open-struct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.5
 description: A runtime validation configuration DSL
 email:
 - drew.fradette@gmail.com
@@ -88,15 +74,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/regexp/regexp.rb
+- examples/regexp/sample.conf
+- examples/simple/sample.conf
+- examples/simple/simple.rb
+- examples/templates/sample.conf
+- examples/templates/templates.rb
+- examples/typechecking/sample.conf
+- examples/typechecking/typechecking.rb
 - ficus.gemspec
 - lib/ficus.rb
-- lib/ficus/dsl.rb
-- lib/ficus/exceptions.rb
-- lib/ficus/loader.rb
 - spec/ficus_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/drewfradette/ruby-ficus

data/lib/ficus/dsl.rb

@@ -1,36 +0,0 @@
-class Ficus < RecursiveOpenStruct
-  def section(name, args = {}, &block)
-    sections(name).each do |s|
-      s.parent = self.parent ? "#{self.parent}.#{name}" : name
-      s.instance_eval(&block) if block_given?
-    end
-  rescue NoSection
-    if args[:optional] == true
-      Ficus.warning("Section #{name} is not defined")
-    else
-      Ficus.error("Section #{name} is not defined")
-    end
-  end
-
-  def sections(name)
-    if name == :all
-      sections(/.*/)
-    elsif name.is_a? Regexp
-      matches = self.marshal_dump.keys
-      matches.map { |k| self.send(k) unless k == :parent }.compact!
-    else
-      s = self.send(name)
-      raise NoSection.new if s.nil?
-      [s]
-    end
-  end
-
-  def optional(name, default)
-    self.send("#{name}=", default) if self.send(name).nil?
-  end
-
-  def required(name)
-    prefix = self.parent ? "#{self.parent}." : nil
-    Ficus.error "Option #{prefix}#{name} is not defined" if self.send(name).nil?
-  end
-end

data/lib/ficus/exceptions.rb

@@ -1,4 +0,0 @@
-class Ficus < RecursiveOpenStruct
-  class ConfigError < StandardError; end
-  class NoSection < StandardError; end
-end

data/lib/ficus/loader.rb

@@ -1,38 +0,0 @@
-class Ficus < RecursiveOpenStruct
-  class << self
-    attr_accessor :verbose, :logger, :errors, :warnings
-
-    # Load the configuration file and validate.
-    def load(file, &block)
-      @errors, @warnings, @config = [], [], nil
-      config(file).instance_eval(&block) if block_given?
-
-      warnings.each { |e| logger.warn e }
-      errors.each { |e| logger.error e }
-      raise ConfigError.new('Unable to start due to invalid settings') if errors.size > 0
-      config(file)
-    end
-
-    def error(msg)
-      @errors << msg
-    end
-
-    def warning(msg)
-      @warnings << msg
-    end
-
-    protected
-    def config(file)
-      if @config.nil?
-        yaml = YAML.load File.read(file)
-        @config = Ficus.new(yaml, :recurse_over_arrays => true)
-      end
-      @config
-    end
-
-    def logger
-      @logger ||= Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
-    end
-  end
-end
-