anyway_config 2.0.0.pre2 → 2.0.0.rc1

data/lib/anyway/dynamic_config.rb

@@ -16,7 +16,7 @@ module Anyway
         config = allocate
         options[:env_prefix] ||= name.to_s.upcase
         options[:config_path] ||= config.resolve_config_path(name, options[:env_prefix])
-        config.load_from_sources(name: name, **options)
+        config.load_from_sources(new_empty_config, name: name, **options)
       end
     end
 

data/lib/anyway/env.rb

@@ -4,43 +4,53 @@ module Anyway
   # Parses environment variables and provides
   # method-like access
   class Env
+    using RubyNext
     using Anyway::Ext::DeepDup
-    using Anyway::Ext::StringSerialize
+    using Anyway::Ext::Hash
 
-    def initialize
+    include Tracing
+
+    attr_reader :data, :traces, :type_cast
+
+    def initialize(type_cast: AutoCast)
+      @type_cast = type_cast
       @data = {}
+      @traces = {}
     end
 
     def clear
-      @data.clear
+      data.clear
+      traces.clear
     end
 
     def fetch(prefix)
-      @data[prefix] ||= parse_env(prefix)
-      @data[prefix].deep_dup
+      return data[prefix].deep_dup if data.key?(prefix)
+
+      Tracing.capture do
+        data[prefix] = parse_env(prefix)
+      end.then do |trace|
+        traces[prefix] = trace
+      end
+
+      data[prefix].deep_dup
+    end
+
+    def fetch_with_trace(prefix)
+      [fetch(prefix), traces[prefix]]
     end
 
     private
 
     def parse_env(prefix)
+      match_prefix = "#{prefix}_"
       ENV.each_pair.with_object({}) do |(key, val), data|
-        next unless key.start_with?(prefix)
+        next unless key.start_with?(match_prefix)
 
         path = key.sub(/^#{prefix}_/, "").downcase
-        set_by_path(data, path, val.serialize)
-      end
-    end
-
-    def set_by_path(to, path, val)
-      parts = path.split("__")
-
-      to = get_hash(to, parts.shift) while parts.length > 1
 
-      to[parts.first] = val
-    end
-
-    def get_hash(from, name)
-      (from[name] ||= {})
+        paths = path.split("__")
+        trace!(:env, *paths, key: key) { data.bury(type_cast.call(val), *paths) }
+      end
     end
   end
 end

data/lib/anyway/ext/hash.rb

@@ -7,18 +7,14 @@ module Anyway
       refine ::Hash do
         # From ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_merge
         def deep_merge!(other_hash)
-          other_hash.each_pair do |current_key, other_value|
-            this_value = self[current_key]
-
+          merge!(other_hash) do |key, this_value, other_value|
             if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
               this_value.deep_merge!(other_value)
               this_value
             else
-              self[current_key] = other_value
+              other_value
             end
           end
-
-          self
         end
 
         def stringify_keys!
@@ -30,6 +26,18 @@ module Anyway
 
           self
         end
+
+        def bury(val, *path)
+          raise ArgumentError, "No path specified" if path.empty?
+          raise ArgumentError, "Path cannot contain nil" if path.compact.size != path.size
+
+          last_key = path.pop
+          hash = path.reduce(self) do |hash, k|
+            hash[k] = {} unless hash.key?(k)
+            hash[k]
+          end
+          hash[last_key] = val
+        end
       end
 
       using self

data/lib/anyway/loaders.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Anyway
+  using RubyNext
+
+  module Loaders
+    class Registry
+      attr_reader :registry
+
+      def initialize
+        @registry = []
+      end
+
+      def prepend(id, handler = nil, &block)
+        handler ||= block
+        insert_at(0, id, handler)
+      end
+
+      def append(id, handler = nil, &block)
+        handler ||= block
+        insert_at(registry.size, id, handler)
+      end
+
+      def insert_before(another_id, id, handler = nil, &block)
+        ind = registry.find_index { |(hid, _)| hid == another_id }
+        raise ArgumentError, "Loader with ID #{another_id} hasn't been registered" if ind.nil?
+
+        handler ||= block
+        insert_at(ind, id, handler)
+      end
+
+      def insert_after(another_id, id, handler = nil, &block)
+        ind = registry.find_index { |(hid, _)| hid == another_id }
+        raise ArgumentError, "Loader with ID #{another_id} hasn't been registered" if ind.nil?
+
+        handler ||= block
+        insert_at(ind + 1, id, handler)
+      end
+
+      def override(id, handler)
+        find(id).then do |id_to_handler|
+          raise ArgumentError, "Loader with ID #{id} hasn't been registered" if id_to_handler.nil?
+          id_to_handler[1] = handler
+        end
+      end
+
+      def delete(id)
+        find(id).then do |id_to_handler|
+          raise ArgumentError, "Loader with ID #{id} hasn't been registered" if id_to_handler.nil?
+          registry.delete id_to_handler
+        end
+      end
+
+      def each(&block)
+        registry.each(&block)
+      end
+
+      def freeze
+        registry.freeze
+      end
+
+      private
+
+      def insert_at(index, id, handler)
+        raise ArgumentError, "Loader with ID #{id} has been already registered" unless find(id).nil?
+
+        registry.insert(index, [id, handler])
+      end
+
+      def find(id)
+        registry.find { |(hid, _)| hid == id }
+      end
+    end
+  end
+end
+
+require "anyway/loaders/base"
+require "anyway/loaders/yaml"
+require "anyway/loaders/env"

data/lib/anyway/loaders/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Loaders
+    class Base
+      include Tracing
+
+      class << self
+        def call(local: Anyway::Settings.use_local_files, **opts)
+          new(local: local).call(**opts)
+        end
+      end
+
+      def initialize(local:)
+        @local = local
+      end
+
+      def use_local?
+        @local == true
+      end
+    end
+  end
+end

data/lib/anyway/loaders/env.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anyway
+  using RubyNext
+
+  module Loaders
+    class Env < Base
+      def call(env_prefix:, **_options)
+        Anyway.env.fetch_with_trace(env_prefix).then do |(conf, trace)|
+          Tracing.current_trace&.merge!(trace)
+          conf
+        end
+      end
+    end
+  end
+end

data/lib/anyway/loaders/yaml.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "anyway/ext/hash"
+
+using RubyNext
+using Anyway::Ext::Hash
+
+module Anyway
+  module Loaders
+    class YAML < Base
+      def call(config_path:, **_options)
+        load_yml(config_path).tap do |config|
+          config.deep_merge!(load_yml(local_config_path(config_path))) if use_local?
+        end
+      end
+
+      private
+
+      def load_yml(path)
+        trace!(:yml, path: relative_config_path(path).to_s) { parse_yml(path) }
+      end
+
+      def parse_yml(path)
+        return {} unless File.file?(path)
+        require "yaml" unless defined?(::YAML)
+        if defined?(ERB)
+          ::YAML.safe_load(ERB.new(File.read(path)).result, [], [], true)
+        else
+          ::YAML.load_file(path)
+        end
+      end
+
+      def local_config_path(path)
+        path.sub(/\.yml/, ".local.yml")
+      end
+
+      def relative_config_path(path)
+        Pathname.new(path).then do |path|
+          return path if path.relative?
+          path.relative_path_from(Pathname.new(Dir.pwd))
+        end
+      end
+    end
+  end
+end

data/lib/anyway/option_parser_builder.rb

@@ -8,9 +8,11 @@ module Anyway # :nodoc:
     class << self
       def call(options)
         OptionParser.new do |opts|
+          opts.accept(AutoCast) { AutoCast.call(_1) }
+
           options.each do |key, descriptor|
-            opts.on(*option_parser_on_args(key, **descriptor)) do |arg|
-              yield [key, arg]
+            opts.on(*option_parser_on_args(key, **descriptor)) do |val|
+              yield [key, val]
             end
           end
         end
@@ -18,8 +20,9 @@ module Anyway # :nodoc:
 
       private
 
-      def option_parser_on_args(key, flag: false, desc: nil)
+      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

data/lib/anyway/optparse_config.rb

@@ -3,11 +3,9 @@
 require "anyway/option_parser_builder"
 
 require "anyway/ext/deep_dup"
-require "anyway/ext/string_serialize"
 
 module Anyway
   using Anyway::Ext::DeepDup
-  using Anyway::Ext::StringSerialize
 
   # Adds ability to use script options as the source
   # of configuration (via optparse)
@@ -21,7 +19,11 @@ module Anyway
 
       def describe_options(**hargs)
         hargs.each do |name, desc|
-          option_parser_descriptors[name.to_s][:desc] = desc
+          if String === desc
+            option_parser_descriptors[name.to_s][:desc] = desc
+          else
+            option_parser_descriptors[name.to_s].merge!(desc)
+          end
         end
       end
 
@@ -69,8 +71,8 @@ module Anyway
 
     def option_parser
       @option_parser ||= begin
-        OptionParserBuilder.call(self.class.option_parser_options) do |key, arg|
-          set_value(key, arg.is_a?(String) ? arg.serialize : arg)
+        OptionParserBuilder.call(self.class.option_parser_options) do |key, val|
+          write_config_attr(key, val)
         end.tap do |parser|
           self.class.option_parser_extensions.map do |extension|
             extension.call(parser, self)
@@ -80,7 +82,9 @@ module Anyway
     end
 
     def parse_options!(options)
-      option_parser.parse!(options)
+      Tracing.with_trace_source(type: :options) do
+        option_parser.parse!(options)
+      end
     end
 
     def self.included(base)

data/lib/anyway/rails.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anyway
+  module Rails
+  end
+end
+
+require "anyway/rails/settings"
+require "anyway/rails/config"
+require "anyway/rails/loaders"
+require "anyway/railtie"
+
+# Configure Rails loaders
+Anyway.loaders.override :yml, Anyway::Rails::Loaders::YAML
+Anyway.loaders.insert_after :yml, :secrets, Anyway::Rails::Loaders::Secrets
+Anyway.loaders.insert_after :secrets, :credentials, Anyway::Rails::Loaders::Credentials

data/lib/anyway/rails/config.rb

@@ -11,76 +11,9 @@ module Anyway
     module Config
       module ClassMethods
         # Make defaults to be a Hash with indifferent access
-        def defaults
-          return @defaults if instance_variable_defined?(:@defaults)
-
-          @defaults = super.with_indifferent_access
-        end
-      end
-
-      def load_from_sources(**options)
-        base_config = {}.with_indifferent_access
-        each_source(options) do |config|
-          base_config.deep_merge!(config) if config
-        end
-        base_config
-      end
-
-      def each_source(options)
-        yield load_from_file(options)
-        yield load_from_secrets(options)
-        yield load_from_credentials(options)
-        yield load_from_env(options)
-      end
-
-      def load_from_file(name:, config_path:, env_prefix:, **_options)
-        file_config = load_from_yml(config_path)[::Rails.env] || {}
-
-        if Anyway::Settings.use_local_files
-          local_config_path = config_path.sub(/\.yml/, ".local.yml")
-          file_config.deep_merge!(load_from_yml(local_config_path) || {})
+        def new_empty_config
+          {}.with_indifferent_access
         end
-
-        file_config
-      end
-
-      def load_from_secrets(name:, **_options)
-        return unless ::Rails.application.respond_to?(:secrets)
-
-        ::Rails.application.secrets.public_send(name)
-      end
-
-      def load_from_credentials(name:, **_options)
-        # do not load from credentials if we're in the context
-        # of the `credentials:edit` command
-        return if defined?(::Rails::Command::CredentialsCommand)
-
-        return unless ::Rails.application.respond_to?(:credentials)
-
-        # Create a new hash cause credentials are mutable!
-        creds_config = {}
-
-        creds_config.deep_merge!(::Rails.application.credentials.public_send(name) || {})
-
-        creds_config.deep_merge!(load_from_local_credentials(name: name) || {}) if Anyway::Settings.use_local_files
-        creds_config
-      end
-
-      def load_from_local_credentials(name:)
-        local_creds_path = ::Rails.root.join("config/credentials/local.yml.enc").to_s
-
-        return unless File.file?(local_creds_path)
-
-        creds = ::Rails.application.encrypted(
-          local_creds_path,
-          key_path: ::Rails.root.join("config/credentials/local.key")
-        )
-
-        creds.public_send(name)
-      end
-
-      def default_config_path(name)
-        ::Rails.root.join("config", "#{name}.yml")
       end
     end
   end