runger_config 3.0.1 → 5.0.0

data/lib/anyway/rails/settings.rb

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

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

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

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

@@ -1,188 +0,0 @@
-# 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, **)
-        key = path.pop
-        trace = if val.is_a?(Hash)
-          Trace.new.tap { _1.merge_values(val, **) }
-        else
-          Trace.new(:value, val, **)
-        end
-
-        target_trace = path.empty? ? self : value.dig(*path)
-        target_trace.record_key(key.to_s, trace)
-
-        val
-      end
-
-      def merge_values(hash, **)
-        return hash unless hash
-
-        hash.each do |key, val|
-          if val.is_a?(Hash)
-            value[key.to_s].merge_values(val, **)
-          else
-            value[key.to_s] = Trace.new(:value, val, **)
-          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, **)
-      return yield unless Tracing.tracing?
-      val = yield
-      if val.is_a?(Hash)
-        Tracing.current_trace.merge_values(val, type:, **)
-      elsif !path.empty?
-        Tracing.current_trace.record_value(val, *path, type:, **)
-      end
-      val
-    end
-  end
-end

data/lib/anyway/utils/which.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway
-  module Utils
-    # Cross-platform solution
-    # taken from https://stackoverflow.com/a/5471032
-    def self.which(cmd)
-      exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
-      ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
-        exts.each do |ext|
-          exe = File.join(path, "#{cmd}#{ext}")
-          return exe if File.executable?(exe) && !File.directory?(exe)
-        end
-      end
-      nil
-    end
-  end
-end

data/lib/anyway/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Anyway # :nodoc:
-  VERSION = "3.0.1"
-end

data/lib/anyway_config.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "anyway/version"
-
-require "anyway/ext/deep_dup"
-require "anyway/ext/deep_freeze"
-require "anyway/ext/hash"
-require "anyway/ext/flatten_names"
-
-require "anyway/utils/deep_merge"
-require "anyway/utils/which"
-
-require "anyway/settings"
-require "anyway/tracing"
-require "anyway/config"
-require "anyway/auto_cast"
-require "anyway/type_casting"
-require "anyway/env"
-require "anyway/loaders"
-require "anyway/rbs"
-
-module Anyway # :nodoc:
-  class << self
-    def env
-      @env ||= ::Anyway::Env.new
-    end
-
-    def loaders
-      @loaders ||= ::Anyway::Loaders::Registry.new
-    end
-  end
-
-  # Configure default loaders
-  loaders.append :yml, Loaders::YAML
-  loaders.append :ejson, Loaders::EJSON if Utils.which("ejson")
-  loaders.append :env, Loaders::Env
-
-  if ENV.key?("DOPPLER_TOKEN") && ENV["ANYWAY_CONFIG_DISABLE_DOPPLER"] != "true"
-    loaders.append :doppler, Loaders::Doppler
-  end
-end
-
-if defined?(::Rails::VERSION)
-  require "anyway/rails"
-else
-  require "anyway/rails/autoload"
-end
-
-require "anyway/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"

data/lib/generators/anyway/app_config/app_config_generator.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "generators/anyway/config/config_generator"
-
-module Anyway
-  module Generators
-    class AppConfigGenerator < ConfigGenerator
-      source_root ConfigGenerator.source_root
-
-      private
-
-      def config_root
-        "app/configs"
-      end
-    end
-  end
-end

data/lib/generators/anyway/config/config_generator.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module Anyway
-  module Generators
-    class ConfigGenerator < ::Rails::Generators::NamedBase
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :yml, type: :boolean
-      class_option :app, type: :boolean, default: false
-      argument :parameters, type: :array, default: [], banner: "param1 param2"
-
-      # check_class_collision suffix: "Config"
-
-      def run_install_if_needed
-        return if ::Rails.root.join(static_config_root, "application_config.rb").exist?
-        generate "anyway:install"
-      end
-
-      def create_config
-        template "config.rb", File.join(config_root, class_path, "#{file_name}_config.rb")
-      end
-
-      def create_yml
-        create_yml = options.fetch(:yml) { yes?("Would you like to generate a #{file_name}.yml file?") }
-        return unless create_yml
-        template "config.yml", File.join("config", "#{file_name}.yml")
-      end
-
-      private
-
-      def static_config_root
-        Anyway::Settings.autoload_static_config_path || Anyway::DEFAULT_CONFIGS_PATH
-      end
-
-      def config_root
-        if options[:app]
-          "app/configs"
-        else
-          static_config_root
-        end
-      end
-    end
-  end
-end

data/lib/generators/anyway/install/install_generator.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module Anyway
-  module Generators
-    class InstallGenerator < ::Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :configs_path, type: :string
-
-      def copy_application_config
-        template "application_config.rb", File.join(static_config_root, "application_config.rb")
-      end
-
-      def add_local_files_to_gitignore
-        if File.exist?(File.join(destination_root, ".gitignore"))
-          append_to_file ".gitignore", "\n/config/*.local.yml\n/config/credentials/local.*\n"
-        end
-      end
-
-      # rubocop:disable Layout/HeredocIndentation
-      def add_setup_autoload_to_config
-        maybe_comment_indented = default_configs_path? ? "    # " : "    "
-        inject_into_file "config/application.rb", after: %r{< Rails::Application\n} do
-          <<-RUBY
-    # Configure the path for configuration classes that should be used before initialization
-    # NOTE: path should be relative to the project root (Rails.root)
-#{maybe_comment_indented}config.anyway_config.autoload_static_config_path = "#{static_config_root}"
-#{maybe_comment_indented.sub(/\s+$/, "")}
-          RUBY
-        end
-      end
-      # rubocop:enable Layout/HeredocIndentation
-
-      private
-
-      def static_config_root
-        options[:configs_path] || Anyway::Settings.autoload_static_config_path || Anyway::DEFAULT_CONFIGS_PATH
-      end
-
-      def default_configs_path?
-        static_config_root == (Anyway::Settings.autoload_static_config_path || Anyway::DEFAULT_CONFIGS_PATH)
-      end
-    end
-  end
-end