env_config 0.1.0

data/.gitignore

@@ -0,0 +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

data/Gemfile

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

data/README.md

@@ -0,0 +1,89 @@
+# EnvConfig
+
+Simple configuration management with environment variables.
+
+Inspired by how Heroku uses environment variables for configs, EnvConfig 
+is a no-magic gem for defining configs in yaml, and loading them into
+environment variables.
+
+### Features
+
+* application.yml can be templated with erb.
+* arbitrary namespaced configuration. e.g. development, qa:mac, integration/aws/ci.
+* heroku friendly.
+* small library, no additional dependencies
+
+### Installation
+
+Install the gem, and initialize the configuation yaml and configuration loader.
+
+    gem install env_config
+
+    # if using Rails
+    rake env_config:init
+
+    # otherwise
+    env_config init
+
+### Example
+
+First we define the configs we want in a yaml file:
+
+    # Each key value pair in this file will be read by EnvConfig and set to an
+    # environment variable. If an environment variable already exists, then it is
+    # not overridden by default. See EnvConfig.configure for more options.
+
+    # shared variables
+    common: &common
+      env_config1: 'config1_value'
+      env_config2: <%= "you can use erb" %>
+
+    # environment specifc variables
+    development:
+      <<: *common
+      env_config1: 'config1_override'
+
+    test:
+      <<: *common
+
+    # If your app is deployed on Heroku, then production Heroku values will
+    # override these settings because existing variables are not overridden by
+    # default. See also: http://devcenter.heroku.com/articles/config-vars
+    production:
+      <<: *common
+
+Then in config/initializers/env_config.rb
+
+    EnvConfig.configure do |config|
+      # yaml to read default config variables
+      config.config_path   = 'config/application.yml'
+
+      # Whether to override a variable that's already defined in an environment
+      # variable. Keep to false if using Heroku.
+      config.override_env  = false
+
+      # Namespace config values
+      # For example, to namespace by platform and rails environment
+      # 
+      #   config.namespace_by = "{RbConfig::CONFIG['host_os']}/#{Rails.env}"
+      #
+      # Then in your config/application.yml, you can nest your config by the
+      # namepaces.
+      # 
+      #   darwin11.0.0:
+      #     development:
+      #       var_name: "mac development specific value"
+      # 
+      config.namespace_by  = Rails.env
+
+      # Delimiter to split namespaces by when finding scoped config
+      config.namespace_delimiter = '/'
+    end
+
+    # This actually sets the variables into ENV
+    EnvConfig.set!
+
+From here, you can access any of your variables via ENV:
+
+    ENV['my_config_name']
+

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << ["lib", "test"]
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/bin/env_config

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'env_config'
+
+unless ARGV.size == 1
+  puts "Simple configuration management with environment variables"
+  puts ""
+  puts "Run 'env_config init' to initialize configuration yaml and loader."
+  puts "Please visit https://github.com/jch/env_config for more details."
+  puts ""
+  puts "Example:"
+  puts ""
+  puts "env_config init config/application.yml config/initializers/env_config.rb"
+  puts ""
+  exit 1
+end
+
+# TODO: gross that defaults are duplicated here. Ideally would just run
+# rake env_config:init config_path=... loader_path=...
+config_path = ARGV[1] || 'config/application.yml'
+loader_path = ARGV[2] || 'config/initializers/env_config.rb'
+
+EnvConfig.init!(config_path, loader_path)

data/env_config.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/env_config/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jerry Cheung"]
+  gem.email         = ["jch@whatcodecraves.com"]
+  gem.description   = "Simple configuration management with environment variables"
+  gem.summary       = <<-SUM
+    Inspired by how Heroku uses environment variables for configs, EnvConfig 
+    is a no-magic gem for defining configs in yaml, and loading them into
+    environment variables.
+  SUM
+  gem.homepage      = "https://github.com/jch/env_config"
+
+  gem.executables   = %w(env_config)
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "env_config"
+  gem.require_paths = ["lib"]
+  gem.version       = EnvConfig::VERSION
+
+  gem.add_development_dependency "fstest"
+end

data/env_config.rb

@@ -0,0 +1,23 @@
+EnvConfig.configure do |config|
+  # yaml to read default config variables
+  config.config_path   = /Users/jch/projects/beerpad/env_config/test/tmp/config_dir/loader.yml
+
+  # Whether to override a variable that's already defined in an environment
+  # variable. Keep to false if using Heroku.
+  config.override_env  = false
+
+  # Namespace config values
+  # for deeper nesting, separate with '/'.
+  # For example, to namespace by platform and rails environment
+  # 
+  #   config.namespace_by = "{RbConfig::CONFIG['host_os']}/#{Rails.env}"
+  #
+  # Then in your config/application.yml, you can nest your config by the
+  # namepaces.
+  # 
+  #   darwin11.0.0:
+  #     development:
+  #       var_name: "mac development specific value"
+  # 
+  config.namespace_by  = ""
+end

data/lib/env_config/config.rb

@@ -0,0 +1,37 @@
+module EnvConfig
+  class Config
+    # yaml to read default config variables
+    # Defaults to config/application.yml
+    attr_accessor :config_path
+
+    # Whether to override a variable that's already defined in an environment
+    # variable.
+    # Defaults to false
+    attr_accessor :override_env
+
+    # string to split namespace_by with. defaults to '/'
+    attr_accessor :namespace_delimiter
+
+    # Namespace config values
+    # Defaults to ""
+    # For deeper nesting, separate with '/'.
+    # For example, to namespace by platform and rails environment
+    # 
+    #   config.namespace_by = "{RbConfig::CONFIG['host_os']}/#{Rails.env}"
+    #
+    # Then in your config/application.yml, you can nest your config by the
+    # namepaces.
+    # 
+    #   darwin11.0.0:
+    #     development:
+    #       var_name: "mac development specific value"
+    # 
+    attr_accessor :namespace_by
+    def initialize
+      @config_path         = "config/application.yml"
+      @override_env        = false
+      @namespace_by        = nil
+      @namespace_delimiter = "/"
+    end
+  end
+end

data/lib/env_config/version.rb

@@ -0,0 +1,3 @@
+module EnvConfig
+  VERSION = "0.1.0"
+end

data/lib/env_config.rb

@@ -0,0 +1,64 @@
+require "env_config/version"
+require "erb"
+require "pathname"
+require "yaml"
+require "env_config/config"
+require 'rake'
+load 'tasks/env_config.rake'
+
+module EnvConfig
+  extend self
+
+  # EnvConfig::Config object
+  attr_accessor :config
+
+  # Creates a new EnvConfig::Config object and yields to block
+  # returns config object
+  def configure
+    @config ||= Config.new
+    yield @config if block_given?
+    @config
+  end
+  
+  # After #configure, this method sets all scoped variables into environment
+  # variables
+  def set!(options = {})
+    options[:scoped] ||= find_scoped_config
+    options[:config] ||= @config
+    options[:scoped].each do |key, value|
+      ENV[key]   = value if config.override_env
+      ENV[key] ||= value
+    end
+  end
+
+  # Creates initial application.yml and loader. See env_config.rake
+  def init!(config_path, loader_path)
+    require 'rake'
+    load 'tasks/env_config.rake'
+    Rake::Task['env_config:init'].invoke(config_path, loader_path)
+  end
+
+  private
+
+  # iterate through namespaces until we have the scoped config we want
+  def find_scoped_config
+    # evalute config yaml through erb
+    template = Pathname.new(config.config_path).read
+    template_result = ERB.new(template).result(binding)
+    yaml = YAML::load(template_result)
+
+    return yaml if (config.namespace_by == '' || config.namespace_by.nil?)
+
+    config.namespace_by.split(config.namespace_delimiter).inject(yaml) do |y, scope|
+      begin
+        y[scope]
+      rescue
+        # namespace config doesn't match up w/ application yaml
+        raise ArgumentError.new("Couldn't find namespace #{scope} within #{config.config_path}")
+      end
+    end
+  end
+end
+
+# Initialize default config
+EnvConfig.configure

data/lib/tasks/env_config.rake

@@ -0,0 +1,44 @@
+require 'fileutils'
+require 'pathname'
+require 'erb'
+
+namespace :env_config do
+  desc <<-DOC
+    Generate initial config/application.yml config file. config_path defaults
+    to 'config/application.yml'.
+  DOC
+  task :init, :config_path, :loader_path, :rails do |t, args|
+    args.with_defaults({
+      :rails       => defined?(Rails),
+      :config_path => 'config/application.yml',
+      :loader_path => defined?(Rails) ?
+        'config/initializers/env_config.rb' :
+        'env_config.rb'
+    })
+    
+    config_path = Pathname.new(args[:config_path])
+    loader_path = Pathname.new(args[:loader_path])
+    [config_path, loader_path].each {|path| path.dirname.mkpath}
+
+    # generate template files. too heavy to use thor
+    # output to config_path and loader_path
+    template_path = Pathname.new File.expand_path('../../../templates', __FILE__)
+
+    # write default config
+    unless config_path.exist?
+      template = template_path + ((args[:rails] ? "rails." : "")  + "application.yml")
+      FileUtils.cp(template, config_path)
+    end
+
+    # write default loader
+    unless loader_path.exist?
+      template = template_path + ((args[:rails] ? "rails." : "")  + "env_config.rb.erb")
+      loader_path.open('w') do |f|
+        f.write(ERB.new(template.read).result(binding))
+      end
+    end
+
+    puts "Successfully added config files."
+    puts "Take a look at #{config_path} and #{loader_path} for customization"
+  end
+end

data/templates/application.yml

@@ -0,0 +1,7 @@
+# Each key value pair in this file will be read by EnvConfig and set to an
+# environment variable. If an environment variable already exists, then it is
+# not overridden by default.  See EnvConfig.configure for more options.
+
+
+env_config: 'config1_value'
+erb_config: <%= "you can use erb" %>

data/templates/env_config.rb.erb

@@ -0,0 +1,29 @@
+EnvConfig.configure do |config|
+  # yaml to read default config variables
+  config.config_path   = "<%= config_path %>"
+
+  # Whether to override a variable that's already defined in an environment
+  # variable. Keep to false if using Heroku.
+  config.override_env  = false
+
+  # Namespace config values
+  # for deeper nesting, separate with '/'.
+  # For example, to namespace by platform and rails environment
+  # 
+  #   config.namespace_by = "{RbConfig::CONFIG['host_os']}/#{Rails.env}"
+  #
+  # Then in your config/application.yml, you can nest your config by the
+  # namepaces.
+  # 
+  #   darwin11.0.0:
+  #     development:
+  #       var_name: "mac development specific value"
+  # 
+  config.namespace_by  = nil
+
+  # Delimiter to split namespaces by when finding scoped config
+  config.namespace_delimiter = '/'
+end
+
+# This actually sets the variables into ENV
+EnvConfig.set!

data/templates/rails.application.yml

@@ -0,0 +1,22 @@
+# Each key value pair in this file will be read by EnvConfig and set to an
+# environment variable. If an environment variable already exists, then it is
+# not overridden by default. See EnvConfig.configure for more options.
+
+# shared variables
+common: &common
+  env_config1: 'config1_value'
+  env_config2: <%= "you can use erb" %>
+
+# environment specifc variables
+development:
+  <<: *common
+  env_config1: 'config1_override'
+
+test:
+  <<: *common
+
+# If your app is deployed on Heroku, then production Heroku values will
+# override these settings because existing variables are not overridden by
+# default. See also: http://devcenter.heroku.com/articles/config-vars
+production:
+  <<: *common

data/templates/rails.env_config.rb.erb

@@ -0,0 +1,29 @@
+EnvConfig.configure do |config|
+  # yaml to read default config variables
+  config.config_path   = "<%= config_path %>"
+
+  # Whether to override a variable that's already defined in an environment
+  # variable. Keep to false if using Heroku.
+  config.override_env  = false
+
+  # Namespace config values
+  # for deeper nesting, separate with '/'.
+  # For example, to namespace by platform and rails environment
+  # 
+  #   config.namespace_by = "{RbConfig::CONFIG['host_os']}/#{Rails.env}"
+  #
+  # Then in your config/application.yml, you can nest your config by the
+  # namepaces.
+  # 
+  #   darwin11.0.0:
+  #     development:
+  #       var_name: "mac development specific value"
+  # 
+  config.namespace_by  = Rails.env
+
+  # Delimiter to split namespaces by when finding scoped config
+  config.namespace_delimiter = '/'
+end
+
+# This actually sets the variables into ENV
+EnvConfig.set!

data/test/config_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class ConfigTest < Test::Unit::TestCase
+  def test_defaults
+    config = EnvConfig::Config.new
+    assert_equal "config/application.yml", config.config_path
+    assert_equal false, config.override_env
+    assert_equal nil, config.namespace_by
+    assert_equal '/', config.namespace_delimiter
+  end
+end

data/test/env_config_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class EnvConfigTest < Test::Unit::TestCase
+  def setup
+    EnvConfig.config = nil
+    @config = EnvConfig.configure
+    ENV.delete_if { true }
+  end
+
+  def test_default_configure
+    assert_not_nil @config
+  end
+
+  def test_configure_yields_same_config
+    EnvConfig.configure do |new_config|
+      assert_equal @config, new_config
+    end
+  end
+
+  def test_flat_app_config
+    EnvConfig.configure do |c|
+      c.config_path         = fixture_path('flat.yml')
+      c.namespace_by        = ''
+    end
+    scoped = EnvConfig.send(:find_scoped_config)
+    assert_equal 2, scoped.keys.size
+    assert_equal 'NYC', scoped['city']
+    assert_equal 'NY', scoped['state']
+  end
+
+  def test_scoped_app_config
+    EnvConfig.configure do |c|
+      c.config_path         = fixture_path('nested.yml')
+      c.namespace_by        = 'foo:bar'
+      c.namespace_delimiter = ':'
+    end
+    scoped = EnvConfig.send(:find_scoped_config)
+    assert_equal 2, scoped.keys.size
+    assert_equal 'Sam Adams', scoped['beer']
+    assert_equal 'PopEyes', scoped['dinner']
+  end
+
+  def test_invalid_scope
+    EnvConfig.configure do |c|
+      c.config_path         = fixture_path('flat.yml')
+      c.namespace_by        = 'foo:bar'
+      c.namespace_delimiter = ':'
+    end
+    assert_raises(ArgumentError) do
+      EnvConfig.send(:find_scoped_config)
+    end
+  end
+
+  def test_set_environment_no_override
+    ENV['city'] = "Austin"
+    EnvConfig.configure do |c|
+      c.config_path         = fixture_path('flat.yml')
+      c.override_env        = false
+    end
+    EnvConfig.set!
+    assert_equal 'Austin', ENV['city']
+  end
+
+  def test_set_environment_override
+    ENV['city'] = "Berkeley"
+    EnvConfig.configure do |c|
+      c.config_path         = fixture_path('flat.yml')
+      c.override_env        = true
+    end
+    EnvConfig.set!
+    assert_equal 'NYC', ENV['city']
+  end
+end

data/test/fixtures/flat.yml

@@ -0,0 +1,2 @@
+city:  'NYC'
+state: 'NY'

data/test/fixtures/nested.yml

@@ -0,0 +1,4 @@
+foo:
+  bar:
+    beer: 'Sam Adams'
+    dinner: 'PopEyes'

data/test/rake_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+require 'pathname'
+require 'fstest'
+
+class RakeTest < Test::Unit::TestCase
+  include FSTest
+
+  def setup
+    temp_dir = Pathname.new File.expand_path('../tmp', __FILE__)
+    temp_dir.rmtree rescue nil
+    temp_dir.mkpath
+    @config_path = temp_dir + 'config_dir/config.yml'
+    @loader_path = temp_dir + 'app_dir/loader.rb'
+    Rake::Task['env_config:init'].reenable  # rake tasks only run once
+  end
+
+  def test_init_normal
+    capture_io { Rake::Task['env_config:init'].invoke(@config_path, @loader_path, false) }
+    assert_file @config_path, /erb_config/
+    assert_file @loader_path, /config.namespace_by  = nil/, /EnvConfig.set!/, Regexp.new("config.config_path   = \"#{@config_path}\"")
+  end
+
+  def test_init_rails
+    capture_io { Rake::Task['env_config:init'].invoke(@config_path, @loader_path, true) }
+    assert_file @config_path, /development/
+    assert_file @loader_path, /config.namespace_by  = Rails.env/, /EnvConfig.set!/, Regexp.new("config.config_path   = \"#{@config_path}\"")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'env_config'
+
+class Test::Unit::TestCase
+  def fixture_path(filename)
+    Pathname.new File.expand_path("../fixtures/#{filename}", __FILE__)
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: env_config
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jerry Cheung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-23 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fstest
+  requirement: &70268031170440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70268031170440
+description: Simple configuration management with environment variables
+email:
+- jch@whatcodecraves.com
+executables:
+- env_config
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/env_config
+- env_config.gemspec
+- env_config.rb
+- lib/env_config.rb
+- lib/env_config/config.rb
+- lib/env_config/version.rb
+- lib/tasks/env_config.rake
+- templates/application.yml
+- templates/env_config.rb.erb
+- templates/rails.application.yml
+- templates/rails.env_config.rb.erb
+- test/config_test.rb
+- test/env_config_test.rb
+- test/fixtures/flat.yml
+- test/fixtures/nested.yml
+- test/rake_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/jch/env_config
+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.6.2
+signing_key: 
+specification_version: 3
+summary: Inspired by how Heroku uses environment variables for configs, EnvConfig  is
+  a no-magic gem for defining configs in yaml, and loading them into environment variables.
+test_files:
+- test/config_test.rb
+- test/env_config_test.rb
+- test/fixtures/flat.yml
+- test/fixtures/nested.yml
+- test/rake_test.rb
+- test/test_helper.rb