piko-quick-lib 0.0.1

data/dry-system-1.2.5/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2025 Hanakai team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/dry-system-1.2.5/README.md

@@ -0,0 +1,17 @@
+<!--- This file is synced from hanakai-rb/repo-sync -->
+
+[rubygem]: https://rubygems.org/gems/dry-system
+[actions]: https://github.com/dry-rb/dry-system/actions
+
+# dry-system [![Gem Version](https://badge.fury.io/rb/dry-system.svg)][rubygem] [![CI Status](https://github.com/dry-rb/dry-system/workflows/CI/badge.svg)][actions]
+
+## Links
+
+- [User documentation](https://dry-rb.org/gems/dry-system)
+- [API documentation](http://rubydoc.info/gems/dry-system)
+- [Forum](https://discourse.dry-rb.org)
+
+## License
+
+See `LICENSE` file.
+

data/dry-system-1.2.5/dry-system.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# This file is synced from hanakai-rb/repo-sync. To update it, edit repo-sync.yml.
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dry/system/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dry-system"
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
+  spec.license       = "MIT"
+  spec.version       = Dry::System::VERSION.dup
+
+  spec.summary       = "Organize your code into reusable components"
+  spec.description   = spec.summary
+  spec.homepage      = "https://dry-rb.org/gems/dry-system"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-system.gemspec", "lib/**/*"]
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-system/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-system"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-system/issues"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.add_runtime_dependency "dry-auto_inject", "~> 1.1"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.3"
+  spec.add_runtime_dependency "dry-core", "~> 1.1"
+  spec.add_runtime_dependency "dry-inflector", "~> 1.1"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end
+

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    # Default auto-registration implementation
+    #
+    # This is currently configured by default for every System::Container.
+    # Auto-registrar objects are responsible for loading files from configured
+    # auto-register paths and registering components automatically within the
+    # container.
+    #
+    # @api private
+    class AutoRegistrar
+      attr_reader :container
+
+      def initialize(container)
+        @container = container
+      end
+
+      # @api private
+      def finalize!
+        container.component_dirs.each do |component_dir|
+          call(component_dir) if component_dir.auto_register?
+        end
+      end
+
+      # @api private
+      def call(component_dir)
+        component_dir.each_component do |component|
+          next unless register_component?(component)
+
+          container.register(component.key, memoize: component.memoize?) { component.instance }
+        end
+      end
+
+      private
+
+      def register_component?(component)
+        !container.registered?(component.key) && component.auto_register?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/inflector"
+require "dry/system/errors"
+require "dry/system/constants"
+
+module Dry
+  module System
+    # Components are objects providing information about auto-registered files.
+    # They expose an API to query this information and use a configurable
+    # loader object to initialize class instances.
+    #
+    # @api public
+    class Component
+      include Dry::Equalizer(:identifier, :file_path, :namespace, :options)
+
+      DEFAULT_OPTIONS = {
+        inflector: Dry::Inflector.new,
+        loader: Loader
+      }.freeze
+
+      # @!attribute [r] identifier
+      #   @return [String] the component's unique identifier
+      attr_reader :identifier
+
+      # @!attribute [r] file_path
+      #   @return [Pathname] the component's source file path
+      attr_reader :file_path
+
+      # @!attribute [r] namespace
+      #   @return [Dry::System::Config::Namespace] the component's namespace
+      attr_reader :namespace
+
+      # @!attribute [r] options
+      #   @return [Hash] the component's options
+      attr_reader :options
+
+      # @api private
+      def initialize(identifier, file_path:, namespace:, **options)
+        @identifier = identifier
+        @file_path = Pathname(file_path)
+        @namespace = namespace
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      # Returns true, indicating that the component is directly loadable from the files
+      # managed by the container
+      #
+      # This is the inverse of {IndirectComponent#loadable?}
+      #
+      # @return [TrueClass]
+      #
+      # @api private
+      def loadable?
+        true
+      end
+
+      # Returns the component's instance
+      #
+      # @return [Object] component's class instance
+      # @api public
+      def instance(*args, **kwargs)
+        options[:instance]&.call(self, *args, **kwargs) || loader.call(self, *args, **kwargs)
+      end
+
+      # Returns the component's unique key
+      #
+      # @return [String] the key
+      #
+      # @see Identifier#key
+      #
+      # @api public
+      def key
+        identifier.key
+      end
+
+      # Returns the root namespace segment of the component's key, as a symbol
+      #
+      # @see Identifier#root_key
+      #
+      # @return [Symbol] the root key
+      #
+      # @api public
+      def root_key
+        identifier.root_key
+      end
+
+      # Returns a path-delimited representation of the compnent, appropriate for passing
+      # to `Kernel#require` to require its source file
+      #
+      # The path takes into account the rules of the namespace used to load the component.
+      #
+      # @example Component from a root namespace
+      #   component.key # => "articles.create"
+      #   component.require_path # => "articles/create"
+      #
+      # @example Component from an "admin/" path namespace (with `key: nil`)
+      #   component.key # => "articles.create"
+      #   component.require_path # => "admin/articles/create"
+      #
+      # @see Config::Namespaces#add
+      # @see Config::Namespace
+      #
+      # @return [String] the require path
+      #
+      # @api public
+      def require_path
+        if namespace.path
+          "#{namespace.path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
+      end
+
+      # Returns an "underscored", path-delimited representation of the component,
+      # appropriate for passing to the inflector for constantizing
+      #
+      # The const path takes into account the rules of the namespace used to load the
+      # component.
+      #
+      # @example Component from a namespace with `const: nil`
+      #   component.key # => "articles.create_article"
+      #   component.const_path # => "articles/create_article"
+      #   component.inflector.constantize(component.const_path) # => Articles::CreateArticle
+      #
+      # @example Component from a namespace with `const: "admin"`
+      #   component.key # => "articles.create_article"
+      #   component.const_path # => "admin/articles/create_article"
+      #   component.inflector.constantize(component.const_path) # => Admin::Articles::CreateArticle
+      #
+      # @see Config::Namespaces#add
+      # @see Config::Namespace
+      #
+      # @return [String] the const path
+      #
+      # @api public
+      def const_path
+        namespace_const_path = namespace.const&.gsub(KEY_SEPARATOR, PATH_SEPARATOR)
+
+        if namespace_const_path
+          "#{namespace_const_path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
+      end
+
+      # @api private
+      def loader
+        options.fetch(:loader)
+      end
+
+      # @api private
+      def inflector
+        options.fetch(:inflector)
+      end
+
+      # @api private
+      def auto_register?
+        callable_option?(options[:auto_register])
+      end
+
+      # @api private
+      def memoize?
+        callable_option?(options[:memoize])
+      end
+
+      private
+
+      def path_in_namespace
+        identifier_in_namespace =
+          if namespace.key
+            identifier.namespaced(from: namespace.key, to: nil)
+          else
+            identifier
+          end
+
+        identifier_in_namespace.key_with_separator(PATH_SEPARATOR)
+      end
+
+      def callable_option?(value)
+        if value.respond_to?(:call)
+          !!value.call(self)
+        else
+          !!value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/system/constants"
+
+module Dry
+  module System
+    # A configured component directory within the container's root. Provides access to the
+    # component directory's configuration, as well as methods for locating component files
+    # within the directory
+    #
+    # @see Dry::System::Config::ComponentDir
+    # @api private
+    class ComponentDir
+      # @!attribute [r] config
+      #   @return [Dry::System::Config::ComponentDir] the component directory configuration
+      #   @api private
+      attr_reader :config
+
+      # @!attribute [r] container
+      #   @return [Dry::System::Container] the container managing the component directory
+      #   @api private
+      attr_reader :container
+
+      # @api private
+      def initialize(config:, container:)
+        @config = config
+        @container = container
+      end
+
+      # Returns a component for the given key if a matching source file is found within
+      # the component dir
+      #
+      # This searches according to the component dir's configured namespaces, in order of
+      # definition, with the first match returned as the component.
+      #
+      # @param key [String] the component's key
+      # @return [Dry::System::Component, nil] the component, if found
+      #
+      # @api private
+      def component_for_key(key)
+        config.namespaces.each do |namespace|
+          identifier = Identifier.new(key)
+
+          next unless identifier.start_with?(namespace.key)
+
+          if (file_path = find_component_file(identifier, namespace))
+            return build_component(identifier, namespace, file_path)
+          end
+        end
+
+        nil
+      end
+
+      def each_component
+        return enum_for(:each_component) unless block_given?
+
+        each_file do |file_path, namespace|
+          yield component_for_path(file_path, namespace)
+        end
+      end
+
+      private
+
+      def each_file
+        return enum_for(:each_file) unless block_given?
+
+        raise ComponentDirNotFoundError, full_path unless Dir.exist?(full_path)
+
+        config.namespaces.each do |namespace|
+          files(namespace).each do |file|
+            yield file, namespace
+          end
+        end
+      end
+
+      def files(namespace)
+        if namespace.path?
+          ::Dir[::File.join(full_path, namespace.path, "**", RB_GLOB)]
+        else
+          non_root_paths = config.namespaces.to_a.reject(&:root?).map(&:path)
+
+          ::Dir[::File.join(full_path, "**", RB_GLOB)].reject { |file_path|
+            Pathname(file_path).relative_path_from(full_path).to_s.start_with?(*non_root_paths)
+          }
+        end
+      end
+
+      # Returns the full path of the component directory
+      #
+      # @return [Pathname]
+      def full_path
+        container.root.join(path)
+      end
+
+      # Returns a component for a full path to a Ruby source file within the component dir
+      #
+      # @param path [String] the full path to the file
+      # @return [Dry::System::Component] the component
+      def component_for_path(path, namespace)
+        key = Pathname(path).relative_path_from(full_path).to_s
+          .sub(RB_EXT, EMPTY_STRING)
+          .scan(WORD_REGEX)
+          .join(KEY_SEPARATOR)
+
+        identifier = Identifier.new(key)
+          .namespaced(
+            from: namespace.path&.gsub(PATH_SEPARATOR, KEY_SEPARATOR),
+            to: namespace.key
+          )
+
+        build_component(identifier, namespace, path)
+      end
+
+      def find_component_file(identifier, namespace)
+        # To properly find the file within a namespace with a key, we should strip the key
+        # from beginning of our given identifier
+        if namespace.key
+          identifier = identifier.namespaced(from: namespace.key, to: nil)
+        end
+
+        file_name = "#{identifier.key_with_separator(PATH_SEPARATOR)}#{RB_EXT}"
+
+        component_file =
+          if namespace.path?
+            full_path.join(namespace.path, file_name)
+          else
+            full_path.join(file_name)
+          end
+
+        component_file if component_file.exist?
+      end
+
+      def build_component(identifier, namespace, file_path)
+        options = {
+          inflector: container.config.inflector,
+          **component_options,
+          **MagicCommentsParser.(file_path)
+        }
+
+        Component.new(
+          identifier,
+          namespace: namespace,
+          file_path: file_path,
+          **options
+        )
+      end
+
+      def component_options
+        {
+          auto_register: auto_register,
+          loader: loader,
+          instance: instance,
+          memoize: memoize
+        }
+      end
+
+      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) || super
+      end
+    end
+  end
+end