chalk-config 0.2.1

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/.yardopts

@@ -0,0 +1,3 @@
+--markup markdown
+--output yardoc/
+-M redcarpet

data/Gemfile

@@ -0,0 +1,7 @@
+# Execute bundler hook if present
+['~/.', '/etc/'].any? do |file|
+ File.lstat(path = File.expand_path(file + 'bundle-gemfile-hook')) rescue next
+ eval(File.read(path), binding, path); break true
+end || source('https://rubygems.org/')
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Stripe
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+# Chalk::Config
+
+Maps on-disk config files into a loaded global
+[configatron](https://github.com/markbates/configatron) instance,
+taking into account your current environment.
+
+`configatron` is used within many Chalk gems to control their
+behavior, and is also great for configuration within your application.
+
+## Usage
+
+### Environment
+
+`Chalk::Config` relies on describing your environment as an opaque
+string (`production`, `qa`, etc). You can set it like so:
+
+```ruby
+Chalk::Config.environment = 'production'
+```
+
+At that point, the global `configatron` will be cleared and all
+registered config reapplied, meaning you don't have to worry about
+setting the environment prior to registering files.
+
+`environment` defaults to the value `'default'`.
+
+### Registering config files
+
+Additional configuration files are registered using
+{Chalk::Config.register}. The most basic usage looks like
+
+```ruby
+Chalk::Config.register('/path/to/file')
+```
+
+to register a YAML configuration file. You must provide an absolute
+path, in order to ensure you're not relying on the present working
+directory. The following is a pretty good idiom:
+
+```ruby
+Chalk::Config.register(File.expand_path('../config.yaml', __FILE__))
+```
+
+By default, YAML configuration files should have a top-level key for
+each environment.
+
+A good convention is to have most configuration in a dummy `default`
+environment and use YAML's native merging to keep your file somewhat
+DRY (WARNING: there exists at least one gem which changes Ruby's YAML
+parser in the presence of multiple merge operators on a single key, so
+be wary of two `<<` calls at once.) However, it's also fine to repeat
+yourself to make the file more human readable.
+
+```yaml
+# /path/to/config.yaml
+
+default: &default
+  my_feature:
+    enable: true
+    shards: 2
+
+  my_service:
+    host: localhost
+    port: 2800
+
+production:
+  <<: *default
+  my_service:
+    host: appserver1
+	port: 2800
+
+  send_emails: true
+
+development:
+  <<: *default
+  send_emails: false
+```
+
+The configuration from the currently active environment will then be
+added to the global `configatron` when you register the file:
+
+```ruby
+Chalk::Config.register('/path/to/config.yaml')
+
+Chalk::Config.environment = 'production'
+configatron.my_service.host
+#=> 'appserver1'
+
+Chalk::Config.environment = 'development'
+configatron.my_service.host
+#=> 'localhost'
+```
+
+Keys present in multiple files will be deep merged:
+
+```yaml
+# /path/to/site.yaml
+
+production:
+  my_service:
+    host: otherappserver
+
+development: {}
+```
+
+```ruby
+Chalk::Config.register('/path/to/config.yaml')
+Chalk::Config.register('/path/to/site.yaml')
+
+Chalk::Config.environment = 'production'
+configatron.my_service.host
+#=> 'otherappserver'
+configatron.my_service.port
+#=> 2800
+```
+
+You can explicitly nest a config file (only a single level of nesting
+is current supported) using the `:nested` option. You can also
+indicate a file has no environment keys and should be applied directly
+via `:raw`:
+
+
+```yaml
+# /path/to/cookies.yaml
+
+tasty: yes
+```
+
+```ruby
+Chalk::Config.register('/path/to/cookies.yaml', nested: 'cookies', raw: true)
+configatron.cookies.tasty
+#=> 'yes'
+```
+
+## Best practices
+
+### Config keys for everything
+
+Writing code that switches off the environment is usually indicative
+of the antipattern:
+
+```ruby
+# BAD!
+if Chalk::Config.environment == 'production'
+  email.send!
+else
+  puts email
+end
+```
+
+Instead, you should create a fresh config key for all of these cases:
+
+```ruby
+if configatron.send_emails
+  email.send!
+else
+  puts email
+end
+```
+
+This means your code doesn't need to know anything about the set of
+environment names, making adding a new environment easy. As well, it's
+much easier to have fine-grained control and visibility over exactly
+how your application behaves.
+
+It's totally fine (and expected) to have many config keys that are
+used only once.
+
+# Contributors
+
+- Greg Brockman
+- Evan Broder
+- Michelle Bu
+- Nelson Elhage
+- Jeremy Hoon

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+require 'chalk-rake/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib']
+  # t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/**/*.rb'].reject do |file|
+    file.end_with?('_lib.rb') || file.include?('/_lib/')
+  end
+end

data/chalk-config.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chalk-config/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'chalk-config'
+  gem.version       = Chalk::Config::VERSION
+  gem.authors       = ['Stripe']
+  gem.email         = ['oss@stripe.com']
+  gem.description   = %q{Layer over configatron with conventions for environment-based and site-specific config}
+  gem.summary       = %q{chalk-configatron uses a config_schema.yaml file to figure out how to configure your app}
+  gem.homepage      = 'https://github.com/stripe/chalk-config'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+  gem.add_dependency 'configatron', '~> 4.4'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'chalk-rake'
+end

data/demo_schema.rb

@@ -0,0 +1,8 @@
+Chalk::Config.environment = 'local'
+
+Chalk::Config.register('config.yaml')
+Chalk::Config.register('secrets.yaml')
+
+Chalk::Config.register('ops/ops-secrets.yaml', nested: 'ops')
+
+Chalk::Config.environment = 'production'

data/lib/chalk-config.rb

@@ -0,0 +1,317 @@
+require 'set'
+require 'yaml'
+require 'chalk-config/version'
+require 'chalk-config/errors'
+
+# We don't necessarily need to keep this, but it's preferable to make
+# sure no one defines any keys outside of Chalk::Config
+if defined?(configatron)
+  raise "Someone already loaded 'configatron'. You should let chalk-config load it itself."
+end
+
+require 'configatron'
+configatron.lock!
+
+# The main class powering Chalk's configuration.
+#
+# This is written using a wrapped Singleton, which makes testing
+# possible (just stub `Chalk::Config.instance` to return a fresh
+# instance) and helps hide implementation.
+class Chalk::Config
+  include Singleton
+
+  # Sets the current environment. All configuration is then reapplied
+  # in the order it was {.register}ed. This means you don't have to
+  # worry about setting your environment prior to registering config
+  # files.
+  #
+  # @return [String] The current environment.
+  def self.environment=(name)
+    instance.send(:environment=, name)
+  end
+
+  # You should generally not take any action directly off this
+  # value. All codepath switches should be triggered off configuration
+  # keys, possibly with environment assertions to ensure safety.
+  #
+  # @return [String] The current environment (default: `'default'`)
+  def self.environment
+    instance.send(:environment)
+  end
+
+  # Specify the list of environments every configuration file must
+  # include.
+  #
+  # It's generally recommended to set this in a wrapper library, and
+  # use that wrapper library in all your projects. This way you can be
+  # defensive, and have certainty no config file slips through without
+  # the requisite environment keys.
+  #
+  # @param environments [Enumerable<String>] The list of required environments.
+  def self.required_environments=(environments)
+    instance.send(:required_environments=, environments)
+  end
+
+  # Access the environments registered by {.required_environments=}.
+  #
+  # @return [Enumerable] The registered environments list (by default, nil)
+  def self.required_environments
+    instance.send(:required_environments)
+  end
+
+  # Register a given YAML file to be included in the global
+  # configuration.
+  #
+  # The config will be loaded once (cached in memory) and be
+  # immediately deep-merged onto configatron. If you later run
+  # {.environment=}, then all registered configs will be reapplied in
+  # the order they were loaded.
+  #
+  # So for example, running
+  # `Chalk::Config.register('/path/to/config.yaml')` for a file with
+  # contents:
+  #
+  # ```yaml
+  # env1:
+  #   key1: value1
+  #   key2: value2
+  # ```
+  #
+  # would yield `configatron.env1.key1 == value1`,
+  # `configatron.env1.key2 == value2`. Later registering a file with
+  # contents:
+  #
+  # ```yaml
+  # env1:
+  #   key1: value3
+  # ```
+  #
+  # would yield `configatron.env1.key1 == value3`,
+  # `configatron.env1.key2 == value2`.
+  #
+  # @param filepath [String] Absolute path to the config file
+  # @option options [Boolean] :optional If true, it's fine for the
+  #   file to be missing, in which case this registration is
+  #   discarded.
+  # @option options [Boolean] :raw If true, the file doesn't have
+  #  environment keys and should be splatted onto configatron
+  #  directly. Otherwise, grab just the config under the appropriate
+  #  environment key.
+  # @option options [String] :nested What key to namespace all of
+  #  this configuration under. (So `nested: 'foo'` would result in
+  #  configuration available under `configatron.foo.*`.)
+  def self.register(filepath, options={})
+    unless filepath.start_with?('/')
+      raise ArgumentError.new("Register only accepts absolute paths, not #{filepath.inspect}. (This ensures that config is always correctly loaded rather than depending on your current directory. To avoid this error in the future, you may want to use a wrapper that expands paths based on a base directory.)")
+    end
+    instance.send(:register, filepath, options)
+  end
+
+  # Register a given raw hash to be included in the global
+  # configuration.
+  #
+  # This allows you to specify arbitrary configuration at
+  # runtime. It's generally not recommended that you use this method
+  # unless your configuration really can't be encoded in config
+  # files. A common example is configuration from environment
+  # variables (which might be something like the name of your
+  # service).
+  #
+  # Like {.register}, if you later run {.environment=}, this
+  # configuration will be reapplied in the order it was registered.
+  #
+  # @param config [Hash] The raw configuration to be deep-merged into configatron.
+  def self.register_raw(config)
+    instance.send(:register_raw, config)
+  end
+
+  # Raises if the current environment is not one of the whitelisted
+  # environments provided.
+  #
+  # Generally useful if you have a dev-only codepath you want to be
+  # *sure* never activates in production.
+  def self.assert_environment(environments)
+    environments = [environments] if environments.kind_of?(String)
+    return if environments.include?(environment)
+
+    raise DisallowedEnvironment.new("Current environment #{environment.inspect} is not one of the allowed environments #{environments.inspect}")
+  end
+
+  # Raises if the current environment is one of the blacklisted
+  # environments provided.
+  #
+  # Generally useful if you have a dev-only codepath you want to be
+  # *sure* never activates in production.
+  def self.assert_not_environment(environments)
+    environments = [environments] if environments.kind_of?(String)
+    return unless environments.include?(environment)
+
+    raise DisallowedEnvironment.new("Current environment #{environment.inspect} is one of the disallowed environments #{environments.inspect}")
+  end
+
+  private
+
+  def initialize
+    # List of registered configs, in the form:
+    #
+    # file => {config: ..., options: ...}
+    @registrations = []
+    @registered_files = Set.new
+    @environment = 'default'
+  end
+
+  ## The actual instance implementations
+
+  # Possibly reconfigure if the environment changes.
+  def environment=(name)
+    @environment = name
+    reapply_config
+  end
+
+  def environment
+    @environment
+  end
+
+  def required_environments=(environments)
+    @required_environments = environments
+    @registrations.each do |registration|
+      # Validate all existing config
+      validate_config(registration)
+    end
+  end
+
+  def required_environments
+    @required_environments
+  end
+
+  def register(filepath, options)
+    if @registered_files.include?(filepath)
+      raise Error.new("You've already registered #{filepath}.")
+    end
+    @registered_files << filepath
+
+    begin
+      config = load!(filepath)
+    rescue Errno::ENOENT
+      return if options[:optional]
+      raise
+    end
+
+    register_parsed(config, filepath, options)
+  end
+
+  def register_raw(config)
+    register_parsed(config, nil, {})
+  end
+
+  private
+
+  # Register some raw config
+  def register_parsed(config, filepath, options)
+    allow_configatron_changes do
+      directive = {
+        config: config,
+        filepath: filepath,
+        options: options,
+      }
+
+      validate_config(directive)
+      @registrations << directive
+
+      allow_configatron_changes do
+        mixin_config(directive)
+      end
+    end
+  end
+
+  def allow_configatron_changes(&blk)
+    configatron.unlock!
+
+    begin
+      blk.call
+    ensure
+      configatron.lock!
+    end
+  end
+
+  def load!(filepath)
+    begin
+      loaded = YAML.load_file(filepath)
+    rescue Psych::BadAlias => e
+      # YAML parse-time errors include the filepath already, but
+      # load-time errors do not.
+      #
+      # Specifically, `Psych::BadAlias` (raised by doing something
+      # like `YAML.load('foo: *bar')`) does not:
+      # https://github.com/tenderlove/psych/issues/192
+      e.message << " (while loading #{filepath})"
+      raise
+    end
+    unless loaded.is_a?(Hash)
+      raise Error.new("YAML.load(#{filepath.inspect}) parses into a #{loaded.class}, not a Hash")
+    end
+    loaded
+  end
+
+  # Take a hash and mix in the environment-appropriate key to an
+  # existing configatron object.
+  def mixin_config(directive)
+    raw = directive[:options][:raw]
+
+    config = directive[:config]
+    filepath = directive[:filepath]
+
+    if !raw && filepath && config && !config.include?(environment)
+      # Directive is derived from a file (i.e. not runtime_config)
+      # with environments and that file existed, but is missing the
+      # environment.
+      raise MissingEnvironment.new("Current environment #{environment.inspect} not defined in config file #{directive[:filepath].inspect}. (HINT: you should have a YAML key of #{environment.inspect}. You may want to inherit a default via YAML's `<<` operator.)")
+    end
+
+    if raw
+      choice = config
+    elsif filepath && config
+      # Derived from file, and file present
+      choice = config.fetch(environment)
+    elsif filepath
+      # Derived from file, but file missing
+      choice = {}
+    else
+      # Manually specified runtime_config
+      choice = config
+    end
+
+    subconfigatron = configatron
+    if nested = directive[:options][:nested]
+      nested.split('.').each do |key|
+        subconfigatron = subconfigatron[key]
+      end
+    end
+
+    subconfigatron.configure_from_hash(choice)
+  end
+
+  def validate_config(directive)
+    (@required_environments || []).each do |environment|
+      raw = directive[:options][:raw]
+
+      config = directive[:config]
+      filepath = directive[:filepath]
+
+      next if raw
+
+      if filepath && config && !config.include?(environment)
+        raise MissingEnvironment.new("Required environment #{environment.inspect} not defined in config file #{directive[:filepath].inspect}. (HINT: you should have a YAML key of #{environment.inspect}. You may want to inherit a default via YAML's `<<` operator.)")
+      end
+    end
+  end
+
+  def reapply_config
+    allow_configatron_changes do
+      configatron.reset!
+      @registrations.each do |registration|
+        mixin_config(registration)
+      end
+    end
+  end
+end

data/lib/chalk-config/errors.rb

@@ -0,0 +1,8 @@
+class Chalk::Config
+  # Base error class for Chalk::Config
+  class Error < StandardError; end
+  # Thrown if an environment is missing from a config file.
+  class MissingEnvironment < Error; end
+  # Thrown from environment assertions.
+  class DisallowedEnvironment < Error; end
+end

data/lib/chalk-config/version.rb

@@ -0,0 +1,6 @@
+
+module Chalk
+  class Config
+    VERSION = "0.2.1"
+  end
+end

data/tddium.yml

@@ -0,0 +1,11 @@
+:tddium:
+  :ruby_version: ruby-1.9.3-p194
+  :bundler_version: 1.3.5
+  :test_pattern:
+    - "test/wholesome/[^_]*.rb"
+    - "test/unit/[^_]*.rb"
+    - "test/integration/[^_]*.rb"
+    - "test/functional/[^_]*.rb"
+  :boot_hook: >
+    /usr/bin/env sh -c "gem install --user-install --no-rdoc --no-ri github_api -v=0.10.1 && gem install --user-install --no-rdoc --no-ri --ignore-dependencies tddium_status_github -v=0.2.0 &&
+    echo '$:.concat(Dir.glob(File.join(Gem.user_dir, \"gems\", \"*\", \"lib\"))); require \"tddium_status_github\"' >> Rakefile"

data/test/_lib.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'mocha/setup'
+
+module Critic
+  class Test < ::MiniTest::Spec
+    def setup
+      # Put any stubs here that you want to apply globally
+    end
+
+    def fresh_chalk_config
+      config = Chalk::Config.send(:new)
+      Chalk::Config.stubs(instance: config)
+    end
+  end
+end

data/test/functional/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Functional
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/functional/general.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../_lib', __FILE__)
+require 'chalk-config'
+
+class Critic::Functional::GeneralTest < Critic::Functional::Test
+  include Configatron::Integrations::Minitest
+
+  before do
+    fresh_chalk_config
+
+    Chalk::Config.environment = 'testing'
+    Chalk::Config.register(File.expand_path('../general/config.yaml', __FILE__))
+  end
+
+  it 'loads config correctly' do
+    assert_equal('value1', configatron.config1)
+    assert_equal('value3', configatron.config2)
+  end
+
+  it 'allows switching environments' do
+    Chalk::Config.environment = 'default'
+    assert_equal('value1', configatron.config1)
+    assert_equal('value2', configatron.config2)
+  end
+
+  describe 'register_raw' do
+    it 'merges in registered config' do
+      Chalk::Config.register_raw(foo: 'bar', config1: 'hi')
+      assert_equal('bar', configatron.foo)
+      assert_equal('hi', configatron.config1)
+    end
+
+    it 'environment validation continues to succeed' do
+      Chalk::Config.register_raw(foo: 'bar')
+      Chalk::Config.required_environments = ['default']
+    end
+  end
+
+  describe 'raw files' do
+    it 'merges the file contents directly' do
+      Chalk::Config.register(File.expand_path('../general/raw.yaml', __FILE__),
+        raw: true)
+      assert_equal('there', configatron.hi)
+      assert_equal('bat', configatron.baz)
+      assert_equal('no_environment', configatron.config1)
+    end
+
+    it 'does not try to validate presence of environments' do
+      Chalk::Config.required_environments = ['default']
+      Chalk::Config.register(File.expand_path('../general/raw.yaml', __FILE__),
+        raw: true)
+    end
+  end
+
+  describe 'missing nested files' do
+    it 'does not create the relevant config key' do
+      Chalk::Config.register(File.expand_path('../general/nonexistent.yaml', __FILE__),
+        optional: true,
+        nested: 'nonexistent')
+      assert_raises(Configatron::UndefinedKeyError) do
+        configatron.nonexistent
+      end
+    end
+
+    it 'environment validation continues to succeed' do
+      Chalk::Config.register(File.expand_path('../general/nonexistent.yaml', __FILE__),
+        optional: true,
+        nested: 'nonexistent')
+      Chalk::Config.required_environments = ['default']
+    end
+  end
+
+  describe 'nested config files' do
+    it 'nests' do
+      Chalk::Config.register(File.expand_path('../general/raw.yaml', __FILE__),
+        nested: 'nested',
+        raw: true)
+      assert_equal('there', configatron.nested.hi)
+    end
+
+    it 'deep-nests' do
+      Chalk::Config.register(File.expand_path('../general/raw.yaml', __FILE__),
+        nested: 'nested.deeply',
+        raw: true)
+      assert_equal('there', configatron.nested.deeply.hi)
+    end
+  end
+
+  describe 'required_environments' do
+    it 'raises if an existing config is missing an environment' do
+      assert_raises(Chalk::Config::MissingEnvironment) do
+        Chalk::Config.required_environments = ['missing']
+      end
+    end
+
+    it 'raises if a new config is missing an environment' do
+      Chalk::Config.required_environments = ['testing']
+      assert_raises(Chalk::Config::MissingEnvironment) do
+        Chalk::Config.register(File.expand_path('../general/missing.yaml', __FILE__))
+      end
+    end
+  end
+end

data/test/functional/general/config.yaml

@@ -0,0 +1,7 @@
+default: &default
+  config1: value1
+  config2: value2
+
+testing:
+  <<: *default
+  config2: value3

data/test/functional/general/missing.yaml

@@ -0,0 +1,2 @@
+default:
+  hi: there

data/test/functional/general/raw.yaml

@@ -0,0 +1,3 @@
+hi: there
+baz: bat
+config1: no_environment

data/test/integration/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Integration
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/meta/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Meta
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/unit/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Unit
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/unit/chalk-config.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../_lib', __FILE__)
+require 'chalk-config'
+
+class Critic::Unit::ChalkConfig < Critic::Unit::Test
+  include Configatron::Integrations::Minitest
+
+  before do
+    fresh_chalk_config
+  end
+
+  describe '.assert_environment' do
+    it 'raises if the environment is not in the array' do
+      Chalk::Config.environment = 'hello'
+      assert_raises(Chalk::Config::DisallowedEnvironment) do
+        Chalk::Config.assert_environment(%w{foo bar})
+      end
+    end
+
+    it 'raises if the environment is not the string' do
+      Chalk::Config.environment = 'hello'
+      assert_raises(Chalk::Config::DisallowedEnvironment) do
+        Chalk::Config.assert_environment('foo')
+      end
+    end
+
+    it 'does not raise if the environment is in the array' do
+      Chalk::Config.environment = 'hello'
+      Chalk::Config.assert_environment(%w{hello there})
+    end
+
+    it 'does not raise if the environment is the string' do
+      Chalk::Config.environment = 'hello'
+      Chalk::Config.assert_environment('hello')
+    end
+  end
+
+  describe '.assert_not_environment' do
+    it 'does not raise if the environment is not in the array' do
+      Chalk::Config.environment = 'hello'
+      Chalk::Config.assert_not_environment(%w{foo bar})
+    end
+
+    it 'does not raise if the environment is not the string' do
+      Chalk::Config.environment = 'hello'
+      Chalk::Config.assert_not_environment('foo')
+    end
+
+    it 'raises if the environment is in the array' do
+      Chalk::Config.environment = 'hello'
+      assert_raises(Chalk::Config::DisallowedEnvironment) do
+        Chalk::Config.assert_not_environment(%w{hello there})
+      end
+    end
+
+    it 'raises if the environment is the string' do
+      Chalk::Config.environment = 'hello'
+      assert_raises(Chalk::Config::DisallowedEnvironment) do
+        Chalk::Config.assert_not_environment('hello')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: chalk-config
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Stripe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: configatron
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: minitest
+  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: mocha
+  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: chalk-rake
+  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: Layer over configatron with conventions for environment-based and site-specific
+  config
+email:
+- oss@stripe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- chalk-config.gemspec
+- demo_schema.rb
+- lib/chalk-config.rb
+- lib/chalk-config/errors.rb
+- lib/chalk-config/version.rb
+- tddium.yml
+- test/_lib.rb
+- test/functional/_lib.rb
+- test/functional/general.rb
+- test/functional/general/config.yaml
+- test/functional/general/missing.yaml
+- test/functional/general/raw.yaml
+- test/integration/_lib.rb
+- test/meta/_lib.rb
+- test/unit/_lib.rb
+- test/unit/chalk-config.rb
+homepage: https://github.com/stripe/chalk-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'
+      segments:
+      - 0
+      hash: 2093141279955038068
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2093141279955038068
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: chalk-configatron uses a config_schema.yaml file to figure out how to configure
+  your app
+test_files:
+- test/_lib.rb
+- test/functional/_lib.rb
+- test/functional/general.rb
+- test/functional/general/config.yaml
+- test/functional/general/missing.yaml
+- test/functional/general/raw.yaml
+- test/integration/_lib.rb
+- test/meta/_lib.rb
+- test/unit/_lib.rb
+- test/unit/chalk-config.rb