rconfigurator 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in configurator.gemspec
+gem "rspec"

data/README

@@ -0,0 +1,87 @@
+=== Welcome to RConfigurator!
+
+--- Configuration shouldn't be hard...
+
+...and loading configuration for your Ruby application has never been easier. 
+
+RConfigurator automatically "hydrates" your application's module constants by walking
+through a .yml file. If you've got module constants strewn throughout your project, 
+you can use RConfigurator to aggregate these into one place.
+
+--- Usage
+
+To get this going, you just have to require 'rconfigurator' and provide use with the
+name of the project and the location of the configuration file:
+
+    require 'rconfigurator'
+    RConfigurator.configure! "ExampleModule", "/path/to/my/config"
+
+Configurator will analyze the file and 'inflate' your module constants using the data it finds there. Let's say you've got the following module constants:
+
+  ExampleModule::KEY = 'value'
+  ExampleModule::NUMERIC_DATA = 3.221
+  ExampleModule::SampleModule::SOME_KEY = 'another value'    
+  ExampleModule::KEY_SHOULD_BE_MODULE = I::Am::A::Module
+
+RConfigurator can create these for you (before you've even defined the modules
+themselves!) if you point it to the following .yml file:
+
+	key: value
+	numeric_data: 3.221
+	sample_module:
+	    some_key: another value
+	key_should_be_module: I::Am::A::Module
+
+
+RConfigurator even handles some common edge cases for you, in particular the case 
+when the value is itself a module. RConfigurator will construct the module context 
+in place just before it needs a reference. 
+
+For a better feel of how this ends up being useful, or perhaps some inspiration,
+here's an example of part of a real configuration file I am using for another small project:
+
+		version: 0.3.9
+		release: alpha
+		authors: joseph weissman
+		license: artistic license <http://www.perlfoundation.org/artistic_license_2_0>
+
+		# support module config
+		support:
+		    logging:
+		        use_chainsaw: true
+		        chainsaw:
+		            hostname: 'localhost'
+		            port: 8071
+
+		# graphics subsystem config
+		graphics:
+		    default_window_options:
+		        fullscreen: true
+		        width:  1920
+		        height: 1080
+	
+		# ... 
+
+
+--- RConfig
+
+RConfigurator comes with a debugger that will output the statements it will 'eval'. You can
+invoke this utility as 'rconfig [file1] [file2] ...' assuming you have installed the gem.
+
+Running rconfig over the first example yaml file gives us the module structure we are expecting:
+
+	module HypotheticalParentModule; module SampleModule; SOME_KEY = "another value"; end; ; end
+	module I;  module Am;  module A;  module Module; end; end; end; end; 
+	module HypotheticalParentModule; KEY_SHOULD_BE_MODULE = I::Am::A::Module; ; end
+	module HypotheticalParentModule; KEY = "value"; ; end
+	module HypotheticalParentModule; NUMERIC_DATA = 3.221; ; end
+
+
+
+--- Problems? 
+
+Please log bug reports and enhancement proposals here, or feel free to email the author/maintainer of RConfigurator, Joseph Weissman, jweissman1986 (at) gmail.com
+
+--- Conclusion
+
+So far in practice, I have found that it is definitely convenient to be able to architecturally separate 'tuning' from code. I like that I can instantiate complex module structures just by adding a few lines of YAML.

data/Rakefile

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

data/bin/rconfig

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+unless ARGV.count > 0
+  puts "rconfig -- RConfiguration file verify"
+  puts "USAGE: rconfig [file1] [file2] ... "
+end
+
+
+require 'rubygems'			    	
+require 'rconfigurator' 
+require 'yaml'      
+
+ARGV.each do |config_file|
+  RConfigurator.configure!("HypotheticalParentModule", config_file, true)
+end

data/configurator.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'rconfigurator/version'
+Gem::Specification.new do |s|
+  s.name        = "rconfigurator"
+  s.version     = RConfigurator::VERSION
+  s.authors     = ["Joseph Weissman"]
+  s.email       = ["jweissman1986@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{RConfigurator "hydrates" your Ruby application's module constants by walking
+  through a yaml file}
+  s.description = %q{Got constants strewn throughout your project? 
+  You can use RConfigurator to aggregate their definitions into one place.}
+
+  s.rubyforge_project = "rconfigurator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  # s.add_runtime_dependency "rspec"
+end

data/lib/rconfigurator.rb

@@ -0,0 +1,89 @@
+require "rconfigurator/version"
+require "rconfigurator/utilities"
+# require "rconfigurator/configurator"
+
+
+# make a 'binding' to the local scope visible
+$__global_scope = binding()
+
+module RConfigurator
+  
+  #
+  #  Use this configure! method to both create a new configurator AND
+  #  launch the configuration process in one go.
+  #
+  def self.configure!(name, file, debug=false)
+    configurator = Configurator.new(name, file)
+    configurator.configure(debug)
+  end
+  
+  #
+  # "Hydrate" a Ruby application's module constants from a configuration .yml
+  #
+  class Configurator
+    
+    include StringUtilities
+    
+    #
+    #  Configurator.new takes the name of the project and a configuration file
+    #  It does not perform any configuration yet; you must also call configure 
+    #  if RConfigurator is invoked this way.
+    #
+    def initialize(project_name, config_file, opts={})
+      @project_name = project_name
+      @config_file  = config_file
+      @data = YAML::load(File.open(@config_file)).to_hash
+    end
+
+    #
+    #  Kicks off our recursive enumeration of the configuration
+    #  data and module constant generation business logic.
+    #
+    def configure(debug=false)
+      parse_and_recursively_create_constants!(@data, [], debug)
+    end
+
+    #
+    #   configure application based on an easily-managed .yml file -- use 'eval' 
+    #   to generate constants based on the structure of the hash we get from the yaml.
+    #   most of the business logic for recursively parsing a hash and creating module 
+    #   constants basically just involves tracking module names properly.
+    #
+    def parse_and_recursively_create_constants!(hash, module_context = [], debug=false)
+      hash.each do |key, value|
+        if value.is_a? Hash
+          module_name = convert_string_to_camel_case(key)
+          context = module_context.dup << module_name
+          parse_and_recursively_create_constants!(hash[key], context, debug)
+        else
+          value_is_a_module = false
+
+          if value.is_a? String
+            if value.include? "::"
+              value_is_a_module = true
+            else
+              value = "\"#{value}\""          
+            end
+          end
+
+          if value_is_a_module
+            # explicitly build out this module (since it doesn't exist) so that we can talk about it
+            expression = value.split('::').map { |module_name| "module #{module_name}; "}.join(' ')
+            value.split('::').count.times { expression << "end; "}
+            eval(expression, $__global_scope)
+            puts(expression) if debug
+          end
+
+          # define the given constant
+          depth = module_context.count
+          expr = module_context.map { |module_name| "module #{module_name}; " }.join(" ")
+          expr << "#{key.upcase} = #{value}; " 
+          depth.times { expr << "end; "}
+          expr = "module #{@project_name}; #{expr}; end"
+          eval(expr, $__global_scope)
+          puts(expr) if debug
+        end
+      end
+    end
+  end
+end

data/lib/rconfigurator/configurator.rb

@@ -0,0 +1 @@
+# placeholder for gem process, apparently? any, the real logic is in rconfigurator/configurator.rb

data/lib/rconfigurator/utilities.rb

@@ -0,0 +1,13 @@
+module RConfigurator
+  
+  #
+  #   takes a string_with_underbars and ConvertsToCamelCase
+  #
+  module StringUtilities
+    def convert_string_to_camel_case(string)
+      new_string = string.gsub(/^[a-z]|_+[a-z]/) { |a| a.upcase }
+      new_string.gsub!('_', '')
+      new_string
+    end
+  end
+end

data/lib/rconfigurator/version.rb

@@ -0,0 +1,3 @@
+module RConfigurator
+  VERSION = "0.0.2"
+end

data/spec/rconfigurator/rconfigurator_spec.rb

@@ -0,0 +1,27 @@
+libs = %w[ lib/  ]
+libs.each { |lib| $:.unshift lib unless $:.include? lib }
+
+require 'rconfigurator'
+
+describe RConfigurator, "performs dynamic Ruby application initialization" do
+  it "parses a yaml configuration file and generates module constants" do
+    # p RConfigurator.methods - Module.methods
+    
+    RConfigurator.configure!("ExampleModuleName", "spec/resources/sample.yml")
+    
+    # n.b., these values are defined in the config file at spec/resources/sample.yml
+    ExampleModuleName::KEY.should == 'value'
+  end
+  it "should construct numeric constants correctly" do
+    ExampleModuleName::NUMERIC_DATA.should == 3.221
+  end
+  
+  it "should handle nested constants" do
+    ExampleModuleName::SampleModule::SOME_KEY.should == 'another value'    
+  end
+  
+  it "should explicitly construct modules if passed as values" do
+    ExampleModuleName::KEY_SHOULD_BE_MODULE.should be_a_kind_of(Module)
+    ExampleModuleName::KEY_SHOULD_BE_MODULE.should == I::Am::A::Module
+  end
+end

data/spec/resources/sample.yml

@@ -0,0 +1,23 @@
+###########################################
+#
+#     testing config file
+#
+#
+
+key: value
+numeric_data: 3.221
+
+sample_module:
+    some_key: another value
+
+key_should_be_module: I::Am::A::Module
+
+#
+# So, RConfigurator.configure! should create
+#
+# Sample::KEY = value
+# Sample::NUMERIC_DATA = 3.221
+# Sample::SampleModule::SOME_KEY = 'another value'
+#
+# ...etc.
+#

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: rconfigurator
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Joseph Weissman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-23 00:00:00 Z
+dependencies: []
+
+description: |-
+  Got constants strewn throughout your project? 
+    You can use RConfigurator to aggregate their definitions into one place.
+email: 
+- jweissman1986@gmail.com
+executables: 
+- rconfig
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README
+- Rakefile
+- bin/rconfig
+- configurator.gemspec
+- lib/rconfigurator.rb
+- lib/rconfigurator/configurator.rb
+- lib/rconfigurator/utilities.rb
+- lib/rconfigurator/version.rb
+- spec/rconfigurator/rconfigurator_spec.rb
+- spec/resources/sample.yml
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rconfigurator
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: RConfigurator "hydrates" your Ruby application's module constants by walking through a yaml file
+test_files: 
+- spec/rconfigurator/rconfigurator_spec.rb
+- spec/resources/sample.yml