ravioli 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10956034d9851d2c30cc00a73bbb95ece033cb8ca1d6bc66dee4ad106335b430
-  data.tar.gz: 340b538b33f19016fbc494633ef809a79b1df518016af43de1c84f5428ce42fd
+  metadata.gz: 7531708baaf2764477fc99c00343d6ccb10873695ccd6d20c56cb38a21f6520d
+  data.tar.gz: 13b46317a8d6b9fa5f167cab39c3cef998889951fb99b44d0177612798c087e8
 SHA512:
-  metadata.gz: e639d69ce9ccd5e373805b8e06edc8d2e5a468af695ce40dc6630cafbfe2d8ae403fe63cda38ba61b6d6b8becdbdca846566d6f5aea374a4ae9905ae66527d74
-  data.tar.gz: f71dd8b25999a8972fc3ac9173c488ce337233f5f2496dcdb084c59067ea48056026ac65d9f1a8f176aac52c5eca9b5c71b6202998ebc40761bb6ff0064c491e
+  metadata.gz: 79ba9026307074c13efb196b3fd3213ac76668def0064bb4c13a1abf0244c74be128bd259ec472aa09ef36b0bd26f4f5097f097206e42def11b59e04e9f01d25
+  data.tar.gz: ea102e1c1ad70d0fe6b6cfa9460804cf726a8bde10c404dc7eb03e598f6d6e03f7c9d4aca848c5f1f8b9642f906155af7feed4cde336d0328b4f137d1839bc4e

data/README.md

@@ -1,6 +1,5 @@
 # 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.
@@ -35,7 +34,7 @@ key = Rails.config.dig!(:thing, :api_key)
 -->
 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*
+3. Add an initializer (totally optional): `rails generate ravioli:install` - Ravioli will do **everything** automatically for you if you skip this step, because I'm here to put a little meat on your bones.
 
 ## Usage
 
@@ -207,7 +206,7 @@ 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`.
+**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_file(filename, key: File.basename(filename) != "app")`](#load_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
 
@@ -217,7 +216,7 @@ Ravioli will then check for [encrypted credentials](https://guides.rubyonrails.o
 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
+This allows you to use your secure credentials stores without duplicating information; you can simply layer environment-specific values over top of a "root" `config/credentials.yml.enc` file.
 
 ### All put together, it does this:
 
@@ -225,7 +224,7 @@ This allows you to use your secure credentials stores without duplicating inform
 def Rails.config
   @config ||= Ravioli.build(strict: Rails.env.production?) do |config|
     config.add_staging_flag!
-    config.auto_load_config_files!
+    config.auto_load_files!
     config.auto_load_credentials!
   end
 end
@@ -243,16 +242,16 @@ The best way to build your own configuration is by calling `Ravioli.build`. It w
 
 ```ruby
 configuration = Ravioli.build do |config|
-  config.load_configuration_file("whatever.yml")
+  config.load_file("things.yml")
   config.whatever = {things: true}
 end
 ```
 
-This will yield a configured instance of `Ravioli::Configuration` with structure
+This will return a configured instance of `Ravioli::Configuration` with structure
 
 ```yaml
-rubocop:
-  # ...the contents of whatever.yml
+things:
+  # ...the contents of things.yml
 whatever:
   things: true
 ```
@@ -303,7 +302,7 @@ end
 ### `add_staging_flag!`
 
 
-### `load_config_file`
+### `load_file`
 
 Let's imagine we have this config file:
 
@@ -329,24 +328,24 @@ 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")
+  load_file(:mailjet) # given a symbol, it automatically assumes you meant `config/mailjet.yml`
+  load_file("config/mailjet") # same as above
+  load_file("lib/mailjet/config") # looks for `Rails.root.join("lib", "mailjet", "config.yml")
 end
 ```
 
 `config/initializers/_ravioli.rb`
 
 ```ruby
-Config = Ravioli.build do
+Config = Ravioli.build do |config|
   %i[new_relic sentry google].each do |service|
-    load_config_file(service)
+    config.load_file(service)
   end
 
-  load_credentials # just load the base credentials file
-  load_credentials("credentials/production") if Rails.env.production? # add production overrides when appropriate
+  config.load_credentials # just load the base credentials file
+  config.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
+  config.staging = File.exists?("./staging.txt") # technically you could do this ... I don't know why you would, but technically you could
 end
 ```
 
@@ -418,47 +417,47 @@ staging:
 
 ### 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"]`
+Here are a few facts about credentials in Rails and how they're deployed:
 
-</td><td>
+1. Rails assumes you want to use the file that matches your environment, if it exists (e.g. `RAILS_ENV=production` will look for `config/credentials/production.yml.enc`)
+2. Rails does _not_ support environment-specfic keys, but it _does_ now aggressively loads credentials at boot time.
 
-`ENV["RAILS_MASTER_KEY"]`
+**This means `RAILS_MASTER_KEY` MUST be the decryption key for your environment-specific credential file, if one exists.**
 
-</td></tr><tr><td>
+But, 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 way that mirrors Rails' assumptions, but allows progressive layering of credentials.
 
-`config/credentials/production.yml.enc`
+Here are a few examples
 
-</td><td>
+<table><thead><tr><th>File</th><th>First it tries...</th><th>Then it tries...</th></tr></thead><tbody>
 
-`ENV["RAILS_PRODUCTION_KEY"]`
+<tr>
+	<td><code>config/credentials.yml.enc</code></td>
+	<td><code>ENV["RAILS_MASTER_KEY"]</code></td>
+	<td><code>ENV["RAILS_ROOT_KEY"]</code></td>
+</tr>
 
-</td><td>
+<tr>
+	<td><code>config/credentials/#{RAILS_ENV}.yml.enc</code></td>
+	<td><code>ENV["RAILS_MASTER_KEY"]</code></td>
+	<td><code>ENV["RAILS_#{RAILS_ENV}_KEY"]</code></td>
+</tr>
 
-`ENV["RAILS_MASTER_KEY"]`
 
-</td></tr><tr><td>
+<tr>
+	<td><code>config/credentials/staging.yml.enc</code></td>
+	<td><code>ENV["RAILS_MASTER_KEY"]</code></td>
+	<td><code>ENV["RAILS_STAGING_KEY"]</code></td>
+</tr>
 
-`config/credentials/staging.yml.enc` (only if running on staging)
+</tbody></table>
 
-</td><td>
-
-`ENV["RAILS_STAGING_KEY"]`
-
-</td><td>
-
-`ENV["RAILS_MASTER_KEY"]`
+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.
 
-</td></tr></tbody></table>
+#### TLDR:
 
-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.
+1. Set `RAILS_MASTER_KEY` to the key for your specific environment
+2. Set `RAILS_STAGING_KEY` to the key for your staging credentials (if deploying to staging AND you have staging-specific credentials)
+3. Set `RAILS_ROOT_KEY` to the key for your root credentials (if you have anything in `config/credentials.yml.enc`)
 
 ## License
 

data/lib/ravioli.rb

@@ -7,28 +7,36 @@ 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
+# The root namespace for all of Ravioli, and owner of two handly
+# configuration-related class methods
 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
+    # Forwards arguments to a {Ravioli::Builder}. See
+    # {Ravioli::Builder#new} for complete documentation.
+    #
+    # @param namespace [String, Module, Class] the name of, or a direct reference to, the module or class your Configuration class should namespace itself within
+    # @param class_name [String] the name of the namespace's Configuration class
+    # @param strict [boolean] whether or not the Builder instance should throw errors when there are errors loading configuration files or encrypted credentials
+    def build(namespace: nil, class_name: "Configuration", strict: false, &block)
+      builder = Builder.new(
+        class_name: class_name,
+        hijack: true,
+        namespace: namespace,
+        strict: strict,
+      )
+      yield builder if block
+      builder.build!
     end
 
+    # Returns a list of all of the configuration instances
     def configurations
       @configurations ||= []
     end
+
+    # Returns the most-recently configured Ravioli instance that has been built with {Ravioli::build}.
+    def default
+      configurations.last
+    end
   end
 end
 

data/lib/ravioli/builder.rb

@@ -1,18 +1,60 @@
 # frozen_string_literal: true
 
 require "active_support/all"
+require "erb"
 require_relative "configuration"
 
 module Ravioli
-  # The Builder clas provides a simple interface for building a Ravioli configuration. It has
+  # The Builder class 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).
+  #
+  # == ENV variables and encrypted credentials keys
+  #
+  # <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>
   class Builder
-    def initialize(class_name: "Configuration", namespace: nil, strict: false)
+    def initialize(class_name: "Configuration", hijack: false, namespace: nil, strict: false)
       configuration_class = if namespace.present?
         namespace.class_eval <<-EOC, __FILE__, __LINE__ + 1
+          # class Configuration < Ravioli::Configuration; end
           class #{class_name.to_s.classify} < Ravioli::Configuration; end
         EOC
         namespace.const_get(class_name)
@@ -21,49 +63,81 @@ module Ravioli
       end
       @strict = !!strict
       @configuration = configuration_class.new
+      @reload_credentials = Set.new
+      @reload_paths = Set.new
+      @hijack = !!hijack
+
+      if @hijack
+        # Put this builder on the configurations stack - it will intercept setters on the underyling
+        # configuration object as it loads files, and mark those files as needing a reload once
+        # loading is complete
+        Ravioli.configurations.push(self)
+      end
     end
 
-    # Automatically infer a `staging?` status
+    # Automatically infer a `staging` status from the current environment
+    #
+    # @param is_staging [boolean, #present?] whether or not the current environment is considered a staging environment
     def add_staging_flag!(is_staging = Rails.env.production? && ENV["STAGING"].present?)
+      is_staging = is_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!
+    # Iterates through the config directory (including nested folders) and
+    # calls {Ravioli::Builder::load_file} on each JSON or YAML file it
+    # finds. Ignores `config/locales`.
+    def auto_load_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?)
+        auto_load_file(config_file)
       end
     end
 
-    # Load config/credentials**/*.yml.enc files (assuming we can find a key)
+    # Loads Rails encrypted credentials that it can. Checks for corresponding private key files, or ENV vars based on the {Ravioli::Builder credentials preadmlogic}
     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")
+      # Load the root config (supports using the master key or `RAILS_ROOT_KEY`)
+      load_credentials(
+        key_path: "config/master.key",
+        env_names: %w[master root],
+      )
+
+      # Load any environment-specific configuration on top of it. Since Rails will try
+      # `RAILS_MASTER_KEY` from the environment, we assume the same
+      load_credentials(
+        "config/credentials/#{Rails.env}",
+        key_path: "config/credentials/#{Rails.env}.key",
+        env_names: ["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?
+      if configuration.staging?
+        load_credentials(
+          "config/credentials/staging",
+          env_names: %w[staging master],
+          key_path: "config/credentials/staging.key",
+        )
+      end
     end
 
     # When the builder is done working, lock the configuration and return it
     def build!
+      if @hijack
+        # Replace this builder with the underlying configuration on the configurations stack...
+        Ravioli.configurations.delete(self)
+        Ravioli.configurations.push(configuration)
+
+        # ...and then reload any config file that referenced the configuration the first time it was
+        # loaded!
+        @reload_paths.each do |path|
+          auto_load_file(path)
+        end
+      end
+
       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 = {})
+    # Load a file either with a given path or by name (e.g. `config/whatever.yml` or `:whatever`)
+    def load_file(path, options = {})
       config = parse_config_file(path, options)
       configuration.append(config) if config.present?
     rescue => error
@@ -71,11 +145,30 @@ module Ravioli
     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
+    def load_credentials(path = "credentials", key_path: path, env_names: path.split("/").last)
+      error = nil
+      env_names = Array(env_names).map { |env_name| parse_env_name(env_name) }
+      env_names.each do |env_name|
+        credentials = parse_credentials(path, env_name: env_name, key_path: key_path)
+        if credentials.present?
+          configuration.append(credentials)
+          return credentials
+        end
+      rescue => e
+        error = e
+      end
+
+      if error
+        attempted_names = ["key file `#{key_path}'"]
+        attempted_names.push(*env_names.map { |env_name| "`ENV[\"#{env_name}\"]'" })
+        attempted_names = attempted_names.to_sentence(two_words_connector: " or ", last_word_connector: ", or ")
+        warn(
+          "Could not decrypt `#{path}.yml.enc' with #{attempted_names}",
+          error,
+          critical: false,
+        )
+      end
+
       {}
     end
 
@@ -86,6 +179,13 @@ module Ravioli
 
     attr_reader :configuration
 
+    def auto_load_file(config_file)
+      basename = File.basename(config_file, File.extname(config_file))
+      dirname = File.dirname(config_file)
+      key = %w[app application].exclude?(basename) && dirname != config_dir
+      load_file(config_file, key: key)
+    end
+
     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.
@@ -105,12 +205,23 @@ module Ravioli
     # rubocop:disable Style/MethodMissingSuper
     # rubocop:disable Style/MissingRespondToMissing
     def method_missing(*args, &block)
+      if @current_path
+        @reload_paths.add(@current_path)
+      end
+
+      if @current_credentials
+        @reload_credentials.add(@current_credentials)
+      end
+
       configuration.send(*args, &block)
     end
     # rubocop:enable Style/MissingRespondToMissing
     # rubocop:enable Style/MethodMissingSuper
 
     def parse_config_file(path, options = {})
+      # Stash a reference to the file we're parsing, so we can reload it later if it tries to use
+      # the configuration object
+      @current_path = path
       path = path_to_config_file_path(path)
 
       config = case path.extname.downcase
@@ -119,9 +230,11 @@ module Ravioli
       when ".yml", ".yaml"
         parse_yaml_config_file(path)
       else
-        raise ParseError.new("#{Ravioli::NAME} doesn't know how to parse #{path}")
+        raise ParseError.new("Ravioli doesn't know how to parse #{path}")
       end
 
+      # We are no longer loading anything
+      @current_path = nil
       # At least expect a hash to be returned from the loaded config file
       return {} unless config.is_a?(Hash)
 
@@ -144,16 +257,22 @@ module Ravioli
       {name => config}
     end
 
-    def parse_credentials(path, key_path: path, env_name: path.split("/").last)
+    def parse_env_name(env_name)
       env_name = env_name.to_s
-      env_name = "RAILS_#{env_name.upcase}_KEY" unless env_name.upcase == env_name
+      env_name.match?(/^RAILS_/) ? env_name : "RAILS_#{env_name.upcase}_KEY"
+    end
+
+    def parse_credentials(path, key_path: path, env_name: path.split("/").last)
+      @current_credentials = path
+      env_name = parse_env_name(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)
+      options = {key_path: key_path.to_s}
+      options[:env_key] = ENV[env_name].present? ? env_name : "__RAVIOLI__#{SecureRandom.hex(6)}"
 
       path = path_to_config_file_path(path, extnames: "yml.enc")
-      credentials = Rails.application.encrypted(path, options)&.config || {}
-      credentials
+      (Rails.application.encrypted(path, **options)&.config || {}).tap do
+        @current_credentials = nil
+      end
     end
 
     def parse_json_config_file(path)
@@ -162,10 +281,9 @@ module Ravioli
     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)
+      YAML.safe_load(erb.result, [Symbol], aliases: true)
     end
 
     def path_to_config_file_path(path, extnames: EXTNAMES, quiet: false)
@@ -192,18 +310,19 @@ module Ravioli
       path
     end
 
-    def warn(message, error = $!)
-      message = "[#{Ravioli::NAME}] #{message}"
+    def warn(message, error = $!, critical: true)
+      message = "[Ravioli] #{message}"
       message = "#{message}:\n\n#{error.cause.inspect}" if error&.cause.present?
-      if @strict
+      if @strict && critical
         raise BuildError.new(message, error)
       else
-        Rails.logger.warn(message) if defined? Rails
+        Rails.logger.try(:warn, message) if defined? Rails
         $stderr.write message # rubocop:disable Rails/Output
       end
     end
   end
 
+  # Error raised when Ravioli is in strict mode. Includes the original error for context.
   class BuildError < StandardError
     def initialize(message, cause = nil)
       super message
@@ -214,5 +333,7 @@ module Ravioli
       @cause || super
     end
   end
+
+  # Error raised when Ravioli encounters a problem parsing a file
   class ParseError < StandardError; end
 end

data/lib/ravioli/configuration.rb

@@ -5,20 +5,17 @@ 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
-
+    # Convert a hash to accessors and nested {Ravioli::Configuration} instances.
+    #
+    # @param [Hash, #each] key-value pairs to be converted to accessors
     def append(attributes = {})
+      return unless attributes.respond_to?(:each)
       attributes.each do |key, value|
         self[key.to_sym] = cast(key.to_sym, value)
       end
@@ -40,6 +37,10 @@ module Ravioli
       fetch(*keys) { raise KeyMissingError.new("Could not find value at key path #{keys.inspect}") }
     end
 
+    def delete(key)
+      table.delete(key.to_s)
+    end
+
     def fetch(*keys)
       dig(*keys) || yield
     end
@@ -54,6 +55,8 @@ module Ravioli
 
     private
 
+    attr_reader :key_path
+
     def build(keys, attributes = {})
       attributes[:key_path] = key_path_for(keys)
       child = self.class.new(attributes)

data/lib/ravioli/engine.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "./staging_inquirer"
+Rails.env.class.prepend Ravioli::StagingInquirer
+
 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)
+    initializer "ravioli", before: :load_environment_config do |app|
+      Rails.extend Ravioli::RailsConfig unless Rails.respond_to?(:config)
     end
   end
 
-  module Config
+  private
+
+  module RailsConfig
     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_files!
         config.auto_load_credentials!
       end
     end

data/lib/ravioli/staging_inquirer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ravioli
+  # A module that we mix in to the `Rails.env` inquirer class to add some extra staging-related
+  # metadata
+  module StagingInquirer
+    # Add a `name` method to `Rails.env` that will return "staging" for staging environments, and
+    # otherwise the string's value
+    def name
+      staging? ? "staging" : to_s
+    end
+
+    # Add a `strict:` keyword to reduce `Rails.env.production && !Rails.env.staging` calls
+    def production?(strict: false)
+      is_production = super()
+      return is_production unless strict && is_production
+
+      is_production && !staging?
+    end
+
+    # Override staging inquiries to check against the current configuration
+    def staging?
+      Rails.try(:config)&.staging?
+    end
+  end
+end

data/lib/ravioli/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ravioli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Flip Sasser
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-23 00:00:00.000000000 Z
+date: 2021-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,6 +30,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: guard
+  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: guard-rspec
+  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: guard-rubocop
+  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: pry
   requirement: !ruby/object:Gem::Requirement
@@ -90,16 +132,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rubocop-ordered_methods
   requirement: !ruby/object:Gem::Requirement
@@ -118,44 +160,44 @@ dependencies:
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rubocop-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.2
+        version: 2.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.2
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.39'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.39'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -190,14 +232,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -229,6 +271,7 @@ files:
 - lib/ravioli/builder.rb
 - lib/ravioli/configuration.rb
 - lib/ravioli/engine.rb
+- lib/ravioli/staging_inquirer.rb
 - lib/ravioli/version.rb
 homepage: https://github.com/flipsasser/ravioli
 licenses:
@@ -236,7 +279,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/flipsasser/ravioli
   source_code_uri: https://github.com/flipsasser/ravioli
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -244,15 +287,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Grab a fork and twist all your configuration spaghetti into a single, delicious
   bundle