runger_config 2.6.0

data/lib/anyway/ext/deep_freeze.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Ext
+    # Add #deep_freeze to hashes and arrays
+    module 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
+  end
+end

data/lib/anyway/ext/flatten_names.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Ext
+    # Convert Hash with mixed array and hash values to an
+    # array of paths.
+    module 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
+  end
+end

data/lib/anyway/ext/hash.rb

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

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

data/lib/anyway/loaders/doppler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+require "json"
+
+module Anyway
+  using RubyNext
+
+  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

@@ -0,0 +1,89 @@
+# 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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Anyway
+  using RubyNext
+
+  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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "anyway/ext/hash"
+
+using RubyNext
+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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Anyway
+  using RubyNext
+
+  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

@@ -0,0 +1,29 @@
+# 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/optparse_config.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "anyway/option_parser_builder"
+
+require "anyway/ext/deep_dup"
+
+module Anyway
+  using Anyway::Ext::DeepDup
+
+  # Adds ability to use script options as the source
+  # of configuration (via optparse)
+  module OptparseConfig
+    module ClassMethods
+      def ignore_options(*args)
+        args.each do |name|
+          option_parser_descriptors[name.to_s][:ignore] = true
+        end
+      end
+
+      def describe_options(**hargs)
+        hargs.each do |name, desc|
+          if String === desc
+            option_parser_descriptors[name.to_s][:desc] = desc
+          else
+            option_parser_descriptors[name.to_s].merge!(desc)
+          end
+        end
+      end
+
+      def flag_options(*args)
+        args.each do |name|
+          option_parser_descriptors[name.to_s][:flag] = true
+        end
+      end
+
+      def extend_options(&block)
+        option_parser_extensions << block
+      end
+
+      def option_parser_options
+        config_attributes.each_with_object({}) do |key, result|
+          descriptor = option_parser_descriptors[key.to_s]
+          next if descriptor[:ignore] == true
+
+          result[key] = descriptor
+        end
+      end
+
+      def option_parser_extensions
+        return @option_parser_extensions if instance_variable_defined?(:@option_parser_extensions)
+
+        @option_parser_extensions =
+          if superclass < Anyway::Config
+            superclass.option_parser_extensions.dup
+          else
+            []
+          end
+      end
+
+      def option_parser_descriptors
+        return @option_parser_descriptors if instance_variable_defined?(:@option_parser_descriptors)
+
+        @option_parser_descriptors =
+          if superclass < Anyway::Config
+            superclass.option_parser_descriptors.deep_dup
+          else
+            Hash.new { |h, k| h[k] = {} }
+          end
+      end
+    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)
+        end
+      end
+    end
+
+    def parse_options!(options)
+      Tracing.with_trace_source(type: :options) do
+        option_parser.parse!(options)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/anyway/rails/autoload.rb

@@ -0,0 +1,42 @@
+# 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
+    using RubyNext
+
+    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

@@ -0,0 +1,23 @@
+# 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