Configuration.rb

Ruby
1

NAME
configuration.rb

SYNOPSIS
pure ruby scoped configuration files

DESCRIPTION
configuration.rb provides a mechanism for configuring ruby programs
with
ruby configuration files. a configuration.rb file, for example
‘config/app.rb’, can be written simply as

   Configuration.for('app'){
     key 'value'
     foo 'bar'
     port 42
   }

and loaded via the normal ruby require/load mechanism

   Kernel.load 'config/app.rb'

or with a slightly augmented loading mechnanism which simply
searches an
extra set of paths in addition to the standard ones

   Configuration.path = %w( config configuration )

   Configuration.load 'app'

configurations are completely open

   Configuration.for('app'){
     object_id 'very open'
   }

support arbitrarily nested values

   Configuration.for('app'){
     a { b { c { d 42 } } }
   }

   c = Configuration.for 'app'

   p c.a.b.c.d #=> 42

allow POLS scoped lookup of vars

 Configuration.for('config'){
   outer 'bar'

   inner {
     value 42
   }
 }

 c = Configuration.for 'config'

 p c.outer       #=> 'bar'
 p c.inner.value #=> 42
 p c.inner.outer #=> 'bar'

and not a whole lot else - configuration.rb is s very small library
consisting of one file and < 150 loc

SAMPLES

<========< samples/a.rb >========>

~ > cat samples/a.rb

 #
 # basic usage is quite, simple, load the config and use it's

values. the
# config syntax is fairly obvious, i think, but note that it is
ruby and any
# ruby can be included. also note that each config is named,
allowing
# multiple configs to be places in one file
#
require ‘configuration’

   c = Configuration.load 'a'

   p c.a + c.b - c.c

~ > cat config/a.rb

 Configuration.for('a'){
   a 40
   b 4
   c 2
 }

~ > ruby samples/a.rb

 42

<========< samples/b.rb >========>

~ > cat samples/b.rb

 #
 # configuration.rb supports a very natural nesting syntax.  note

how values
# are scoped in a POLS fashion
#
require ‘configuration’

   c = Configuration.for 'b'

   p c.www.url
   p c.db.url
   p c.mail.url

~ > cat config/b.rb

 Configuration.for('b'){
   host "codeforpeople.com"

   www {
     port 80
     url "http://#{ host }:#{ port }"
   }

   db {
     port 5342
     url "db://#{ host }:#{ port }"
   }

   mail {
     host "gmail.com"
     port 25
     url "mail://#{ host }:#{ port }"
   }
 }

~ > ruby samples/b.rb

 "http://codeforpeople.com:80"
 "db://codeforpeople.com:5342"
 "mail://gmail.com:25"

<========< samples/c.rb >========>

~ > cat samples/c.rb

 #
 # configuration.rb let's you keep code very dry.
 #

   require 'configuration'

   Configuration.load 'c'

   p Configuration.for('development').db
   p Configuration.for('production').db
   p Configuration.for('testing').db

~ > cat config/c.rb

 %w( development production testing ).each do |environment|

   Configuration.for(environment){
     adapter "sqlite3"
     db "db/#{ environment }"
   }

 end

~ > ruby samples/c.rb

 "db/development"
 "db/production"
 "db/testing"

<========< samples/d.rb >========>

~ > cat samples/d.rb

 #
 # configuration.rb makes use of an external blank slate dsl, this

means that
# you Configuration objects do, in fact, have all built-in ruby
methods such
# as #inspect, etc, unless you configure over the top of them.
the effect
# is a configuration object that behaves like a nice ruby object,
but which
# allows any key to be configured
#
require ‘configuration’

   c = Configuration.for 'd'

   p c.object_id
   p c.inspect

~ > cat config/d.rb

 Configuration.for('d'){
   object_id 42
   inspect 'forty-two'
 }

~ > ruby samples/d.rb

 42
 "forty-two"

AUTHOR
[email protected]

enjoy.

a @ http://drawohara.com/