README.md in dotenv-rails-2.8.1 vs README.md in dotenv-rails-3.0.0.beta
- old
+ new
@@ -1,62 +1,46 @@
-# dotenv [](https://badge.fury.io/rb/dotenv) [](https://gitter.im/bkeepers/dotenv?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# dotenv [](https://badge.fury.io/rb/dotenv)
Shim to load environment variables from `.env` into `ENV` in *development*.
Storing [configuration in the environment](http://12factor.net/config) is one of the tenets of a [twelve-factor app](http://12factor.net). Anything that is likely to change between deployment environments–such as resource handles for databases or credentials for external services–should be extracted from the code into environment variables.
But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. dotenv loads variables from a `.env` file into `ENV` when the environment is bootstrapped.
## Installation
-### Rails
+Add this line to the top of your application's Gemfile and run `bundle install`:
-Add this line to the top of your application's Gemfile:
-
```ruby
-gem 'dotenv-rails', groups: [:development, :test]
+gem 'dotenv', groups: [:development, :test]
```
-And then execute:
+## Usage
+Add your application configuration to your `.env` file in the root of your project:
+
```shell
-$ bundle
+S3_BUCKET=YOURS3BUCKET
+SECRET_KEY=YOURSECRETKEYGOESHERE
```
-#### Note on load order
+Whenever your application loads, these variables will be available in `ENV`:
-dotenv is initialized in your Rails app during the `before_configuration` callback, which is fired when the `Application` constant is defined in `config/application.rb` with `class Application < Rails::Application`. If you need it to be initialized sooner, you can manually call `Dotenv::Railtie.load`.
-
```ruby
-# config/application.rb
-Bundler.require(*Rails.groups)
-
-# Load dotenv only in development or test environment
-if ['development', 'test'].include? ENV['RAILS_ENV']
- Dotenv::Railtie.load
-end
-
-HOSTNAME = ENV['HOSTNAME']
+config.fog_directory = ENV['S3_BUCKET']
```
-If you use gems that require environment variables to be set before they are loaded, then list `dotenv-rails` in the `Gemfile` before those other gems and require `dotenv/rails-now`.
+See the [API Docs](https://rubydoc.info/github/bkeepers/dotenv/main) for more.
-```ruby
-gem 'dotenv-rails', require: 'dotenv/rails-now'
-gem 'gem-that-requires-env-variables'
-```
+### Rails
-### Sinatra or Plain ol' Ruby
+Dotenv will automatically load when your Rails app boots. See [Customizing Rails](#customizing-rails) to change which files are loaded and when.
-Install the gem:
+### Sinatra / Ruby
-```shell
-$ gem install dotenv
-```
+Load Dotenv as early as possible in your application bootstrap process:
-As early as possible in your application bootstrap process, load `.env`:
-
```ruby
require 'dotenv/load'
# or
require 'dotenv'
@@ -68,74 +52,109 @@
```ruby
require 'dotenv'
Dotenv.load('file1.env', 'file2.env')
```
-Alternatively, you can use the `dotenv` executable to launch your application:
+## Autorestore in tests
-```shell
-$ dotenv ./script.rb
-```
+Since 3.0, dotenv in a Rails app will automatically restore `ENV` to its original state before each test. This means you can modify `ENV` in your tests without fear of leaking state to other tests. It works with both `ActiveSupport::TestCase` and `Rspec`.
-The `dotenv` executable also accepts a single flag, `-f`. Its value should be a comma-separated list of configuration files, in the order of most important to least. All of the files must exist. There _must_ be a space between the flag and its value.
+To disable this behavior, set `config.dotenv.autorestore = false` in `config/application.rb` or `config/environments/test.rb`.
-```
-$ dotenv -f ".env.local,.env" ./script.rb
-```
+To use this behavior outside of a Rails app, just `require "dotenv/autorestore"` in your test suite.
+See [`Dotenv.save`](https://rubydoc.info/github/bkeepers/dotenv/main/Dotenv:save), [Dotenv.restore](https://rubydoc.info/github/bkeepers/dotenv/main/Dotenv:restore), and [`Dotenv.modify(hash) { ... }`](https://rubydoc.info/github/bkeepers/dotenv/main/Dotenv:modify) for manual usage.
+
+### Rake
+
To ensure `.env` is loaded in rake, load the tasks:
```ruby
require 'dotenv/tasks'
task mytask: :dotenv do
- # things that require .env
+ # things that require .env
end
```
-## Usage
+### CLI
-Add your application configuration to your `.env` file in the root of your project:
+You can use the `dotenv` executable load `.env` before launching your application:
-```shell
-S3_BUCKET=YOURS3BUCKET
-SECRET_KEY=YOURSECRETKEYGOESHERE
+```console
+$ dotenv ./script.rb
```
-Whenever your application loads, these variables will be available in `ENV`:
+The `dotenv` executable also accepts the flag `-f`. Its value should be a comma-separated list of configuration files, in the order of most important to least. All of the files must exist. There _must_ be a space between the flag and its value.
-```ruby
-config.fog_directory = ENV['S3_BUCKET']
+```console
+$ dotenv -f ".env.local,.env" ./script.rb
```
-You may also add `export` in front of each line so you can `source` the file in bash:
+The `dotenv` executable can optionally ignore missing files with the `-i` or `--ignore` flag. For example, if the `.env.local` file does not exist, the following will ignore the missing file and only load the `.env` file.
-```shell
-export S3_BUCKET=YOURS3BUCKET
-export SECRET_KEY=YOURSECRETKEYGOESHERE
+```console
+$ dotenv -i -f ".env.local,.env" ./script.rb
```
-### Multi-line values
+### Load Order
-If you need multiline variables, for example private keys, you can double quote strings and use the `\n` character for newlines:
+If you use gems that require environment variables to be set before they are loaded, then list `dotenv` in the `Gemfile` before those other gems and require `dotenv/load`.
-```shell
-PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nHkVN9...\n-----END DSA PRIVATE KEY-----\n"
+```ruby
+gem 'dotenv', require: 'dotenv/load'
+gem 'gem-that-requires-env-variables'
```
-Alternatively, multi-line values with line breaks are now supported for quoted values.
+### Customizing Rails
+Dotenv will load the following files depending on `RAILS_ENV`, with the last file listed having the highest precedence:
+
+* **development**: `.env`, `.env.development`, `.env.local`, `.env.development.local`
+* **test**: `.env`, `.env.test`, `.env.test.local` - Note that it will **not** load `.env.local`.
+* **development**: `.env`, `.env.production`, `.env.local`, `.env.production.local`
+
+These files are loaded during the `before_configuration` callback, which is fired when the `Application` constant is defined in `config/application.rb` with `class Application < Rails::Application`. If you need it to be initialized sooner, or need to customize the loading process, you can do so at the top of `application.rb`
+
+```ruby
+# config/application.rb
+Bundler.require(*Rails.groups)
+
+# Load .env.local in test
+Dotenv::Rails.files.unshift(".env.local") if ENV["RAILS_ENV"] == "test"
+
+module YourApp
+ class Application < Rails::Application
+ # ...
+ end
+end
+```
+
+Available options:
+
+* `Dotenv::Rails.files` - list of files to be loaded, in order of precedence.
+* `Dotenv::Rails.overwrite` - Overwrite exiting `ENV` variables with contents of `.env*` files
+
+### Multi-line values
+
+Multi-line values with line breaks must be surrounded with double quotes.
+
```shell
PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
...
HkVN9...
...
-----END DSA PRIVATE KEY-----"
```
-This is particularly helpful when using the Heroku command line plugin [`heroku-config`](https://github.com/xavdid/heroku-config) to pull configuration variables down that may have line breaks.
+Prior to 3.0, dotenv would replace `\n` in quoted strings with a newline, but that behavior is deprecated. To use the old behavior, set `DOTENV_LINEBREAK_MODE=legacy` before any variables that include `\n`:
+```shell
+DOTENV_LINEBREAK_MODE=legacy
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nHkVN9...\n-----END DSA PRIVATE KEY-----\n"
+```
+
### Command Substitution
You need to add the output of a command in one of your variables? Simply add it with `$(your_command)`:
```shell
@@ -164,10 +183,19 @@
# This is a comment
SECRET_KEY=YOURSECRETKEYGOESHERE # comment
SECRET_HASH="something-with-a-#-hash"
```
+### Exports
+
+For compatability, you may also add `export` in front of each line so you can `source` the file in bash:
+
+```shell
+export S3_BUCKET=YOURS3BUCKET
+export SECRET_KEY=YOURSECRETKEYGOESHERE
+```
+
### Required Keys
If a particular configuration value is required but not set, it's appropriate to raise an error.
To require configuration keys:
@@ -189,43 +217,15 @@
# => {'S3_BUCKET' => 'YOURS3BUCKET', 'SECRET_KEY' => 'YOURSECRETKEYGOESHERE', ...}
```
This method returns a hash of the ENV var name/value pairs.
-## Frequently Answered Questions
+### Templates
-### Can I use dotenv in production?
-
-dotenv was originally created to load configuration variables into `ENV` in *development*. There are typically better ways to manage configuration in production environments - such as `/etc/environment` managed by [Puppet](https://github.com/puppetlabs/puppet) or [Chef](https://github.com/chef/chef), `heroku config`, etc.
-
-However, some find dotenv to be a convenient way to configure Rails applications in staging and production environments, and you can do that by defining environment-specific files like `.env.production` or `.env.test`.
-
-If you use this gem to handle env vars for multiple Rails environments (development, test, production, etc.), please note that env vars that are general to all environments should be stored in `.env`. Then, environment specific env vars should be stored in `.env.<that environment's name>`.
-
-### What other .env* files can I use?
-
-`dotenv-rails` will override in the following order (highest defined variable overrides lower):
-
-| Hierarchy Priority | Filename | Environment | Should I `.gitignore`it? | Notes |
-| ------------------ | ------------------------ | -------------------- | --------------------------------------------------- | ------------------------------------------------------------ |
-| 1st (highest) | `.env.development.local` | Development | Yes! | Local overrides of environment-specific settings. |
-| 1st | `.env.test.local` | Test | Yes! | Local overrides of environment-specific settings. |
-| 1st | `.env.production.local` | Production | Yes! | Local overrides of environment-specific settings. |
-| 2nd | `.env.local` | Wherever the file is | Definitely. | Local overrides. This file is loaded for all environments _except_ `test`. |
-| 3rd | `.env.development` | Development | No. | Shared environment-specific settings |
-| 3rd | `.env.test` | Test | No. | Shared environment-specific settings |
-| 3rd | `.env.production` | Production | No. | Shared environment-specific settings |
-| Last | `.env` | All Environments | Depends (See [below](#should-i-commit-my-env-file)) | The Original® |
-
-
-### Should I commit my .env file?
-
-Credentials should only be accessible on the machines that need access to them. Never commit sensitive information to a repository that is not needed by every development machine and server.
-
-
You can use the `-t` or `--template` flag on the dotenv cli to create a template of your `.env` file.
-```shell
+
+```console
$ dotenv -t .env
```
A template will be created in your working directory named `{FINAME}.template`. So in the above example, it would create a `.env.template` file.
The template will contain all the environment variables in your `.env` file but with their values set to the variable names.
@@ -242,17 +242,32 @@
# .env.template
S3_BUCKET=S3_BUCKET
SECRET_KEY=SECRET_KEY
```
+## Frequently Answered Questions
+
+### Can I use dotenv in production?
+
+dotenv was originally created to load configuration variables into `ENV` in *development*. There are typically better ways to manage configuration in production environments - such as `/etc/environment` managed by [Puppet](https://github.com/puppetlabs/puppet) or [Chef](https://github.com/chef/chef), `heroku config`, etc.
+
+However, some find dotenv to be a convenient way to configure Rails applications in staging and production environments, and you can do that by defining environment-specific files like `.env.production` or `.env.test`.
+
+If you use this gem to handle env vars for multiple Rails environments (development, test, production, etc.), please note that env vars that are general to all environments should be stored in `.env`. Then, environment specific env vars should be stored in `.env.<that environment's name>`.
+
+### Should I commit my .env file?
+
+Credentials should only be accessible on the machines that need access to them. Never commit sensitive information to a repository that is not needed by every development machine and server.
+
Personally, I prefer to commit the `.env` file with development-only settings. This makes it easy for other developers to get started on the project without compromising credentials for other environments. If you follow this advice, make sure that all the credentials for your development environment are different from your other deployments and that the development credentials do not have access to any confidential data.
-### Why is it not overriding existing `ENV` variables?
+### Why is it not overwriting existing `ENV` variables?
-By default, it **won't** overwrite existing environment variables as dotenv assumes the deployment environment has more knowledge about configuration than the application does. To overwrite existing environment variables you can use `Dotenv.overload`.
+By default, it **won't** overwrite existing environment variables as dotenv assumes the deployment environment has more knowledge about configuration than the application does. To overwrite existing environment variables you can use `Dotenv.load files, overwrite: true`.
-You can also use the `-o` or `--overload` flag on the dotenv cli to override existing `ENV` variables.
-```shell
+You can also use the `-o` or `--overwrite` flag on the dotenv cli to overwrite existing `ENV` variables.
+
+```console
$ dotenv -o -f ".env.local,.env"
```
## Contributing