anyway_config 2.1.0 → 2.2.0

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/tracing.rb

@@ -34,11 +34,11 @@ module Anyway
 
       def record_value(val, *path, **opts)
         key = path.pop
-        if val.is_a?(Hash)
+        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

data/lib/anyway/type_casting.rb

@@ -0,0 +1,121 @@
+# 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)
+      caster =
+        if type_id.is_a?(Symbol)
+          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?(Array) ? raw : raw.split(/\s*,\s*/)
+        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(:string, &:to_s)
+    obj.accept(:integer, &:to_i)
+    obj.accept(:float, &:to_f)
+
+    obj.accept(:date) do
+      require "date" unless defined?(::Date)
+
+      Date.parse(_1)
+    end
+
+    obj.accept(:datetime) do
+      require "date" unless defined?(::Date)
+
+      DateTime.parse(_1)
+    end
+
+    obj.accept(:uri) do
+      require "uri" unless defined?(::URI)
+
+      URI.parse(_1)
+    end
+
+    obj.accept(:boolean) do
+      _1.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/version.rb

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

data/lib/anyway_config.rb

@@ -17,8 +17,10 @@ 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,123 @@
+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
+
+  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: (untyped mapping) -> untyped
+    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.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-28 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.11.0
+        version: 0.13.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.13.1
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -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
   \ "
@@ -113,10 +127,12 @@ files:
 - 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.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
@@ -143,10 +159,12 @@ 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
@@ -159,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
@@ -168,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
@@ -183,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