piko-quick-lib 0.0.1

data/dry-system-1.2.5/lib/dry/system/manifest_registrar.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # Default manifest registration implementation
+    #
+    # This is configured by default for every System::Container. The manifest registrar is
+    # responsible for loading manifest files that contain code to manually register
+    # certain objects with the container.
+    #
+    # @api private
+    class ManifestRegistrar
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :config
+
+      # @api private
+      def initialize(container)
+        @container = container
+        @config = container.config
+      end
+
+      # @api private
+      def finalize!
+        ::Dir[registrations_dir.join(RB_GLOB)].each do |file|
+          call(Identifier.new(File.basename(file, RB_EXT)))
+        end
+      end
+
+      # @api private
+      def call(component)
+        load(root.join(config.registrations_dir, "#{component.root_key}#{RB_EXT}"))
+      end
+
+      # @api private
+      def file_exists?(component)
+        ::File.exist?(::File.join(registrations_dir, "#{component.root_key}#{RB_EXT}"))
+      end
+
+      private
+
+      # @api private
+      def registrations_dir
+        root.join(config.registrations_dir)
+      end
+
+      # @api private
+      def root
+        container.root
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/bootsnap.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      module Bootsnap
+        DEFAULT_OPTIONS = {
+          load_path_cache: true,
+          compile_cache_iseq: true,
+          compile_cache_yaml: true
+        }.freeze
+
+        # @api private
+        def self.extended(system)
+          super
+
+          system.use(:env)
+          system.setting :bootsnap, default: DEFAULT_OPTIONS
+          system.after(:configure, &:setup_bootsnap)
+        end
+
+        # @api private
+        def self.dependencies
+          {bootsnap: "bootsnap"}
+        end
+
+        # Set up bootsnap for faster booting
+        #
+        # @api public
+        def setup_bootsnap
+          return unless bootsnap_available?
+
+          ::Bootsnap.setup(**config.bootsnap, cache_dir: root.join("tmp/cache").to_s)
+        end
+
+        # @api private
+        def bootsnap_available?
+          spec = Gem.loaded_specs["bootsnap"] or return false
+
+          RUBY_ENGINE == "ruby" &&
+            spec.match_platform(RUBY_PLATFORM) &&
+            spec.required_ruby_version.satisfied_by?(Gem::Version.new(RUBY_VERSION))
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/dependency_graph/strategies.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      module DependencyGraph
+        # @api private
+        class Strategies
+          extend Core::Container::Mixin
+
+          # @api private
+          class Kwargs < Dry::AutoInject::Strategies::Kwargs
+            private
+
+            # @api private
+            def define_initialize(klass)
+              @container["notifications"].instrument(
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
+              )
+
+              super
+            end
+          end
+
+          # @api private
+          class Args < Dry::AutoInject::Strategies::Args
+            private
+
+            # @api private
+            def define_initialize(klass)
+              @container["notifications"].instrument(
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
+              )
+
+              super
+            end
+          end
+
+          class Hash < Dry::AutoInject::Strategies::Hash
+            private
+
+            # @api private
+            def define_initialize(klass)
+              @container["notifications"].instrument(
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
+              )
+
+              super
+            end
+          end
+
+          register :kwargs, Kwargs
+          register :args, Args
+          register :hash, Hash
+          register :default, Kwargs
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/dependency_graph.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      # @api public
+      module DependencyGraph
+        # @api private
+        def self.extended(system)
+          super
+
+          system.instance_eval do
+            use(:notifications)
+
+            setting :dependency_graph do
+              setting :ignored_dependencies, default: []
+            end
+
+            after(:configure) do
+              self[:notifications].register_event(:resolved_dependency)
+              self[:notifications].register_event(:registered_dependency)
+            end
+          end
+        end
+
+        # @api private
+        def self.dependencies
+          {"dry-events" => "dry/events/publisher"}
+        end
+
+        # @api private
+        def injector(**options)
+          super(**options, strategies: DependencyGraph::Strategies)
+        end
+
+        # @api private
+        def register(key, contents = nil, options = {}, &)
+          super.tap do
+            key = key.to_s
+
+            unless config.dependency_graph.ignored_dependencies.include?(key)
+              self[:notifications].instrument(
+                :registered_dependency,
+                key: key,
+                class: self[key].class
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/env.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      # @api public
+      class Env < Module
+        DEFAULT_INFERRER = -> { :development }
+
+        attr_reader :options
+
+        # @api private
+        def initialize(**options)
+          @options = options
+          super()
+        end
+
+        def inferrer
+          options.fetch(:inferrer, DEFAULT_INFERRER)
+        end
+
+        # @api private
+        def extended(system)
+          system.setting :env, default: inferrer.(), reader: true
+          super
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/logging.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Dry
+  module System
+    module Plugins
+      module Logging
+        # @api private
+        def self.extended(system)
+          system.instance_eval do
+            setting :logger, reader: true
+
+            setting :log_dir, default: "log"
+
+            setting :log_levels, default: {
+              development: Logger::DEBUG,
+              test: Logger::DEBUG,
+              production: Logger::ERROR
+            }
+
+            setting :logger_class, default: ::Logger, reader: true
+          end
+
+          system.after(:configure, &:register_logger)
+
+          super
+        end
+
+        # Set a logger
+        #
+        # This is invoked automatically when a container is being configured
+        #
+        # @return [self]
+        #
+        # @api private
+        def register_logger
+          if registered?(:logger)
+            self
+          elsif config.logger
+            register(:logger, config.logger)
+          else
+            config.logger = config.logger_class.new(log_file_path)
+            config.logger.level = log_level
+
+            register(:logger, config.logger)
+            self
+          end
+        end
+
+        # @api private
+        def log_level
+          config.log_levels.fetch(config.env, Logger::ERROR)
+        end
+
+        # @api private
+        def log_dir_path
+          root.join(config.log_dir).realpath
+        end
+
+        # @api private
+        def log_file_path
+          log_dir_path.join(log_file_name)
+        end
+
+        # @api private
+        def log_file_name
+          "#{config.env}.log"
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/monitoring/proxy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Dry
+  module System
+    module Plugins
+      module Monitoring
+        # @api private
+        class Proxy < SimpleDelegator
+          # @api private
+          def self.for(target, key:, methods: [])
+            monitored_methods =
+              if methods.empty?
+                target.public_methods - Object.public_instance_methods
+              else
+                methods
+              end
+
+            Class.new(self) do
+              extend Dry::Core::ClassAttributes
+              include Dry::Events::Publisher[target.class.name]
+
+              defines :monitored_methods
+
+              attr_reader :__notifications__
+
+              monitored_methods(monitored_methods)
+
+              monitored_methods.each do |meth|
+                define_method(meth) do |*args, **kwargs, &block|
+                  object = __getobj__
+                  opts = {target: key, object: object, method: meth, args: args, kwargs: kwargs}
+
+                  __notifications__.instrument(:monitoring, opts) do
+                    object.public_send(meth, *args, **kwargs, &block)
+                  end
+                end
+              end
+            end
+          end
+
+          def initialize(target, notifications)
+            super(target)
+            @__notifications__ = notifications
+          end
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/monitoring.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    module Plugins
+      # @api public
+      module Monitoring
+        # @api private
+        def self.extended(system)
+          super
+
+          system.use(:notifications)
+
+          system.after(:configure) do
+            self[:notifications].register_event(:monitoring)
+          end
+        end
+
+        # @api private
+        def self.dependencies
+          {"dry-events": "dry/events/publisher"}
+        end
+
+        # @api private
+        def monitor(key, **options, &block)
+          notifications = self[:notifications]
+
+          resolve(key).tap do |target|
+            proxy = Proxy.for(target, **options, key: key)
+
+            if block_given?
+              proxy.monitored_methods.each do |meth|
+                notifications.subscribe(:monitoring, target: key, method: meth, &block)
+              end
+            end
+
+            decorate(key, with: -> tgt { proxy.new(tgt, notifications) })
+          end
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/notifications.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      # @api public
+      module Notifications
+        # @api private
+        def self.extended(system)
+          system.after(:configure, &:register_notifications)
+        end
+
+        # @api private
+        def self.dependencies
+          {"dry-monitor": "dry/monitor"}
+        end
+
+        # @api private
+        def register_notifications
+          return self if registered?(:notifications)
+
+          register(:notifications, Monitor::Notifications.new(config.name))
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      # @api private
+      class Plugin
+        attr_reader :name
+
+        attr_reader :mod
+
+        attr_reader :block
+
+        # @api private
+        def initialize(name, mod, &block)
+          @name = name
+          @mod = mod
+          @block = block
+        end
+
+        # @api private
+        def apply_to(system, **options)
+          system.extend(stateful? ? mod.new(**options) : mod)
+          system.instance_eval(&block) if block
+          system
+        end
+
+        # @api private
+        def load_dependencies(dependencies = mod_dependencies, gem = nil)
+          Array(dependencies).each do |dependency|
+            if dependency.is_a?(Array) || dependency.is_a?(Hash)
+              dependency.each { |value| load_dependencies(*Array(value).reverse) }
+            elsif !Plugins.loaded_dependencies.include?(dependency.to_s)
+              load_dependency(dependency, gem)
+            end
+          end
+        end
+
+        # @api private
+        def load_dependency(dependency, gem)
+          Kernel.require dependency
+          Plugins.loaded_dependencies << dependency.to_s
+        rescue LoadError => exception
+          raise PluginDependencyMissing.new(name, exception.message, gem)
+        end
+
+        # @api private
+        def stateful?
+          mod < Module
+        end
+
+        # @api private
+        def mod_dependencies
+          return EMPTY_ARRAY unless mod.respond_to?(:dependencies)
+
+          mod.dependencies.is_a?(Array) ? mod.dependencies : [mod.dependencies]
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/zeitwerk/compat_inflector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      class Zeitwerk < Module
+        # @api private
+        class CompatInflector
+          attr_reader :config
+
+          def initialize(config)
+            @config = config
+          end
+
+          def camelize(string, _)
+            config.inflector.camelize(string)
+          end
+        end
+      end
+    end
+  end
+end

data/dry-system-1.2.5/lib/dry/system/plugins/zeitwerk.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    module Plugins
+      # @api private
+      class Zeitwerk < Module
+        # @api private
+        def self.dependencies
+          [
+            "dry/system/loader/autoloading",
+            "dry/system/plugins/zeitwerk/compat_inflector",
+            {"zeitwerk" => "zeitwerk"}
+          ]
+        end
+
+        # @api private
+        attr_reader :loader, :run_setup, :eager_load, :debug
+
+        # @api private
+        def initialize(loader: nil, run_setup: true, eager_load: nil, debug: false)
+          @loader = loader || ::Zeitwerk::Loader.new
+          @run_setup = run_setup
+          @eager_load = eager_load
+          @debug = debug
+          super()
+        end
+
+        # @api private
+        def extended(system)
+          system.setting :autoloader, reader: true
+
+          system.config.autoloader = loader
+          system.config.component_dirs.loader = Dry::System::Loader::Autoloading
+          system.config.component_dirs.add_to_load_path = false
+
+          system.after(:configure, &method(:setup_autoloader))
+
+          super
+        end
+
+        private
+
+        def setup_autoloader(system)
+          configure_loader(system.autoloader, system)
+
+          push_component_dirs_to_loader(system, system.autoloader)
+
+          system.autoloader.setup if run_setup
+
+          system.after(:finalize) { system.autoloader.eager_load } if eager_load?(system)
+
+          system
+        end
+
+        # Build a zeitwerk loader with the configured component directories
+        #
+        # @return [Zeitwerk::Loader]
+        def configure_loader(loader, system)
+          loader.tag = system.config.name || system.name unless loader.tag
+          loader.inflector = CompatInflector.new(system.config)
+          loader.logger = method(:puts) if debug
+        end
+
+        # Add component dirs to the zeitwerk loader
+        #
+        # @return [Zeitwerk::Loader]
+        def push_component_dirs_to_loader(system, loader)
+          system.config.component_dirs.each do |dir|
+            dir.namespaces.each do |ns|
+              loader.push_dir(
+                system.root.join(dir.path, ns.path.to_s),
+                namespace: module_for_namespace(ns, system.config.inflector)
+              )
+            end
+          end
+
+          loader
+        end
+
+        def module_for_namespace(namespace, inflector)
+          return Object unless namespace.const
+
+          begin
+            inflector.constantize(inflector.camelize(namespace.const))
+          rescue NameError
+            namespace.const.split(PATH_SEPARATOR).reduce(Object) { |parent_mod, mod_path|
+              get_or_define_module(parent_mod, inflector.camelize(mod_path))
+            }
+          end
+        end
+
+        def get_or_define_module(parent_mod, name)
+          parent_mod.const_get(name)
+        rescue NameError
+          parent_mod.const_set(name, Module.new)
+        end
+
+        def eager_load?(system)
+          return eager_load unless eager_load.nil?
+
+          system.config.respond_to?(:env) && system.config.env == :production
+        end
+      end
+    end
+  end
+end