piko-quick-lib 0.0.1

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    # Error raised when import is called on an already finalized container
+    #
+    # @api public
+    ContainerAlreadyFinalizedError = Class.new(StandardError)
+
+    # Error raised when a component dir is added to configuration more than once
+    #
+    # @api public
+    ComponentDirAlreadyAddedError = Class.new(StandardError) do
+      def initialize(dir)
+        super("Component directory #{dir.inspect} already added")
+      end
+    end
+
+    # Error raised when a configured component directory could not be found
+    #
+    # @api public
+    ComponentDirNotFoundError = Class.new(StandardError) do
+      def initialize(dir)
+        super("Component dir '#{dir}' not found")
+      end
+    end
+
+    # Error raised when a namespace for a component dir is added to configuration more
+    # than once
+    #
+    # @api public
+    NamespaceAlreadyAddedError = Class.new(StandardError) do
+      def initialize(path)
+        path_label = path ? "path #{path.inspect}" : "root path"
+
+        super("Namespace for #{path_label} already added")
+      end
+    end
+
+    # Error raised when attempting to register provider using a name that has already been
+    # registered
+    #
+    # @api public
+    ProviderAlreadyRegisteredError = Class.new(ArgumentError) do
+      def initialize(provider_name)
+        super("Provider #{provider_name.inspect} has already been registered")
+      end
+    end
+
+    # Error raised when a named provider could not be found
+    #
+    # @api public
+    ProviderNotFoundError = Class.new(ArgumentError) do
+      def initialize(name)
+        super("Provider #{name.inspect} not found")
+      end
+    end
+
+    # Error raised when a named provider source could not be found
+    #
+    # @api public
+    ProviderSourceNotFoundError = Class.new(StandardError) do
+      def initialize(name:, group:, keys:)
+        msg = "Provider source not found: #{name.inspect}, group: #{group.inspect}"
+
+        key_list = keys.map { |key| "- #{key[:name].inspect}, group: #{key[:group].inspect}" }
+        msg += "Available provider sources:\n\n#{key_list}"
+
+        super(msg)
+      end
+    end
+
+    # Error raised when trying to use a plugin that does not exist.
+    #
+    # @api public
+    PluginNotFoundError = Class.new(StandardError) do
+      def initialize(plugin_name)
+        super("Plugin #{plugin_name.inspect} does not exist")
+      end
+    end
+
+    # Exception raise when a plugin dependency failed to load
+    #
+    # @api public
+    PluginDependencyMissing = Class.new(StandardError) do
+      # @api private
+      def initialize(plugin, message, gem = nil)
+        details = gem ? "#{message} - add #{gem} to your Gemfile" : message
+        super("dry-system plugin #{plugin.inspect} failed to load its dependencies: #{details}")
+      end
+    end
+
+    # Exception raised when auto-registerable component is not loadable
+    #
+    # @api public
+    ComponentNotLoadableError = Class.new(NameError) do
+      # @api private
+      def initialize(component, error,
+                     corrections: DidYouMean::ClassNameChecker.new(error).corrections)
+        full_class_name = [error.receiver, error.name].join("::")
+
+        message = [
+          "Component '#{component.key}' is not loadable.",
+          "Looking for #{full_class_name}."
+        ]
+
+        if corrections.any?
+          case_correction = corrections.find { |correction| correction.casecmp?(full_class_name) }
+          if case_correction
+            acronyms_needed = case_correction.split("::").difference(full_class_name.split("::"))
+            stringified_acronyms_needed = acronyms_needed.map { |acronym|
+              "'#{acronym}'"
+            } .join(", ")
+            message <<
+              <<~ERROR_MESSAGE
+
+                You likely need to add:
+
+                    acronym(#{stringified_acronyms_needed})
+
+                to your container's inflector, since we found a #{case_correction} class.
+              ERROR_MESSAGE
+          else
+            message << DidYouMean.formatter.message_for(corrections)
+          end
+        end
+
+        super(message.join("\n"))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # An identifier representing a component to be registered.
+    #
+    # Components are eventually registered in the container using plain string
+    # identifiers, available as the `identifier` or `key` attribute here. Additional
+    # methods are provided to make it easier to evaluate or manipulate these identifiers.
+    #
+    # @api public
+    class Identifier
+      include Dry::Equalizer(:key)
+
+      # @return [String] the identifier's string key
+      # @api public
+      attr_reader :key
+
+      # @api private
+      def initialize(key)
+        @key = key.to_s
+      end
+
+      # @!method to_s
+      #   Returns the identifier string key
+      #
+      #   @return [String]
+      #   @see #key
+      #   @api public
+      alias_method :to_s, :key
+
+      # Returns the root namespace segment of the identifier string, as a symbol
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #   identifier.root_key # => :articles
+      #
+      # @return [Symbol] the root key
+      # @api public
+      def root_key
+        segments.first.to_sym
+      end
+
+      # Returns true if the given leading segments string is a leading part of the {key}.
+      #
+      # Also returns true if nil or an empty string is given.
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #
+      #   identifier.start_with?("articles.operations") # => true
+      #   identifier.start_with?("articles") # => true
+      #   identifier.start_with?("article") # => false
+      #   identifier.start_with?(nil) # => true
+      #
+      # @param leading_segments [String] the one or more leading segments to check
+      # @return [Boolean]
+      # @api public
+      def start_with?(leading_segments)
+        leading_segments.to_s.empty? ||
+          key.start_with?("#{leading_segments}#{KEY_SEPARATOR}") ||
+          key.eql?(leading_segments)
+      end
+
+      # Returns true if the given trailing segments string is the end part of the {key}.
+      #
+      # Also returns true if nil or an empty string is given.
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #
+      #   identifier.end_with?("create") # => true
+      #   identifier.end_with?("operations.create") # => true
+      #   identifier.end_with?("ate") # => false, not a whole segment
+      #   identifier.end_with?("nup") # => false, not in key at all
+      #
+      # @param trailing_segments [String] the one or more trailing key segments to check
+      # @return [Boolean]
+      # @api public
+      def end_with?(trailing_segments)
+        trailing_segments.to_s.empty? ||
+          key.end_with?("#{KEY_SEPARATOR}#{trailing_segments}") ||
+          key.eql?(trailing_segments)
+      end
+
+      # Returns true if the given segments string matches whole segments within the {key}.
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #
+      #   identifier.include?("operations") # => true
+      #   identifier.include?("articles.operations") # => true
+      #   identifier.include?("operations.create") # => true
+      #
+      #   identifier.include?("article") # => false, not a whole segment
+      #   identifier.include?("update") # => false, not in key at all
+      #
+      # @param segments [String] the one of more key segments to check
+      # @return [Boolean]
+      # @api public
+      def include?(segments)
+        return false if segments.to_s.empty?
+
+        sep_re = Regexp.escape(KEY_SEPARATOR)
+        key.match?(
+          /
+            (\A|#{sep_re})
+            #{Regexp.escape(segments)}
+            (\Z|#{sep_re})
+          /x
+        )
+      end
+
+      # Returns the key with its segments separated by the given separator
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #   identifier.key_with_separator("/") # => "articles/operations/create"
+      #
+      # @return [String] the key using the separator
+      # @api private
+      def key_with_separator(separator)
+        segments.join(separator)
+      end
+
+      # Returns a copy of the identifier with the key's leading namespace(s) replaced
+      #
+      # @example Changing a namespace
+      #   identifier.key # => "articles.operations.create"
+      #   identifier.namespaced(from: "articles", to: "posts").key # => "posts.commands.create"
+      #
+      # @example Removing a namespace
+      #   identifier.key # => "articles.operations.create"
+      #   identifier.namespaced(from: "articles", to: nil).key # => "operations.create"
+      #
+      # @example Adding a namespace
+      #   identifier.key # => "articles.operations.create"
+      #   identifier.namespaced(from: nil, to: "admin").key # => "admin.articles.operations.create"
+      #
+      # @param from [String, nil] the leading namespace(s) to replace
+      # @param to [String, nil] the replacement for the leading namespace
+      #
+      # @return [Dry::System::Identifier] the copy of the identifier
+      #
+      # @see #initialize
+      # @api private
+      def namespaced(from:, to:)
+        return self if from == to
+
+        separated_to = "#{to}#{KEY_SEPARATOR}" if to
+
+        new_key =
+          if from.nil?
+            "#{separated_to}#{key}"
+          else
+            key.sub(
+              /^#{Regexp.escape(from.to_s)}#{Regexp.escape(KEY_SEPARATOR)}/,
+              separated_to || EMPTY_STRING
+            )
+          end
+
+        return self if new_key == key
+
+        self.class.new(new_key)
+      end
+
+      private
+
+      def segments
+        @segments ||= key.split(KEY_SEPARATOR)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # Default importer implementation
+    #
+    # This is currently configured by default for every System::Container.
+    # Importer objects are responsible for importing components from one
+    # container to another. This is used in cases where an application is split
+    # into multiple sub-systems.
+    #
+    # @api private
+    class Importer
+      # @api private
+      class Item
+        attr_reader :namespace, :container, :import_keys
+
+        def initialize(namespace:, container:, import_keys:)
+          @namespace = namespace
+          @container = container
+          @import_keys = import_keys
+        end
+      end
+
+      attr_reader :container
+
+      attr_reader :registry
+
+      # @api private
+      def initialize(container)
+        @container = container
+        @registry = {}
+      end
+
+      # @api private
+      def register(namespace:, container:, keys: nil)
+        registry[namespace_key(namespace)] = Item.new(
+          namespace: namespace,
+          container: container,
+          import_keys: keys
+        )
+      end
+
+      # @api private
+      def [](name)
+        registry.fetch(namespace_key(name))
+      end
+
+      # @api private
+      def key?(name)
+        registry.key?(namespace_key(name))
+      end
+      alias_method :namespace?, :key?
+
+      # @api private
+      def finalize!
+        registry.each_key { import(_1) }
+        self
+      end
+
+      # @api private
+      def import(namespace, keys: Undefined)
+        item = self[namespace]
+        keys = Undefined.default(keys, item.import_keys)
+
+        if keys
+          import_keys(item.container, namespace, keys_to_import(keys, item))
+        else
+          import_all(item.container, namespace)
+        end
+
+        self
+      end
+
+      private
+
+      # Returns nil if given a nil (i.e. root) namespace. Otherwise, converts the namespace to a
+      # string.
+      #
+      # This ensures imported components are found when either symbols or strings to given as the
+      # namespace in {Container.import}.
+      def namespace_key(namespace)
+        return nil if namespace.nil?
+
+        namespace.to_s
+      end
+
+      def keys_to_import(keys, item)
+        keys
+          .then { (arr = item.import_keys) ? _1 & arr : _1 }
+          .then { (arr = item.container.exports) ? _1 & arr : _1 }
+      end
+
+      def import_keys(other, namespace, keys)
+        merge(container, build_merge_container(other, keys), namespace: namespace)
+      end
+
+      def import_all(other, namespace)
+        merge_container =
+          if other.exports
+            build_merge_container(other, other.exports)
+          else
+            build_merge_container(other.finalize!, other.keys)
+          end
+
+        merge(container, merge_container, namespace: namespace)
+      end
+
+      # Merges `other` into `container`, favoring the container's existing registrations
+      def merge(container, other, namespace:)
+        container.merge(other, namespace: namespace) { |_key, old_item, new_item|
+          old_item || new_item
+        }
+      end
+
+      def build_merge_container(other, keys)
+        keys.each_with_object(Core::Container.new) { |key, ic|
+          next unless other.key?(key)
+
+          # Access the other container's items directly so that we can preserve all their
+          # options when we merge them with the target container (e.g. if a component in
+          # the provider container was registered with a block, we want block registration
+          # behavior to be exhibited when later resolving that component from the target
+          # container). TODO: Make this part of dry-system's public API.
+          item = other._container[key]
+
+          # By default, we "protect" components that were themselves imported into the
+          # other container from being implicitly exported; imported components are
+          # considered "private" and must be explicitly included in `exports` to be
+          # exported.
+          next if item.options[:imported] && !other.exports
+
+          if item.callable?
+            ic.register(key, **item.options, imported: true, &item.item)
+          else
+            ic.register(key, item.item, **item.options, imported: true)
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    # An indirect component is a component that cannot be directly from a source file
+    # directly managed by the container. It may be component that needs to be loaded
+    # indirectly, either via a registration manifest file or an imported container
+    #
+    # Indirect components are an internal abstraction and, unlike ordinary components, are
+    # not exposed to users via component dir configuration hooks.
+    #
+    # @see Container#load_component
+    # @see Container#find_component
+    #
+    # @api private
+    class IndirectComponent
+      include Dry::Equalizer(:identifier)
+
+      # @!attribute [r] identifier
+      #   @return [String] the component's unique identifier
+      attr_reader :identifier
+
+      # @api private
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      # Returns false, indicating that the component is not directly loadable from the
+      # files managed by the container
+      #
+      # This is the inverse of {Component#loadable?}
+      #
+      # @return [FalseClass]
+      #
+      # @api private
+      def loadable?
+        false
+      end
+
+      # Returns the component's unique key
+      #
+      # @return [String] the key
+      #
+      # @see Identifier#key
+      #
+      # @api private
+      def key
+        identifier.to_s
+      end
+
+      # Returns the root namespace segment of the component's key, as a symbol
+      #
+      # @see Identifier#root_key
+      #
+      # @return [Symbol] the root key
+      #
+      # @api private
+      def root_key
+        identifier.root_key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    class Loader
+      # Component loader for autoloading-enabled applications
+      #
+      # This behaves like the default loader, except instead of requiring the given path,
+      # it loads the respective constant, allowing the autoloader to load the
+      # corresponding file per its own configuration.
+      #
+      # @see Loader
+      # @api public
+      class Autoloading < Loader
+        class << self
+          def require!(component)
+            constant(component)
+            self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "dry/system/errors"
+
+module Dry
+  module System
+    # Default component loader implementation
+    #
+    # This class is configured by default for every System::Container. You can
+    # provide your own and use it in your containers too.
+    #
+    # @example
+    #   class MyLoader < Dry::System::Loader
+    #     def call(*args)
+    #       constant.build(*args)
+    #     end
+    #   end
+    #
+    #   class MyApp < Dry::System::Container
+    #     configure do |config|
+    #       # ...
+    #       config.component_dirs.loader = MyLoader
+    #     end
+    #   end
+    #
+    # @api public
+    class Loader
+      class << self
+        # Requires the component's source file
+        #
+        # @api public
+        def require!(component)
+          require(component.require_path)
+          self
+        end
+
+        # Returns an instance of the component
+        #
+        # Provided optional args are passed to object's constructor
+        #
+        # @param [Array] args Optional constructor args
+        #
+        # @return [Object]
+        #
+        # @api public
+        def call(component, *args, **kwargs)
+          require!(component)
+
+          constant = self.constant(component)
+
+          if singleton?(constant)
+            constant.instance(*args, **kwargs)
+          else
+            constant.new(*args, **kwargs)
+          end
+        end
+
+        # Returns the component's class constant
+        #
+        # @return [Class]
+        #
+        # @api public
+        def constant(component)
+          inflector = component.inflector
+          const_name = inflector.camelize(component.const_path)
+          inflector.constantize(const_name)
+        rescue NameError => exception
+          # Ensure it's this component's constant, not any other NameError within the component
+          if exception.message =~ /#{const_name}( |\n|$)/
+            raise ComponentNotLoadableError.new(component, exception)
+          else
+            raise exception
+          end
+        end
+
+        private
+
+        def singleton?(constant)
+          constant.respond_to?(:instance) && !constant.respond_to?(:new)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    class MagicCommentsParser
+      VALID_LINE_RE = /^(#.*)?$/
+      COMMENT_RE = /^#\s+(?<name>[A-Za-z]{1}[A-Za-z0-9_]+):\s+(?<value>.+?)$/
+
+      COERCIONS = {
+        "true" => true,
+        "false" => false
+      }.freeze
+
+      def self.call(file_name)
+        {}.tap do |options|
+          File.foreach(file_name) do |line|
+            break unless line =~ VALID_LINE_RE
+
+            if (comment = line.match(COMMENT_RE))
+              options[comment[:name].to_sym] = coerce(comment[:value])
+            end
+          end
+        end
+      end
+
+      def self.coerce(value)
+        COERCIONS.fetch(value) { value }
+      end
+    end
+  end
+end