runger_config 3.0.1 → 5.0.0

data/lib/runger/ext/deep_freeze.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Add #deep_freeze to hashes and arrays
+module Runger::Ext::DeepFreeze
+  refine ::Hash do
+    def deep_freeze
+      freeze
+      each_value do |value|
+        value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
+      end
+    end
+  end
+
+  refine ::Array do
+    def deep_freeze
+      freeze
+      each do |value|
+        value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
+      end
+    end
+  end
+
+  begin
+    require 'active_support/core_ext/hash/indifferent_access'
+  rescue LoadError
+  end
+
+  if defined?(::ActiveSupport::HashWithIndifferentAccess)
+    refine ::ActiveSupport::HashWithIndifferentAccess do
+      def deep_freeze
+        freeze
+        each_value do |value|
+          value.deep_freeze if value.is_a?(::Hash) || value.is_a?(::Array)
+        end
+      end
+    end
+  end
+
+  using self
+end

data/lib/runger/ext/flatten_names.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Convert Hash with mixed array and hash values to an
+# array of paths.
+module Runger::Ext::FlattenNames
+  refine ::Array do
+    def flatten_names(prefix, buf)
+      if empty?
+        buf << :"#{prefix}"
+        return buf
+      end
+
+      each_with_object(buf) do |name, acc|
+        if name.is_a?(::Symbol)
+          acc << :"#{prefix}.#{name}"
+        else
+          name.flatten_names(prefix, acc)
+        end
+      end
+    end
+  end
+
+  refine ::Hash do
+    def flatten_names(prefix = nil, buf = [])
+      each_with_object(buf) do |(k, v), acc|
+        parent = prefix ? "#{prefix}.#{k}" : k
+        v.flatten_names(parent, acc)
+      end
+    end
+  end
+
+  using self
+end

data/lib/runger/ext/hash.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Extend Hash through refinements
+module Runger::Ext::Hash
+  refine ::Hash do
+    def stringify_keys!
+      keys.each do |key|
+        value = delete(key)
+        self[key.to_s] = value
+      end
+
+      self
+    end
+
+    def bury(val, *path)
+      raise(ArgumentError, 'No path specified') if path.empty?
+      raise(ArgumentError, 'Path cannot contain nil') if path.compact.size != path.size
+
+      last_key = path.pop
+      hash =
+        path.reduce(self) do |hash, k|
+          hash[k] = {} unless hash.key?(k) && hash[k].is_a?(::Hash)
+          hash[k]
+        end
+
+      hash[last_key] = val
+    end
+
+    def deep_transform_keys(&block)
+      each_with_object({}) do |(key, value), result|
+        result[yield(key)] = value.is_a?(::Hash) ? value.deep_transform_keys(&block) : value
+      end
+    end
+  end
+
+  using self
+end

data/lib/runger/ext/string_constantize.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Add simple safe_constantize method to String
+module Runger::Ext::StringConstantize
+  refine String do
+    def safe_constantize
+      names = split('::')
+
+      return nil if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        break if constant.nil?
+
+        constant.const_get(name, false) if constant.const_defined?(name, false)
+      end
+    end
+  end
+end

data/lib/runger/loaders/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Runger::Loaders::Base
+  include ::Runger::Tracing
+
+  class << self
+    def call(local: Runger::Settings.use_local_files, **options)
+      new(local:).call(**options)
+    end
+  end
+
+  def initialize(local:)
+    @local = local
+  end
+
+  def use_local? = @local == true
+end

data/lib/runger/loaders/doppler.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+class Runger::Loaders::Doppler < Runger::Loaders::Base
+  class RequestError < StandardError; end
+
+  class << self
+    attr_accessor :download_url
+    attr_writer :token
+
+    def token
+      @token || ENV.fetch('DOPPLER_TOKEN', nil)
+    end
+  end
+
+  self.download_url = 'https://api.doppler.com/v3/configs/config/secrets/download'
+
+  def call(env_prefix:, **_options)
+    env_payload = parse_doppler_response(url: Runger::Loaders::Doppler.download_url, token: Runger::Loaders::Doppler.token)
+
+    env = ::Runger::Env.new(type_cast: ::Runger::NoCast, env_container: env_payload)
+
+    env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+      ::Runger::Tracing.current_trace&.merge!(trace)
+      conf
+    end
+  end
+
+  private
+
+  def parse_doppler_response(url:, token:)
+    response = fetch_doppler_config(url, token)
+
+    unless response.is_a?(Net::HTTPSuccess)
+      raise(RequestError, "#{response.code} #{response.message}")
+    end
+
+    JSON.parse(response.read_body)
+  end
+
+  def fetch_doppler_config(url, token)
+    uri = URI.parse(url)
+    raise('Doppler token is required to load configuration from Doppler') if token.nil?
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == 'https'
+
+    request = Net::HTTP::Get.new(uri)
+    request['Accept'] = 'application/json'
+    request['Authorization'] = "Bearer #{token}"
+
+    http.request(request)
+  end
+end

data/lib/runger/loaders/ejson.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'runger/ejson_parser'
+
+class Runger::Loaders::EJSON < Runger::Loaders::Base
+  class << self
+    attr_accessor :bin_path
+  end
+
+  self.bin_path = 'ejson'
+
+  def call(
+    name:,
+    ejson_namespace: name,
+    ejson_parser: Runger::EJSONParser.new(Runger::Loaders::EJSON.bin_path),
+    **_options
+  )
+    configs = []
+
+    rel_config_paths.each do |rel_config_path|
+      secrets_hash, rel_path =
+        extract_hash_from_rel_config_path(
+          ejson_parser:,
+          rel_config_path:,
+        )
+
+      next unless secrets_hash
+
+      config_hash =
+        if ejson_namespace
+          secrets_hash[ejson_namespace]
+        else
+          secrets_hash.except('_public_key')
+        end
+
+      next unless config_hash.is_a?(Hash)
+
+      configs <<
+        trace!(:ejson, path: rel_path) do
+          config_hash
+        end
+    end
+
+    return {} if configs.empty?
+
+    configs.inject do |result_config, next_config|
+      ::Runger::Utils.deep_merge!(result_config, next_config)
+    end
+  end
+
+  private
+
+  def rel_config_paths
+    chain = [environmental_rel_config_path]
+
+    chain << 'secrets.local.ejson' if use_local?
+
+    chain
+  end
+
+  def environmental_rel_config_path
+    if ::Runger::Settings.current_environment
+      # if environment file is absent, then take data from the default one
+      [
+        "#{::Runger::Settings.current_environment}/secrets.ejson",
+        default_rel_config_path,
+      ]
+    else
+      default_rel_config_path
+    end
+  end
+
+  def default_rel_config_path
+    'secrets.ejson'
+  end
+
+  def extract_hash_from_rel_config_path(ejson_parser:, rel_config_path:)
+    rel_config_path = Array(rel_config_path)
+
+    rel_config_path.each do |rel_conf_path|
+      rel_path = "config/#{rel_conf_path}"
+      abs_path = "#{::Runger::Settings.app_root}/#{rel_path}"
+
+      result = ejson_parser.call(abs_path)
+
+      return [result, rel_path] if result
+    end
+
+    nil
+  end
+end

data/lib/runger/loaders/env.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Runger::Loaders::Env < Runger::Loaders::Base
+  def call(env_prefix:, **_options)
+    env = ::Runger::Env.new(type_cast: ::Runger::NoCast)
+
+    env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+      ::Runger::Tracing.current_trace&.merge!(trace)
+      conf
+    end
+  end
+end

data/lib/runger/loaders/yaml.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'runger/ext/hash'
+
+using Runger::Ext::Hash
+
+class Runger::Loaders::YAML < Runger::Loaders::Base
+  def call(config_path:, **_options)
+    rel_config_path = relative_config_path(config_path).to_s
+    base_config =
+      trace!(:yml, path: rel_config_path) do
+        config = load_base_yml(config_path)
+        environmental?(config) ? config_with_env(config) : config
+      end
+
+    return base_config unless use_local?
+
+    local_path = local_config_path(config_path)
+    local_config =
+      trace!(:yml, path: relative_config_path(local_path).to_s) {
+        load_local_yml(local_path)
+      }
+    ::Runger::Utils.deep_merge!(base_config, local_config)
+  end
+
+  private
+
+  def environmental?(parsed_yml)
+    # strange, but still possible
+    return true if ::Runger::Settings.default_environmental_key? && parsed_yml.key?(::Runger::Settings.default_environmental_key)
+    # possible
+    return true if !::Runger::Settings.future.unwrap_known_environments && ::Runger::Settings.current_environment
+    # for other environments
+    return true if ::Runger::Settings.known_environments&.any? { parsed_yml.key?(_1) }
+
+    # preferred
+    parsed_yml.key?(::Runger::Settings.current_environment)
+  end
+
+  def config_with_env(config)
+    env_config = config[::Runger::Settings.current_environment] || {}
+    return env_config unless ::Runger::Settings.default_environmental_key?
+
+    default_config = config[::Runger::Settings.default_environmental_key] || {}
+    ::Runger::Utils.deep_merge!(default_config, env_config)
+  end
+
+  def parse_yml(path)
+    return {} unless File.file?(path)
+
+    require 'yaml' unless defined?(::YAML)
+
+    # By default, YAML load will return `false` when the yaml document is
+    # empty. When this occurs, we return an empty hash instead, to match
+    # the interface when no config file is present.
+    begin
+      if defined?(ERB)
+        ::YAML.load(ERB.new(File.read(path)).result, aliases: true) || {}
+      else
+        ::YAML.load_file(path, aliases: true) || {}
+      end
+    rescue ArgumentError
+      if defined?(ERB)
+        ::YAML.load(ERB.new(File.read(path)).result) || {}
+      else
+        ::YAML.load_file(path) || {}
+      end
+    end
+  end
+
+  alias load_base_yml parse_yml
+  alias load_local_yml parse_yml
+
+  def local_config_path(path)
+    path.sub('.yml', '.local.yml')
+  end
+
+  def relative_config_path(path)
+    Pathname.new(path).then do |path|
+      return path if path.relative?
+
+      path.relative_path_from(::Runger::Settings.app_root)
+    end
+  end
+end

data/lib/runger/loaders.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class Runger::Loaders::Registry
+  attr_reader :registry
+
+  def initialize
+    @registry = []
+  end
+
+  def prepend(id, handler = nil, &block)
+    handler ||= block
+    insert_at(0, id, handler)
+  end
+
+  def append(id, handler = nil, &block)
+    handler ||= block
+    insert_at(registry.size, id, handler)
+  end
+
+  def insert_before(another_id, id, handler = nil, &block)
+    ind = registry.find_index { |(hid, _)| hid == another_id }
+    raise(ArgumentError, "Loader with ID #{another_id} hasn't been registered") if ind.nil?
+
+    handler ||= block
+    insert_at(ind, id, handler)
+  end
+
+  def insert_after(another_id, id, handler = nil, &block)
+    ind = registry.find_index { |(hid, _)| hid == another_id }
+    raise(ArgumentError, "Loader with ID #{another_id} hasn't been registered") if ind.nil?
+
+    handler ||= block
+    insert_at(ind + 1, id, handler)
+  end
+
+  def override(id, handler)
+    find(id).then do |id_to_handler|
+      raise(ArgumentError, "Loader with ID #{id} hasn't been registered") if id_to_handler.nil?
+
+      id_to_handler[1] = handler
+    end
+  end
+
+  def delete(id)
+    find(id).then do |id_to_handler|
+      raise(ArgumentError, "Loader with ID #{id} hasn't been registered") if id_to_handler.nil?
+
+      registry.delete(id_to_handler)
+    end
+  end
+
+  def each(&block)
+    registry.each(&block)
+  end
+
+  def freeze = registry.freeze
+
+  private
+
+  def insert_at(index, id, handler)
+    raise(ArgumentError, "Loader with ID #{id} has been already registered") unless find(id).nil?
+
+    registry.insert(index, [id, handler])
+  end
+
+  def find(id)
+    registry.find { |(hid, _)| hid == id }
+  end
+end
+
+require 'runger/loaders/base'
+require 'runger/loaders/doppler'
+require 'runger/loaders/ejson'
+require 'runger/loaders/env'
+require 'runger/loaders/yaml'

data/lib/runger/option_parser_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+# Initializes the OptionParser instance using the given configuration
+class Runger::OptionParserBuilder
+  class << self
+    def call(options)
+      OptionParser.new do |opts|
+        options.each do |key, descriptor|
+          opts.on(*option_parser_on_args(key, **descriptor)) do |val|
+            yield([key, val])
+          end
+        end
+      end
+    end
+
+    private
+
+    def option_parser_on_args(key, flag: false, desc: nil, type: ::String)
+      on_args = ["--#{key.to_s.tr('_', '-')}#{flag ? '' : ' VALUE'}"]
+      on_args << type unless flag
+      on_args << desc unless desc.nil?
+      on_args
+    end
+  end
+end

data/lib/{anyway → runger}/optparse_config.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "anyway/option_parser_builder"
+require 'runger/option_parser_builder'
 
-require "anyway/ext/deep_dup"
+require 'runger/ext/deep_dup'
 
-module Anyway
-  using Anyway::Ext::DeepDup
+module Runger
+  using Runger::Ext::DeepDup
 
   # Adds ability to use script options as the source
   # of configuration (via optparse)
@@ -19,7 +19,7 @@ module Anyway
 
       def describe_options(**hargs)
         hargs.each do |name, desc|
-          if String === desc
+          if desc.is_a?(String)
             option_parser_descriptors[name.to_s][:desc] = desc
           else
             option_parser_descriptors[name.to_s].merge!(desc)
@@ -50,7 +50,7 @@ module Anyway
         return @option_parser_extensions if instance_variable_defined?(:@option_parser_extensions)
 
         @option_parser_extensions =
-          if superclass < Anyway::Config
+          if superclass < Runger::Config
             superclass.option_parser_extensions.dup
           else
             []
@@ -61,7 +61,7 @@ module Anyway
         return @option_parser_descriptors if instance_variable_defined?(:@option_parser_descriptors)
 
         @option_parser_descriptors =
-          if superclass < Anyway::Config
+          if superclass < Runger::Config
             superclass.option_parser_descriptors.deep_dup
           else
             Hash.new { |h, k| h[k] = {} }
@@ -70,13 +70,14 @@ module Anyway
     end
 
     def option_parser
-      @option_parser ||= OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
-                           write_config_attr(key, val)
-                         end.tap do |parser|
-        self.class.option_parser_extensions.map do |extension|
-          extension.call(parser, self)
+      @option_parser ||=
+        OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
+          write_config_attr(key, val)
+        end.tap do |parser|
+          self.class.option_parser_extensions.map do |extension|
+            extension.call(parser, self)
+          end
         end
-      end
     end
 
     def parse_options!(options)
@@ -86,7 +87,7 @@ module Anyway
     end
 
     def self.included(base)
-      base.extend ClassMethods
+      base.extend(ClassMethods)
     end
   end
 end

data/lib/runger/rails/autoload.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# This module is used to detect a Rails application and activate the corresponding plugins
+# when Runger Config is loaded before Rails (e.g., in config/puma.rb).
+module Runger::Rails
+  class << self
+    attr_reader :tracer, :name_method
+    attr_accessor :disable_postponed_load_warning
+
+    private
+
+    def tracepoint_class_callback(event)
+      # Ignore singletons
+      return if event.self.singleton_class?
+
+      # We wait till `rails/application/configuration.rb` has been loaded, since we rely on it
+      # See https://github.com/palkan/runger_config/issues/134
+      return unless name_method.bind_call(event.self) == 'Rails::Application::Configuration'
+
+      tracer.disable
+
+      unless disable_postponed_load_warning
+        warn("Runger Config was loaded before Rails. Activating Runger Config Rails plugins now.\n" \
+             'NOTE: Already loaded configs were provisioned without Rails-specific sources.')
+      end
+
+      require 'runger/rails'
+    end
+  end
+
+  # TruffleRuby doesn't support TracePoint's end event
+  unless defined?(::TruffleRuby)
+    @tracer = TracePoint.new(:end, &method(:tracepoint_class_callback))
+    @tracer.enable
+    # Use `Module#name` instead of `self.name` to handle overwritten `name` method
+    @name_method = Module.instance_method(:name)
+  end
+end

data/lib/runger/rails/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Runger::Rails::Config ; end
+
+# Enhance config to be more Railsy-like:
+# – accept hashes with indeferent access
+# - load data from secrets
+# - recognize Rails env when loading from YML
+module Runger::Rails::Config::ClassMethods
+  # Make defaults to be a Hash with indifferent access
+  def new_empty_config
+    {}.with_indifferent_access
+  end
+end
+
+Runger::Config.prepend(Runger::Rails::Config)
+Runger::Config.singleton_class.prepend(Runger::Rails::Config::ClassMethods)

data/lib/runger/rails/loaders/credentials.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Runger::Rails::Loaders ; end
+
+class Runger::Rails::Loaders::Credentials < Runger::Loaders::Base
+  LOCAL_CONTENT_PATH = 'config/credentials/local.yml.enc'
+
+  def call(name:, **_options)
+    return {} unless ::Rails.application.respond_to?(:credentials)
+
+    # do not load from credentials if we're in the context
+    # of the `credentials:edit` command
+    return {} if defined?(::Rails::Command::CredentialsCommand)
+
+    # Create a new hash cause credentials are mutable!
+    config = {}
+
+    trace!(
+      :credentials,
+      store: credentials_path,
+    ) do
+      ::Rails.application.credentials.config[name.to_sym]
+    end.then do |creds|
+      Runger::Utils.deep_merge!(config, creds) if creds
+    end
+
+    if use_local?
+      trace!(:credentials, store: LOCAL_CONTENT_PATH) do
+        local_credentials(name)
+      end.then { |creds| Runger::Utils.deep_merge!(config, creds) if creds }
+    end
+
+    config
+  end
+
+  private
+
+  def local_credentials(name)
+    local_creds_path = ::Rails.root.join(LOCAL_CONTENT_PATH).to_s
+
+    return unless File.file?(local_creds_path)
+
+    creds = ::Rails.application.encrypted(
+      local_creds_path,
+      key_path: ::Rails.root.join('config/credentials/local.key'),
+    )
+
+    creds.config[name.to_sym]
+  end
+
+  def credentials_path
+    if ::Rails.application.config.respond_to?(:credentials)
+      ::Rails.root.join(::Rails.application.config.credentials.content_path).relative_path_from(::Rails.root).to_s
+    else
+      'config/credentials.yml.enc'
+    end
+  end
+end