Easiest way to add multi-environment yaml settings to Rails, Sinatra, Pandrino and other Ruby projects.
Clone or download
Latest commit 2439d5a Feb 15, 2018



Build Status Gem Version Dependency Status Maintainability Test Coverage


Config helps you easily manage environment specific settings in an easy and usable manner.


  • simple YAML config files
  • config files support ERB
  • config files support inheritance and multiple environments
  • access config information via convenient object member notation
  • support for multi-level settings (Settings.group.subgroup.setting)
  • local developer settings ignored when committing the code


  • Ruby 2.x
  • Rails >= 3.1, 4 and 5
  • Padrino
  • Sinatra

For older versions of Rails or Ruby use AppConfig.


Installing on Rails 3, 4 or 5

Add gem 'config' to your Gemfile and run bundle install to install it. Then run

rails g config:install

which will generate customizable config file config/initializers/config.rb and set of default settings files:


You can now edit them to adjust to your needs.

Installing on Padrino

Add the gem to your Gemfile and run bundle install to install it. Then edit app.rb and register Config

register Config

Installing on Sinatra

Add the gem to your Gemfile and run bundle install to install it. Afterwards in need to register Config in your app and give it a root so it can find the config files.

set :root, File.dirname(__FILE__)
register Config

Installing on other ruby projects

Add the gem to your Gemfile and run bundle install to install it. Then initialize Config manually within your configure block.

Config.load_and_set_settings(Config.setting_files("/path/to/config_root", "your_project_environment"))

It's also possible to initialize Config manually within your configure block if you want to just give it some yml paths to load from.

Config.load_and_set_settings("/path/to/yaml1", "/path/to/yaml2", ...)

Accessing the Settings object

After installing the gem, Settings object will become available globally and by default will be compiled from the files listed below. Settings defined in files that are lower in the list override settings higher.



Entries can be accessed via object member notation:


Nested entries are supported:


Alternatively, you can also use the [] operator if you don't know which exact setting you need to access ahead of time.

# All the following are equivalent to Settings.my_section.some_entry

Reloading settings

You can reload the Settings object at any time by running Settings.reload!.

Reloading settings and config files

You can also reload the Settings object from different config files at runtime.

For example, in your tests if you want to test the production settings, you can:

Rails.env = "production"
  Rails.root.join("config", "settings.yml").to_s,
  Rails.root.join("config", "settings", "#{Rails.env}.yml").to_s,
  Rails.root.join("config", "environments", "#{Rails.env}.yml").to_s

Environment specific config files

You can have environment specific config files. Environment specific config entries take precedence over common config entries.

Example development environment config file:


Example production environment config file:


Developer specific config files

If you want to have local settings, specific to your machine or development environment, you can use the following files, which are automatically .gitignore :

Rails.root.join("config", "settings.local.yml").to_s,
Rails.root.join("config", "settings", "#{Rails.env}.local.yml").to_s,
Rails.root.join("config", "environments", "#{Rails.env}.local.yml").to_s

Adding sources at runtime

You can add new YAML config files at runtime. Just use:


This will use the given source.yml file and use its settings to overwrite any previous ones.

On the other hand, you can prepend a YML file to the list of configuration files:


This will do the same as add_source, but the given YML file will be loaded first (instead of last) and its settings will be overwritten by any other configuration file. This is especially useful if you want to define defaults.

One thing I like to do for my Rails projects is provide a local.yml config file that is .gitignored (so its independent per developer). Then I create a new initializer in config/initializers/add_local_config.rb with the contents


Note: this is an example usage, it is easier to just use the default local files settings.local.yml, settings/#{Rails.env}.local.yml and environments/#{Rails.env}.local.yml for your developer specific settings.

You also have the option to add a raw hash as a source. One use case might be storing settings in the database or in environment variables that overwrite what is in the YML files.

Settings.add_source!({some_secret: ENV['some_secret']})

You may pass a hash to prepend_source! as well.

Embedded Ruby (ERB)

Embedded Ruby is allowed in the configuration files. Consider the two following config files.

  • #{Rails.root}/config/settings.yml
size: 1
server: google.com
  • #{Rails.root}/config/environments/development.yml
size: 2
computed: <%= 1 + 2 + 3 %>
  size: 3
  servers: [ {name: yahoo.com}, {name: amazon.com} ]

Notice that the environment specific config entries overwrite the common entries.

Settings.size   # => 2
Settings.server # => google.com

Notice the embedded Ruby.

Settings.computed # => 6

Notice that object member notation is maintained even in nested entries.

Settings.section.size # => 3

Notice array notation and object member notation is maintained.

Settings.section.servers[0].name # => yahoo.com
Settings.section.servers[1].name # => amazon.com


There are multiple configuration options available, however you can customize Config only once, preferably during application initialization phase:

Config.setup do |config|
  config.const_name = 'Settings'

After installing Config in Rails, you will find automatically generated file that contains default configuration located at config/initializers/config.rb.


  • const_name - name of the object holing you settings. Default: 'Settings'

Merge customization

  • overwrite_arrays - overwrite arrays found in previously loaded settings file. Default: true
  • knockout_prefix - ability to remove elements of the array set in earlier loaded settings file. Makes sense only when overwrite_arrays = false, otherwise array settings would be overwritten by default. Default: nil
  • merge_nil_values - nil values will overwrite an existing value when merging configs. Default: true.
# merge_nil_values is true by default
c = Config.load_files("./spec/fixtures/development.yml") # => #<Config::Options size=2, ...>
c.size # => 2
c.merge!(size: nil) => #<Config::Options size=nil, ...>
c.size # => nil
# To reject nil values when merging settings:
Config.setup do |config|
  config.merge_nil_values = false

c = Config.load_files("./spec/fixtures/development.yml") # => #<Config::Options size=2, ...>
c.size # => 2
c.merge!(size: nil) => #<Config::Options size=nil, ...>
c.size # => 2

Check Deep Merge for more details.


With Ruby 2.1 or newer, you can optionally define a schema to validate presence (and type) of specific config values:

Config.setup do |config|
  # ...
  config.schema do
    required(:youtube).schema do

The above example demonstrates how to ensure that the configuration has the youtube structure with the api_key field filled.

If you define a schema it will automatically be used to validate your config. If validation fails it will raise a Config::Validation::Error containing a nice message with information about all the mismatches between the schema and your config.

Check dry-validation for more details.

Missing keys

For an example settings file:

size: 1
server: google.com

You can test if a value was set for a given key using key? and its alias has_key?:

# => false
# => true

By default, accessing to a missing key returns nil:

# => false
# => nil

This is not "typo-safe". To solve this problem, you can configure the fail_on_missing option:

Config.setup do |config|
  config.fail_on_missing = true
  # ...

So it will raise a KeyError when accessing a non-existing key (similar to Hash#fetch behaviour):

# => raises KeyError: key not found: :path

Environment variables

See section below for more details.

Working with environment variables

To load environment variables from the ENV object, that will override any settings defined in files, set the use_env to true in your config/initializers/config.rb file:

Config.setup do |config|
  config.const_name = 'Settings'
  config.use_env = true

Now config would read values from the ENV object to the settings. For the example above it would look for keys starting with Settings:

ENV['Settings.section.size'] = 1
ENV['Settings.section.server'] = 'google.com'

It won't work with arrays, though.

Working with Heroku

Heroku uses ENV object to store sensitive settings. You cannot upload such files to Heroku because it's ephemeral filesystem gets recreated from the git sources on each instance refresh. To use config with Heroku just set the use_env var to true as mentioned above.

To upload your local values to Heroku you could ran bundle exec rake config:heroku.


You can customize how environment variables are processed:

  • env_prefix (default: SETTINGS) - which ENV variables to load into config
  • env_separator (default: .) - what string to use as level separator - default value of . works well with Heroku, but you might want to change it for example for __ to easy override settings from command line, where using dots in variable names might not be allowed (eg. Bash)
  • env_converter (default: :downcase) - how to process variables names:
    • nil - no change
    • :downcase - convert to lower case
  • env_parse_values (default: true) - try to parse values to a correct type (Boolean, Integer, Float, String)

For instance, given the following environment:


And the following configuration:

Config.setup do |config|
  config.use_env = true
  config.env_prefix = 'SETTINGS'
  config.env_separator = '__'
  config.env_converter = :downcase
  config.env_parse_values = true

The following settings will be available:

Settings.section.server_size # => 1
Settings.section.server # => 'google.com'
Settings.section.ssl_enabled # => false



appraisal install

Run the test suite:

appraisal rspec

If you modified any of the documentation files verify their format:

mdl --style .mdlstyle.rb *.md



Config is released under the MIT License.