dry-system 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94d4f0b0085ef8e7edf3938fe94d39f4c26d2ea9
-  data.tar.gz: 15a9499b38c9d1a8ef109728d86b577616dad388
+  metadata.gz: e2b3c4fc9aed09b6920d6c285df0407e8cb506f2
+  data.tar.gz: 5034704e210f09cae4f54e7ddb67371fc31bba31
 SHA512:
-  metadata.gz: 4979edbd2d31b3039bc25438a2340462ce94e946e9ceeded7003c488e8322209a07b1d58ccfd5419a922ac1a96cf326bf8dddc5fa22069b82387e9578564a944
-  data.tar.gz: 887221bf029d0b6cf26f32e06ff8ac8d642e9cdc289cf8428351f8185a73161900ee26ee762d778f1912c0f7926c936e397cef28db3afb4b2d2c5ddda38518de
+  metadata.gz: cff3f64d9fe0762d3e59893caf4f8e7f85da8b17ed40f7b6970a4518950e1ab60ad99531ae20383c10915ed296895df21a149f872a3d8dc0da214f7ed5caeabc
+  data.tar.gz: 51092e33d452c9008ddba0a384a989420287c9fce19f730b85f5903a99f7da5f4b4aa626ee4c83d693434135f8793b33aea7df037682b408f8fcfe1b751a3e00

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# 0.8.0 - 2017-10-16
+
+### Added
+
+* Support for external bootable components (solnic)
+* Built-in `:system` components including `:settings` component (solnic)
+
+### Fixed
+
+* Lazy-loading components work when a container has `default_namespace` configured (GustavoCaso)
+
+### Changed
+
+* [BREAKING] Improved boot DSL with support for namespacing and lifecycle before/after callbacks (solnic)
+
+[Compare v0.7.3...v0.8.0](https://github.com/dry-rb/dry-system/compare/v0.7.3...v0.8.0)
+
 # 0.7.3 - 2017-08-02
 
 ### Fixed

data/lib/dry/system.rb

@@ -1,4 +1,28 @@
+require 'dry/system/provider'
+require 'dry/system/provider_registry'
+
 module Dry
   module System
+    # Register external component provider
+    #
+    # @api public
+    def self.register_provider(identifier, options)
+      providers.register(identifier, options)
+      providers[identifier].load_components
+      self
+    end
+
+    # Register an external component that can be booted within other systems
+    #
+    # @api public
+    def self.register_component(identifier, provider:, &block)
+      providers[provider].register_component(identifier, block)
+      self
+    end
+
+    # @api private
+    def self.providers
+      @__providers__ ||= ProviderRegistry.new
+    end
   end
 end

data/lib/dry/system/booter.rb

@@ -1,5 +1,7 @@
+require 'dry/system/components/bootable'
 require 'dry/system/errors'
 require 'dry/system/lifecycle'
+require 'dry/system/booter/component_registry'
 
 module Dry
   module System
@@ -13,93 +15,123 @@ module Dry
     class Booter
       attr_reader :path
 
-      attr_reader :finalizers
-
       attr_reader :booted
 
+      attr_reader :components
+
       # @api private
       def initialize(path)
         @path = path
-        @booted = {}
-        @finalizers = {}
+        @booted = []
+        @components = ComponentRegistry.new
       end
 
       # @api private
-      def []=(name, fn)
-        @finalizers[name] = fn
+      def register_component(component)
+        components.register(component)
         self
       end
 
       # @api private
-      def finalize!
-        Dir[boot_files].each do |path|
-          start(File.basename(path, '.rb').to_sym)
+      def load_component(path)
+        identifier = Pathname(path).basename('.rb').to_s.to_sym
+
+        unless components.exists?(identifier)
+          require path
         end
-        freeze
+
+        self
       end
 
       # @api private
-      def init(name)
-        Kernel.require(path.join(name.to_s))
+      def finalize!
+        boot_files.each do |path|
+          load_component(path)
+        end
 
-        call(name) do |lifecycle|
-          lifecycle.(:init)
-          yield(lifecycle) if block_given?
+        components.each do |component|
+          start(component)
         end
 
-        self
+        freeze
       end
 
       # @api private
-      def start(name)
-        check_component_identifier(name)
+      def init(name_or_component)
+        with_component(name_or_component) do |component|
+          call(component) do
+            component.init
+            yield if block_given?
+          end
+
+          self
+        end
+      end
 
-        return self if booted.key?(name)
+      # @api private
+      def start(name_or_component)
+        with_component(name_or_component) do |component|
+          return self if booted.include?(component)
 
-        init(name) { |lifecycle| lifecycle.(:start) }
-        booted[name] = true
+          init(name_or_component) do
+            component.start
+          end
 
-        self
+          booted << component.finalize
+
+          self
+        end
       end
 
       # @api private
-      def call(name)
-        container, finalizer = finalizers[name]
+      def call(name_or_component)
+        with_component(name_or_component) do |component|
+          unless component
+            raise ComponentFileMismatchError.new(name, registered_booted_keys)
+          end
 
-        raise ComponentFileMismatchError.new(name, registered_booted_keys) unless finalizer
+          yield(component) if block_given?
 
-        lifecycle = Lifecycle.new(container, &finalizer)
-        yield(lifecycle) if block_given?
-        lifecycle
+          component
+        end
       end
 
       # @api private
-      def boot_dependency(component)
-        boot_file = component.boot_file(path)
-        start(boot_file.basename('.*').to_s.to_sym) if boot_file.exist?
+      def lifecycle_container(container)
+        LifecycleContainer.new(container)
       end
 
-      private
+      # @api private
+      def with_component(id_or_component)
+        component =
+          case id_or_component
+          when Symbol
+            require_boot_file(id_or_component) unless components.exists?(id_or_component)
+            components[id_or_component]
+          when Components::Bootable
+            id_or_component
+          end
+
+        raise InvalidComponentError, id_or_component unless component
+
+        yield(component)
+      end
 
       # @api private
-      def registered_booted_keys
-        finalizers.keys - booted.keys
+      def require_boot_file(identifier)
+        boot_file = boot_files.detect { |path| Pathname(path).basename('.rb').to_s == identifier.to_s }
+        require boot_file if boot_file
       end
 
       # @api private
       def boot_files
-        path.join('**/*.rb').to_s
+        Dir["#{path}/**/*.rb"]
       end
 
       # @api private
-      def check_component_identifier(name)
-        unless name.is_a?(Symbol)
-          raise InvalidComponentIdentifierTypeError, name
-        end
-
-        unless path.join("#{name}.rb").exist?
-          raise InvalidComponentIdentifierError, name
-        end
+      def boot_dependency(component)
+        boot_file = component.boot_file(path)
+        start(boot_file.basename('.*').to_s.to_sym) if boot_file.exist?
       end
     end
   end

data/lib/dry/system/booter/component_registry.rb

@@ -0,0 +1,37 @@
+module Dry
+  module System
+    class Booter
+      class ComponentRegistry
+        include Enumerable
+
+        attr_reader :components
+
+        def initialize
+          @components = []
+        end
+
+        def each(&block)
+          components.each(&block)
+        end
+
+        def register(component)
+          @components << component
+        end
+
+        def exists?(name)
+          components.any? { |component| component.identifier == name }
+        end
+
+        def [](name)
+          component = components.detect { |component| component.identifier == name }
+
+          if component
+            component
+          else
+            raise InvalidComponentIdentifierError, name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/component.rb

@@ -41,8 +41,8 @@ module Dry
       attr_reader :loader
 
       # @api private
-      def self.new(*args)
-        cache.fetch_or_store(args.hash) do
+      def self.new(*args, &block)
+        cache.fetch_or_store([*args, block].hash) do
           name, options = args
           options = DEFAULT_OPTIONS.merge(options || {})
 
@@ -67,8 +67,8 @@ module Dry
       # @api private
       def self.remove_namespace_from_path(name, ns)
         match_value = name.match(/^(?<remove_namespace>#{ns}).(?<identifier>.*)/)
-        raise InvalidComponentError.new(name, "namespace +#{ns}+ not found in path") unless match_value
-        match_value[:identifier]
+
+        match_value ? match_value[:identifier] : name
       end
 
       # @api private
@@ -108,6 +108,11 @@ module Dry
         loader.call(*args)
       end
 
+      # @api private
+      def boot?
+        false
+      end
+
       # @api private
       def bootable?(path)
         boot_file(path).exist?

data/lib/dry/system/components.rb

@@ -0,0 +1,6 @@
+require 'dry/system'
+
+Dry::System.register_provider(
+  :system,
+  boot_path: Pathname(__dir__).join('system_components').realpath
+)

data/lib/dry/system/components/bootable.rb

@@ -0,0 +1,307 @@
+require 'dry/system/lifecycle'
+require 'dry/system/settings'
+require 'dry/system/components/config'
+
+module Dry
+  module System
+    module Components
+      # Bootable components can provide one or more objects and typically depend
+      # on 3rd-party code. A typical bootable component can be a database library,
+      # or an API client.
+      #
+      # These components can be registered via `Container.boot` and external component
+      # providers can register their components too, which then can be used and configured
+      # by your system.
+      #
+      # @example simple logger
+      #   class App < Dry::System::Container
+      #     boot(:logger) do
+      #       init do
+      #         require "logger"
+      #       end
+      #
+      #       start do
+      #         register(:logger, Logger.new($stdout))
+      #       end
+      #     end
+      #   end
+      #
+      #   App[:logger] # returns configured logger
+      #
+      # @example using built-in system components
+      #   class App < Dry::System::Container
+      #     boot(:settings, from: :system) do
+      #       settings do
+      #         key :database_url, Types::String.constrained(filled: true)
+      #         key :session_secret, Types::String.constrained(filled: true)
+      #       end
+      #     end
+      #   end
+      #
+      #   App[:settings] # returns loaded settings
+      #
+      # @api public
+      class Bootable
+        DEFAULT_FINALIZE = proc {}
+
+        # @!attribute [r] identifier
+        #   @return [Symbol] component's unique identifier
+        attr_reader :identifier
+
+        # @!attribute [r] finalize
+        #   @return [Proc] Finalization proc
+        attr_reader :finalize
+
+        # @!attribute [r] options
+        #   @return [Hash] component's options
+        attr_reader :options
+
+        # @!attribute [r] triggers
+        #   @return [Hash] lifecycle step after/before callbacks
+        attr_reader :triggers
+
+        # @!attribute [r] namespace
+        #   @return [Symbol,String] default namespace for the container keys
+        attr_reader :namespace
+
+        # @api private
+        def initialize(identifier, options = {}, &block)
+          @identifier = identifier
+          @triggers = { before: Hash.new { |h, k| h[k] = [] }, after: Hash.new { |h, k| h[k] = [] } }
+          @options = block ? options.merge(block: block) : options
+          @namespace = options[:namespace]
+          finalize = options[:finalize] || DEFAULT_FINALIZE
+          instance_exec(&finalize)
+        end
+
+        # Execute `init` step
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def init
+          trigger(:before, :init)
+          lifecycle.(:init)
+          trigger(:after, :init)
+          self
+        end
+
+        # Execute `start` step
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def start
+          trigger(:before, :start)
+          lifecycle.(:start)
+          trigger(:after, :start)
+          self
+        end
+
+        # Execute `stop` step
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def stop
+          lifecycle.(:stop)
+          self
+        end
+
+        # Specify a before callback
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def before(event, &block)
+          triggers[:before][event] << block
+          self
+        end
+
+        # Specify an after callback
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def after(event, &block)
+          triggers[:after][event] << block
+          self
+        end
+
+        # Configure a component
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def configure(&block)
+          @config_block = block
+        end
+
+        # Define configuration settings with keys and types
+        #
+        # @return [Bootable]
+        #
+        # @api public
+        def settings(&block)
+          if block
+            @settings_block = block
+          elsif @settings_block
+            @settings = Settings::DSL.new(identifier, &@settings_block).call
+          else
+            @settings
+          end
+        end
+
+        # Return component's configuration
+        #
+        # @return [Dry::Struct]
+        #
+        # @api public
+        def config
+          if @config
+            @config
+          else
+            configure!
+          end
+        end
+
+        # Return a list of lifecycle steps that were executed
+        #
+        # @return [Array<Symbol>]
+        #
+        # @api public
+        def statuses
+          lifecycle.statuses
+        end
+
+        # Return system's container used by this component
+        #
+        # @return [Dry::Struct]
+        #
+        # @api public
+        def container
+          options.fetch(:container)
+        end
+
+        # Automatically called by the booter object after starting a component
+        #
+        # @return [Bootable]
+        #
+        # @api private
+        def finalize
+          lifecycle.container.each do |key, item|
+            container.register(key, item) unless container.key?(key)
+          end
+          self
+        end
+
+        # Trigger a callback
+        #
+        # @return [Bootable]
+        #
+        # @api private
+        def trigger(key, event)
+          triggers[key][event].each do |fn|
+            container.instance_exec(lifecycle.container, &fn)
+          end
+          self
+        end
+
+        # Return a new instance with updated options
+        #
+        # @return [Dry::Struct]
+        #
+        # @api private
+        def with(new_options)
+          self.class.new(identifier, options.merge(new_options))
+        end
+
+        # Return true
+        #
+        # @return [TrueClass]
+        #
+        # @api private
+        def boot?
+          true
+        end
+
+        # Return path to component's boot file
+        #
+        # @return [String]
+        #
+        # @api private
+        def boot_file
+          container_boot_files.
+            detect { |path| Pathname(path).basename('.rb').to_s == identifier.to_s }
+        end
+
+        # Return path to boot dir
+        #
+        # @return [String]
+        #
+        # @api private
+        def boot_path
+          container.boot_path
+        end
+
+        # Return all boot files defined under container's boot path
+        #
+        # @return [String]
+        #
+        # @api private
+        def container_boot_files
+          Dir[container.boot_path.join('**/*.rb')]
+        end
+
+        private
+
+        # Return lifecycle object used for this component
+        #
+        # @return [Lifecycle]
+        #
+        # @api private
+        def lifecycle
+          @lifecycle ||= Lifecycle.new(lf_container, component: self, &block)
+        end
+
+        # Return configured container for the lifecycle object
+        #
+        # @return [Dry::Container]
+        #
+        # @api private
+        def lf_container
+          container = Dry::Container.new
+
+          case namespace
+          when String, Symbol
+            container.namespace(namespace) { |c| return c }
+          when true
+            container.namespace(identifier) { |c| return c }
+          when nil
+            container
+          else
+            raise RuntimeError, "+namespace+ boot option must be true, string or symbol #{namespace.inspect} given."
+          end
+        end
+
+        # Set config object
+        #
+        # @return [Dry::Struct]
+        #
+        # @api private
+        def configure!
+          @config = settings.new(Config.new(&@config_block)) if settings
+        end
+
+        # Return block that will be evaluated in the lifecycle context
+        #
+        # @return [Proc]
+        #
+        # @api private
+        def block
+          options.fetch(:block)
+        end
+      end
+    end
+  end
+end