piko-quick-lib 0.0.1

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

@@ -0,0 +1,289 @@
+# 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 public
+    # @since 1.1.0
+    class ProviderRegistrar
+      # @api private
+      attr_reader :providers
+
+      # @api private
+      attr_reader :container
+
+      # Returns the container exposed to providers as `target_container`.
+      #
+      # @return [Dry::System::Container]
+      #
+      # @api public
+      # @since 1.1.0
+      alias_method :target_container, :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, from: nil, source: nil, if: true, **provider_options, &)
+        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_given? && 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,
+              source: source || name,
+              group: from,
+              options: provider_options,
+              &
+            )
+          else
+            build_provider(
+              name,
+              source: source,
+              options: provider_options,
+              &
+            )
+          end
+
+        providers[provider.name] = provider
+
+        self
+      end
+
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # Returns a provider if it can be found or loaded, otherwise nil
+      #
+      # @return [Dry::System::Provider, nil]
+      #
+      # @api public
+      def [](provider_name)
+        provider_name = provider_name.to_sym
+
+        if (provider = providers[provider_name])
+          return provider
+        end
+
+        return if finalized?
+
+        require_provider_file(provider_name)
+
+        providers[provider_name]
+      end
+
+      # @api public
+      alias_method :find_and_load_provider, :[]
+
+      # @api private
+      def key?(provider_name)
+        providers.key?(provider_name)
+      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)|
+          files = ::Dir["#{path}/#{RB_GLOB}"]
+
+          files.each do |file|
+            basename = ::File.basename(file)
+
+            unless loaded.include?(basename)
+              provider_files << Pathname(file)
+              loaded << basename
+            end
+          end
+        }.first
+      end
+
+      # Extension point for subclasses to customize their
+      # provider source superclass. Expected to be a subclass
+      # of Dry::System::Provider::Source
+      #
+      # @api public
+      # @since 1.1.0
+      def provider_source_class = Dry::System::Provider::Source
+
+      # Extension point for subclasses to customize initialization
+      # params for provider_source_class
+      #
+      # @api public
+      # @since 1.1.0
+      def provider_source_options = {}
+
+      # @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, options:, source: nil, &)
+        source_class = source || Provider::Source.for(
+          name: name,
+          superclass: provider_source_class,
+          &
+        )
+
+        source_options =
+          if source_class < provider_source_class
+            provider_source_options
+          else
+            {}
+          end
+
+        Provider.new(
+          **options,
+          name: name,
+          target_container: target_container,
+          source_class: source_class,
+          source_options: source_options
+        )
+      end
+
+      def build_provider_from_source(name, source:, group:, options:, &)
+        provider_source = System.provider_sources.resolve(name: source, group: group)
+
+        source_options =
+          if provider_source.source <= provider_source_class
+            provider_source_options
+          else
+            {}
+          end
+
+        Provider.new(
+          **provider_source.provider_options,
+          **options,
+          name: name,
+          target_container: target_container,
+          source_class: provider_source.source,
+          source_options: source_options,
+          &
+        )
+      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/dry-system-1.2.5/lib/dry/system/provider_source_registry.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # @api private
+    class ProviderSourceRegistry
+      # @api private
+      class Registration
+        attr_reader :source
+        attr_reader :provider_options
+
+        def initialize(source:, provider_options:)
+          @source = source
+          @provider_options = provider_options
+        end
+      end
+
+      attr_reader :sources
+
+      def initialize
+        @sources = {}
+      end
+
+      def load_sources(path)
+        ::Dir[::File.join(path, "**/#{RB_GLOB}")].each do |file|
+          require file
+        end
+      end
+
+      def register(name:, group:, source:, provider_options:)
+        sources[key(name, group)] = Registration.new(
+          source: source,
+          provider_options: provider_options
+        )
+      end
+
+      def register_from_block(name:, group:, provider_options:, &)
+        register(
+          name: name,
+          group: group,
+          source: Provider::Source.for(name: name, group: group, &),
+          provider_options: provider_options
+        )
+      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/dry-system-1.2.5/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 => exception # rubocop:disable Style/RescueStandardError
+                  errors[setting.name] = exception
+                end
+              end
+
+              raise InvalidSettingsError, errors unless errors.empty?
+            end
+          end
+
+          include Dry::Configurable
+
+          private
+
+          def method_missing(name, ...)
+            if config.respond_to?(name)
+              config.public_send(name, ...)
+            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/dry-system-1.2.5/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/dry-system-1.2.5/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/dry-system-1.2.5/lib/dry/system/provider_sources.rb

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

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "dry/core/container/stub"
+
+module Dry
+  module System
+    class Container
+      # @api private
+      module Stubs
+        # This overrides default finalize! just to disable automatic freezing
+        # of the container
+        #
+        # @api private
+        def finalize!(**, &)
+          super(freeze: false, &)
+        end
+      end
+
+      # Enables stubbing container's components
+      #
+      # @example
+      #   require 'dry/system/stubs'
+      #
+      #   MyContainer.enable_stubs!
+      #   MyContainer.finalize!
+      #
+      #   MyContainer.stub('some.component', some_stub_object)
+      #
+      # @return Container
+      #
+      # @api public
+      def self.enable_stubs!
+        super
+        extend ::Dry::System::Container::Stubs
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    VERSION = "1.2.5"
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "dry/core"
+
+module Dry
+  module System
+    # @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_sources(path)
+      provider_sources.load_sources(path)
+    end
+
+    # Registers a provider source, which can be used as the basis for other providers
+    #
+    # @api public
+    def self.register_provider_source(name, group:, source: nil, provider_options: {}, &)
+      if source && block_given?
+        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,
+          provider_options: provider_options
+        )
+      else
+        provider_sources.register_from_block(
+          name: name,
+          group: group,
+          provider_options: provider_options,
+          &
+        )
+      end
+    end
+
+    # @api private
+    def self.provider_sources
+      @provider_sources ||= ProviderSourceRegistry.new
+    end
+
+    loader.setup
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "dry/system"

data/piko-quick-lib.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = "piko-quick-lib"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on dry-system"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+end