runger_config 2.6.0

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

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

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

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

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

data/lib/anyway/rails/settings.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Try to require zeitwerk
+begin
+  require "zeitwerk"
+  require "active_support/dependencies/zeitwerk_integration"
+rescue LoadError
+end
+
+module Anyway
+  class Settings
+    class << self
+      attr_reader :autoload_static_config_path, :autoloader
+      attr_writer :autoload_via_zeitwerk
+
+      def autoload_static_config_path=(val)
+        if autoload_via_zeitwerk
+          raise "Cannot setup autoloader after application has been initialized" if ::Rails.application.initialized?
+
+          return unless ::Rails.root.join(val).exist?
+
+          return if val == autoload_static_config_path
+
+          autoloader&.unload
+
+          @autoload_static_config_path = val
+
+          # See Rails 6 https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+          # and Rails 7 https://github.com/rails/rails/blob/5462fbd5de1900c1b1ce1c9dc11c1a2d8cdcd809/railties/lib/rails/autoloaders.rb#L15
+          @autoloader = Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = "anyway.config"
+
+            if defined?(ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector)
+              loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+            elsif defined?(::Rails::Autoloaders::Inflector)
+              loader.inflector = ::Rails::Autoloaders::Inflector
+            end
+            loader.push_dir(::Rails.root.join(val))
+            loader.setup
+          end
+        else
+          if autoload_static_config_path
+            old_path = ::Rails.root.join(autoload_static_config_path).to_s
+            ActiveSupport::Dependencies.autoload_paths.delete(old_path)
+            ::Rails.application.config.eager_load_paths.delete(old_path)
+          end
+
+          @autoload_static_config_path = val
+          new_path = ::Rails.root.join(val).to_s
+          ActiveSupport::Dependencies.autoload_paths << new_path
+          ::Rails.application.config.eager_load_paths << new_path
+        end
+      end
+
+      def cleanup_autoload_paths
+        return unless autoload_via_zeitwerk
+
+        return unless autoload_static_config_path
+        ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
+      end
+
+      def autoload_via_zeitwerk
+        return @autoload_via_zeitwerk if instance_variable_defined?(:@autoload_via_zeitwerk)
+
+        @autoload_via_zeitwerk = defined?(::Zeitwerk)
+      end
+
+      def current_environment
+        @current_environment || ::Rails.env.to_s
+      end
+
+      def app_root
+        ::Rails.root
+      end
+    end
+
+    self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }
+    self.known_environments = %w[test development production]
+    self.use_local_files ||= ::Rails.env.development?
+    # Don't try read defaults when no key defined
+    self.default_environmental_key = nil
+  end
+end

data/lib/anyway/rails.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Rails
+  end
+end
+
+require "anyway/rails/settings"
+require "anyway/rails/config"
+require "anyway/rails/loaders"
+
+# Configure Rails loaders
+Anyway.loaders.override :yml, Anyway::Rails::Loaders::YAML
+
+if Rails::VERSION::MAJOR >= 7 && Rails::VERSION::MINOR >= 1
+  Anyway.loaders.insert_after :yml, :credentials, Anyway::Rails::Loaders::Credentials
+else
+  Anyway.loaders.insert_after :yml, :secrets, Anyway::Rails::Loaders::Secrets
+  Anyway.loaders.insert_after :secrets, :credentials, Anyway::Rails::Loaders::Credentials
+end
+
+# Load Railties after configuring loaders.
+# The application could be already initialized, and that would make `Anyway.loaders` frozen
+require "anyway/railtie"

data/lib/anyway/railtie.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Anyway # :nodoc:
+  DEFAULT_CONFIGS_PATH = "config/configs"
+
+  class Railtie < ::Rails::Railtie # :nodoc:
+    # Add settings to Rails config
+    config.anyway_config = Anyway::Settings
+
+    config.before_configuration do
+      next if ::Rails.application.initialized?
+      config.anyway_config.autoload_static_config_path = DEFAULT_CONFIGS_PATH
+    end
+
+    config.before_eager_load do
+      Anyway::Settings.autoloader&.eager_load
+    end
+
+    # Remove `autoload_static_config_path` from Rails `autoload_paths`
+    # since we use our own autoloading mechanism
+    initializer "anyway_config.cleanup_autoload" do
+      Anyway::Settings.cleanup_autoload_paths
+    end
+
+    # Make sure loaders are not changed in runtime
+    config.after_initialize { Anyway.loaders.freeze }
+  end
+end

data/lib/anyway/rbs.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Anyway
+  module RBSGenerator
+    TYPE_TO_CLASS = {
+      string: "String",
+      integer: "Integer",
+      float: "Float",
+      date: "Date",
+      datetime: "DateTime",
+      uri: "URI",
+      boolean: "bool"
+    }.freeze
+
+    # Generate RBS signature from a config class
+    def to_rbs
+      *namespace, class_name = name.split("::")
+
+      buf = []
+      indent = 0
+      interface_name = "_Config"
+
+      if namespace.empty?
+        interface_name = "_#{class_name}"
+      else
+        buf << "module #{namespace.join("::")}"
+        indent += 1
+      end
+
+      # Using interface emulates a module we include to provide getters and setters
+      # (thus making `super` possible)
+      buf << "#{"  " * indent}interface #{interface_name}"
+      indent += 1
+
+      # Generating setters and getters for config attributes
+      config_attributes.each do |param|
+        type = coercion_mapping[param] || defaults[param.to_s]
+
+        type =
+          case type
+          in NilClass
+            "untyped"
+          in Symbol
+            TYPE_TO_CLASS.fetch(type) { defaults[param] ? "Symbol" : "untyped" }
+          in Array
+            "Array[untyped]"
+          in array: _, type:, **nil
+            "Array[#{TYPE_TO_CLASS.fetch(type, "untyped")}]"
+          in Hash
+            "Hash[string,untyped]"
+          in TrueClass | FalseClass
+            "bool"
+          else
+            type.class.to_s
+          end
+
+        getter_type = type
+        getter_type = "#{type}?" unless required_attributes.include?(param)
+
+        buf << "#{"  " * indent}def #{param}: () -> #{getter_type}"
+        buf << "#{"  " * indent}def #{param}=: (#{type}) -> void"
+
+        if type == "bool" || type == "bool?"
+          buf << "#{"  " * indent}def #{param}?: () -> #{getter_type}"
+        end
+      end
+
+      indent -= 1
+      buf << "#{"  " * indent}end"
+
+      buf << ""
+
+      buf << "#{"  " * indent}class #{class_name} < #{superclass.name}"
+      indent += 1
+
+      buf << "#{"  " * indent}include #{interface_name}"
+
+      indent -= 1
+      buf << "#{"  " * indent}end"
+
+      unless namespace.empty?
+        buf << "end"
+      end
+
+      buf << ""
+
+      buf.join("\n")
+    end
+  end
+
+  Config.extend RBSGenerator
+end

data/lib/anyway/settings.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Anyway
+  # Use Settings name to not confuse with Config.
+  #
+  # Settings contain the library-wide configuration.
+  class Settings
+    # Future encapsulates settings that will be introduced in the upcoming version
+    # with the default values, which could break compatibility
+    class Future
+      class << self
+        def setting(name, default_value)
+          settings[name] = default_value
+
+          define_method(name) do
+            store[name]
+          end
+
+          define_method(:"#{name}=") do |val|
+            store[name] = val
+          end
+        end
+
+        def settings
+          @settings ||= {}
+        end
+      end
+
+      def initialize
+        @store = {}
+      end
+
+      def use(*names)
+        store.clear
+        names.each { store[_1] = self.class.settings[_1] }
+      end
+
+      setting :unwrap_known_environments, true
+
+      private
+
+      attr_reader :store
+    end
+
+    class << self
+      # Define whether to load data from
+      # *.yml.local (or credentials/local.yml.enc)
+      attr_accessor :use_local_files,
+        :current_environment,
+        :default_environmental_key,
+        :known_environments
+
+      # A proc returning a path to YML config file given the config name
+      attr_reader :default_config_path
+
+      def default_config_path=(val)
+        if val.is_a?(Proc)
+          @default_config_path = val
+          return
+        end
+
+        val = val.to_s
+
+        @default_config_path = ->(name) { File.join(val, "#{name}.yml") }
+      end
+
+      # Enable source tracing
+      attr_accessor :tracing_enabled
+
+      def future
+        @future ||= Future.new
+      end
+
+      def app_root
+        Pathname.new(Dir.pwd)
+      end
+
+      def default_environmental_key?
+        !default_environmental_key.nil?
+      end
+
+      def matching_env?(env)
+        return true if env.nil? || env.to_s == current_environment
+
+        if env.is_a?(::Hash)
+          envs = env[:except]
+          excluded_envs = [envs].flat_map(&:to_s)
+          excluded_envs.none?(current_environment)
+        elsif env.is_a?(::Array)
+          env.flat_map(&:to_s).include?(current_environment)
+        else
+          false
+        end
+      end
+    end
+
+    # By default, use ANYWAY_ENV
+    self.current_environment = ENV["ANYWAY_ENV"]
+
+    # By default, use local files only in development (that's the purpose if the local files)
+    self.use_local_files = (ENV["ANYWAY_ENV"] == "development" || ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development" || (defined?(Rails) && Rails.env.development?))
+
+    # By default, consider configs are stored in the ./config folder
+    self.default_config_path = ->(name) { "./config/#{name}.yml" }
+
+    # Tracing is enabled by default
+    self.tracing_enabled = true
+  end
+end

data/lib/anyway/testing/helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Testing
+    module Helpers
+      # Sets the ENV variables to the provided
+      # values and restore outside the block
+      #
+      # Also resets Anyway.env before and after calling the block
+      # to make sure that the values are not cached.
+      #
+      # NOTE: to remove the env value, pass `nil` as the value
+      def with_env(data)
+        was_values = []
+
+        data.each do |key, val|
+          was_values << [key, ENV[key]]
+          next ENV.delete(key) if val.nil?
+          ENV[key] = val
+        end
+
+        # clear cached env values
+        Anyway.env.clear
+        yield
+      ensure
+        was_values.each do |(key, val)|
+          next ENV.delete(key) if val.nil?
+          ENV[key] = val
+        end
+
+        # clear cache again
+        Anyway.env.clear
+      end
+    end
+  end
+end

data/lib/anyway/testing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "anyway/testing/helpers"
+
+if defined?(RSpec::Core) && RSpec.respond_to?(:configure)
+  RSpec.configure do |config|
+    config.include(
+      Anyway::Testing::Helpers,
+      type: :config,
+      file_path: %r{spec/configs}
+    )
+  end
+end

data/lib/anyway/tracing.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Provides method to trace values association
+  module Tracing
+    using Anyway::Ext::DeepDup
+
+    using(Module.new do
+      refine Thread::Backtrace::Location do
+        def path_lineno() = "#{path}:#{lineno}"
+      end
+    end)
+
+    class Trace
+      UNDEF = Object.new
+
+      attr_reader :type, :value, :source
+
+      def initialize(type = :trace, value = UNDEF, **source)
+        @type = type
+        @source = source
+        @value = (value == UNDEF) ? Hash.new { |h, k| h[k] = Trace.new(:trace) } : value
+      end
+
+      def dig(...)
+        value.dig(...)
+      end
+
+      def record_value(val, *path, **opts)
+        key = path.pop
+        trace = if val.is_a?(Hash)
+          Trace.new.tap { _1.merge_values(val, **opts) }
+        else
+          Trace.new(:value, val, **opts)
+        end
+
+        target_trace = path.empty? ? self : value.dig(*path)
+        target_trace.record_key(key.to_s, trace)
+
+        val
+      end
+
+      def merge_values(hash, **opts)
+        return hash unless hash
+
+        hash.each do |key, val|
+          if val.is_a?(Hash)
+            value[key.to_s].merge_values(val, **opts)
+          else
+            value[key.to_s] = Trace.new(:value, val, **opts)
+          end
+        end
+
+        hash
+      end
+
+      def record_key(key, key_trace)
+        @value = Hash.new { |h, k| h[k] = Trace.new(:trace) } unless value.is_a?(::Hash)
+
+        value[key] = key_trace
+      end
+
+      def merge!(another_trace)
+        raise ArgumentError, "You can only merge into a :trace type, and this is :#{type}" unless trace?
+        raise ArgumentError, "You can only merge a :trace type, but trying :#{type}" unless another_trace.trace?
+
+        another_trace.value.each do |key, sub_trace|
+          if sub_trace.trace?
+            value[key].merge! sub_trace
+          else
+            value[key] = sub_trace
+          end
+        end
+      end
+
+      def keep_if(...)
+        raise ArgumentError, "You can only filter :trace type, and this is :#{type}" unless trace?
+        value.keep_if(...)
+      end
+
+      def clear() = value.clear
+
+      def trace?() = type == :trace
+
+      def to_h
+        if trace?
+          value.transform_values(&:to_h).tap { _1.default_proc = nil }
+        else
+          {value:, source:}
+        end
+      end
+
+      def dup() = self.class.new(type, value.dup, **source)
+
+      def pretty_print(q)
+        if trace?
+          q.nest(2) do
+            q.breakable ""
+            q.seplist(value, nil, :each) do |k, v|
+              q.group do
+                q.text k
+                q.text " =>"
+                if v.trace?
+                  q.text " { "
+                  q.pp v
+                  q.breakable " "
+                  q.text "}"
+                else
+                  q.breakable " "
+                  q.pp v
+                end
+              end
+            end
+          end
+        else
+          q.pp value
+          q.group(0, " (", ")") do
+            q.seplist(source, lambda { q.breakable " " }, :each) do |k, v|
+              q.group do
+                q.text k.to_s
+                q.text "="
+                q.text v.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      def capture
+        unless Settings.tracing_enabled
+          yield
+          return
+        end
+
+        trace = Trace.new
+        trace_stack.push trace
+        yield
+        trace_stack.last
+      ensure
+        trace_stack.pop
+      end
+
+      def trace_stack
+        (Thread.current[:__anyway__trace_stack__] ||= [])
+      end
+
+      def current_trace() = trace_stack.last
+
+      alias_method :tracing?, :current_trace
+
+      def source_stack
+        (Thread.current[:__anyway__trace_source_stack__] ||= [])
+      end
+
+      def current_trace_source
+        source_stack.last || accessor_source(caller_locations(2, 1).first)
+      end
+
+      def with_trace_source(src)
+        source_stack << src
+        yield
+      ensure
+        source_stack.pop
+      end
+
+      private
+
+      def accessor_source(location)
+        {type: :accessor, called_from: location.path_lineno}
+      end
+    end
+
+    module_function
+
+    def trace!(type, *path, **opts)
+      return yield unless Tracing.tracing?
+      val = yield
+      if val.is_a?(Hash)
+        Tracing.current_trace.merge_values(val, type:, **opts)
+      elsif !path.empty?
+        Tracing.current_trace.record_value(val, *path, type:, **opts)
+      end
+      val
+    end
+  end
+end