runger_config 3.0.1 → 5.0.0

data/lib/anyway/ext/hash.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Ext
-    # Extend Hash through refinements
-    module 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
-  end
-end

data/lib/anyway/ext/string_constantize.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Ext
-    # Add simple safe_constantize method to String
-    module 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
-  end
-end

data/lib/anyway/loaders/base.rb

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

data/lib/anyway/loaders/doppler.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-require "net/http"
-require "json"
-
-module Anyway
-  module Loaders
-    class Doppler < Base
-      class RequestError < StandardError; end
-
-      class << self
-        attr_accessor :download_url
-        attr_writer :token
-
-        def token
-          @token || ENV["DOPPLER_TOKEN"]
-        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: Doppler.download_url, token: Doppler.token)
-
-        env = ::Anyway::Env.new(type_cast: ::Anyway::NoCast, env_container: env_payload)
-
-        env.fetch_with_trace(env_prefix).then do |(conf, trace)|
-          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
-  end
-end

data/lib/anyway/loaders/ejson.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "anyway/ejson_parser"
-
-module Anyway
-  module Loaders
-    class EJSON < Base
-      class << self
-        attr_accessor :bin_path
-      end
-
-      self.bin_path = "ejson"
-
-      def call(name:, ejson_namespace: name, ejson_parser: Anyway::EJSONParser.new(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: ejson_parser,
-              rel_config_path: 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|
-          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 Settings.current_environment
-          # if environment file is absent, then take data from the default one
-          [
-            "#{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 = [rel_config_path] unless rel_config_path.is_a?(Array)
-
-        rel_config_path.each do |rel_conf_path|
-          rel_path = "config/#{rel_conf_path}"
-          abs_path = "#{Settings.app_root}/#{rel_path}"
-
-          result = ejson_parser.call(abs_path)
-
-          return [result, rel_path] if result
-        end
-
-        nil
-      end
-    end
-  end
-end

data/lib/anyway/loaders/env.rb

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

data/lib/anyway/loaders/yaml.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require "anyway/ext/hash"
-
-using Anyway::Ext::Hash
-
-module Anyway
-  module Loaders
-    class YAML < 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) }
-        Utils.deep_merge!(base_config, local_config)
-      end
-
-      private
-
-      def environmental?(parsed_yml)
-        # strange, but still possible
-        return true if Settings.default_environmental_key? && parsed_yml.key?(Settings.default_environmental_key)
-        # possible
-        return true if !Settings.future.unwrap_known_environments && Settings.current_environment
-        # for other environments
-        return true if Settings.known_environments&.any? { parsed_yml.key?(_1) }
-        # preferred
-        parsed_yml.key?(Settings.current_environment)
-      end
-
-      def config_with_env(config)
-        env_config = config[Settings.current_environment] || {}
-        return env_config unless Settings.default_environmental_key?
-
-        default_config = config[Settings.default_environmental_key] || {}
-        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_method :load_base_yml, :parse_yml
-      alias_method :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(Settings.app_root)
-        end
-      end
-    end
-  end
-end

data/lib/anyway/loaders.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Loaders
-    class 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
-  end
-end
-
-require "anyway/loaders/base"
-require "anyway/loaders/yaml"
-require "anyway/loaders/env"
-require "anyway/loaders/doppler"
-require "anyway/loaders/ejson"

data/lib/anyway/option_parser_builder.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-module Anyway # :nodoc:
-  # Initializes the OptionParser instance using the given configuration
-  class 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
-end

data/lib/anyway/rails/autoload.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# This module is used to detect a Rails application and activate the corresponding plugins
-# when Anyway Config is loaded before Rails (e.g., in config/puma.rb).
-module Anyway
-  module 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/anyway_config/issues/134
-        return unless name_method.bind_call(event.self) == "Rails::Application::Configuration"
-
-        tracer.disable
-
-        unless disable_postponed_load_warning
-          warn "Anyway Config was loaded before Rails. Activating Anyway Config Rails plugins now.\n" \
-                "NOTE: Already loaded configs were provisioned without Rails-specific sources."
-        end
-
-        require "anyway/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
-end

data/lib/anyway/rails/config.rb

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

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Rails
-    module Loaders
-      class Credentials < Anyway::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|
-            Utils.deep_merge!(config, creds) if creds
-          end
-
-          if use_local?
-            trace!(:credentials, store: LOCAL_CONTENT_PATH) do
-              local_credentials(name)
-            end.then { |creds| 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
-    end
-  end
-end

data/lib/anyway/rails/loaders/secrets.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Rails
-    module Loaders
-      class Secrets < Anyway::Loaders::Base
-        def call(name:, **_options)
-          return {} unless ::Rails.application.respond_to?(:secrets)
-
-          # Create a new hash cause secrets are mutable!
-          config = {}
-
-          trace!(:secrets) do
-            secrets.public_send(name)
-          end.then do |secrets|
-            Utils.deep_merge!(config, secrets) if secrets
-          end
-
-          config
-        end
-
-        private
-
-        def secrets
-          @secrets ||= ::Rails.application.secrets.tap do |_|
-            # Reset secrets state if the app hasn't been initialized
-            # See https://github.com/palkan/anyway_config/issues/14
-            next if ::Rails.application.initialized?
-            ::Rails.application.remove_instance_variable(:@secrets)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/anyway/rails/loaders/yaml.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Rails
-    module Loaders
-      class YAML < Anyway::Loaders::YAML; end
-    end
-  end
-end

data/lib/anyway/rails/loaders.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "anyway/rails/loaders/yaml"
-require "anyway/rails/loaders/secrets"
-require "anyway/rails/loaders/credentials"