anyway_config 2.0.0.pre2 → 2.0.0.rc1

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/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.public_send(name)
+          end.then do |creds|
+            config.deep_merge!(creds) if creds
+          end
+
+          if use_local?
+            trace!(:credentials, store: LOCAL_CONTENT_PATH) do
+              local_credentials(name)
+            end.then { |creds| config.deep_merge!(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.public_send(name)
+        end
+
+        def credentials_path
+          if ::Rails.application.config.respond_to?(:credentials)
+            ::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,39 @@
+# 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|
+            config.deep_merge!(secrets) if secrets
+          end
+
+          config
+        end
+
+        private
+
+        def secrets
+          @secrets ||= begin
+            ::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
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Rails
+    module Loaders
+      class YAML < Anyway::Loaders::YAML
+        def parse_yml(*)
+          super[::Rails.env] || {}
+        end
+
+        private
+
+        def relative_config_path(path)
+          Pathname.new(path).relative_path_from(::Rails.root)
+        end
+      end
+    end
+  end
+end

data/lib/anyway/rails/settings.rb

@@ -0,0 +1,58 @@
+# 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
+
+      if defined?(::Zeitwerk)
+        attr_reader :autoloader
+
+        def autoload_static_config_path=(val)
+          raise "Cannot setup autoloader after application has been initialized" if ::Rails.application.initialized?
+
+          return unless ::Rails.root.join(val).exist?
+
+          autoloader&.unload
+
+          @autoload_static_config_path = val
+
+          # See https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+          @autoloader = Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = "anyway.config"
+            loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+            loader.push_dir(::Rails.root.join(val))
+            loader.setup
+          end
+        end
+
+        def cleanup_autoload_paths
+          return unless autoload_static_config_path
+          ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
+        end
+      else
+        def autoload_static_config_path=(val)
+          if autoload_static_config_path
+            ActiveSupport::Dependencies.autoload_paths.delete(::Rails.root.join(autoload_static_config_path).to_s)
+          end
+
+          @autoload_static_config_path = val
+          ActiveSupport::Dependencies.autoload_paths << ::Rails.root.join(val)
+        end
+
+        def cleanup_autoload_paths
+          :no_op
+        end
+      end
+    end
+
+    self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }
+  end
+end

data/lib/anyway/railtie.rb

@@ -1,11 +1,23 @@
 # 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
 
-    # Allow autoloading of app/configs in configuration files
-    ActiveSupport::Dependencies.autoload_paths << "app/configs"
+    ActiveSupport.on_load(:before_configuration) do
+      config.anyway_config.autoload_static_config_path = DEFAULT_CONFIGS_PATH
+    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/settings.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Use Settings name to not confuse with Config.
+  #
+  # Settings contain the library-wide configuration.
+  class Settings
+    class << self
+      # Define whether to load data from
+      # *.yml.local (or credentials/local.yml.enc)
+      attr_accessor :use_local_files
+
+      # Return a path to YML config file given the config name
+      attr_accessor :default_config_path
+
+      # Enable source tracing
+      attr_accessor :tracing_enabled
+    end
+
+    # By default, use local files only in development (that's the purpose if the local files)
+    self.use_local_files = (ENV["RACK_ENV"] == "development" || ENV["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/tracing.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Provides method to trace values association
+  module Tracing
+    using Anyway::Ext::DeepDup
+
+    using(Module.new do
+      refine Hash do
+        def inspect
+          "{#{map { |k, v| "#{k}: #{v.inspect}" }.join(", ")}}"
+        end
+      end
+
+      refine Thread::Backtrace::Location do
+        def path_lineno
+          "#{path}:#{lineno}"
+        end
+      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, key, **opts)
+        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.value[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 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
+      end
+
+      def trace?
+        type == :trace
+      end
+
+      def to_h
+        if trace?
+          value.transform_values(&:to_h).tap { _1.default_proc = nil }
+        else
+          {value: value, source: source}
+        end
+      end
+
+      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 " =>"
+                q.breakable " " unless v.trace?
+                q.pp v
+              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
+      end
+
+      alias 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?
+      source = {type: type}.merge(opts)
+      val = yield
+      if val.is_a?(Hash)
+        Tracing.current_trace.merge_values(val, **source)
+      else
+        Tracing.current_trace.record_value(yield, *path, **source)
+      end
+      val
+    end
+  end
+end

data/lib/anyway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anyway # :nodoc:
-  VERSION = "2.0.0.pre2"
+  VERSION = "2.0.0.rc1"
 end

data/lib/anyway_config.rb

@@ -1,32 +1,38 @@
 # frozen_string_literal: true
 
-module Anyway # :nodoc:
-  require "anyway/version"
-
-  require "anyway/config"
-  require "anyway/rails/config" if defined?(::Rails::VERSION)
-  require "anyway/env"
-
-  # Use Settings name to not confuse with Config.
-  #
-  # Settings contain the library-wide configuration.
-  class Settings
-    class << self
-      # Define whether to load data from
-      # *.yml.local (or credentials/local.yml.enc)
-      attr_accessor :use_local_files
-    end
+require "ruby-next"
 
-    # By default, use local files only in development (that's the purpose if the local files)
-    self.use_local_files = (ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development")
-  end
+require "ruby-next/language/setup"
+RubyNext::Language.setup_gem_load_path
+
+require "anyway/version"
+
+require "anyway/ext/deep_dup"
+require "anyway/ext/deep_freeze"
+require "anyway/ext/hash"
 
+require "anyway/settings"
+require "anyway/tracing"
+require "anyway/config"
+require "anyway/auto_cast"
+require "anyway/env"
+require "anyway/loaders"
+
+module Anyway # :nodoc:
   class << self
     def env
       @env ||= ::Anyway::Env.new
     end
+
+    def loaders
+      @loaders ||= ::Anyway::Loaders::Registry.new
+    end
   end
 
-  require "anyway/railtie" if defined?(::Rails::VERSION)
-  require "anyway/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"
+  # Configure default loaders
+  loaders.append :yml, Loaders::YAML
+  loaders.append :env, Loaders::Env
 end
+
+require "anyway/rails" if defined?(::Rails::VERSION)
+require "anyway/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"