anyway_config 2.1.0 → 2.2.3

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

@@ -22,7 +22,7 @@ module Anyway
             :credentials,
             store: credentials_path
           ) do
-            ::Rails.application.credentials.public_send(name)
+            ::Rails.application.credentials.config[name.to_sym]
           end.then do |creds|
             Utils.deep_merge!(config, creds) if creds
           end
@@ -48,7 +48,7 @@ module Anyway
             key_path: ::Rails.root.join("config/credentials/local.key")
           )
 
-          creds.public_send(name)
+          creds.config[name.to_sym]
         end
 
         def credentials_path

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

@@ -24,13 +24,11 @@ module Anyway
         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
+          @secrets ||= ::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

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

@@ -8,7 +8,11 @@ module Anyway
           parsed_yml = super
           return parsed_yml unless environmental?(parsed_yml)
 
-          super[::Rails.env] || {}
+          env_config = parsed_yml[::Rails.env] || {}
+          return env_config if Anyway::Settings.default_environmental_key.blank?
+
+          default_config = parsed_yml[Anyway::Settings.default_environmental_key] || {}
+          Utils.deep_merge!(default_config, env_config)
         end
 
         private
@@ -18,7 +22,9 @@ module Anyway
           # likely
           return true if parsed_yml.key?(::Rails.env)
           # less likely
-          ::Rails.application.config.anyway_config.known_environments.any? { parsed_yml.key?(_1) }
+          return true if ::Rails.application.config.anyway_config.known_environments.any? { parsed_yml.key?(_1) }
+          # strange, but still possible
+          Anyway::Settings.default_environmental_key.present? && parsed_yml.key?(Anyway::Settings.default_environmental_key)
         end
 
         def relative_config_path(path)

data/lib/anyway/rails/settings.rb

@@ -17,6 +17,9 @@ module Anyway
       attr_reader :autoload_static_config_path, :autoloader
       attr_accessor :known_environments
 
+      # Define a key for environmental yaml files to read default values from
+      attr_accessor :default_environmental_key
+
       if defined?(::Zeitwerk)
         def autoload_static_config_path=(val)
           raise "Cannot setup autoloader after application has been initialized" if ::Rails.application.initialized?
@@ -27,10 +30,11 @@ module Anyway
 
           @autoload_static_config_path = val
 
-          # See https://github.com/rails/rails/blob/8ab4fd12f18203b83d0f252db96d10731485ff6a/railties/lib/rails/autoloaders.rb#L10
+          # 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"
-            loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+            loader.inflector = defined?(ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector) ? ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector : ::Rails::Autoloaders::Inflector
             loader.push_dir(::Rails.root.join(val))
             loader.setup
           end
@@ -62,5 +66,7 @@ module Anyway
 
     self.default_config_path = ->(name) { ::Rails.root.join("config", "#{name}.yml") }
     self.known_environments = %w[test development production]
+    # Don't try read defaults when no key defined
+    self.default_environmental_key = nil
   end
 end

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
@@ -86,7 +86,7 @@ module Anyway
         if trace?
           value.transform_values(&:to_h).tap { _1.default_proc = nil }
         else
-          {value, source}
+          {value:, source:}
         end
       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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anyway # :nodoc:
-  VERSION = "2.1.0"
+  VERSION = "2.2.3"
 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/lib/generators/anyway/install/templates/application_config.rb.tt

@@ -4,7 +4,7 @@
 class ApplicationConfig < Anyway::Config
   class << self
     # Make it possible to access a singleton config instance
-    # via class methods (i.e., without explictly calling `instance`)
+    # via class methods (i.e., without explicitly calling `instance`)
     delegate_missing_to :instance
 
     private

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.1.0
+  version: 2.2.3
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2022-01-21 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.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: ammeter
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.14.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,21 +106,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.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/.rbnext/3.1/anyway/config.rb
+- lib/.rbnext/3.1/anyway/dynamic_config.rb
+- lib/.rbnext/3.1/anyway/env.rb
+- lib/.rbnext/3.1/anyway/loaders/base.rb
+- lib/.rbnext/3.1/anyway/tracing.rb
 - lib/anyway.rb
 - lib/anyway/auto_cast.rb
 - lib/anyway/config.rb
@@ -143,10 +145,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 +163,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 +173,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 +188,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