dotruby 0.1.0

data/.index

@@ -0,0 +1,55 @@
+---
+revision: 2013
+type: ruby
+sources:
+- var
+authors:
+- name: trans
+  email: transfire@gmail.com
+organizations:
+- name: Rubyworks
+requirements:
+- groups:
+  - test
+  development: true
+  name: qed
+- groups:
+  - test
+  development: true
+  name: ae
+- groups:
+  - build
+  development: true
+  name: detroit
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/dotruby
+  label: Homepage
+- type: code
+  uri: http://github.com/rubyworks/dotruby
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/group/rubyworks-mailinglist
+  label: Mailing List
+repositories:
+- name: upstream
+  scm: git
+  uri: git@github.com:rubyworks/dotruby.git
+categories: []
+copyrights:
+- holder: Rubyworks
+  year: '2013'
+  license: BSD-2-Clause
+customs: []
+paths:
+  lib:
+  - lib
+created: '2013-01-19'
+summary: Transparent Runtime Configuration for Ruby
+title: DotRuby
+version: 0.1.0
+name: dotruby
+description: DotRuby is a universal runtime configuration system for Ruby tools.
+date: '2013-01-22'

data/.yardopts

@@ -0,0 +1,10 @@
+--title DotRuby
+--readme README.md
+--output-dir doc
+--protected
+--private
+lib
+-
+*.md
+*.txt
+

data/HISTORY.md

@@ -0,0 +1,10 @@
+# RELEASE HISTORY
+
+## 0.1.0 / 2013-01-23
+
+First release of DotRuby.
+
+Changes:
+
+* It's Your Birthday!
+

data/LICENSE.txt

@@ -0,0 +1,23 @@
+BSD-2-Clause License
+
+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 ``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 HOLDERS 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,283 @@
+# DotRuby (formerly known as Ruby Courtier)
+
+**Universal Runtime Configuration for Ruby Tools**
+
+[Homepage](http://rubyworks.github.com/dotruby) /
+[Report Issue](http://github.com/rubyworks/dotruby/issues) /
+[Source Code](http://github.com/rubyworks/dotruby)
+( [![Build Status](https://secure.travis-ci.org/rubyworks/dotruby.png)](http://travis-ci.org/rubyworks/dotruby) )
+
+
+## About
+
+DotRuby is a is multi-tenant runtime configuration system for Ruby tools.
+It is designed to facilitate Ruby-based configuration for multiple
+tools in a single file, and designed to work whether the tool has
+built-in support for DotRuby or not. The syntax is simple, universally
+applicable, and... oh yeah, damn clever.
+
+DotRuby can be used with any Ruby-based commandline tool or library utilized by
+such tool, where there exists some means of configuring it via a toplevel or global
+interface; or the tool has been designed to directly support DotRuby, of course.
+
+
+## Installation
+
+To use DotRuby with any tool, including those that do not in themselves have a
+built-in dependency on DotRuby, first install the DotRuby library, typically
+via RubyGems:
+
+    gem install dotruby
+
+Then add `-rdotruby` to your system's `RUBYOPT` environment variable.
+
+    $ export RUBYOPT='-rdotruby'
+
+You will want to add that to your `.bashrc`, `.profile` or equivalent configuration
+script, so it is always available.
+
+To use DotRuby with tools that support DotRuby directly, there is likely nothing
+to install. Installing the tool should install `dotruby` via a dependency and
+load runtime configurations when the tool is used.
+
+
+## Instruction
+
+### Configuring
+
+To use DotRuby in a project create a configuration file called `.ruby`.
+(Hey, now you know why it has the name, *DotRuby*!). In this file add 
+configuration code as you would normally do for a given library. The
+only caveat is that all such configurations must be against a constant.
+
+For example, let's say we need to configure RSpec. In the `.ruby` file we can
+add the following.
+
+    RSpec.configure do |config|
+      config.color_enabled = true
+      config.tty = true
+      config.formatter = :documentation
+    end
+
+This might seems pretty ordinary, but consider that the RSpec library hasn't
+necessarily been loaded when this is evaluated! Think about that a bit
+and we'll explain how it works below.
+
+For another example, let's demonstrate how we could use this to configure Rake
+tasks. Rake is not the most obvious choice, since developers are just as happy
+to keep using a Rakefile. That's fine. But using Rake as an example serves to
+show that it *can* be done, and also it makes a good tie-in with next example.
+
+    Rake.file do
+      desc 'generate yard docs'
+      task :yard do
+        sh 'yard'
+      end
+    end
+
+Now when `rake` is run the tasks defined in this configuration will be available.
+
+Getting back to our Rake example, you might wonder why anyone would want to do 
+this. That's where the *multi-tenancy* comes into play. Let's add another
+configuration.
+
+    title = "MyApp"
+
+    Rake.file do
+      desc 'generate yard docs'
+      task :yard do
+        sh "yard doc --title #{title}"
+      end
+    end
+
+    QED.config do |c|
+       c.title = "#{title} Demos"
+    end
+
+Now we have configuration for both the `rake` tool and the `qed` tool in
+a single file. Thus we gain the advantage of reducing the file count of our 
+project while pulling our tool configurations together into one place.
+Moreover, these configurations can potentially share settings as demonstrated
+here via the `title` local variable.
+
+### Tagging
+
+Some commands don't correspond to their API namespaces. For example, in the 
+above example we configured QED's title option. But that is actually of
+use when running the `qedoc` command, which belongs to the same library.
+We can easily tell DotRuby to expect this by adding a `tag`.
+
+    tag :QED, :command=>'qedoc'
+
+DotRuby's configurations are triggered by three criteria: a constant,
+a command and a feature. In the above tag example, the constant is
+`QED`, the command is `qedoc` and the feature is not given so it defaults
+to the constant name downcased, i.e. `qed`. If need be we can specify a
+different feature via the `:feature` option.
+
+### Profiles
+
+Sometimes you need to configure a tool with different settings for different
+circumstances. If the tool doesn't have built in support for this, DotRuby
+provides some convenience methods for handling this via environment variables.
+
+A `profile` block can be used to only run if `ENV['profile']', or as a nice
+shortcut `ENV['p']` is set to the given name.
+
+    profile :doc do
+      RSpec.configure do |config|
+        config.color_enabled = true
+        config.tty = true
+        config.formatter = :documentation
+      end
+    end
+
+To be clear why this is just a convenience method, it is essentially the same
+as doing:
+
+    if 'doc' === (ENV['profile'] || ENV['p'])
+      ...
+    end
+
+When utilizing the tool, set the `profile` via an environment variable.
+
+    $ profile=cov qed
+
+Or for additional convenience just `p`:
+
+    $ p=cov qed
+
+### Environments
+
+DotRuby also provided the `environment` convenience method, which is along
+the same line but allows any environment variable to be used.
+
+    environment :testing => 'yes' do
+      ...
+    end
+
+Again, this is just a shortcut for:
+
+    if 'yes' === ENV['testing']
+       ...
+    end
+
+It is recommended that you use the `profile` instead of `environment` unless their
+is specific reason not to do so. This makes it easier for other to utilize, instead
+of having to recollect which environment variables where used for what configurations.
+
+### Tweaks
+
+In the Rake example, you might notice that `Rake.file` isn't an official method
+of the Rake API. This is called a *tweak* and is built-in with DotRuby. Some
+tools that we might wish to use with DotRuby don't have an interface that
+suffices, in these cases a tweak can be used to give it one.
+
+If there is a tool you would like to configure with DotRuby, but it doesn't
+provided a means for it, and a reasonably simple tweak can make it viable, 
+please submit a patch and it will be added to DotRuby. And let the tool creator
+know about it! Hopefully, in time tool developers will make the tweak unnecessary.
+
+### Importing
+
+**(Comming soon)**
+
+Configurations can also be pulled in from other gems using the `import` command.
+For instance, if we wanted to reuse the Rake configurations as defined in
+the `QED` gem:
+
+    import :Rake, :from=>'qed'
+
+If a particular profile or environment is needed, these can specified as options.
+
+    import :RSpec, :from=>'rspec', :profile=>'simplecov'
+
+As long as a project includes its `.ruby` file (and any local imported files)
+in it's gem package, it's possible to share configurations in this manner.
+
+Generally we want all our configurations stored in a single file, but if need be
+the `import` method can be used to place configuration in multiple files.
+Simple use a local path `import` method to load them, e.g.
+
+    import './config/*.dotrb'
+
+DotRuby translates the initial dot into a path relative to the file itself,
+i.e. `__dir__`. Why can't we leave off the initial dot? If we did import
+would work like require and try to load the file from a gem --however,
+there is an issue with implementing this that needs to be resolved with 
+Ruby itself (autoload), so this feature is on hold for the time being.
+
+### Third Party Support
+
+To support DotRuby, all developers have to do is make sure their tools
+have a way of being configured via a toplevel namespace constant.
+
+It is also helps when the the library name to be required is the the same
+as the library's namespace downcased. When it's not the same a `tag` entry
+is needed to tell DotRuby from which feature to expect the constant. For
+popular tools that have such a discrepancy, DotRuby provides *tweaks* that
+take care of it automatically. But it's always best to follow the general
+good practice that the gem name is the same as the lib name which is the same
+as the namespace downcased.
+
+Finally a third party tool can take the final step of full support by using 
+DotRuby as it preferred means of configuration. In that case, just make 
+sure to `require 'dotruby'`.
+
+
+## How It Works
+
+The design of DotRuby is actually quite clever. What it does is proxy all
+calls to *virtual constants*, keeping a record of the messages sent to them.
+When it is time to apply these configurations, it fins the ones that apply
+to the given command and sends the recorded messages on the the real constants.
+If those constants haven't been loaded yet, it adds a hook to `require` and 
+waits for the matching feature to load, at which time it applies the configuration.
+In the way, DotRuby can actually be required before or after the library that
+it will configure and it works regardless.
+
+There is an unfortunate caveat here though. Luckily it will rarely be a real issue,
+but it is possible for `autoload` to fowl up the works, b/c it does not call out
+the standard require method. So there is no way override it and insert the necessary
+hook. Again, this is not likely to be a problem, especially if good naming practices
+are used, but it a good thing to know just in case you run into some unexpected
+behavior.
+
+
+## Dependencies
+
+### Libraries
+
+DotRuby depends on the [Finder](http://rubyworks.github.com/finder) library
+to provide reliable load path and Gem searching. This is used when importing
+configurations from other projects. (It's very much a shame Ruby and RubyGems
+does not have this kind of functionality built-in.)
+
+### Core Extensions
+
+DotRuby uses two core extensions, `#to_h`, which applies to a few different
+classes, and `String#tabto`. These are *copied* from
+[Ruby Facets](http://rubyworks.github.com/facets) to ensure a high
+standard of interoperability.
+
+Both of these methods have been suggested for inclusion in Ruby proper.
+Please head over to Ruby Issue Tracker and add your support.
+
+* http://bugs.ruby-lang.org/issues/749
+* http://bugs.ruby-lang.org/issues/6056
+
+
+## Release Notes
+
+Please see HISTORY.md file.
+
+
+## Copyrights & Licensing
+
+DotRuby is copyrighted open-source software.
+
+    Copyright (c) 2011 Rubyworks. All rights reserved.
+
+It is modifiable and redistributable in accordance with the **BSD-2-Clause** license.
+
+See LICENSE.txt file for details.

data/lib/dotruby.rb

@@ -0,0 +1,25 @@
+# DotRuby - Universal Runtime Configuration for Ruby Tools
+#
+# Q. What if a program needs to be configured, but it does not provide
+# an interface via a constant? For example, what if it uses a global
+# variable?
+#
+# A. Most likely the program has a toplevel namespace module. You
+# can always call module_eval to handle it if there is no other means.
+# You ccould alos define a *make-shift* extension method on it that does
+# the dirty deed. If there is no such module, just make a *make-shift*
+# module for it too.
+#
+#    module ProgramWithoutNamespace
+#      def self.configure(settings)
+#        $dirty_program_settings = settings
+#      end
+#    end
+#
+# We call this *tweaking*.
+
+require 'dotruby/api'
+
+DotRuby.configure!
+
+# DotRuby Copyright (c) 2012 Rubyworks. All rights reserved. (BSD-2-Clause License)

data/lib/dotruby/api.rb

@@ -0,0 +1,106 @@
+module DotRuby
+  require 'dotruby/dsl'
+  require 'dotruby/constant'
+
+  #
+  def self.configuration
+    @configuration ||= DSL.new(dotruby_file)
+  end
+
+  # This is a convenience interfact to the configuration domain, which
+  # is useful for tweaks to redefine the default tag.
+  def self.default_tag(cname, command, feature=nil)
+    configuration.default_tag(cname, command, feature)
+  end
+
+  # Configure the system.
+  #
+  # @return nothing
+  def self.configure!
+    return unless dotruby_file
+
+    dotruby = DotRuby.configuration
+
+    begin
+      require_relative "tweaks/#{DotRuby.command}"
+    rescue LoadError
+    end
+
+    # If the constant already exists, apply the configuration.
+    #
+    # Since Ruby provides no way to ask if a feature has been required or not,
+    # we can only condition application of pre-extisting constants on a
+    # matching command.
+    dotruby.tags.each do |cname, tags|
+      tags.each do |tag|
+        next unless Object.const_defined?(cname)
+        next unless DotRuby.command == tag.first  # command of the tag
+        if config = dotruby.constants[name]
+          execute(&config)
+        end
+      end
+    end
+
+    # If the constant doesn't already exist, wait until it is required.
+    ::Kernel.module_eval {
+      alias _require require
+
+      def require(fname)
+        _require(fname)
+
+        dotruby = DotRuby.configuration
+        command = DotRuby.command
+        dotruby.tags.each do |cname, tags|
+          tags.each do  |tag|
+            next unless fname == tag.last     # feature of the tag
+            next unless command == tag.first  # command of the tag
+            if config = dotruby.constants[cname]
+              DotRuby.execute(&config)
+            end
+          end
+        end
+      end
+
+      module_function :require
+    }
+  end
+
+  # Current command.
+  #
+  # @return [String]
+  def self.command
+    ENV['command'] || File.basename($0)
+  end
+
+  # Execute the configuration.
+  #
+  # @return nothing
+  def self.execute(&config)
+    config.call
+  end
+
+  # Returns the `.ruby` file of the current project.
+  #
+  # @return {String] The .ruby file of the project.
+  def self.dotruby_file
+    file = File.join(project_root, '.ruby')
+    return nil unless File.exist?(file)
+    return file
+  end
+
+  # Find the root directory of the current project.
+  #
+  # @return [String,nil] The root directory of the project.
+  def self.project_root(start_dir=Dir.pwd)
+    dir  = start_dir
+    home = File.expand_path('~')
+    until dir == home || dir == '/'
+      if file = Dir[File.join(dir, '{.ruby,.git,.hg}')].first
+        return dir
+      end
+      dir = File.dirname(dir)
+    end
+    nil
+  end
+
+end

data/lib/dotruby/constant.rb

@@ -0,0 +1,55 @@
+module DotRuby
+
+  # The virtual constant class is a simple recorder. Every method
+  # called on it is recorded for later recall on the actual constant
+  # given by name.
+  #
+  # To invoke the recordeed calls on the real constant use `to_proc.call`.
+  #
+  class Constant < BasicObject
+
+    # Initialize configuration.
+    #
+    # @param [Symbol] Name of constant.
+    #
+    def initialize(name)
+      @name  = name
+      @calls = []
+    end
+
+    # An inspection string for the Configuration class.
+    #
+    # @return [String]
+    def inspect
+      "#<Constant #{@name}>"
+    end
+
+    #
+    def method_missing(s, *a, &b)
+      @calls << [s, a, b]
+    end
+
+    # TODO: Add support for const_missing? But these need
+    #       to be recalled in order with method_missing.
+
+    #def const_missing(name)
+    #  @calls << Configuration.new("#{@name}::#{name}")
+    #end
+
+    # Create a Proc instance that will recall the method
+    # invocations on the actual constant.
+    #
+    # @return [Proc]
+    def to_proc
+      name, calls = @name, @calls
+      ::Proc.new do
+        const = ::Object.const_get(name)
+        calls.each do |s, a, b|
+          const.public_send(s, *a, &b)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/dotruby/dsl.rb

@@ -0,0 +1,125 @@
+module DotRuby
+
+  # DotRuby DSL class is used to evaluate the `.ruby` configuration file.
+  #
+  class DSL < BasicObject #Module
+    include ::Kernel
+
+    # Initialize new DSL instance.
+    #
+    def initialize(file)
+      @file = file
+
+      @@default_tags ||= {}
+      @@defined_tags ||= {}
+
+      @@contants ||= {}
+
+      instance_eval(::File.read(file), file)
+    end
+
+    # The path of the current project's `.ruby` file.
+    #
+    # @return [String]
+    attr :file
+
+    # Return recognizes tags.
+    #
+    # @return [Hash]
+    def tags
+      keys = @@default_tags.keys - @@defined_tags.keys
+      tags = @@defined_tags.dup
+      keys.each do |key|
+        tags[key] = [@@default_tags[key]]
+      end
+      tags
+    end
+
+    # Defined tags map constant names to a list of `[command, feature]` pairs.
+    #
+    # @return [Hash<Array>]
+    #def defined_tag
+    #end
+
+    # Table of constant configurations.
+    #
+    # @return [Hash]
+    def constants
+      @@contants
+    end
+
+    # Tag a constant to a command and/or feature.
+    #
+    def tag(constant, *target)
+      options = (::Hash === target.last ? target.pop : {})
+      target  = target.first
+
+      command = options[:command] || target
+      feature = options[:feature] || target
+
+      tag = [command.to_s, feature.to_s]
+
+      @@defined_tags[constant] ||= []
+      @@defined_tags[constant] << tag unless @@defined_tags[constant].include?(tag)
+      @@defined_tags
+    end
+
+    # Set the default tag for a constant.
+    # Unlike defined tags, there can be only one associate for a default tag.
+    #
+    # @return [Hash<Array>]
+    def default_tag(cname, command, feature=nil)
+      @@default_tags[cname.to_sym] = [command.to_s, (feature || command).to_s]
+    end
+
+    # Only configure if profile matches.
+    #
+    # @param [#===] match
+    #   A String or Regexp or any other object that can 
+    #   check a match to a String via #===.
+    #
+    # @return nothing
+    def profile(match, &block)
+      if match === (ENV['profile'] || ENV['p'])
+        block.call
+      end
+    end
+
+    # Only configure if environment matches.
+    #
+    # @param [Hash<name,#===>] matches
+    #   A Hash of String or Regexp or any other object that can 
+    #   check a match to a String via #===.
+    #
+    # @todo Should it be logical-or or logical-and?
+    #
+    # @return nothing
+    def environment(matches={}, &block)
+      if matches.any?{ |e, m| m === ENV[e] }
+        block.call
+      end
+    end
+
+    # Import configuration from an external source.
+    #
+    # @param [Symbol,String] Name of constant or file path.
+    #
+    # @return nothing
+    def import(name, options={})
+      raise 'import is not implemented yet'
+    end
+
+    # Constants provide configuration.
+    #
+    # @param [Symbol,String] cname
+    #
+    # @return [Constant]
+    def self.const_missing(cname)
+      @@default_tags[cname.to_sym] = [cname.to_s.downcase, cname.to_s.downcase]
+
+      @@contants[cname] ||= Constant.new(cname)
+    end
+
+  end
+
+end

data/lib/dotruby/tweaks/rake.rb

@@ -0,0 +1,33 @@
+require 'rake'
+
+module Rake
+
+  # TODO: While probably a complete YAGNI, how might we load a .ruby rake config into a Rakefile?
+
+  # TODO: rake -T doesn't work, why?
+
+  # Use this method to add tasks to Rake.
+  def self.file(&config)
+    Module.new do
+      extend Rake::DSL
+      module_eval(&config)
+    end
+  end
+
+  class Application
+    remove_const(:DEFAULT_RAKEFILES)
+    DEFAULT_RAKEFILES = ['rakefile', 'Rakefile', 'rakefile.rb', 'Rakefile.rb', '.ruby']
+    #DEFAULT_RAKEFILES << '.ruby'
+  end
+
+  def self.load_rakefile(path)
+    case File.basename(path)
+    when '.ruby'
+      # do nothing, DotRuby will do it
+    else
+      load(path)
+    end
+  end
+
+end
+

data/lib/dotruby/tweaks/rspec.rb

@@ -0,0 +1 @@
+DotRuby.default_tag(:RSpec, 'rspec', 'rspec/core')

data/lib/dotruby/tweaks/rubytest.rb

@@ -0,0 +1 @@
+DotRuby.default_tag(:Test, 'rubytest')

data/spec/helper.rb

@@ -0,0 +1 @@
+require 'dotruby/api'

data/spec/spec_api.rb

@@ -0,0 +1,6 @@
+# You need tests! No shit, Sherlock.
+
+describe DotRuby do
+
+end
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: dotruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DotRuby is a universal runtime configuration system for Ruby tools.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- HISTORY.md
+- README.md
+files:
+- .index
+- .yardopts
+- lib/dotruby.rb
+- lib/dotruby/api.rb
+- lib/dotruby/tweaks/rubytest.rb
+- lib/dotruby/tweaks/rake.rb
+- lib/dotruby/tweaks/rspec.rb
+- lib/dotruby/dsl.rb
+- lib/dotruby/constant.rb
+- spec/spec_api.rb
+- spec/helper.rb
+- LICENSE.txt
+- HISTORY.md
+- README.md
+homepage: http://rubyworks.github.com/dotruby
+licenses:
+- BSD-2-Clause
+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: Transparent Runtime Configuration for Ruby
+test_files:
+- spec/spec_api.rb
+- spec/helper.rb
+has_rdoc: