configdsl 1.2.0 → 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f7a1fe10ca22b9a57f0864b3fc838877e8bd58a5
+  data.tar.gz: 3112cbc27003a4ea77bae907b339ccbfb3f999a8
+SHA512:
+  metadata.gz: 9e49134ef6f2db5cb16f0df91efc3972a52e3ffd69db6082f48788aaf9cb281c2b94e041c8e577f6099e45de33bb9885b5605317a124fb1722c8dce62fb7240e
+  data.tar.gz: fc81060fce52ed8a8e9f0442370eaff61720c6937adfc567721dc7cdb23ea01f3288b4b083e6fc3174125af51a8d5ca0a7b02c66f3ed318fd287ec8815b60c47

data/.gitignore

@@ -1,17 +1,17 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in configdsl.gemspec
-gemspec
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in configdsl.gemspec
+gemspec

data/LICENSE

@@ -1,22 +1,22 @@
-Copyright (c) 2012 MOZGIII
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+Copyright (c) 2012 MOZGIII
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,247 +1,247 @@
-# ConfigDSL
-
-A tasty Ruby-based DSL for configuration files. Get rid of those silly YAML and JSON configs.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'configdsl'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install configdsl
-
-## Usage
-
-### Standalone Usage
-
-#### To read a config file
-
- - in your app:
-
-```ruby
-# Read external data
-ConfigDSL.read("test.cdsl.rb")
-```
-
- - test.cdsl.rb
-
-```ruby
-hi "User"
-# p hi  # => "User"
-
-list do
-  one "123"
-  two "345"
-  three do
-    one "1"
-    three_two one + " 2"
-    three_three "three"
-  end
-  see "will_be_overwritten"
-end
-
-list 5 do |index|
-  append "anything"
-  second index + 1
-  square index ** 2
-  
-  see "overwritten!"
-end
-
-starting_time Time.now
-```
-
-   will produce
-
-```ruby
-pp ConfigDSL.data
-
-{:hi=>"User",
- :list=>
-  {:one=>"123",
-   :two=>"345",
-   :three=>{:one=>"1", :three_two=>"1 2", :three_three=>"three"},
-   :see=>"overwritten!",
-   :append=>"anything",
-   :second=>6,
-   :square=>25},
- :starting_time=>2012-11-05 22:47:36 +0000}
-```
-
-#### You can also load inline configs form your code
-
-```ruby
-# Execute inline data
-ConfigDSL.execute do
-  inline_loading_example "here goes"
-  value "awesome"
-  code "great"
-  block_test "config option" do |preset|
-    block_val preset
-  end
-end
-
-# Another inline data
-ConfigDSL.execute do
-  value "awesome"
-end
-```
-    
-   gives
-
-```ruby
-{:inline_loading_example=>"here goes",
- :value=>"awesome",
- :code=>"great",
- :block_test=>{:block_val=>"config option"}}
-```
-
-
-#### You can combine theese two
-
-```ruby
-# Read external data
-ConfigDSL.read("test.cdsl.rb")
-
-# Execute inline data
-ConfigDSL.execute do
-  inline_loading_example "here goes"
-  value "awesome"
-  code "great"
-  block_test "config option" do |preset|
-    block_val preset
-  end
-end
-
-# Another inline data
-ConfigDSL.execute do
-  value "awesome"
-end
-
-require "pp" # for pretty print    
-pp ConfigDSL.data
-```
-
-   is
-
-```ruby
-{:hi=>"User",
- :list=>
-  {:one=>"123",
-   :two=>"345",
-   :three=>{:one=>"1", :three_two=>"1 2", :three_three=>"three"},
-   :see=>"overwritten!",
-   :append=>"anything",
-   :second=>6,
-   :square=>25},
- :starting_time=>2012-11-05 22:48:40 +0000,
- :inline_loading_example=>"here goes",
- :value=>"awesome",
- :code=>"great",
- :block_test=>{:block_val=>"config option"}}
-```
-
-#### You can coviniently access all the config values in your app
-
-```ruby
-# Here is how you get all the config
-p ConfigDSL.data
-
-# To read data from your app you can do this:
-
-puts ; puts "Value of :value is: "
-p ConfigDSL.data[:value]
-
-# or this
-
-puts ; puts "Another way to get it is: "
-p ConfigDSL[:value]
-
-# Access block values
-
-puts "Block values: "
-
-puts ; puts "-- [:list][:one]"
-p ConfigDSL[:list][:one]
-
-puts ; puts "-- [:list][:two]"
-p ConfigDSL[:list][:two]
-
-puts ; puts "-- [:list][:three]"
-p ConfigDSL[:list][:three]
-
-puts ; puts "-- [:list][:three][:three_two]"
-p ConfigDSL[:list][:three][:three_two]
-
-# Get something complex
-puts ; puts "Program was stared at: "
-p ConfigDSL[:starting_time]
-```
-
-#### Keys as methods
-
-You can access all config values using method chaining syntax instead of using the square brackets.
-
-```ruby
-ConfigDSL[:list][:three][:three_two]
-```
-
-is equal to
-
-```ruby
-ConfigDSL.list.three.three_two
-```
-
-However, there is a little problem with this approach.
-Data container objects do have their own methods besides the methods that they provide to get data values.
-
-Notice that `ConfigDSL.data` is also a reserved method (it returns internal first-level data container).
-
-#### Check out the example!
-
-There is an `examples` dir. Check it out to see how it works for yourself!
-
-### Lazy Values
-
-You can have lazy values in your configuration code! By default, those values are evaluated when you call them for the first time.
-This can be very useful when you want to load config before everything else. Storing some config data in the database? This is for you.
-
-```ruby
-ConfigDSL.execute do
-  lazy_varaible lazy!{ Time.now }
-  standart_variable Time.now
-end
-
-sleep 2
-
-ConfigDSL.standart_variable  # => 2012-11-11 21:37:09 +0400
-ConfigDSL.lazy_varaible      # => 2012-11-11 21:37:11 +0400
-```
-
-Can be tricky! Make sure you understand what Lazy Values do and what they don't do!
-
-### Use Hashie::Mash - Deprecated!
-
-Hashie::Mash can not be used as a layer-level storage anymore (because of lazy values implementation).
-
-### Ruby on Rails
-
-To be implemented. For now you can use it like standalone as initializer.
-
-### To-Do List
-
- - Ruby on Rails integration
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+# ConfigDSL
+
+A tasty Ruby-based DSL for configuration files. Get rid of those silly YAML and JSON configs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'configdsl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install configdsl
+
+## Usage
+
+### Standalone Usage
+
+#### To read a config file
+
+ - in your app:
+
+```ruby
+# Read external data
+ConfigDSL.read("test.cdsl.rb")
+```
+
+ - test.cdsl.rb
+
+```ruby
+hi "User"
+# p hi  # => "User"
+
+list do
+  one "123"
+  two "345"
+  three do
+    one "1"
+    three_two one + " 2"
+    three_three "three"
+  end
+  see "will_be_overwritten"
+end
+
+list 5 do |index|
+  append "anything"
+  second index + 1
+  square index ** 2
+  
+  see "overwritten!"
+end
+
+starting_time Time.now
+```
+
+   will produce
+
+```ruby
+pp ConfigDSL.data
+
+{:hi=>"User",
+ :list=>
+  {:one=>"123",
+   :two=>"345",
+   :three=>{:one=>"1", :three_two=>"1 2", :three_three=>"three"},
+   :see=>"overwritten!",
+   :append=>"anything",
+   :second=>6,
+   :square=>25},
+ :starting_time=>2012-11-05 22:47:36 +0000}
+```
+
+#### You can also load inline configs form your code
+
+```ruby
+# Execute inline data
+ConfigDSL.execute do
+  inline_loading_example "here goes"
+  value "awesome"
+  code "great"
+  block_test "config option" do |preset|
+    block_val preset
+  end
+end
+
+# Another inline data
+ConfigDSL.execute do
+  value "awesome"
+end
+```
+    
+   gives
+
+```ruby
+{:inline_loading_example=>"here goes",
+ :value=>"awesome",
+ :code=>"great",
+ :block_test=>{:block_val=>"config option"}}
+```
+
+
+#### You can combine theese two
+
+```ruby
+# Read external data
+ConfigDSL.read("test.cdsl.rb")
+
+# Execute inline data
+ConfigDSL.execute do
+  inline_loading_example "here goes"
+  value "awesome"
+  code "great"
+  block_test "config option" do |preset|
+    block_val preset
+  end
+end
+
+# Another inline data
+ConfigDSL.execute do
+  value "awesome"
+end
+
+require "pp" # for pretty print    
+pp ConfigDSL.data
+```
+
+   is
+
+```ruby
+{:hi=>"User",
+ :list=>
+  {:one=>"123",
+   :two=>"345",
+   :three=>{:one=>"1", :three_two=>"1 2", :three_three=>"three"},
+   :see=>"overwritten!",
+   :append=>"anything",
+   :second=>6,
+   :square=>25},
+ :starting_time=>2012-11-05 22:48:40 +0000,
+ :inline_loading_example=>"here goes",
+ :value=>"awesome",
+ :code=>"great",
+ :block_test=>{:block_val=>"config option"}}
+```
+
+#### You can coviniently access all the config values in your app
+
+```ruby
+# Here is how you get all the config
+p ConfigDSL.data
+
+# To read data from your app you can do this:
+
+puts ; puts "Value of :value is: "
+p ConfigDSL.data[:value]
+
+# or this
+
+puts ; puts "Another way to get it is: "
+p ConfigDSL[:value]
+
+# Access block values
+
+puts "Block values: "
+
+puts ; puts "-- [:list][:one]"
+p ConfigDSL[:list][:one]
+
+puts ; puts "-- [:list][:two]"
+p ConfigDSL[:list][:two]
+
+puts ; puts "-- [:list][:three]"
+p ConfigDSL[:list][:three]
+
+puts ; puts "-- [:list][:three][:three_two]"
+p ConfigDSL[:list][:three][:three_two]
+
+# Get something complex
+puts ; puts "Program was stared at: "
+p ConfigDSL[:starting_time]
+```
+
+#### Keys as methods
+
+You can access all config values using method chaining syntax instead of using the square brackets.
+
+```ruby
+ConfigDSL[:list][:three][:three_two]
+```
+
+is equal to
+
+```ruby
+ConfigDSL.list.three.three_two
+```
+
+However, there is a little problem with this approach.
+Data container objects do have their own methods besides the methods that they provide to get data values.
+
+Notice that `ConfigDSL.data` is also a reserved method (it returns internal first-level data container).
+
+#### Check out the example!
+
+There is an `examples` dir. Check it out to see how it works for yourself!
+
+### Lazy Values
+
+You can have lazy values in your configuration code! By default, those values are evaluated when you call them for the first time.
+This can be very useful when you want to load config before everything else. Storing some config data in the database? This is for you.
+
+```ruby
+ConfigDSL.execute do
+  lazy_varaible lazy!{ Time.now }
+  standart_variable Time.now
+end
+
+sleep 2
+
+ConfigDSL.standart_variable  # => 2012-11-11 21:37:09 +0400
+ConfigDSL.lazy_varaible      # => 2012-11-11 21:37:11 +0400
+```
+
+Can be tricky! Make sure you understand what Lazy Values do and what they don't do!
+
+### Use Hashie::Mash - Deprecated!
+
+Hashie::Mash can not be used as a layer-level storage anymore (because of lazy values implementation).
+
+### Ruby on Rails
+
+To be implemented. For now you can use it like standalone as initializer.
+
+### To-Do List
+
+ - Ruby on Rails integration
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -1,2 +1,2 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/configdsl.gemspec

@@ -1,19 +1,19 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/configdsl/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["MOZGIII"]
-  gem.email         = ["mike-n@narod.ru"]
-  gem.description   = %q{A convinient Ruby-based DSL for your app configuration!}
-  gem.summary       = %q{A convinient Ruby-based DSL for your app configuration!}
-  gem.homepage      = "http://github.com/MOZGIII/ConfigDSL"
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "configdsl"
-  gem.require_paths = ["lib"]
-  gem.version       = ConfigDSL::VERSION
-  
-  gem.add_runtime_dependency "activesupport"
-end
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/configdsl/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["MOZGIII"]
+  gem.email         = ["mike-n@narod.ru"]
+  gem.description   = %q{A convinient Ruby-based DSL for your app configuration!}
+  gem.summary       = %q{A convinient Ruby-based DSL for your app configuration!}
+  gem.homepage      = "http://github.com/MOZGIII/ConfigDSL"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "configdsl"
+  gem.require_paths = ["lib"]
+  gem.version       = ConfigDSL::VERSION
+  
+  gem.add_runtime_dependency "activesupport", ">= 0.0.1"
+end

data/lib/configdsl.rb

@@ -1,255 +1,255 @@
-require "configdsl/version"
-require "active_support/concern"
-require "forwardable"
-
-module ConfigDSL
-  module Memory
-    class MemoryLayer < Hash
-      def self.make_alias_method(meth)
-        "original_#{meth}".to_sym
-      end
-    
-      ALIASED_METHODS = [
-        :[], :fetch
-      ]
-      
-      ALIASED_METHODS.each do |meth|
-        original_method = make_alias_method(meth)
-        
-        begin
-          alias_method original_method, meth
-          
-          define_method meth do |*args, &block|
-            lazy_value = __send__(original_method, *args, &block)
-            lazy_value = lazy_value.value if lazy_value.kind_of?(LazyValue)
-            lazy_value
-          end
-        rescue NameError
-        end
-      end
-      
-      # Give a more handy name
-      alias_method :original_reader, make_alias_method(:[])
-      
-      # Allow methods invocation to read values
-      def method_missing(meth, *args, &block)
-        return self[meth] if has_key?(meth)
-        super
-      end
-      
-      # Allow methods invocation to read values, second part
-      def respond_to?(meth)
-        return true if has_key?(meth)
-        super
-      end
-    end
-  
-    class << self
-      # Creates a new layer-level storage element
-      def layers_factory
-        @factory_base_class ||= MemoryLayer
-        @factory_base_class.new
-      end
-    
-      # Main data container
-      def data
-        @data ||= layers_factory
-      end
-
-      # Stores a value in specified key for specified context
-      def store(key, value, context = [])
-        layer = expand_context(context)
-        layer[key] = value
-      end
-      
-      # Fetches a specified key for a specified context
-      # Allows to provide a default value
-      def fetch(key, defaul_value = nil, context = [])
-        fetch!(key, context)
-      rescue KeyError => e
-        defaul_value
-      end
-      
-      # Fetches a specified key for a specified context
-      # Raises exception if something goes wrong
-      def fetch!(key, context = [])
-        layer = expand_context(context)
-        raise KeyError, "In context #{context} key not found: #{key.inspect}" unless layer.has_key?(key)
-        layer[key]
-      end
-      
-      # Return a layer described by context or rises an exception
-      # if any of parent layers is undefined
-      def expand_context(context)
-        context.inject(data) do |hash, level|
-          hash[level]
-        end
-      end
-      
-      # Adds a new layer if it does not exist
-      def add_layer(new_layer, context)
-        current_layer = expand_context(context)
-        current_layer[new_layer] ||= layers_factory
-      end
-    end
-  end
-
-  module DSL    
-    extend ActiveSupport::Concern
-    
-    def self.debug?
-      @debug ||= false
-    end
-    
-    def self.debug!(value = true)
-      @debug = value
-    end
-    
-    def context
-      @@context ||= []
-    end
-    
-    def debug(text)
-      puts text if DSL.debug?
-    end
-    
-    def lazy!(*args, &block)
-      LazyValue.new(block, args)
-    end
-    
-    def assign!(sym, value = nil, &block)
-      return sym.each { |key, val| assign!(key, val) } if sym.kind_of? Hash
-      varibales_hook(sym, value, &block)
-    end
-
-    def varibales_hook(meth, *args, &block)
-      debug "Hooked #{meth}"
-      debug "Context is #{context}"
-      if block_given?
-        # Add list
-        debug "Adding list #{meth}"
-        evaluate_within_layer(meth, block, args)
-      else
-        if args.empty?
-          # Read variable
-          debug "Reading variable #{meth}"
-          Memory.fetch!(meth, context)
-        else
-          # Add variable
-          debug "Adding variable #{meth}"
-          value = args.size == 1 ? args.first : args.dup
-          Memory.store(meth, value, context)
-        end
-      end
-    end
-
-    def evaluate_within_layer(new_layer, block, args = [])
-      Memory.add_layer(new_layer, context)
-      begin
-        context.push new_layer
-        block.call(*args)
-      ensure
-        context.pop
-      end
-    end
-    
-    def method_missing(meth, *args, &block)
-      if respond_to?(meth)
-        super
-      else
-        varibales_hook(meth, *args, &block)
-      end
-    end
-
-  end
-  
-  module Processor
-    class Sandbox
-      include DSL
-    end
-
-    def self.process(filename)
-      sandbox = Sandbox.new
-      sandbox.instance_eval(File.read(filename), filename)
-      sandbox
-    end
-    
-    def self.execute(&block)
-      sandbox = Sandbox.new
-      sandbox.instance_eval(&block)
-      sandbox
-    end
-    
-    def self.add_module(module_const)
-      Sandbox.extend module_const
-    end
-  end
-  
-  class << self  
-    def read(filename)
-      Processor.process(filename)
-    end
-    
-    def execute(&block)
-      Processor.execute(&block)
-    end
-    
-    def data
-      Memory.data
-    end
-    
-    def method_missing(meth, *args, &block)
-      if data.respond_to?(meth)
-        data.send(meth, *args, &block)
-      else
-        super
-      end
-    end
-    
-    def respond_to?(meth)
-      super_value = super
-      return super_value if super_value != false
-      data.respond_to?(meth)
-    end
-  end
-  
-  class LazyValue
-    def self.default_options
-      {
-        caching: true        
-      }
-    end
-    
-    attr_reader :block, :args, :options
-  
-    def initialize(block, args = [], options = {})
-      @block = block
-      @args = args
-      @options = self.class.default_options.merge(options)
-      @cached = false
-    end
-    
-    def value(new_args = nil)
-      return @cache if caching? && cached?
-      value = block.call(*(new_args ? new_args : args))
-      if caching?
-        @cache = value
-        @cached = true
-      end
-      value
-    end
-    
-    def caching?
-      !!options[:caching]
-    end
-    
-    def flush_cache!
-      @cache = nil # clean pointer so that GC can do it's work immediately
-      @cached = true
-    end
-    
-    def cached?
-      @cached
-    end
-  end
-end
+require "configdsl/version"
+require "active_support/concern"
+require "forwardable"
+
+module ConfigDSL
+  module Memory
+    class MemoryLayer < Hash
+      def self.make_alias_method(meth)
+        "original_#{meth}".to_sym
+      end
+    
+      ALIASED_METHODS = [
+        :[], :fetch
+      ]
+      
+      ALIASED_METHODS.each do |meth|
+        original_method = make_alias_method(meth)
+        
+        begin
+          alias_method original_method, meth
+          
+          define_method meth do |*args, &block|
+            lazy_value = __send__(original_method, *args, &block)
+            lazy_value = lazy_value.value if lazy_value.kind_of?(LazyValue)
+            lazy_value
+          end
+        rescue NameError
+        end
+      end
+      
+      # Give a more handy name
+      alias_method :original_reader, make_alias_method(:[])
+      
+      # Allow methods invocation to read values
+      def method_missing(meth, *args, &block)
+        return self[meth] if has_key?(meth)
+        super
+      end
+      
+      # Allow methods invocation to read values, second part
+      def respond_to?(meth)
+        return true if has_key?(meth)
+        super
+      end
+    end
+  
+    class << self
+      # Creates a new layer-level storage element
+      def layers_factory
+        @factory_base_class ||= MemoryLayer
+        @factory_base_class.new
+      end
+    
+      # Main data container
+      def data
+        @data ||= layers_factory
+      end
+
+      # Stores a value in specified key for specified context
+      def store(key, value, context = [])
+        layer = expand_context(context)
+        layer[key] = value
+      end
+      
+      # Fetches a specified key for a specified context
+      # Allows to provide a default value
+      def fetch(key, defaul_value = nil, context = [])
+        fetch!(key, context)
+      rescue KeyError => e
+        defaul_value
+      end
+      
+      # Fetches a specified key for a specified context
+      # Raises exception if something goes wrong
+      def fetch!(key, context = [])
+        layer = expand_context(context)
+        raise KeyError, "In context #{context} key not found: #{key.inspect}" unless layer.has_key?(key)
+        layer[key]
+      end
+      
+      # Return a layer described by context or rises an exception
+      # if any of parent layers is undefined
+      def expand_context(context)
+        context.inject(data) do |hash, level|
+          hash[level]
+        end
+      end
+      
+      # Adds a new layer if it does not exist
+      def add_layer(new_layer, context)
+        current_layer = expand_context(context)
+        current_layer[new_layer] ||= layers_factory
+      end
+    end
+  end
+
+  module DSL    
+    extend ActiveSupport::Concern
+    
+    def self.debug?
+      @debug ||= false
+    end
+    
+    def self.debug!(value = true)
+      @debug = value
+    end
+    
+    def context
+      @@context ||= []
+    end
+    
+    def debug(text)
+      puts text if DSL.debug?
+    end
+    
+    def lazy!(*args, &block)
+      LazyValue.new(block, args)
+    end
+    
+    def assign!(sym, value = nil, &block)
+      return sym.each { |key, val| assign!(key, val) } if sym.kind_of? Hash
+      varibales_hook(sym, value, &block)
+    end
+
+    def varibales_hook(meth, *args, &block)
+      debug "Hooked #{meth}"
+      debug "Context is #{context}"
+      if block_given?
+        # Add list
+        debug "Adding list #{meth}"
+        evaluate_within_layer(meth, block, args)
+      else
+        if args.empty?
+          # Read variable
+          debug "Reading variable #{meth}"
+          Memory.fetch!(meth, context)
+        else
+          # Add variable
+          debug "Adding variable #{meth}"
+          value = args.size == 1 ? args.first : args.dup
+          Memory.store(meth, value, context)
+        end
+      end
+    end
+
+    def evaluate_within_layer(new_layer, block, args = [])
+      Memory.add_layer(new_layer, context)
+      begin
+        context.push new_layer
+        block.call(*args)
+      ensure
+        context.pop
+      end
+    end
+    
+    def method_missing(meth, *args, &block)
+      if respond_to?(meth)
+        super
+      else
+        varibales_hook(meth, *args, &block)
+      end
+    end
+
+  end
+  
+  module Processor
+    class Sandbox
+      include DSL
+    end
+
+    def self.process(filename)
+      sandbox = Sandbox.new
+      sandbox.instance_eval(File.read(filename), filename)
+      sandbox
+    end
+    
+    def self.execute(&block)
+      sandbox = Sandbox.new
+      sandbox.instance_eval(&block)
+      sandbox
+    end
+    
+    def self.add_module(module_const)
+      Sandbox.extend module_const
+    end
+  end
+  
+  class << self  
+    def read(filename)
+      Processor.process(filename)
+    end
+    
+    def execute(&block)
+      Processor.execute(&block)
+    end
+    
+    def data
+      Memory.data
+    end
+    
+    def method_missing(meth, *args, &block)
+      if data.respond_to?(meth)
+        data.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+    
+    def respond_to?(meth)
+      super_value = super
+      return super_value if super_value != false
+      data.respond_to?(meth)
+    end
+  end
+  
+  class LazyValue
+    def self.default_options
+      {
+        caching: true        
+      }
+    end
+    
+    attr_reader :block, :args, :options
+  
+    def initialize(block, args = [], options = {})
+      @block = block
+      @args = args
+      @options = self.class.default_options.merge(options)
+      @cached = false
+    end
+    
+    def value(new_args = nil)
+      return @cache if caching? && cached?
+      value = block.call(*(new_args ? new_args : args))
+      if caching?
+        @cache = value
+        @cached = true
+      end
+      value
+    end
+    
+    def caching?
+      !!options[:caching]
+    end
+    
+    def flush_cache!
+      @cache = nil # clean pointer so that GC can do it's work immediately
+      @cached = true
+    end
+    
+    def cached?
+      @cached
+    end
+  end
+end

data/lib/configdsl/version.rb

@@ -1,3 +1,3 @@
-module ConfigDSL
-  VERSION = "1.2.0"
-end
+module ConfigDSL
+  VERSION = "1.2.1"
+end

metadata

@@ -1,32 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: configdsl
 version: !ruby/object:Gem::Version
-  version: 1.2.0
-  prerelease: 
+  version: 1.2.1
 platform: ruby
 authors:
 - MOZGIII
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-15 00:00:00.000000000 Z
+date: 2013-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.1
 description: A convinient Ruby-based DSL for your app configuration!
 email:
 - mike-n@narod.ru
@@ -47,27 +44,25 @@ files:
 - lib/configdsl/version.rb
 homepage: http://github.com/MOZGIII/ConfigDSL
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.1.10
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A convinient Ruby-based DSL for your app configuration!
 test_files: []
-has_rdoc: