dry-system 0.18.1 → 1.0.1

data/lib/dry/system/provider_registrar.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "dry/system/errors"
+require "dry/system/constants"
+
+module Dry
+  module System
+    # Default provider registrar implementation
+    #
+    # This is currently configured by default for every Dry::System::Container. The
+    # provider registrar is responsible for loading provider files and exposing an API for
+    # running the provider lifecycle steps.
+    #
+    # @api private
+    class ProviderRegistrar
+      # @api private
+      attr_reader :providers
+
+      # @api private
+      attr_reader :container
+
+      # @api private
+      def initialize(container)
+        @providers = {}
+        @container = container
+      end
+
+      # @api private
+      def freeze
+        providers.freeze
+        super
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+
+      # @see Container.register_provider
+      # @api private
+      def register_provider(name, namespace: nil, from: nil, source: nil, if: true, &block)
+        raise ProviderAlreadyRegisteredError, name if providers.key?(name)
+
+        if from && source.is_a?(Class)
+          raise ArgumentError, "You must supply a block when using a provider source"
+        end
+
+        if block && source.is_a?(Class)
+          raise ArgumentError, "You must supply only a `source:` option or a block, not both"
+        end
+
+        return self unless binding.local_variable_get(:if)
+
+        provider =
+          if from
+            build_provider_from_source(
+              name,
+              namespace: namespace,
+              source: source || name,
+              group: from,
+              &block
+            )
+          else
+            build_provider(name, namespace: namespace, source: source, &block)
+          end
+
+        providers[provider.name] = provider
+
+        self
+      end
+
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # Returns a provider for the given name, if it has already been loaded
+      #
+      # @api public
+      def [](provider_name)
+        providers[provider_name]
+      end
+      alias_method :provider, :[]
+
+      # @api private
+      def key?(provider_name)
+        providers.key?(provider_name)
+      end
+
+      # Returns a provider if it can be found or loaded, otherwise nil
+      #
+      # @return [Dry::System::Provider, nil]
+      #
+      # @api private
+      def find_and_load_provider(name)
+        name = name.to_sym
+
+        if (provider = providers[name])
+          return provider
+        end
+
+        return if finalized?
+
+        require_provider_file(name)
+
+        providers[name]
+      end
+
+      # @api private
+      def start_provider_dependency(component)
+        if (provider = find_and_load_provider(component.root_key))
+          provider.start
+        end
+      end
+
+      # Returns all provider files within the configured provider_paths.
+      #
+      # Searches for files in the order of the configured provider_paths. In the case of multiple
+      # identically-named boot files within different provider_paths, the file found first will be
+      # returned, and other matching files will be discarded.
+      #
+      # This method is public to allow other tools extending dry-system (like dry-rails)
+      # to access a canonical list of real, in-use provider files.
+      #
+      # @see Container.provider_paths
+      #
+      # @return [Array<Pathname>]
+      # @api public
+      def provider_files
+        @provider_files ||= provider_paths.each_with_object([[], []]) { |path, (provider_files, loaded)| # rubocop:disable Layout/LineLength
+          files = Dir["#{path}/#{RB_GLOB}"].sort
+
+          files.each do |file|
+            basename = File.basename(file)
+
+            unless loaded.include?(basename)
+              provider_files << Pathname(file)
+              loaded << basename
+            end
+          end
+        }.first
+      end
+
+      # @api private
+      def finalize!
+        provider_files.each do |path|
+          load_provider(path)
+        end
+
+        providers.each_value(&:start)
+
+        freeze
+      end
+
+      # @!method finalized?
+      #   Returns true if the booter has been finalized
+      #
+      #   @return [Boolean]
+      #   @api private
+      alias_method :finalized?, :frozen?
+
+      # @api private
+      def shutdown
+        providers.each_value(&:stop)
+        self
+      end
+
+      # @api private
+      def prepare(provider_name)
+        with_provider(provider_name, &:prepare)
+        self
+      end
+
+      # @api private
+      def start(provider_name)
+        with_provider(provider_name, &:start)
+        self
+      end
+
+      # @api private
+      def stop(provider_name)
+        with_provider(provider_name, &:stop)
+        self
+      end
+
+      private
+
+      # @api private
+      def provider_paths
+        provider_dirs = container.config.provider_dirs
+
+        provider_dirs.map { |dir|
+          dir = Pathname(dir)
+
+          if dir.relative?
+            container.root.join(dir)
+          else
+            dir
+          end
+        }
+      end
+
+      def build_provider(name, namespace:, source: nil, &block)
+        source_class = source || Provider::Source.for(name: name, &block)
+
+        Provider.new(
+          name: name,
+          namespace: namespace,
+          target_container: container,
+          source_class: source_class
+        )
+      end
+
+      def build_provider_from_source(name, source:, group:, namespace:, &block)
+        source_class = System.provider_sources.resolve(name: source, group: group)
+
+        Provider.new(
+          name: name,
+          namespace: namespace,
+          target_container: container,
+          source_class: source_class,
+          &block
+        )
+      end
+
+      def with_provider(provider_name)
+        require_provider_file(provider_name) unless providers.key?(provider_name)
+
+        provider = providers[provider_name]
+
+        raise ProviderNotFoundError, provider_name unless provider
+
+        yield(provider)
+      end
+
+      def load_provider(path)
+        name = Pathname(path).basename(RB_EXT).to_s.to_sym
+
+        Kernel.require path unless providers.key?(name)
+
+        self
+      end
+
+      def require_provider_file(name)
+        provider_file = find_provider_file(name)
+
+        Kernel.require provider_file if provider_file
+      end
+
+      def find_provider_file(name)
+        provider_files.detect { |file| File.basename(file, RB_EXT) == name.to_s }
+      end
+    end
+  end
+end

data/lib/dry/system/provider_source_registry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # @api private
+    class ProviderSourceRegistry
+      attr_reader :sources
+
+      def initialize
+        @sources = {}
+      end
+
+      def load_sources(path)
+        Dir[File.join(path, "**/#{RB_GLOB}")].sort.each do |file|
+          require file
+        end
+      end
+
+      def register(name:, group:, source:)
+        sources[key(name, group)] = source
+      end
+
+      def register_from_block(name:, group:, &block)
+        register(
+          name: name,
+          group: group,
+          source: Provider::Source.for(
+            name: name,
+            group: group,
+            &block
+          )
+        )
+      end
+
+      def resolve(name:, group:)
+        sources[key(name, group)].tap { |source|
+          unless source
+            raise ProviderSourceNotFoundError.new(
+              name: name,
+              group: group,
+              keys: sources.keys
+            )
+          end
+        }
+      end
+
+      private
+
+      def key(name, group)
+        {group: group, name: name}
+      end
+    end
+  end
+end

data/lib/dry/system/provider_sources/settings/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module ProviderSources
+      # @api private
+      module Settings
+        InvalidSettingsError = Class.new(ArgumentError) do
+          # @api private
+          def initialize(errors)
+            message = <<~STR
+              Could not load settings. The following settings were invalid:
+
+              #{setting_errors(errors).join("\n")}
+            STR
+
+            super(message)
+          end
+
+          private
+
+          def setting_errors(errors)
+            errors.sort_by { |k, _| k }.map { |key, error| "#{key}: #{error}" }
+          end
+        end
+
+        # @api private
+        class Config
+          # @api private
+          def self.load(root:, env:, loader: Loader)
+            loader = loader.new(root: root, env: env)
+
+            new.tap do |settings_obj|
+              errors = {}
+
+              settings.to_a.each do |setting|
+                value = loader[setting.name.to_s.upcase]
+
+                begin
+                  if value
+                    settings_obj.config.public_send(:"#{setting.name}=", value)
+                  else
+                    settings_obj.config[setting.name]
+                  end
+                rescue => e # rubocop:disable Style/RescueStandardError
+                  errors[setting.name] = e
+                end
+              end
+
+              raise InvalidSettingsError, errors unless errors.empty?
+            end
+          end
+
+          include Dry::Configurable
+
+          private
+
+          def method_missing(name, *args, &block)
+            if config.respond_to?(name)
+              config.public_send(name, *args, &block)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(name, include_all = false)
+            config.respond_to?(name, include_all) || super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/provider_sources/settings/loader.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module ProviderSources
+      module Settings
+        # @api private
+        class Loader
+          # @api private
+          attr_reader :store
+
+          # @api private
+          def initialize(root:, env:, store: ENV)
+            @store = store
+            load_dotenv(root, env.to_sym)
+          end
+
+          # @api private
+          def [](key)
+            store[key]
+          end
+
+          private
+
+          def load_dotenv(root, env)
+            require "dotenv"
+            Dotenv.load(*dotenv_files(root, env)) if defined?(Dotenv)
+          rescue LoadError
+            # Do nothing if dotenv is unavailable
+          end
+
+          def dotenv_files(root, env)
+            [
+              File.join(root, ".env.#{env}.local"),
+              (File.join(root, ".env.local") unless env == :test),
+              File.join(root, ".env.#{env}"),
+              File.join(root, ".env")
+            ].compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/provider_sources/settings.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module ProviderSources
+      module Settings
+        class Source < Dry::System::Provider::Source
+          setting :store
+
+          def prepare
+            require "dry/system/provider_sources/settings/config"
+          end
+
+          def start
+            register(:settings, settings.load(root: target.root, env: target.config.env))
+          end
+
+          def settings(&block)
+            # Save the block and evaluate it lazily to allow a provider with this source
+            # to `require` any necessary files for the block to evaluate correctly (e.g.
+            # requiring an app-specific types module for setting constructors)
+            if block
+              @settings_block = block
+            elsif defined? @settings_class
+              @settings_class
+            elsif @settings_block
+              @settings_class = Class.new(Settings::Config, &@settings_block)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Dry::System.register_provider_source(
+  :settings,
+  group: :dry_system,
+  source: Dry::System::ProviderSources::Settings::Source
+)

data/lib/dry/system/provider_sources.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "dry/system"
+
+Dry::System.register_provider_sources Pathname(__dir__).join("provider_sources").realpath

data/lib/dry/system/stubs.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
-require "dry/container/stub"
+require "dry/core/container/stub"
 
 module Dry
   module System
     class Container
       # @api private
       module Stubs
-        def finalize!(&block)
+        # This overrides default finalize! just to disable automatic freezing
+        # of the container
+        #
+        # @api private
+        def finalize!(**, &block)
           super(freeze: false, &block)
         end
       end

data/lib/dry/system/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module System
-    VERSION = "0.18.1"
+    VERSION = "1.0.1"
   end
 end

data/lib/dry/system.rb

@@ -1,30 +1,52 @@
 # frozen_string_literal: true
 
-require "dry/system/provider"
-require "dry/system/provider_registry"
+require "zeitwerk"
+require "dry/core"
 
 module Dry
   module System
-    # Register external component provider
+    # @api private
+    def self.loader
+      @loader ||= Zeitwerk::Loader.new.tap do |loader|
+        root = File.expand_path("..", __dir__)
+        loader.tag = "dry-system"
+        loader.inflector = Zeitwerk::GemInflector.new("#{root}/dry-system.rb")
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/dry-system.rb",
+          "#{root}/dry/system/{components,constants,errors,stubs,version}.rb"
+        )
+        loader.inflector.inflect("source_dsl" => "SourceDSL")
+      end
+    end
+
+    # Registers the provider sources in the files under the given path
     #
     # @api public
-    def self.register_provider(identifier, options)
-      providers.register(identifier, options)
-      providers[identifier].load_components
-      self
+    def self.register_provider_sources(path)
+      provider_sources.load_sources(path)
     end
 
-    # Register an external component that can be booted within other systems
+    # Registers a provider source, which can be used as the basis for other providers
     #
     # @api public
-    def self.register_component(identifier, provider:, &block)
-      providers[provider].register_component(identifier, block)
-      self
+    def self.register_provider_source(name, group:, source: nil, &block)
+      if source && block
+        raise ArgumentError, "You must supply only a `source:` option or a block, not both"
+      end
+
+      if source
+        provider_sources.register(name: name, group: group, source: source)
+      else
+        provider_sources.register_from_block(name: name, group: group, &block)
+      end
     end
 
     # @api private
-    def self.providers
-      @providers ||= ProviderRegistry.new
+    def self.provider_sources
+      @provider_sources ||= ProviderSourceRegistry.new
     end
+
+    loader.setup
   end
 end