dry-system 0.21.0 → 0.24.0

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

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system/lifecycle"
-require "dry/system/settings"
-require "dry/system/components/config"
-require "dry/system/constants"
-
-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] key
-        #   @return [Symbol] component's unique name
-        attr_reader :name
-
-        # @!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
-
-        TRIGGER_MAP = Hash.new { |h, k| h[k] = [] }.freeze
-
-        # @api private
-        def initialize(name, options = {}, &block)
-          @config = nil
-          @config_block = nil
-          @name = name
-          @triggers = {before: TRIGGER_MAP.dup, after: TRIGGER_MAP.dup}
-          @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(&@settings_block).call
-          else
-            @settings
-          end
-        end
-
-        # Return component's configuration
-        #
-        # @return [Dry::Struct]
-        #
-        # @api public
-        def config
-          @config || configure!
-        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.registered?(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 name and options
-        #
-        # @return [Dry::Struct]
-        #
-        # @api private
-        def new(name, new_options = EMPTY_HASH)
-          self.class.new(name, options.merge(new_options))
-        end
-
-        # Return a new instance with updated options
-        #
-        # @return [Dry::Struct]
-        #
-        # @api private
-        def with(new_options)
-          self.class.new(name, options.merge(new_options))
-        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(name) { |c| return c }
-          when nil
-            container
-          else
-            raise <<-STR
-              +namespace+ boot option must be true, string or symbol #{namespace.inspect} given.
-            STR
-          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

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  module System
-    module Components
-      class Config
-        def self.new(&block)
-          config = super
-          yield(config) if block_given?
-          config
-        end
-
-        def initialize
-          @settings = {}
-        end
-
-        def to_hash
-          @settings
-        end
-
-        private
-
-        def method_missing(meth, value = nil)
-          if meth.to_s.end_with?("=")
-            @settings[meth.to_s.gsub("=", "").to_sym] = value
-          elsif @settings.key?(meth)
-            @settings[meth]
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dry/system/lifecycle.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-require "dry/system/settings"
-
-module Dry
-  module System
-    # Lifecycle booting DSL
-    #
-    # Lifecycle objects are used in the boot files where you can register custom
-    # init/start/stop triggers
-    #
-    # @see [Container.finalize]
-    #
-    # @api private
-    class Lifecycle < BasicObject
-      attr_reader :container
-
-      attr_reader :statuses
-
-      attr_reader :triggers
-
-      attr_reader :opts
-
-      # @api private
-      def self.new(container, opts = {}, &block)
-        cache.fetch_or_store([container, opts, block].hash) do
-          super
-        end
-      end
-
-      # @api private
-      def self.cache
-        @cache ||= ::Concurrent::Map.new
-      end
-
-      # @api private
-      def initialize(container, opts, &block)
-        @container = container
-        @settings = nil
-        @statuses = []
-        @triggers = {}
-        @opts = opts
-        instance_exec(target, &block)
-      end
-
-      # @api private
-      def call(*triggers)
-        triggers.each do |trigger|
-          unless statuses.include?(trigger)
-            __send__(trigger)
-            statuses << trigger
-          end
-        end
-      end
-
-      # @api private
-      def settings(&block)
-        component.settings(&block)
-      end
-
-      # @api private
-      def configure(&block)
-        component.configure(&block)
-      end
-
-      # @api private
-      def config
-        component.config
-      end
-
-      # @api private
-      def init(&block)
-        trigger!(:init, &block)
-      end
-
-      # @api private
-      def start(&block)
-        trigger!(:start, &block)
-      end
-
-      # @api private
-      def stop(&block)
-        trigger!(:stop, &block)
-      end
-
-      # @api private
-      def use(*names)
-        names.each do |name|
-          target.start(name)
-        end
-      end
-
-      # @api private
-      def register(*args, &block)
-        container.register(*args, &block)
-      end
-
-      # @api private
-      def component
-        opts[:component]
-      end
-
-      # @api private
-      def target
-        component.container
-      end
-
-      private
-
-      # @api private
-      def trigger!(name, &block)
-        if triggers.key?(name)
-          triggers[name].(target)
-        elsif block
-          triggers[name] = block
-        end
-      end
-
-      # @api private
-      def method_missing(meth, *args, &block)
-        if target.registered?(meth)
-          target[meth]
-        elsif container.key?(meth)
-          container[meth]
-        elsif ::Kernel.respond_to?(meth)
-          ::Kernel.public_send(meth, *args, &block)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/dry/system/provider_registry.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  module System
-    class ProviderRegistry
-      include Enumerable
-
-      attr_reader :items
-
-      def initialize
-        @items = []
-      end
-
-      def each(&block)
-        items.each(&block)
-      end
-
-      def register(name, options)
-        items << Provider.new(name, options)
-      end
-
-      def [](name)
-        detect { |provider| provider.name == name }
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system/settings/file_parser"
-
-module Dry
-  module System
-    module Settings
-      class FileLoader
-        def call(root, env)
-          files(root, env).reduce({}) do |hash, file|
-            hash.merge(parser.(file))
-          end
-        end
-
-        private
-
-        def parser
-          @parser ||= FileParser.new
-        end
-
-        def files(root, env)
-          [
-            root.join(".env"),
-            root.join(".env.#{env}")
-          ].compact
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  module System
-    module Settings
-      class FileParser
-        # Regex extracted from dotenv gem
-        # https://github.com/bkeepers/dotenv/blob/master/lib/dotenv/parser.rb#L14
-        LINE = /
-          \A
-          \s*
-          (?:export\s+)?    # optional export
-          ([\w\.]+)         # key
-          (?:\s*=\s*|:\s+?) # separator
-          (                 # optional value begin
-            '(?:\'|[^'])*'  #   single quoted value
-            |               #   or
-            "(?:\"|[^"])*"  #   double quoted value
-            |               #   or
-            [^#\n]+         #   unquoted value
-          )?                # value end
-          \s*
-          (?:\#.*)?         # optional comment
-          \z
-        /x.freeze
-
-        def call(file)
-          File.readlines(file).each_with_object({}) do |line, hash|
-            parse_line(line, hash)
-          end
-        rescue Errno::ENOENT
-          {}
-        end
-
-        private
-
-        def parse_line(line, hash)
-          if (match = line.match(LINE))
-            key, value = match.captures
-            hash[key] = parse_value(value || "")
-          end
-          hash
-        end
-
-        def parse_value(value)
-          value.strip.sub(/\A(['"])(.*)\1\z/, '\2')
-        end
-      end
-    end
-  end
-end

data/lib/dry/system/settings.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/core/class_builder"
-require "dry/types"
-require "dry/struct"
-
-require "dry/system/settings/file_loader"
-require "dry/system/constants"
-
-module Dry
-  module System
-    module Settings
-      class DSL < BasicObject
-        attr_reader :schema
-
-        def initialize(&block)
-          @schema = {}
-          instance_eval(&block)
-        end
-
-        def call
-          Core::ClassBuilder.new(name: "Configuration", parent: Configuration).call do |klass|
-            schema.each do |key, type|
-              klass.setting(key, type)
-            end
-          end
-        end
-
-        def key(name, type)
-          schema[name] = type
-        end
-      end
-
-      class Configuration < Dry::Struct
-        def self.setting(*args)
-          attribute(*args)
-        end
-
-        def self.init(root, env)
-          env_data = load_files(root, env)
-          attributes = {}
-          errors = {}
-
-          schema.each do |key|
-            value = ENV.fetch(key.name.to_s.upcase) { env_data[key.name.to_s.upcase] }
-            type_check = key.try(value || Undefined)
-
-            attributes[key.name] = value if value
-            errors[key] = type_check if type_check.failure?
-          end
-
-          raise InvalidSettingsError, errors unless errors.empty?
-
-          new(attributes)
-        end
-
-        def self.load_files(root, env)
-          FileLoader.new.(root, env)
-        end
-        private_class_method :load_files
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-Dry::System.register_component(:settings, provider: :system) do
-  init do
-    require "dry/system/settings"
-  end
-
-  start do
-    register(:settings, settings.init(target.root, target.config.env))
-  end
-end