ravioli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10956034d9851d2c30cc00a73bbb95ece033cb8ca1d6bc66dee4ad106335b430
+  data.tar.gz: 340b538b33f19016fbc494633ef809a79b1df518016af43de1c84f5428ce42fd
+SHA512:
+  metadata.gz: e639d69ce9ccd5e373805b8e06edc8d2e5a468af695ce40dc6630cafbfe2d8ae403fe63cda38ba61b6d6b8becdbdca846566d6f5aea374a4ae9905ae66527d74
+  data.tar.gz: f71dd8b25999a8972fc3ac9173c488ce337233f5f2496dcdb084c59067ea48056026ac65d9f1a8f176aac52c5eca9b5c71b6202998ebc40761bb6ff0064c491e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Flip Sasser
+
+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,465 @@
+# Ravioli.rb 🍝
+
+
+**Grab a fork and twist your configuration spaghetti in a single, delicious dumpling!**
+
+Ravioli combines all of your app's runtime configuration into a unified, simple interface. **It combines YAML or JSON configuration files, encrypted Rails credentials, and ENV vars into one easy-to-consume interface** so you can focus on writing code and not on where configuration comes from.
+
+**Ravioli turns this...**
+
+```ruby
+key = ENV.fetch("THING_API_KEY") { Rails.credentials.thing&["api_key"] || raise("I need an API key for thing to work") }
+```
+
+**...into this:**
+
+```ruby
+key = Rails.config.dig!(:thing, :api_key)
+```
+
+**🚨 FYI:** Ravioli is two libraries: a Ruby gem (this doc), and a [JavaScript NPM package](src/README.md). The NPM docs contain specifics about how to [use Ravioli in the Rails asset pipeline](src/README.md#using-in-the-rails-asset-pipeline), in [a Node web server](src/README.md#using-in-a-server), or [bundled into a client using Webpack](src/README.md#using-with-webpack), [Rollup](src/README.md#using-with-rollup), or [whatever else](src/README.md#using-with-another-bundler).
+
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Usage](#usage)
+3. [Automatic Configuration](#automatic-configuration)
+4. [Manual Configuration](#manual-configuration)
+5. [Deploying](#deploying)
+6. [License](#license)
+<!-- 5. [JavaScript library](#javascript-library) -->
+
+## Installation
+
+<!--Ravioli comes as a Ruby gem or an NPM package; they work marginally differently. Let's focus on Ruby/Rails for now.
+-->
+1. Add `gem "ravioli"` to your `Gemfile`
+2. Run `bundle install`
+3. Add an initializer (totally optional): `rails generate ravioli:install` - Ravioli will do **everything** automatically for you if you skip this step, because I aim to *please*
+
+## Usage
+
+Ravioli turns your app's configuration environment into a [PORO](http://blog.jayfields.com/2007/10/ruby-poro.html) with direct accessors and a few special methods. By *default*, it adds the method `Rails.config` that returns a Ravioli instance. You can access all of your app's configuration from there. _This is totally optional_ and you can also do everything manually, but for the sake of these initial examples, we'll use the `Rails.config` setup.
+
+Either way, for the following examples, imagine we had the following configuration structure:*
+
+```yaml
+host: "example.com"
+url: "https://www.example.com"
+sender: "reply-welcome@example.com"
+
+database:
+  host: "localhost"
+  port: "5432"
+
+sendgrid:
+  api_key: "12345"
+
+sentry:
+  api_key: "12345"
+  environment: <%= Rails.env %>
+  dsn: "https://sentry.io/whatever?api_key=12345"
+```
+
+<small>*this structure is the end result of Ravioli's loading process; it has nothing to do with filesystem organization or config file layout. We'll talk about that in a bit, so just slow your roll about loading up config files until then.</small>
+
+**Got it? Good.** Let's access some configuration,
+
+### Accessing values directly
+
+Ravioli objects support direct accessors:
+
+```ruby
+Rails.config.host #=> "example.com"
+Rails.config.database.port #=> "5432"
+Rails.config.not.here #=> NoMethodError (undefined method `here' for nil:NilClass)
+```
+
+### Accessing configuration values safely by key path
+
+#### Traversing the keypath with `dig`
+
+You can traverse deeply nested config values safely with `dig`:
+
+```ruby
+Rails.config.dig(:database, :port) #=> "5432"
+Rails.config.dig(:not, :here) #=> nil
+```
+
+This works the same in principle as the [`dig`](https://ruby-doc.org/core-2.7.2/Hash.html#method-i-dig) method on `Hash` objects, with the added benefit of not caring about key type (both symbols and strings are accepted).
+
+#### Providing fallback values with `fetch`
+
+You can provide a sane fallback value using `fetch`, which works like `dig` but accepts a block:
+
+```ruby
+Rails.config.fetch(:database, :port) { "5678" } #=> "5432" is returned from the config
+Rails.config.fetch(:not, :here) { "PRESENT!" } #=> "PRESENT!" is returned from the block
+```
+
+**Note that `fetch` differs from the [`fetch`](https://ruby-doc.org/core-2.7.2/Hash.html#method-i-fetch) method on `Hash` objects.**  Ravioli's `fetch` accepts keys as arguments, and does not accept a `default` argument - instead, the default _must_ appear inside of a block.
+
+#### Requiring configuration values with `dig!`
+
+If a part of your app cannot operate without a configuration value, e.g. an API key is required to make an API call, you can use `dig!`, which behaves identically to `dig` except it will raise a `KeyMissingError` if no value is specified:
+
+```ruby
+uri = URI("https://api.example.com/things/1")
+request = Net::HTTP::Get.new(uri)
+request["X-Example-API-Key"] = Rails.config.dig!(:example, :api_key) #=> Ravioli::KeyMissingError (could not find configuration value at key path [:example, :api_key])
+```
+
+#### Allowing for blank values with `safe` (or `dig(*keys, safe: true)`)
+
+As a convenience for avoiding the billion dollar mistake, you can use `safe` to ensure you're operating on a configuration object, even if it has not been set for your environment:
+
+```ruby
+Rails.config.dig(:google) #=> nil
+Rails.config.safe(:google) #=> #<Ravioli::Configuration {}>
+Rails.config.dig(:google, safe: true) #=> #<Ravioli::Configuration {}>
+```
+
+Use `safe` when, for example, you don't want your code to explode because a root config key is not set. Here's an example:
+
+```ruby
+class GoogleMapsClient
+  include HTTParty
+
+  config = Rails.config.safe(:google)
+  headers "Auth-Token" => config.token, "Other-Header" => config.other_thing
+  base_uri config.fetch(:base_uri) { "https://api.google.com/maps-do-stuff-cool-right" }
+end
+```
+
+### Querying for presence
+
+In addition to direct accessors, you can append a `?` to a method to see if a value exists. For example:
+
+```ruby
+Rails.config.database.host? #=> true
+Rails.config.database.password? #=> false
+```
+
+### `ENV` variables take precedence over loaded configuration
+
+I guess the headline is the thing: `ENV` variables take precedence over loaded configuration files. When loading or querying your configuration, Ravioli checks for a capitalized `ENV` variable corresponding to the keypath you're searching.
+
+For example:
+
+```env
+Rails.config.dig(:database, :url)
+
+# ...is equivalent to...
+
+ENV.fetch("DATABASE_URL") { Rails.config.database&.url }
+```
+
+This means that you can use Ravioli instead of querying `ENV` for its keys, and it'll get you the right value every time.
+
+## Automatic Configuration
+
+**The fastest way to use Ravioli is via automatic configuration,** bootstrapping it into the `Rails.config` method. This is the default experience when you `require "ravioli"`, either explicitly through an initializer or implicitly through `gem "ravioli"` in your Gemfile.
+
+**Automatic configuration takes the following steps for you:**
+
+### 1. Adds a `staging` flag
+
+First, Ravioli adds a `staging` flag to `Rails.config`. It defaults to `true` if:
+
+1. `ENV["RAILS_ENV"]` is set to "production"
+2. `ENV["STAGING"]` is not blank
+
+Using [query accessors](#querying-for-presence), you can access this value as `Rails.config.staging?`.
+
+**BUT, as I am a generous and loving man,** Ravioli will also ensure `Rails.env.staging?` returns `true` if 1 and 2 are true above:
+
+```ruby
+ENV["RAILS_ENV"] = "production"
+Rails.env.staging? #=> false
+Rails.env.production? #=> true
+
+ENV["STAGING"] = "totes"
+Rails.env.staging? #=> true
+Rails.env.production? #=> true
+```
+
+### 2. Loads every plaintext configuration file it can find
+
+Ravioli will traverse your `config/` directory looking for every YAML or JSON file it can find. It loads them in arbitrary order, and keys them by name. For example, with the following directory layout:
+
+```
+config/
+  app.yml
+  cable.yml
+  database.yml
+  mailjet.json
+```
+
+...the automatically loaded configuration will look like
+
+```
+# ...the contents of app.yml
+cable:
+  # ...the contents of cable.yml
+database:
+  # ...the contents of database.yml
+mailjet:
+  # ...the contents of mailjet.json
+```
+
+**NOTE THAT APP.YML GOT LOADED INTO THE ROOT OF THE CONFIGURATION!** This is because the automatic loading system assumes you want some configuration values that aren't nested. It effectively calls [`load_configuration_file(filename, key: File.basename(filename) != "app")`](#load_configuration_file), which ensures that, for example, the values in `config/mailjet.json` get loaded under `Rails.config.mailjet` while the valuaes in `config/app.yml` get loaded directly into `Rails.config`.
+
+### 3. Loads and combines encrypted credentials
+
+Ravioli will then check for [encrypted credentials](https://guides.rubyonrails.org/security.html#custom-credentials). It loads credentials in the following order:
+
+1. First, it loads `config/credentials.yml.enc`
+2. Then, it loads and applies `config/credentials/RAILS_ENV.yml.enc` over top of what it has already loaded
+3. Finally, IF `Rails.config.staging?` IS TRUE, it loads and applies `config/credentials/staging.yml.enc`
+
+This allows you to use your secure credentials stores without duplicating information; you can simply layer environment-specific values over top of
+
+### All put together, it does this:
+
+```ruby
+def Rails.config
+  @config ||= Ravioli.build(strict: Rails.env.production?) do |config|
+    config.add_staging_flag!
+    config.auto_load_config_files!
+    config.auto_load_credentials!
+  end
+end
+```
+
+I documented that because, you know, you can do parts of that yourself when we get into the weeds with.........
+
+## Manual configuration
+
+If any of the above doesn't suit you, by all means, Ravioli is flexible enough for you to build your own instance. There are a number of things you can change, so read through to see what you can do by going your own way.
+
+### Using `Ravioli.build`
+
+The best way to build your own configuration is by calling `Ravioli.build`. It will yield an instance of a `Ravioli::Builder`, which has lots of convenient methods for loading configuration files, credentials, and the like. It works like so:
+
+```ruby
+configuration = Ravioli.build do |config|
+  config.load_configuration_file("whatever.yml")
+  config.whatever = {things: true}
+end
+```
+
+This will yield a configured instance of `Ravioli::Configuration` with structure
+
+```yaml
+rubocop:
+  # ...the contents of whatever.yml
+whatever:
+  things: true
+```
+
+`Ravioli.build` also does a few handy things:
+
+- It freezes the configuration object so it is immutable,
+- It caches the final configuration in `Ravioli.configurations`, and
+- It sets `Ravioli.default` to the most-recently built configuration
+
+### Direct construction with `Ravioli::Configuration.new`
+
+You can also directly construct a configuration object by passing a hash to `Ravioli::Configuration.new`. This is basically the same thing as an `OpenStruct` with the added [helper methods of a Ravioli object](#usage):
+
+```ruby
+config = Ravioli::Configuration.new(whatever: true, test: {things: "stuff"})
+config.dig(:test, :things) #=> "stuff
+```
+
+### Alternatives to using `Rails.config`
+
+By default, Ravioli loads a default configuration in `Rails.config`. If you are already using `Rails.config` for something else, or you just hate the idea of all those letters, you can do it however else makes sense to you: in a constant (e.g. `Config` or `App`), or somewhere else entirely (you could, for example, define a `Config` module, mix it in to your classes where it's needed, and access it via a `config` instance method).
+
+Here's an example using an `App` constant:
+
+```ruby
+# config/initializers/_config.rb
+App = Raviloli.build { |config| ... }
+```
+
+You can also point it to `Rails.config` if you'd like to access configuration somewhere other than `Rails.config`, but you want to enjoy the benefits of [automatic configuration](#automatic-configuration):
+
+```ruby
+# config/initializers/_config.rb
+App = Rails.config
+```
+
+You could also opt-in to configuration access with a module:
+
+```ruby
+module Config
+  def config
+    Ravioli.default || Ravioli.build {|config| ... }
+  end
+end
+```
+
+### `add_staging_flag!`
+
+
+### `load_config_file`
+
+Let's imagine we have this config file:
+
+`config/mailjet.yml`
+
+```yaml
+development:
+  api_key: "NOT_USED"
+
+test:
+  api_key: "VCR"
+
+staging:
+  api_key: "12345678"
+
+production:
+  api_key: "98765432"
+```
+
+In an initializer, generate your Ravioli instance and load it up:
+
+
+```ruby
+# config/initializers/_ravioli.rb`
+Config = Ravioli.build do
+  load_config_file(:mailjet) # given a symbol, it automatically assumes you meant `config/mailjet.yml`
+  load_config_file("config/mailjet") # same as above
+  load_config_file("lib/mailjet/config") # looks for `Rails.root.join("lib", "mailjet", "config.yml")
+end
+```
+
+`config/initializers/_ravioli.rb`
+
+```ruby
+Config = Ravioli.build do
+  %i[new_relic sentry google].each do |service|
+    load_config_file(service)
+  end
+
+  load_credentials # just load the base credentials file
+  load_credentials("credentials/production") if Rails.env.production? # add production overrides when appropriate
+
+  self.staging = File.exists?("./staging.txt") # technically you could do this ... I don't know why you would, but technically you could
+end
+```
+
+Configuration values take precedence in the order they are applied. For example, if you load two config files defining `host`, the latest one will overwrite the earlier one's value.
+
+
+### `load_credentials`
+
+Imagine the following encrypted YAML files:
+
+#### `config/credentials.yml.enc`
+
+Accessing the credentials with `rails credentials:edit`, let's say you have the following encrypted file:
+
+```yaml
+mailet:
+  api_key: "12345"
+```
+
+#### `config/credentials/production.yml.enc`
+
+Edit with `rails credentials:edit --environment production`
+
+```yaml
+mailet:
+  api_key: "67891"
+```
+
+You can then load credentials like so:
+
+``config/initializers/_ravioli.rb`
+
+```ruby
+Config = Ravioli.build do
+  # Load the base credentials
+  load_credentials
+
+  # Load the env-specific credentials file. It will look for `config/credentials/#{Rails.env}.key`
+  # just like Rails does. But in this case, it falls back on e.g. `ENV["PRODUCTION_KEY"]` if that
+  # file is missing (as it should be when deployed to a remote server)
+  load_credentials("credentials/#{Rails.env}", env_key: "#{Rails.env}_KEY")
+
+  # Load the staging credentials. Because we did not provide an `env_key` argument, this will
+  # default to looking for `ENV["RAILS_STAGING_KEY"]` or `ENV["RAILS_MASTER_KEY"]`.
+  load_credentials("credentials/staging") if Rails.env.production? && srand.zero?
+end
+```
+
+
+
+You can manually define your configuration in an initializer if you don't want the automatic configuration assumptions to step on any toes.
+
+For the following examples, imagine a file in `config/sentry.yml`:
+
+```yaml
+development:
+  dsn: "https://dev_user:pass@sentry.io/dsn/12345"
+  environment: "development"
+
+production:
+  dsn: "https://prod_user:pass@sentry.io/dsn/12345"
+  environment: "production"
+
+staging:
+  environment: "staging"
+```
+
+## Deploying
+
+### Encryption keys in ENV
+
+Because Ravioli merges environment-specific credentials over top of the root credentials file, you'll need to provide encryption keys for two (or, if you have a staging setup, three) different files in ENV vars. As such, Ravioli looks for decryption keys in a fallback-specific way. Here's where it looks for each file:
+
+<table><thead><tr><th>File</th><th>First it tries...</th><th>Then it tries...</th></tr></thead><tbody><tr><td>
+
+`config/credentials.yml.enc`
+
+</td><td>
+
+`ENV["RAILS_BASE_KEY"]`
+
+</td><td>
+
+`ENV["RAILS_MASTER_KEY"]`
+
+</td></tr><tr><td>
+
+`config/credentials/production.yml.enc`
+
+</td><td>
+
+`ENV["RAILS_PRODUCTION_KEY"]`
+
+</td><td>
+
+`ENV["RAILS_MASTER_KEY"]`
+
+</td></tr><tr><td>
+
+`config/credentials/staging.yml.enc` (only if running on staging)
+
+</td><td>
+
+`ENV["RAILS_STAGING_KEY"]`
+
+</td><td>
+
+`ENV["RAILS_MASTER_KEY"]`
+
+</td></tr></tbody></table>
+
+Credentials are loaded in that order, too, so that you can have a base setup on `config/credentials.yml.enc`, overlay that with production-specific stuff from `config/credentials/production.yml.enc`, and then short-circuit or redirect some stuff in `config/credentials/staging.yml.enc` for staging environments.
+
+## License
+
+Ravioli is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "Ravioli"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+APP_RAKEFILE = File.expand_path("spec/fixtures/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/lib/ravioli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+# These are the basic building blocks of Ravioli
+require_relative "ravioli/builder"
+require_relative "ravioli/configuration"
+require_relative "ravioli/version"
+
+##
+# Ravioli contains helper methods for building Configuration instances and accessing them, as well
+# as the Builder class for help loading configuration files and encrypted credentials
+module Ravioli
+  NAME = "Ravioli"
+
+  class << self
+    def build(class_name: "Configuration", namespace: nil, strict: false, &block)
+      builder = Builder.new(class_name: class_name, namespace: namespace, strict: strict)
+      yield builder if block_given?
+      builder.build!.tap do |configuration|
+        configurations.push(configuration)
+      end
+    end
+
+    def default
+      configurations.last
+    end
+
+    def configurations
+      @configurations ||= []
+    end
+  end
+end
+
+require_relative "ravioli/engine" if defined?(Rails)

data/lib/ravioli/builder.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+require_relative "configuration"
+
+module Ravioli
+  # The Builder clas provides a simple interface for building a Ravioli configuration. It has
+  # methods for loading configuration files and encrypted credentials, and forwards direct
+  # configuration on to the configuration instance. This allows us to keep a clean separation of
+  # concerns (builder: loads configuration details; configuration: provides access to information
+  # in memory).
+  class Builder
+    def initialize(class_name: "Configuration", namespace: nil, strict: false)
+      configuration_class = if namespace.present?
+        namespace.class_eval <<-EOC, __FILE__, __LINE__ + 1
+          class #{class_name.to_s.classify} < Ravioli::Configuration; end
+        EOC
+        namespace.const_get(class_name)
+      else
+        Ravioli::Configuration
+      end
+      @strict = !!strict
+      @configuration = configuration_class.new
+    end
+
+    # Automatically infer a `staging?` status
+    def add_staging_flag!(is_staging = Rails.env.production? && ENV["STAGING"].present?)
+      configuration.staging = is_staging
+      Rails.env.class_eval <<-EOC, __FILE__, __LINE__ + 1
+        def staging?
+          config = Rails.try(:config)
+          return false unless config&.is_a?(Ravioli::Configuration)
+
+          config.staging?
+        end
+      EOC
+      is_staging
+    end
+
+    # Load YAML or JSON files in config/**/* (except for locales)
+    def auto_load_config_files!
+      config_dir = Rails.root.join("config")
+      Dir[config_dir.join("{[!locales/]**/*,*}.{json,yaml,yml}")].each do |config_file|
+        load_config_file(config_file, key: !File.basename(config_file, File.extname(config_file)).casecmp("app").zero?)
+      end
+    end
+
+    # Load config/credentials**/*.yml.enc files (assuming we can find a key)
+    def auto_load_credentials!
+      # Load the base config
+      load_credentials(key_path: "config/master.key", env_name: "base")
+
+      # Load any environment-specific configuration on top of it
+      load_credentials("config/credentials/#{Rails.env}", key_path: "config/credentials/#{Rails.env}.key", env_name: "master")
+
+      # Apply staging configuration on top of THAT, if need be
+      load_credentials("config/credentials/staging", key_path: "config/credentials/staging.key") if configuration.staging?
+    end
+
+    # When the builder is done working, lock the configuration and return it
+    def build!
+      configuration.freeze
+    end
+
+    # Load a config file either with a given path or by name (e.g. `config/whatever.yml` or `:whatever`)
+    def load_config_file(path, options = {})
+      config = parse_config_file(path, options)
+      configuration.append(config) if config.present?
+    rescue => error
+      warn "Could not load config file #{path}", error
+    end
+
+    # Load secure credentials using a key either from a file or the ENV
+    def load_credentials(path = "credentials", key_path: path, env_name: path.split("/").last)
+      credentials = parse_credentials(path, env_name: env_name, key_path: key_path)
+      configuration.append(credentials) if credentials.present?
+    rescue => error
+      warn "Could not decrypt `#{path}.yml.enc' with key file `#{key_path}' or `ENV[\"#{env_name}\"]'", error
+      {}
+    end
+
+    private
+
+    ENV_KEYS = %w[default development production shared staging test].freeze
+    EXTNAMES = %w[yml yaml json].freeze
+
+    attr_reader :configuration
+
+    def extract_environmental_config(config)
+      # Check if the config hash is keyed by environment - if not, just return it as-is. It's
+      # considered "keyed by environment" if it contains ONLY env-specific keys.
+      return config unless (config.keys & ENV_KEYS).any? && (config.keys - ENV_KEYS).empty?
+
+      # Combine environmental config in the following order:
+      # 1. Shared config
+      # 2. Environment-specific
+      # 3. Staging-specific (if we're in a staging environment)
+      environments = ["shared", Rails.env.to_s]
+      environments.push("staging") if configuration.staging?
+      config.values_at(*environments).inject({}) { |final_config, environment_config|
+        final_config.deep_merge((environment_config || {}))
+      }
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(*args, &block)
+      configuration.send(*args, &block)
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+    # rubocop:enable Style/MethodMissingSuper
+
+    def parse_config_file(path, options = {})
+      path = path_to_config_file_path(path)
+
+      config = case path.extname.downcase
+      when ".json"
+        parse_json_config_file(path)
+      when ".yml", ".yaml"
+        parse_yaml_config_file(path)
+      else
+        raise ParseError.new("#{Ravioli::NAME} doesn't know how to parse #{path}")
+      end
+
+      # At least expect a hash to be returned from the loaded config file
+      return {} unless config.is_a?(Hash)
+
+      # Extract a merged config based on the Rails.env (if the file is keyed that way)
+      config = extract_environmental_config(config)
+
+      # Key the configuration according the passed-in options
+      key = options.delete(:key) { true }
+      return config if key == false # `key: false` means don't key the configuration at all
+
+      if key == true
+        # `key: true` means key it automatically based on the filename
+        name = File.basename(path, File.extname(path))
+        name = File.dirname(path).split(Pathname::SEPARATOR_PAT).last if name.casecmp("config").zero?
+      else
+        # `key: :anything_else` means use `:anything_else` as the key
+        name = key.to_s
+      end
+
+      {name => config}
+    end
+
+    def parse_credentials(path, key_path: path, env_name: path.split("/").last)
+      env_name = env_name.to_s
+      env_name = "RAILS_#{env_name.upcase}_KEY" unless env_name.upcase == env_name
+      key_path = path_to_config_file_path(key_path, extnames: "key", quiet: true)
+      options = {key_path: key_path}
+      options[:env_key] = ENV[env_name].present? ? env_name : SecureRandom.hex(6)
+
+      path = path_to_config_file_path(path, extnames: "yml.enc")
+      credentials = Rails.application.encrypted(path, options)&.config || {}
+      credentials
+    end
+
+    def parse_json_config_file(path)
+      contents = File.read(path)
+      JSON.parse(contents).deep_transform_keys { |key| key.to_s.underscore }
+    end
+
+    def parse_yaml_config_file(path)
+      require "erb"
+      contents = File.read(path)
+      erb = ERB.new(contents).tap { |renderer| renderer.filename = path.to_s }
+      YAML.safe_load(erb.result, aliases: true)
+    end
+
+    def path_to_config_file_path(path, extnames: EXTNAMES, quiet: false)
+      original_path = path.dup
+      unless path.is_a?(Pathname)
+        path = path.to_s
+        path = path.match?(Pathname::SEPARATOR_PAT) ? Pathname.new(path) : Pathname.new("config").join(path)
+      end
+      path = Rails.root.join(path) unless path.absolute?
+
+      # Try to guess an extname, if we weren't given one
+      if path.extname.blank?
+        Array(extnames).each do |extname|
+          other_path = path.sub_ext(".#{extname}")
+          if other_path.exist?
+            path = other_path
+            break
+          end
+        end
+      end
+
+      warn "Could not resolve a configuration file at #{original_path.inspect}" unless quiet || path.exist?
+
+      path
+    end
+
+    def warn(message, error = $!)
+      message = "[#{Ravioli::NAME}] #{message}"
+      message = "#{message}:\n\n#{error.cause.inspect}" if error&.cause.present?
+      if @strict
+        raise BuildError.new(message, error)
+      else
+        Rails.logger.warn(message) if defined? Rails
+        $stderr.write message # rubocop:disable Rails/Output
+      end
+    end
+  end
+
+  class BuildError < StandardError
+    def initialize(message, cause = nil)
+      super message
+      @cause = cause
+    end
+
+    def cause
+      @cause || super
+    end
+  end
+  class ParseError < StandardError; end
+end

data/lib/ravioli/configuration.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+require "ostruct"
+
+module Ravioli
+  class Configuration < OpenStruct
+    attr_reader :key_path
+
+    def initialize(attributes = {})
+      super({})
+      @key_path = attributes.delete(:key_path)
+      append(attributes)
+    end
+
+    # def ==(other)
+    #   other = other.table if other.respond_to?(:table)
+    #   other == table
+    # end
+
+    def append(attributes = {})
+      attributes.each do |key, value|
+        self[key.to_sym] = cast(key.to_sym, value)
+      end
+    end
+
+    def dig(*keys, safe: false)
+      return safe(*keys) if safe
+
+      fetch_env_key_for(keys) do
+        keys.inject(self) do |value, key|
+          value = value.try(:[], key)
+          break if value.blank?
+          value
+        end
+      end
+    end
+
+    def dig!(*keys)
+      fetch(*keys) { raise KeyMissingError.new("Could not find value at key path #{keys.inspect}") }
+    end
+
+    def fetch(*keys)
+      dig(*keys) || yield
+    end
+
+    def pretty_print(printer = nil)
+      table.pretty_print(printer)
+    end
+
+    def safe(*keys)
+      fetch(*keys) { build(keys) }
+    end
+
+    private
+
+    def build(keys, attributes = {})
+      attributes[:key_path] = key_path_for(keys)
+      child = self.class.new(attributes)
+      child.freeze if frozen?
+      child
+    end
+
+    def cast(key, value)
+      if value.is_a?(Hash)
+        original_value = dig(*Array(key))
+        value = original_value.table.deep_merge(value.deep_symbolize_keys) if original_value.is_a?(self.class)
+        build(key, value)
+      else
+        fetch_env_key_for(key) {
+          if value.is_a?(Array)
+            value.each_with_index.map { |subvalue, index| cast(Array(key) + [index], subvalue) }
+          else
+            value
+          end
+        }
+      end
+    end
+
+    def fetch_env_key_for(keys, &block)
+      env_key = key_path_for(keys).join("_").upcase
+      ENV.fetch(env_key, &block)
+    end
+
+    def key_path_for(keys)
+      Array(key_path) + Array(keys)
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(method, *args, &block)
+      # Return proper booleans from query methods
+      return send(method.to_s.chomp("?")).present? if args.empty? && method.to_s.ends_with?("?")
+      super
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+    # rubocop:enable Style/MethodMissingSuper
+  end
+
+  class KeyMissingError < StandardError; end
+end

data/lib/ravioli/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ravioli
+  class Engine < ::Rails::Engine
+    # Bootstrap Ravioli onto the Rails app
+    initializer "ravioli", before: "load_environment_config" do |app|
+      Rails.extend Ravioli::Config unless Rails.respond_to?(:config)
+    end
+  end
+
+  module Config
+    def config
+      Ravioli.default || Ravioli.build(namespace: Rails.application&.class&.module_parent, strict: Rails.env.production?) do |config|
+        config.add_staging_flag!
+        config.auto_load_config_files!
+        config.auto_load_credentials!
+      end
+    end
+  end
+end

data/lib/ravioli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ravioli
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,259 @@
+--- !ruby/object:Gem::Specification
+name: ravioli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Flip Sasser
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop-ordered_methods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.39'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.39'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Ravioli combines all of your app's runtime configuration into a unified,
+  simple interface. It automatically loads and combines YAML config files, encrypted
+  Rails credentials, and ENV vars so you can focus on writing code and not on where
+  configuration comes from
+email:
+- hello@flipsasser.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/ravioli.rb
+- lib/ravioli/builder.rb
+- lib/ravioli/configuration.rb
+- lib/ravioli/engine.rb
+- lib/ravioli/version.rb
+homepage: https://github.com/flipsasser/ravioli
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/flipsasser/ravioli
+  source_code_uri: https://github.com/flipsasser/ravioli
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Grab a fork and twist all your configuration spaghetti into a single, delicious
+  bundle
+test_files: []