runger_config 2.6.0

data/lib/anyway/type_casting.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Anyway
+  # Contains a mapping between type IDs/names and deserializers
+  class TypeRegistry
+    class << self
+      def default
+        @default ||= TypeRegistry.new
+      end
+    end
+
+    def initialize
+      @registry = {}
+    end
+
+    def accept(name_or_object, &block)
+      if !block && !name_or_object.respond_to?(:call)
+        raise ArgumentError, "Please, provide a type casting block or an object implementing #call(val) method"
+      end
+
+      registry[name_or_object] = block || name_or_object
+    end
+
+    def deserialize(raw, type_id, array: false)
+      return if raw.nil?
+
+      caster =
+        if type_id.is_a?(Symbol) || type_id.nil?
+          registry.fetch(type_id) { raise ArgumentError, "Unknown type: #{type_id}" }
+        else
+          raise ArgumentError, "Type must implement #call(val): #{type_id}" unless type_id.respond_to?(:call)
+          type_id
+        end
+
+      if array
+        raw_arr = raw.is_a?(String) ? raw.split(/\s*,\s*/) : Array(raw)
+        raw_arr.map { caster.call(_1) }
+      else
+        caster.call(raw)
+      end
+    end
+
+    def dup
+      new_obj = self.class.allocate
+      new_obj.instance_variable_set(:@registry, registry.dup)
+      new_obj
+    end
+
+    private
+
+    attr_reader :registry
+  end
+
+  TypeRegistry.default.tap do |obj|
+    obj.accept(nil, &:itself)
+    obj.accept(:string, &:to_s)
+    obj.accept(:integer, &:to_i)
+    obj.accept(:float, &:to_f)
+
+    obj.accept(:date) do
+      require "date" unless defined?(::Date)
+
+      next _1 if _1.is_a?(::Date)
+
+      next _1.to_date if _1.respond_to?(:to_date)
+
+      ::Date.parse(_1)
+    end
+
+    obj.accept(:datetime) do
+      require "date" unless defined?(::Date)
+
+      next _1 if _1.is_a?(::DateTime)
+
+      next _1.to_datetime if _1.respond_to?(:to_datetime)
+
+      ::DateTime.parse(_1)
+    end
+
+    obj.accept(:uri) do
+      require "uri" unless defined?(::URI)
+
+      next _1 if _1.is_a?(::URI)
+
+      ::URI.parse(_1)
+    end
+
+    obj.accept(:boolean) do
+      _1.to_s.match?(/\A(true|t|yes|y|1)\z/i)
+    end
+  end
+
+  unless "".respond_to?(:safe_constantize)
+    require "anyway/ext/string_constantize"
+    using Anyway::Ext::StringConstantize
+  end
+
+  # TypeCaster is an object responsible for type-casting.
+  # It uses a provided types registry and mapping, and also
+  # accepts a fallback typecaster.
+  class TypeCaster
+    using Ext::DeepDup
+    using Ext::Hash
+
+    def initialize(mapping, registry: TypeRegistry.default, fallback: ::Anyway::AutoCast)
+      @mapping = mapping.deep_dup
+      @registry = registry
+      @fallback = fallback
+    end
+
+    def coerce(key, val, config: mapping)
+      caster_config = config[key.to_sym]
+
+      return fallback.coerce(key, val) unless caster_config
+
+      case caster_config
+      in Hash[array:, type:, **nil]
+        registry.deserialize(val, type, array: array)
+      in Hash[config: subconfig]
+        subconfig = subconfig.safe_constantize if subconfig.is_a?(::String)
+        raise ArgumentError, "Config is not found: #{subconfig}" unless subconfig
+
+        subconfig.new(val)
+      in Hash
+        return val unless val.is_a?(Hash)
+
+        caster_config.each do |k, v|
+          ks = k.to_s
+          next unless val.key?(ks)
+
+          val[ks] = coerce(k, val[ks], config: caster_config)
+        end
+
+        val
+      else
+        registry.deserialize(val, caster_config)
+      end
+    end
+
+    private
+
+    attr_reader :mapping, :registry, :fallback
+  end
+end

data/lib/anyway/utils/deep_merge.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anyway
+  using Anyway::Ext::DeepDup
+
+  module Utils
+    def self.deep_merge!(source, other)
+      other.each do |key, other_value|
+        this_value = source[key]
+
+        if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
+          deep_merge!(this_value, other_value)
+        else
+          source[key] = other_value.deep_dup
+        end
+      end
+
+      source
+    end
+  end
+end

data/lib/anyway/utils/which.rb

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

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

data/lib/anyway.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "anyway_config"

data/lib/anyway_config.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "ruby-next"
+
+require "ruby-next/language/setup"
+RubyNext::Language.setup_gem_load_path(transpile: 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/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generates a config class with the given name and list of parameters
+    and put it into `app/configs` folder.
+
+Example:
+    rails generate app_config my_service param1 param2 ...
+
+    This will create:
+        app/configs/my_service_config.rb

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

@@ -0,0 +1,17 @@
+# 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/USAGE

@@ -0,0 +1,13 @@
+Description:
+    Generates a config class with the given name and list of parameters.
+
+    Use `--yml` / `--no-yml` option to specify whether you want to create a YAML config as well
+    (if no option is specified, the generator would ask you to choose during the run).
+
+    Use `--app` option to create config class in `app/configs` folder.
+
+Example:
+    rails generate config my_service param1 param2 ...
+
+    This will create:
+        config/configs/my_service_config.rb

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

@@ -0,0 +1,51 @@
+# 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
+
+      def needs_config_name?
+        raise "No longer needed" if Gem::Version.new(Anyway::VERSION) >= Gem::Version.new("3.0.0")
+        file_name.include?("_")
+      end
+    end
+  end
+end

data/lib/generators/anyway/config/templates/config.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Config < ApplicationConfig
+<%- if needs_config_name? %>
+  config_name :<%= file_name %>
+<%- end -%>
+<%- unless parameters.empty? -%>
+  attr_config <%= parameters.map { |param| ":#{param}" }.join(", ") %>
+<%- end -%>
+end
+<% end -%>

data/lib/generators/anyway/config/templates/config.yml.tt

@@ -0,0 +1,13 @@
+default: &default
+<%- parameters.each do |param| -%>
+#  <%= param %>: ""
+<%- end -%>
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default

data/lib/generators/anyway/install/USAGE

@@ -0,0 +1,4 @@
+Description:
+    Generates a base config class (ApplicationConfig) for your application and
+    add the required configuriton (.gitignore, config/application.rb).
+

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

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

data/lib/generators/anyway/install/templates/application_config.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Base class for application config classes
+class ApplicationConfig < Anyway::Config
+  class << self
+    # Make it possible to access a singleton config instance
+    # via class methods (i.e., without explicitly calling `instance`)
+    delegate_missing_to :instance
+
+    private
+
+    # Returns a singleton config instance
+    def instance
+      @instance ||= new
+    end
+  end
+end

data/sig/anyway_config.rbs

@@ -0,0 +1,149 @@
+module Anyway
+  def self.env: -> Env
+  def self.loaders: -> Loaders::Registry
+
+  class Settings
+    def self.default_config_path=: (String | Pathname | ^(untyped) -> String val) -> void
+    def self.future: -> Future
+    def self.current_environment: -> String?
+    def self.default_environmental_key: -> String?
+    def self.known_environments: -> Array[String]?
+
+    class Future
+      def self.setting: (untyped name, untyped default_value) -> untyped
+      def self.settings: -> Hash[untyped, untyped]
+      def use: (*untyped names) -> untyped
+    end
+  end
+
+  module Tracing
+    class Trace
+      def merge!: (Trace another_trace) -> void
+    end
+
+    def inspect: -> String
+    def self.capture: ?{ -> Hash[untyped, untyped]? } -> Trace
+    def self.trace_stack: -> Array[untyped]
+    def self.current_trace: -> Trace?
+    def self.source_stack: -> Array[untyped]
+    def self.current_trace_source: -> ({type: Symbol} & Hash[Symbol, untyped])
+    def self.with_trace_source: (untyped src) { -> void } -> untyped
+    def trace!: [V] (Symbol, *String paths, **untyped) ?{ -> V} -> V
+    def self.trace!: [V] (Symbol, *String paths, **untyped) ?{ -> V} -> V
+  end
+
+  module RBSGenerator
+    def to_rbs: -> String
+  end
+
+  module OptparseConfig
+    def option_parser: -> OptionParser
+    def parse_options!: (Array[String]) -> void
+
+    module ClassMethods
+      def ignore_options: (*Symbol args) -> void
+      def describe_options: (**(String | {desc: String, type: Module})) -> void
+      def flag_options: (*Symbol args) -> void
+      def extend_options: { (OptionParser, Config) -> void } -> void
+    end
+  end
+
+  module DynamicConfig
+    module ClassMethods
+      def for: (String | Symbol name, ?auto_cast: bool, **untyped) -> Hash[untyped, untyped]
+    end
+  end
+
+  type valueType = Symbol | nil
+  type arrayType = {array: bool, type: valueType}
+  type configType = {config: Class | String}
+  type hashType = Hash[Symbol, valueType | arrayType | hashType]
+
+  type mappingType = valueType | arrayType | hashType | configType
+  type envType = String | Symbol | Array[String | Symbol] | {except: String | Symbol | Array[String | Symbol]}
+
+  type requiredType = Array[Symbol | Hash[Symbol, requiredType]]
+
+  class Config
+    extend RBSGenerator
+    extend DynamicConfig::ClassMethods
+    extend OptparseConfig::ClassMethods
+    include DynamicConfig
+    include OptparseConfig
+
+    def self.attr_config: (*Symbol args, **untyped) -> void
+    def self.defaults: -> Hash[String, untyped]
+    def self.config_attributes: -> Array[Symbol]?
+    def self.required: (*Symbol names, ?env: envType, **requiredType) -> void
+    def self.required_attributes: -> Array[Symbol]
+    def self.on_load: (*Symbol callbacks) ?{ () [self: instance] -> void } -> void
+    def self.config_name: (?(Symbol | String) val) -> String?
+    def self.env_prefix: (?(Symbol | String) val) -> String
+    def self.coerce_types: (**mappingType) -> void
+    def self.coercion_mapping: -> Hash[untyped, untyped]?
+    def self.disable_auto_cast!: -> void
+
+    attr_reader config_name: String
+    attr_reader env_prefix: String
+
+    def initialize: (?Hash[Symbol | String, untyped] overrides) -> void
+                  | (NilClass) -> void
+    def reload: (?Hash[Symbol | String, untyped] overrides) -> Config
+    def clear: -> void
+    def load: (Hash[Symbol | String, untyped] overrides) -> Config
+            | (NilClass) -> Config
+    def dig: (*(Symbol | String) keys) -> untyped
+    def to_h: -> Hash[untyped, untyped]
+    def dup: -> Config
+    def deconstruct_keys: (untyped keys) -> Hash[untyped, untyped]
+    def to_source_trace: -> Hash[String, untyped]
+    def inspect: -> String
+    def pretty_print: (untyped q) -> untyped
+    def as_env: -> Hash[String, String]
+
+    private
+    attr_reader values: Hash[untyped, untyped]
+    def raise_validation_error: (String msg) -> void
+    def flatten_hash: (Hash[untyped, untyped], String, Hash[String, String]) -> Hash[String, String]
+
+    class Error < StandardError
+    end
+
+    class ValidationError < Error
+    end
+  end
+
+  class Env
+    def clear: -> void
+    def fetch: (String prefix) -> untyped
+    def fetch_with_trace: (String prefix) -> [untyped, Tracing::Trace?]
+  end
+
+  module Loaders
+    class Base
+      include Tracing
+
+      def self.call: (?local: bool, **untyped) -> untyped
+      def initialize: (local: bool) -> void
+      def use_local?: -> bool
+    end
+
+    interface _Loader
+      def call: (**untyped) -> Hash[untyped, untyped]
+    end
+
+    class Registry
+      def prepend: (Symbol id, _Loader loader) -> void
+                 | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def append: (Symbol id, _Loader loader) -> void
+                | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def insert_before: (Symbol another_id, Symbol id, _Loader loader) -> void
+                       | (Symbol another_id, Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def insert_after: (Symbol another_id, Symbol id, _Loader loader) -> void
+                      | (Symbol another_id, Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def override: (Symbol id, _Loader loader) -> void
+                  | (Symbol id) { (**untyped) -> Hash[untyped, untyped] } -> void
+      def delete: (Symbol id) -> void
+    end
+  end
+end

data/sig/manifest.yml

@@ -0,0 +1,6 @@
+dependencies:
+  - name: optparse
+  - name: json
+  - name: pathname
+  - name: date
+  - name: time