anyway_config 2.0.5 → 2.2.1

data/lib/anyway/settings.rb

@@ -5,16 +5,66 @@ module Anyway
   #
   # 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
+
+      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
 
-      # Return a path to YML config file given the config name
-      attr_accessor :default_config_path
+      # 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
     end
 
     # By default, use local files only in development (that's the purpose if the local files)

data/lib/anyway/tracing.rb

@@ -32,12 +32,13 @@ module Anyway
         value.dig(...)
       end
 
-      def record_value(val, *path, key, **opts)
-        if val.is_a?(Hash)
+      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 => trace
+        end
 
         target_trace = path.empty? ? self : value.dig(*path)
         target_trace.value[key.to_s] = trace
@@ -85,11 +86,11 @@ module Anyway
         if trace?
           value.transform_values(&:to_h).tap { _1.default_proc = nil }
         else
-          {value: value, source: source}
+          {value, source}
         end
       end
 
-      def dup() = self.class.new(type, value.dup, source)
+      def dup() = self.class.new(type, value.dup, **source)
 
       def pretty_print(q)
         if trace?
@@ -140,7 +141,7 @@ module Anyway
 
       def current_trace() = trace_stack.last
 
-      alias tracing? current_trace
+      alias_method :tracing?, :current_trace
 
       def source_stack
         (Thread.current[:__anyway__trace_source_stack__] ||= [])
@@ -168,12 +169,11 @@ module Anyway
 
     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)
+        Tracing.current_trace.merge_values(val, type:, **opts)
       else
-        Tracing.current_trace.record_value(val, *path, **source)
+        Tracing.current_trace.record_value(val, *path, type:, **opts)
       end
       val
     end

data/lib/anyway/type_casting.rb

@@ -0,0 +1,134 @@
+# 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
+
+  # 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 array:, type:, **nil
+        registry.deserialize(val, type, array: array)
+      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/version.rb

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

data/lib/anyway_config.rb

@@ -11,12 +11,16 @@ require "anyway/ext/deep_dup"
 require "anyway/ext/deep_freeze"
 require "anyway/ext/hash"
 
+require "anyway/utils/deep_merge"
+
 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

data/sig/anyway_config.rbs

@@ -0,0 +1,129 @@
+module Anyway
+  def self.env: -> Env
+  def self.loaders: -> Loaders::Registry
+
+  class Settings
+    def self.default_config_path=: (^(untyped) -> String val) -> ^(untyped) -> String?
+    def self.future: -> Future
+
+    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] } -> nil
+    def self.trace_stack: -> Array[untyped]
+    def self.current_trace: -> Trace?
+    def self.source_stack: -> Array[untyped]
+    def self.current_trace_source: -> {type: :accessor, called_from: untyped}
+    def self.with_trace_source: (untyped src) -> untyped
+    def trace!: (Symbol, *Array[String] paths, **untyped) ?{ -> Hash[untyped, untyped]} -> Hash[untyped, untyped]
+    def self.trace!: (Symbol, *Array[String] paths, **untyped) ?{ -> Hash[untyped, untyped]} -> Hash[untyped, untyped]
+  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 hashType = Hash[Symbol, valueType | arrayType | hashType]
+
+  type mappingType = valueType | arrayType | hashType
+
+  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) -> void
+    def self.required_attributes: -> Array[Symbol]
+    def self.on_load: (*Symbol callbacks) ?{ () -> 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
+    def reload: (?Hash[Symbol | String, untyped] overrides) -> Config
+    def clear: -> void
+    def load: (Hash[Symbol | String, untyped] overrides) -> 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
+
+    private
+    attr_reader values: Hash[untyped, untyped]
+    def raise_validation_error: (String msg) -> void
+
+    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
+
+    class Registry
+      def prepend: (Symbol id, Base loader) -> void
+      def append: (Symbol id, Base loader) -> void
+      def insert_before: (Symbol another_id, Symbol id, Base loader) -> void
+      def insert_after: (Symbol another_id, Symbol id, Base loader) -> void
+      def override: (Symbol id, Base loader) -> void
+      def delete: (Symbol id) -> void
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anyway_config
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.2.1
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-15 00:00:00.000000000 Z
+date: 2021-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -70,14 +70,14 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
 - !ruby/object:Gem::Dependency
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "\n    Configuration DSL for Ruby libraries and applications.\n    Allows
   you to easily follow the twelve-factor application principles (https://12factor.net/config).\n
   \ "
@@ -106,14 +120,23 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/.rbnext/1995.next/anyway/config.rb
+- lib/.rbnext/1995.next/anyway/dynamic_config.rb
+- lib/.rbnext/1995.next/anyway/env.rb
+- lib/.rbnext/1995.next/anyway/loaders/base.rb
+- lib/.rbnext/1995.next/anyway/tracing.rb
 - lib/.rbnext/2.7/anyway/auto_cast.rb
 - lib/.rbnext/2.7/anyway/config.rb
-- lib/.rbnext/2.7/anyway/option_parser_builder.rb
+- lib/.rbnext/2.7/anyway/rails/loaders/yaml.rb
+- lib/.rbnext/2.7/anyway/rbs.rb
+- lib/.rbnext/2.7/anyway/settings.rb
 - lib/.rbnext/2.7/anyway/tracing.rb
-- lib/.rbnext/2.8/anyway/config.rb
-- lib/.rbnext/2.8/anyway/loaders.rb
-- lib/.rbnext/2.8/anyway/loaders/base.rb
-- lib/.rbnext/2.8/anyway/tracing.rb
+- lib/.rbnext/2.7/anyway/type_casting.rb
+- lib/.rbnext/3.0/anyway/auto_cast.rb
+- lib/.rbnext/3.0/anyway/config.rb
+- lib/.rbnext/3.0/anyway/loaders.rb
+- lib/.rbnext/3.0/anyway/loaders/base.rb
+- lib/.rbnext/3.0/anyway/tracing.rb
 - lib/anyway.rb
 - lib/anyway/auto_cast.rb
 - lib/anyway/config.rb
@@ -136,10 +159,13 @@ files:
 - lib/anyway/rails/loaders/yaml.rb
 - lib/anyway/rails/settings.rb
 - lib/anyway/railtie.rb
+- lib/anyway/rbs.rb
 - lib/anyway/settings.rb
 - lib/anyway/testing.rb
 - lib/anyway/testing/helpers.rb
 - lib/anyway/tracing.rb
+- lib/anyway/type_casting.rb
+- lib/anyway/utils/deep_merge.rb
 - lib/anyway/version.rb
 - lib/anyway_config.rb
 - lib/generators/anyway/app_config/USAGE
@@ -151,6 +177,7 @@ files:
 - lib/generators/anyway/install/USAGE
 - lib/generators/anyway/install/install_generator.rb
 - lib/generators/anyway/install/templates/application_config.rb.tt
+- sig/anyway_config.rbs
 homepage: http://github.com/palkan/anyway_config
 licenses:
 - MIT
@@ -160,7 +187,7 @@ metadata:
   documentation_uri: http://github.com/palkan/anyway_config
   homepage_uri: http://github.com/palkan/anyway_config
   source_code_uri: http://github.com/palkan/anyway_config
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -175,8 +202,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Configuration DSL for Ruby libraries and applications
 test_files: []

data/lib/.rbnext/2.7/anyway/option_parser_builder.rb

@@ -1,31 +0,0 @@
-# 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|
-          opts.accept(AutoCast) { |_1| AutoCast.call(_1) }
-
-          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: AutoCast)
-        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