yaml2env 0.1.0

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 yaml2env.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)\.rb|)            { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/README.textile

@@ -0,0 +1,80 @@
+h1. YAML2ENV
+
+_Stash environment-specific configs in YAML-files and load them into ENV according to best-practices pattern - and auto-detects on-initialization if something is missing (skipping the "scratching the head"-part)._
+
+h2. Motivation
+
+For some rainy day...or next commit.
+
+h2. Frameworks
+
+@Yaml2env@ detects lean defaults for: *"Rack":https://github.com/rack/rack*, *"Rails":https://github.com/rails/rails*, and *"Sinatra":https://github.com/sinatra/sinatra*. Though by setting @Yaml2env.env@ and @Yaml2env.root@ manually you are good with any Ruby-project.
+
+h2. Installation
+
+Add to your @Gemfile@:
+
+<pre>
+  gem 'yaml2env'
+</pre>
+
+...and @bundle install@.
+
+h2. Usage
+
+To give this some context; this is how we use @Yaml2Env@ to initialize "Hoptoad":http://hoptoadapp.com:
+
+<pre>
+  Yaml2Env.load 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+
+  if defined?(HoptoadNotifier)
+    HoptoadNotifier.configure do |config|
+      config.api_key = ENV['HOPTOAD_API_KEY']
+    end
+  end
+</pre>
+
+...and the corresponding YAML config file:
+
+<pre>
+  development:
+    api_key: NONE
+
+  staging:
+    api_key: 123abc
+
+  production:
+    api_key: abc123
+
+  test:
+    api_key: NONE
+</pre>
+
+...which will yield:
+
+<pre>
+  Rails.env = 'development'
+  ENV['HOPTOAD_API_KEY'] => 'NONE'
+
+  Rails.env = 'staging'
+  ENV['HOPTOAD_API_KEY'] => '123abc'
+
+  Rails.env = 'production'
+  ENV['HOPTOAD_API_KEY'] => 'abc123'
+
+  Rails.env = 'test'
+  ENV['HOPTOAD_API_KEY'] => 'NONE'
+
+  Rails.env = 'other'
+  => "Failed to load required config for environment 'other': /Users/grimen/development/example.com/config/hoptoad.yml"
+</pre>
+
+h2. Notes
+
+This gem was developed for our own requirements at *"Merchii":http://github.com/merchii*, so feel free to send pull-requests with enhancements of any kind (features, bug-fixes, documentation, tests, etc.) to make it better or useful for you as well.
+
+h2. License
+
+Released under the MIT license.
+Copyright (c) "Merchii":http://github.com/merchii, "Jonas Grimfelt":http://github.com/grimen
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/yaml2env/version.rb

@@ -0,0 +1,3 @@
+module Yaml2env
+  VERSION = "0.1.0".freeze
+end

data/lib/yaml2env.rb

@@ -0,0 +1,126 @@
+require 'yaml'
+require 'logger'
+
+module Yaml2env
+
+  autoload :VERSION,  'yaml2env/version'
+
+  class Error < ::StandardError
+  end
+
+  class DetectionFailedError < Error
+  end
+
+  class ConfigLoadingError < Error
+  end
+
+  class MissingConfigKeyError < Error
+  end
+
+  # Hash tracking all of the loaded ENV-values via Yaml2env.load.
+  LOADED_ENV = {}
+
+  # Config root.
+  # Default: (auto-detect if possible)
+  @@root = nil
+
+  # Config environment.
+  # Default: (auto-detect if possible)
+  @@env = nil
+
+  # Logger to use for logging.
+  # Default: +::Logger.new(::STDOUT)+
+  @@logger = ::Logger.new(::STDOUT)
+
+  class << self
+
+    [:root, :env, :logger].each do |name|
+      define_method name do
+        class_variable_get "@@#{name}"
+      end
+      define_method "#{name}=" do |value|
+        class_variable_set "@@#{name}", value
+      end
+    end
+
+    alias :environment :env
+
+    def defaults!
+      @@root ||= nil
+      @@env ||= nil
+      @@logger ||= ::Logger.new(::STDOUT)
+    end
+
+    def configure
+      yield self
+    end
+
+    def load(config_path, required_keys = {}, optional_keys = {})
+      self.detect_root!
+      self.detect_env!
+
+      config ||= {}
+
+      begin
+        config_path = File.expand_path(File.join(self.root, config_path)).to_s
+        config = self.load_config_for_env(config_path, self.env)
+      rescue
+        raise ConfigLoadingError, "Failed to load required config for environment '#{self.env}': #{config_path}"
+      end
+
+      # Merge required + optional keys.
+      keys_values = optional_keys.merge(required_keys)
+
+      # Stash found keys from the config into ENV.
+      keys_values.each do |extected_env_key, extected_yaml_key|
+        ::Yaml2env::LOADED_ENV[extected_env_key.to_s] = ::ENV[extected_env_key.to_s] = config[extected_yaml_key.to_s]
+        self.logger.info ":: ENV[#{extected_env_key.inspect}] = #{::ENV[extected_env_key.to_s].inspect}" if self.logger?
+      end
+
+      # Raise error if any credentials are missing.
+      required_keys.keys.each do |env_key|
+        ::Yaml2env::LOADED_ENV[env_key.to_s] ||
+          raise(MissingConfigKeyError, "ENV variable '#{env_key}' needs to be set. Query: #{keys_values.inspect}. Found: #{config.inspect}")
+      end
+    end
+
+    def detect_root!
+      self.root ||= if ::ENV.key?('RACK_ROOT')
+        ::ENV['RACK_ROOT']
+      elsif defined?(::Rails)
+        ::Rails.root
+      elsif defined?(::Sinatra::Application)
+        ::Sinatra::Application.root
+      else
+        raise DetectionFailedError, "Failed to auto-detect Yaml.env (config environment). Specify environment before loading any configs/initializers using Yaml2env, e.g Yaml2env.env = 'development'."
+      end
+    end
+
+    def detect_env!
+      self.env ||= if ::ENV.key?('RACK_ENV')
+        ::ENV['RACK_ENV']
+      elsif defined?(::Rails)
+        ::Rails.env
+      elsif defined?(::Sinatra::Application)
+        ::Sinatra::Application.environment
+      else
+        raise DetectionFailedError, "Failed to auto-detect Yaml2env.root (config root). Specify environment before loading any configs/initializers using Yaml2env, e.g Yaml2env.env = 'development'."
+      end
+    end
+
+    def logger?
+      self.logger.respond_to?(:info)
+    end
+
+    protected
+      def load_config(config_file)
+        YAML.load(File.open(config_file))
+      end
+
+      def load_config_for_env(config_file, env)
+        config = self.load_config(config_file)
+        config[env]
+      end
+  end
+
+end

data/spec/fixtures/example.yml

@@ -0,0 +1,19 @@
+development:
+  api_key: DEVELOPMENT_KEY
+  api_secret: DEVELOPMENT_SECRET
+
+staging:
+  api_key: STAGING_KEY
+  api_secret: STAGING_SECRET
+
+production:
+  api_key: PRODUCTION_KEY
+  api_secret: PRODUCTION_SECRET
+
+test:
+  api_key: TEST_KEY
+  api_secret: TEST_SECRET
+
+nyan_cat_mode:
+  api_key: NYAN_CAT_MODE_KEY
+  api_secret: NYAN_CAT_MODE_SECRET

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/spec'
+require 'minitest/pride'
+require 'minitest/mock'
+
+require 'yaml2env'
+
+def silence_all_warnings
+  # Ruby 1.8: Kernel.silence_warnings { yield }
+  old_verbose = $VERBOSE
+  $VERBOSE = nil
+  yield
+  $VERBOSE = old_verbose
+end
+
+def with_constants(constants, &block)
+  saved_constants = {}
+  constants.each do |constant, value|
+    saved_constants[constant] = Object.const_get(constant)
+    silence_all_warnings do
+      Object.const_set(constant, value)
+    end
+  end
+
+  begin
+    block.call
+  ensure
+    constants.each do |constant, value|
+      silence_all_warnings do
+        Object.const_set(constant, saved_constants[constant])
+      end
+    end
+  end
+end
+
+def with_values(object, new_values)
+  old_values = {}
+  new_values.each do |key, value|
+    old_values[key] = object.send key
+    object.send :"#{key}=", value
+  end
+  yield
+ensure
+  old_values.each do |key, value|
+    object.send :"#{key}=", value
+  end
+end

data/spec/yaml2env_spec.rb

@@ -0,0 +1,351 @@
+require 'spec/spec_helper'
+
+describe Yaml2env do
+
+  before do
+    @valid_config_filename = 'example.yml'
+    @valid_config_path = File.join(File.dirname(__FILE__), 'fixtures', @valid_config_filename)
+  end
+
+  describe "::VERSION" do
+    it 'should be defined' do
+      defined?(::Yaml2env::VERSION)
+    end
+
+    it 'should be a valid version string (e.g. "0.0.1", or "0.0.1.rc1")' do
+      valid_version_string = /^\d+\.\d+\.\d+/
+      Yaml2env::VERSION.must_match valid_version_string
+    end
+  end
+
+  describe "::LOADED_ENV" do
+    it 'should be defined' do
+      defined?(::Yaml2env::LOADED_ENV)
+    end
+
+    # it 'should be a empty hash' do
+    #   Yaml2env::LOADED_ENV.must_equal({})
+    # end
+  end
+
+  describe ".logger" do
+    before do
+      Yaml2env.defaults!
+    end
+
+    it 'should be defined' do
+      Yaml2env.must_respond_to :logger
+    end
+
+    it 'should be a valid logger' do
+      Yaml2env.logger.must_respond_to :info
+      Yaml2env.logger.must_respond_to :debug
+      Yaml2env.logger.must_respond_to :warn
+    end
+
+    it 'should be writable' do
+      class MyLogger < Logger
+      end
+      custom_logger = MyLogger.new(::STDOUT)
+      Yaml2env.logger = custom_logger
+      Yaml2env.logger.must_equal custom_logger
+    end
+  end
+
+  describe ".logger?" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :logger?
+    end
+
+    it 'should be a valid logger' do
+      Yaml2env.logger = nil
+      Yaml2env.logger?.must_equal false
+
+      Yaml2env.logger = Logger.new(::STDOUT)
+      Yaml2env.logger?.must_equal true
+    end
+  end
+
+  describe ".root" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :root
+    end
+
+    it 'should be writable' do
+      Yaml2env.root = "/tmp"
+      Yaml2env.root.must_equal "/tmp"
+    end
+  end
+
+  describe ".env" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :env
+    end
+
+    it 'should be writable' do
+      Yaml2env.root = "/tmp"
+      Yaml2env.root.must_equal "/tmp"
+    end
+  end
+
+  describe ".configure" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :configure
+    end
+
+    it 'should be possible to change settings in a block' do
+      Yaml2env.root = '/tmp/hello_world'
+      Yaml2env.env = 'staging'
+      Yaml2env.configure do |c|
+        c.root = '/home/grimen/projects/hello_world'
+        c.env = 'production'
+      end
+      Yaml2env.root.must_equal '/home/grimen/projects/hello_world'
+      Yaml2env.env.must_equal 'production'
+    end
+  end
+
+  describe ".detect_root!" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :detect_root!
+    end
+
+    it "should detect environment for Rack-apps - 1st" do
+      rack!(true)
+      rails!(true)
+      sinatra!(true)
+
+      Yaml2env.root = nil
+      Yaml2env.detect_root!
+      Yaml2env.root.must_equal '/home/grimen/development/rack-app'
+    end
+
+    it "should detect environment for Rails-apps - 2nd" do
+      rack!(false)
+      rails!(true)
+      sinatra!(true)
+
+      Yaml2env.root = nil
+      Yaml2env.detect_root!
+      Yaml2env.root.must_equal '/home/grimen/development/rails-app'
+    end
+
+    it "should detect environment for Sinatra-apps - 3rd" do
+      rack!(false)
+      rails!(false)
+      sinatra!(true)
+
+      Yaml2env.root = nil
+      Yaml2env.detect_root!
+      Yaml2env.root.must_equal '/home/grimen/development/sinatra-app'
+    end
+
+    it 'should complain if no environment could be detected' do
+      rack!(false)
+      rails!(false)
+      sinatra!(false)
+
+      Yaml2env.root = nil
+      assert_raises Yaml2env::DetectionFailedError do
+        Yaml2env.detect_root!
+      end
+    end
+  end
+
+  describe ".detect_env!" do
+    it 'should be defined' do
+      Yaml2env.must_respond_to :detect_env!
+    end
+
+    it "should detect environment for Rack-apps - 1st" do
+      rack!(true)
+      rails!(true)
+      sinatra!(true)
+
+      Yaml2env.env = nil
+      Yaml2env.detect_env!
+      Yaml2env.env.must_equal 'rack-env'
+    end
+
+    it "should detect environment for Rails-apps - 2nd" do
+      rack!(false)
+      rails!(true)
+      sinatra!(true)
+
+      Yaml2env.env = nil
+      Yaml2env.detect_env!
+      Yaml2env.env.must_equal 'rails-env'
+    end
+
+    it "should detect environment for Sinatra-apps - 3rd" do
+      rack!(false)
+      rails!(false)
+      sinatra!(true)
+
+      Yaml2env.env = nil
+      Yaml2env.detect_env!
+      Yaml2env.env.must_equal 'sinatra-env'
+    end
+
+    it 'should complain if no environment could be detected' do
+      rack!(false)
+      rails!(false)
+      sinatra!(false)
+
+      Yaml2env.env = nil
+      assert_raises Yaml2env::DetectionFailedError do
+        Yaml2env.detect_env!
+      end
+    end
+  end
+
+  describe "private/protected" do
+    describe ".load_config" do
+      it 'should be defined' do
+        Yaml2env.must_respond_to :load_config
+      end
+
+      it 'should load config for all environments for a valid config YAML file without issues' do
+        assert (config = Yaml2env.send(:load_config, @valid_config_path))
+        config.must_be_kind_of Hash
+        config.must_equal({
+            "development"   => {"api_key"=>"DEVELOPMENT_KEY",   "api_secret"=>"DEVELOPMENT_SECRET"},
+            "test"          => {"api_key"=>"TEST_KEY",          "api_secret"=>"TEST_SECRET"},
+            "staging"       => {"api_key"=>"STAGING_KEY",       "api_secret"=>"STAGING_SECRET"},
+            "production"    => {"api_key"=>"PRODUCTION_KEY",    "api_secret"=>"PRODUCTION_SECRET"},
+            "nyan_cat_mode" => {"api_key"=>"NYAN_CAT_MODE_KEY", "api_secret"=>"NYAN_CAT_MODE_SECRET"}
+          })
+      end
+    end
+
+    describe ".load_config_for_env" do
+      it 'should be defined' do
+        Yaml2env.must_respond_to :load_config_for_env
+      end
+
+      it 'should load config for a valid environment for a valid config YAML file without issues' do
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'development')
+        env_config.must_equal({
+            "api_key"=>"DEVELOPMENT_KEY",
+            "api_secret"=>"DEVELOPMENT_SECRET"
+          })
+
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'test')
+        env_config.must_equal({
+            "api_key"=>"TEST_KEY", "api_secret"=>"TEST_SECRET"
+          })
+
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'staging')
+        env_config.must_equal({
+            "api_key"=>"STAGING_KEY", "api_secret"=>"STAGING_SECRET"
+          })
+
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'production')
+        env_config.must_equal({
+            "api_key"=>"PRODUCTION_KEY",
+            "api_secret"=>"PRODUCTION_SECRET"
+          })
+
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'nyan_cat_mode')
+        env_config.must_equal({
+            "api_key"=>"NYAN_CAT_MODE_KEY",
+            "api_secret"=>"NYAN_CAT_MODE_SECRET"
+          })
+      end
+
+      it 'should not load config for a missing environment for a valid config YAML file without issues' do
+        env_config = Yaml2env.send(:load_config_for_env, @valid_config_path, 'missing')
+        env_config.must_equal(nil)
+      end
+    end
+  end
+
+  describe ".load" do
+    before do
+      Yaml2env.env = 'production'
+      Yaml2env.root = File.dirname(__FILE__)
+      Yaml2env.logger = nil
+    end
+
+    it 'should be defined' do
+      Yaml2env.must_respond_to :load
+    end
+
+    it 'should throw error if specified config file that do not exist' do
+      assert_raises Yaml2env::ConfigLoadingError do
+        Yaml2env.load 'null.yml'
+      end
+    end
+
+    it 'should not throw error if specified config file do exist' do
+      assert Yaml2env.load('fixtures/example.yml')
+    end
+
+    it 'should throw error if a specified constant-key do not exist in the config file' do
+      assert_raises Yaml2env::MissingConfigKeyError do
+        Yaml2env.load 'fixtures/example.yml', {:API_KEY => 'bla'}
+      end
+    end
+
+    it 'should not throw error if a specified constant-key do in fact exist in the config file' do
+      assert Yaml2env.load 'fixtures/example.yml', {:API_KEY => 'api_key', :API_SECRET => 'api_secret'}
+    end
+
+    it 'should set - with Yaml2env - loaded ENV-values' do
+      Yaml2env::LOADED_ENV = {}
+      Yaml2env.load 'fixtures/example.yml', {:API_KEY => 'api_key', :API_SECRET => 'api_secret'}
+      Yaml2env::LOADED_ENV.must_equal({"API_SECRET" => "PRODUCTION_SECRET", "API_KEY" => "PRODUCTION_KEY"})
+    end
+  end
+
+  protected
+
+    def rack!(loaded)
+      if loaded
+        ::ENV['RACK_ROOT'] = '/home/grimen/development/rack-app'
+        ::ENV['RACK_ENV'] = 'rack-env'
+      else
+        ::ENV['RACK_ROOT'] = nil
+        ::ENV['RACK_ENV'] = nil
+      end
+    end
+
+    def rails!(loaded)
+      if loaded
+        eval <<-EVAL
+          unless defined?(::Rails)
+            module Rails
+              class << self
+                attr_accessor :root, :env
+              end
+            end
+          end
+        EVAL
+        Rails.root = '/home/grimen/development/rails-app'
+        Rails.env = 'rails-env'
+      else
+        Object.send(:remove_const, :Rails) if defined?(::Rails)
+      end
+    end
+
+    def sinatra!(loaded)
+      if loaded
+        eval <<-EVAL
+        unless defined?(::Sinatra::Application)
+          module Sinatra
+            class Application
+              class << self
+                attr_accessor :root, :environment
+              end
+            end
+          end
+        end
+        EVAL
+        Sinatra::Application.root = '/home/grimen/development/sinatra-app'
+        Sinatra::Application.environment = 'sinatra-env'
+      else
+        Object.send(:remove_const, :Sinatra) if defined?(::Sinatra::Application)
+      end
+    end
+
+end

data/yaml2env.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yaml2env/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yaml2env"
+  s.version     = Yaml2env::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Merchii", "Jonas Grimfelt"]
+  s.email       = ["jonas@merchii.com", "grimen@gmail.com"]
+  s.homepage    = "http://github.com/merchii/yaml2env"
+  s.summary     = %q{YAML => ENV for environment-specific configs}
+  s.description = %q{Stash environment-specific configs in YAML-files and load them into ENV according to best-practices pattern - and auto-detects on-initialization if something is missing (skipping the "scratching the head"-part).}
+
+  s.required_rubygems_version = '>= 1.3.6'
+  s.rubyforge_project         = s.name
+
+  s.add_development_dependency 'bundler', '~> 1.0.0'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-bundler'
+  s.add_development_dependency 'guard-minitest'
+
+  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"]
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: yaml2env
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Merchii
+- Jonas Grimfelt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: guard-minitest
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Stash environment-specific configs in YAML-files and load them into ENV according to best-practices pattern - and auto-detects on-initialization if something is missing (skipping the "scratching the head"-part).
+email: 
+- jonas@merchii.com
+- grimen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Guardfile
+- README.textile
+- Rakefile
+- lib/yaml2env.rb
+- lib/yaml2env/version.rb
+- spec/fixtures/example.yml
+- spec/spec_helper.rb
+- spec/yaml2env_spec.rb
+- yaml2env.gemspec
+has_rdoc: true
+homepage: http://github.com/merchii/yaml2env
+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: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: yaml2env
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: YAML => ENV for environment-specific configs
+test_files: 
+- spec/fixtures/example.yml
+- spec/spec_helper.rb
+- spec/yaml2env_spec.rb