# Configuration.rb

**URL:** <https://www.ruby-forum.com/t/configuration-rb/128632>\
**Category:** Ruby\
**Created:** [February 9, 2008, 5:25pm UTC](https://www.ruby-forum.com/t/configuration-rb/128632 "2008-02-09T17:25:57Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![ara\_howard](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/a/d9b06d/32.png) [@ara\_howard](https://www.ruby-forum.com/u/ara_howard)\
**Post date:** [February 9, 2008, 5:25pm UTC](https://www.ruby-forum.com/t/configuration-rb/128632/1 "2008-02-09T17:25:57Z")

</div>

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  
removed\_email\_address@domain.invalid

enjoy.

a @ [http://drawohara.com/](http://drawohara.com/)