rack-config-flexible 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012, Tim Hentenaar
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,117 @@
+rack-config-flexible
+====================
+
+An alternative to Rack::Config, offering much greater flexibility.
+
+Licensing
+=========
+
+This software is licensed under the [Simplified BSD License](http://en.wikipedia.org/wiki/BSD_licenses#2-clause_license_.28.22Simplified_BSD_License.22_or_.22FreeBSD_License.22.29) as described in the LICENSE file.
+
+Installation
+============
+
+    gem install rack-config-flexible
+
+Usage
+=====
+
+Just add something like this to your _config.ru_:
+
+```ruby
+require 'rack/config/simple'
+
+use Rack::Config::Flexible do
+  environment :production
+    section :data
+      set :key => 'value'
+
+  environment :development
+    section :data
+      set :key => 'dev_value'
+
+  # Set the current environment
+  environment :production
+end
+```
+
+Of course, individual environments, sections, and even the entire configuration can be loaded from yaml files.
+
+Accessing the Configuration Data
+================================
+
+The configuration can be accessed by downstream middleware via the Rack environment. In the Usage example,
+you could access _key_'s value as follows:
+
+```ruby
+env['rack.config']['data.key']
+```
+
+and you can even modify values as follows:
+
+```ruby
+env['rack.config']['data.key'] = 'new_value'
+```
+
+if, and only if, the given key exists. The format for the hash key is _section.key_.
+
+Loading an Environment/Section from Yaml
+========================================
+
+```ruby
+require 'rack/config/simple'
+
+use Rack::Config::Flexible do
+  environment :production
+    section :data, 'cfg/production/data.yaml'
+
+  environment :development, 'cfg/development.yaml'
+
+  # Set the current environment
+  environment :production
+end
+```
+
+Any calls to _set_ after _environment_ or _section_ will override
+data loaded from the yaml file if the same key is specified.
+Otherwise, they'll just add the values to the hash per usual.
+
+Loading the Entire Configuration from a Yaml
+============================================
+
+You can load the entire configuration from a single file, or a
+directory tree.
+
+This example loads from a single file:
+
+```ruby
+require 'rack/config/flexible'
+
+use Rack::Config::Flexible :from_file => 'settings.yaml' do
+  # Set the current environment to production
+  environment :production
+end
+```
+
+This one from a directory tree:
+
+```ruby
+require 'rack/config/flexible'
+
+use Rack::Config::Flexible :from_file => 'settings' do
+  # Set the current environment to production
+  environment :production
+end
+```
+
+The directory tree is expected to be laid out like:
+
+	settings/environment/section.yaml
+
+Where each directory under _settings_ is an _environment_, 
+containg a separate yaml file for each _section_. 
+The YAML file itself will only hold key-value pairs for
+that particular _section_.
+
+See the inline documentation for more details.
+

data/lib/rack/config/flexible.rb

@@ -0,0 +1,280 @@
+require 'yaml'
+
+module Rack
+module Config
+  #
+  # === Overview
+  #
+  # Rack::Config::Flexible is an alternative to Rack::Config,
+  # offering much greater flexibility.
+  #
+  # Configuration options are stored as key-value pairs in _sections_,
+  # partitioned by _environments_. For example:
+  #
+  #   + environment
+  #     + section
+  #       key -> value pairs
+  #
+  # A simple DSL is provided and can be used either within a passed
+  # configuration block (to ::new), or to the #configuration method.
+  #
+  # Facilities are also provided to load whole environments, and sections
+  # from either a single YAML file structured like, or from a directory tree.
+  #
+  # Note that values from a file/directory tree can be overridden with #configure, or
+  # by passing a block to ::new.
+  #
+  # === DSL Example
+  #
+  # Here's an example showing the intended usage of the provided DSL:
+  #
+  #
+  #    require 'rack/config/flexible'
+  #
+  #    use Rack::Config::Flexible do
+  #      environment :production
+  #      section :data
+  #        set :key => 'value'
+  #     
+  #      environment :development
+  #      section :data
+  #        set :key => 'dev_value'
+  #      
+  #      # Set the current environment
+  #      environment :production
+  #    end
+  #
+  # +data.key+ would return 'value' in *production*, and 'dev_value' in *development*; and
+  # would be accessed via the Rack environment like so:
+  #
+  #   env['rack.config']['data.key']
+  #
+  # Values can also be replaced by:
+  #
+  #   env['rack.config']['data.key'] = 'new_value'
+  #
+  # Keep in mind that anything that you would be able to do inside the block you're passing
+  # to ::new, can also be done in a block passed to #configure since they both run in the
+  # same scope.
+  #
+  # === Single-File Example
+  #
+  # Loading settings from a single file is extremely easy:
+  #
+  #    require 'rack/config/flexible'
+  #
+  #    use Rack::Config::Flexible :from_file => 'settings.yaml' do
+  #      # Set the current environment to production
+  #      environment :production
+  #    end
+  #
+  # This expects the file to be laid out as follows:
+  #
+  #    environment:
+  #      section:
+  #        key: value
+  #        ...
+  #
+  # It's important to note that when loading from YAML files, environment names and 
+  # section names will be converted to +Symbol+s.
+  #
+  # === Directory Tree Example
+  #
+  # This is just as easy as loading from a single file. In this case, instead of
+  # specifying a file name, we specify a path to a directory tree.
+  #
+  #    require 'rack/config/flexible'
+  #
+  #    use Rack::Config::Flexible :from_file => 'settings' do
+  #      # Set the current environment to production
+  #      environment :production
+  #    end
+  #
+  # This expects the directory tree to be laid out as follows:
+  #
+  #    settings/environment/section.yaml
+  #
+  # where each directory under _settings_ is an _environment_, containg a separate YAML
+  # file for each _section_. The YAML file itself will only hold
+  # key-value pairs for that particular _section_.
+  #
+  # === Loading Individual Environments/Sections from YAML
+  #
+  # You can load individual _environment_ and _section_ bits from a YAML file as follows:
+  #
+  #    require 'rack/config/flexible'
+  #
+  #    use Rack::Config::Flexible do
+  #      environment :production
+  #      section :data, 'cfg/production/data.yaml'
+  #     
+  #      environment :development, 'cfg/development.yaml'
+  #      
+  #      # Set the current environment
+  #      environment :production
+  #    end
+  #
+  # Any other calls to #set after #environment or #section will override the data
+  # loaded from the YAML file, if the same key is specified. Otherwise, they
+  # will just add to the Hash per usual.
+  #
+  class Flexible
+    def initialize(app,options={},&block)
+      @app    = app
+      @values = {}
+      raise ArgumentError.new('`options\' must be a Hash') unless options.is_a?(Hash)
+
+      if options.has_key?(:from_file) && File.directory?(options[:from_file])
+        # Load from a directory tree
+        Dir[options[:from_file] + '/*'].each { |env|
+          next unless File.directory?(env)
+          environment File.basename(env)
+           
+          Dir[env + '/*.yaml'].each { |sec|
+            next unless File.file?(sec)
+            section File.basename(sec,'.yaml'),sec
+          }
+        }
+      elsif options.has_key?(:from_file) && File.exist?(options[:from_file])
+        # Load from a single file
+        @values = Hash[YAML.load_file(options[:from_file]).map { |k,v|
+          [k.to_sym, Hash[v.map { |k,v| [ k.to_sym,v ]}]] if k.is_a?(String) && v.is_a?(Hash)
+        }]
+        @env    = @values.keys.first
+        @sec    = @values[@env].keys.last
+      end
+
+      instance_eval(&block) if block_given?
+    end
+
+    def call(env)
+      dup._call(env) # For thread safety...
+    end
+
+    def _call(env)
+      env['rack.config'] = self
+      @app.call(env)
+    end
+
+    def configure(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    # :category:DSL
+    #
+    # Set the current environment
+    #
+    # [env]
+    #   Environment to use. Defaults to +:production+
+    #
+    # [data] 
+    #   If this is a +String+, it's assumed to be the location of a YAML file to load from. 
+    #   Otherwise, a +Hash+ of data for the environment. (Optional)
+    #
+    def environment(env,data=nil)
+      raise ArgumentError.new('`env\' must be a String or Symbol') unless env.is_a?(String) || env.is_a?(Symbol)
+
+      # Load from a hash (if specified) or create a new hash
+      @env          = env.to_sym
+      @values[@env] = {} unless @values.has_key?(@env) && @values[@env].is_a?(Hash)
+
+      # Load from a file, or hash, if specified
+      if data.is_a?(String) && File.exist?(data)
+        @values[@env].merge!(Hash[YAML.load_file(data).map { |k,v| [k.to_sym, v] if k.is_a?(String) }])
+        @sec = @values[@env].keys.last
+      elsif data.is_a?(Hash)
+        @values[@env].merge!(data)
+      end
+    end
+
+    # :category:DSL
+    #
+    # Set the current section
+    #
+    # [sec]  Section to use. Defaults to +:default+
+    # [vals] 
+    #   Values to prepopulate this section with. 
+    #   If this is a +String+, it's assumed to be the location of a YAML file to load from.
+    #
+    def section(sec,vals=nil)
+      raise ArgumentError.new('`sec\' must be a String or Symbol') unless sec.is_a?(String) || sec.is_a?(Symbol)
+
+      @sec = sec.to_sym
+      @values[@env][@sec] = {} unless @values[@env][@sec].is_a?(Hash)
+      @values[@env][@sec].merge!(vals) if vals.is_a?(Hash)
+
+      # If vals is a string, it's assumed to be a YAML file
+      @values[@env][@sec].merge!(YAML.load_file(vals)) if vals.is_a?(String) && File.exist?(vals)
+    end
+
+    # :category:DSL
+    #
+    # Add/Update a value to/in the current section
+    #
+    # [vals] +Hash+ Keys/Value(s) to set
+    #
+    def set(vals)
+      raise ArgumentError.new('`vals\' must be a Hash') unless vals.is_a?(Hash)
+      @values[@env][@sec].merge!(vals)
+    end
+
+    #
+    # Hash-like accessor for config data
+    #
+    # [idx] Path to the requested item, starting with the section (e.g. +default.key.subkey+)
+    #
+    # Returns the value, or +nil+ if the value cannot be located
+    #
+    def [](idx)
+      manipulate_element(idx)
+    end
+
+    #
+    # Hash-like modifier for config data
+    #
+    # This will replace the value at +idx+ with +value+ if, and only if,
+    # +idx+ already exists.
+    #
+    # [idx]   Path to the requested item, starting with the section (e.g. +default.key.subkey+)
+    # [value] New value to set
+    #
+    def []=(idx,value)
+      raise ArgumentError.new('`idx\' must be a String') unless idx.is_a?(String)
+      manipulate_element(idx,value)
+    end
+
+protected
+    #
+    # Manipulate (or lookup) the element specified by +idx+
+    #
+    def manipulate_element(idx,value=nil)
+      raise ArgumentError.new('`idx\' must be a String') unless idx.is_a?(String)
+      idx = idx + '.' unless idx.index('.')
+      tmph = nil ; pieces = idx.split(/\.+/)
+
+      pieces.each_with_index { |part,i|
+        # Look for the section
+        if tmph.nil?
+          tmph   = @values[@env][part]
+          tmph ||= @values[@env][part.to_sym]
+          next
+        end
+
+        # Return nil if we can't find the value
+        return nil unless tmph.is_a?(Hash) && (tmph.has_key?(part) || tmph.has_key?(part.to_sym))
+
+        # Otherwise, return or replace the value when we do find it
+        if i == (pieces.size - 1) && !value.nil?
+           tmph.has_key?(part) ? tmph[part] = value : tmph[part.to_sym] = value
+        else
+           tmph = tmph.has_key?(part) ? tmph[part] : tmph[part.to_sym]
+        end
+      }
+
+      return tmph
+    end
+  end
+end
+end
+
+# vi:set ts=2 sw=2 expandtab sta:

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: rack-config-flexible
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Tim Hentenaar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-17 00:00:00.000000000 Z
+dependencies: []
+description: ! "  Rack::Config::Flexible is an alternative to Rack::Config,\n  offering
+  much greater flexibility.\n  \n  Configuration options are stored as key-value pairs
+  in _sections_,\n  partitioned by _environments_. For example:\n  \n    + environment\n
+  \     + section\n        key -> value pairs\n  \n  A simple DSL is provided and
+  can be used either within a passed\n  configuration block (to ::new), or to the
+  #configuration method.\n  \n  Facilities are also provided to load whole environments,
+  and sections\n  from either a single YAML file structured like, or from a directory
+  tree.\n\n  See the README file or RDoc documentation for more info.\n"
+email: tim.hentenaar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/config/flexible.rb
+- README.md
+- LICENSE
+homepage: https://github.com/thentenaar/rack-config-flexible
+licenses: []
+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
+signing_key: 
+specification_version: 3
+summary: An alternative to Rack::Config, offering much greater flexibility
+test_files: []