piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/providers/rack.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  module Providers
+    # Provider source to register Rack integration components in Hanami slices.
+    #
+    # @see Hanami::Providers::Logger
+    # @see Hanami::Web::RackLogger
+    # @see https://github.com/rack/rack
+    # @see https://dry-rb.org/gems/dry-monitor/
+    #
+    # @api private
+    # @since 2.0.0
+    class Rack < Hanami::Provider::Source
+      # @api private
+      def prepare
+        Dry::Monitor.load_extensions(:rack)
+
+        # Explicitly register the Rack middleware events on our notifications bus. The Dry::Monitor
+        # rack extension (activated above) does register these globally, but if the notifications
+        # bus has been used before this provider loads, then it will have created its own separate
+        # local copy of all registered events as of that moment in time, which will not be included
+        # in the Rack events globally registered above.
+        notifications = target["notifications"]
+        notifications.register_event(Dry::Monitor::Rack::Middleware::REQUEST_START)
+        notifications.register_event(Dry::Monitor::Rack::Middleware::REQUEST_STOP)
+        notifications.register_event(Dry::Monitor::Rack::Middleware::REQUEST_ERROR)
+      end
+
+      # @api private
+      def start
+        slice.start :logger
+
+        monitor_middleware = Dry::Monitor::Rack::Middleware.new(
+          target["notifications"],
+          clock: Dry::Monitor::Clock.new(unit: :microsecond)
+        )
+
+        rack_logger = Hanami::Web::RackLogger.new(target[:logger], env: slice.container.env)
+        rack_logger.attach(monitor_middleware)
+
+        register "monitor", monitor_middleware
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/relations.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    # @api private
+    # @since 2.2.0
+    class Relations < Hanami::Provider::Source
+      def start
+        start_and_import_parent_relations and return if slice.parent && slice.config.db.import_from_parent
+
+        slice.start :db
+
+        register_relations target["db.rom"]
+      end
+
+      private
+
+      def register_relations(rom)
+        rom.relations.each do |name, _|
+          register name, rom.relations[name]
+        end
+      end
+
+      def start_and_import_parent_relations
+        slice.parent.start :relations
+
+        register_relations slice.parent["db.rom"]
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/providers/routes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  module Providers
+    # Provider source to register routes helper component in Hanami slices.
+    #
+    # @see Hanami::Slice::RoutesHelper
+    #
+    # @api private
+    # @since 2.0.0
+    class Routes < Hanami::Provider::Source
+      # @api private
+      def prepare
+        require "hanami/slice/routes_helper"
+      end
+
+      # @api private
+      def start
+        # Register a lazy instance of RoutesHelper to ensure we don't load prematurely load the
+        # router during the process of booting. This ensures the router's resolver can run strict
+        # action key checks once when it runs on a fully booted slice.
+        register :routes do
+          Hanami::Slice::RoutesHelper.new(slice.router)
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/rake_tasks.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+
+Hanami::CLI::RakeTasks.register_tasks do
+  desc "Load the app environment"
+  task :environment do
+    require "hanami/prepare"
+  end
+
+  # Ruby ecosystem compatibility
+  #
+  # Most of the hosting SaaS automatic tasks are designed after Ruby on Rails.
+  # They expect the following Rake tasks to be present:
+  #
+  #   * db:migrate
+  #   * assets:precompile
+  #
+  # See https://github.com/heroku/heroku-buildpack-ruby/issues/442
+  #
+  # ===
+  #
+  # These Rake tasks are **NOT** listed when someone runs `rake -T`, because we
+  # want to encourage developers to use `hanami` CLI commands.
+  #
+  # In order to migrate the database or compile assets a developer should use:
+  #
+  #   * hanami db migrate
+  #   * hanami assets compile
+  #
+  # This is the preferred way to run Hanami command line tasks.
+  # Please use them when you're in control of your deployment environment.
+  #
+  # If you're not in control and your deployment requires these "standard"
+  # Rake tasks, they are here only to solve this specific problem.
+
+  if Hanami.bundled?("hanami-db")
+    namespace :db do
+      task :migrate do
+        Hanami::CLI::Commands::App::DB::Migrate.new.call
+      end
+    end
+  end
+
+  if Hanami.bundled?("hanami-assets")
+    namespace :assets do
+      task :precompile do
+        Hanami::CLI::Commands::App::Assets::Compile.new.call
+      end
+    end
+  end
+end
+
+Hanami::CLI::RakeTasks.install_tasks

data/hanami-3.0.1/lib/hanami/routes.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "errors"
+require_relative "slice/router"
+
+module Hanami
+  # App routes
+  #
+  # Users are expected to inherit from this class to define their app
+  # routes.
+  #
+  # @example
+  #   # config/routes.rb
+  #   # frozen_string_literal: true
+  #
+  #   require "hanami/routes"
+  #
+  #   module MyApp
+  #     class Routes < Hanami::Routes
+  #       root to: "home.show"
+  #     end
+  #   end
+  #
+  #   See {Hanami::Slice::Router} for the syntax allowed within the `define` block.
+  #
+  # @see Hanami::Slice::Router
+  # @since 2.0.0
+  class Routes
+    # Error raised when no action could be found in an app or slice container for the key given in a
+    # routes file.
+    #
+    # @api public
+    # @since 2.0.0
+    class MissingActionError < Hanami::Error
+      # @api private
+      def initialize(action_key, slice)
+        action_path = action_key.gsub(CONTAINER_KEY_DELIMITER, PATH_DELIMITER)
+        action_constant = slice.inflector.camelize(
+          slice.inflector.underscore(slice.namespace.to_s) + PATH_DELIMITER + action_path
+        )
+        action_file_path = slice.relative_source_path.join(action_path).to_s.concat(RB_EXT)
+
+        super(<<~MSG)
+          Could not find action with key #{action_key.inspect} in #{slice}
+
+          To fix this, define the action class #{action_constant} in #{action_file_path}
+        MSG
+      end
+    end
+
+    # Error raised when a given routes endpoint does not implement the `#call` interface required
+    # for Rack.
+    #
+    # @api public
+    # @since 2.0.0
+    class NotCallableEndpointError < Hanami::Error
+      # @api private
+      def initialize(endpoint)
+        super("#{endpoint.inspect} is not compatible with Rack. Please make sure it implements #call.")
+      end
+    end
+
+    # Wrapper class for the (otherwise opaque) proc returned from {.routes}, adding an `#empty?`
+    # method that returns true if no routes were defined.
+    #
+    # This is useful when needing to determine behaviour based on the presence of user-defined
+    # routes, such as determining whether to show the Hanami welcome page in {Slice#load_router}.
+    #
+    # @api private
+    # @since 2.1.0
+    class RoutesProc < DelegateClass(Proc)
+      # @api private
+      # @since 2.1.0
+      def self.empty
+        new(proc {}, empty: true)
+      end
+
+      # @api private
+      # @since 2.1.0
+      def initialize(proc, empty: false)
+        @empty = empty
+        super(proc)
+      end
+
+      # @api private
+      # @since 2.1.0
+      def empty?
+        !!@empty
+      end
+    end
+
+    # @api private
+    def self.routes
+      @routes ||= build_routes
+    end
+
+    class << self
+      # @api private
+      def build_routes(definitions = self.definitions)
+        return RoutesProc.empty if definitions.empty?
+
+        routes_proc = proc do
+          definitions.each do |(name, args, kwargs, block)|
+            if block
+              public_send(name, *args, **kwargs, &block)
+            else
+              public_send(name, *args, **kwargs)
+            end
+          end
+        end
+
+        RoutesProc.new(routes_proc)
+      end
+
+      # @api private
+      def definitions
+        @definitions ||= []
+      end
+
+      private
+
+      # @api private
+      def supported_methods
+        @supported_methods ||= Slice::Router.public_instance_methods
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        supported_methods.include?(name) || super
+      end
+
+      # Capture all method calls that are supported by the router DSL
+      # so that it can be evaluated lazily during configuration/boot
+      # process
+      #
+      # @api private
+      def method_missing(name, *args, **kwargs, &block)
+        return super unless respond_to?(name)
+
+        definitions << [name, args, kwargs, block]
+        self
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/settings/composite_store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # A settings store that chains multiple stores with fallback resolution.
+    #
+    # Each store is tried in order. The first store to return a value wins.
+    # Stores must implement `#fetch` with the same signature as `Hash#fetch`.
+    #
+    # @example
+    #   # config/app.rb
+    #   config.settings_store = Hanami::Settings::CompositeStore.new(
+    #     Hanami::Settings::EnvStore.new,
+    #     MyCustomStore.new
+    #   )
+    #
+    # @api public
+    # @since 3.0.0
+    class CompositeStore
+      # @api private
+      Undefined = Dry::Core::Constants::Undefined
+
+      # @param stores [Array<#fetch>] ordered list of stores to query
+      def initialize(*stores)
+        @stores = stores
+      end
+
+      # Fetches a value by trying each store in order.
+      #
+      # @param name [String, Symbol] the setting name
+      # @param args [Array] optional default value
+      # @yield [name] optional block for default value
+      # @return [Object] the setting value
+      # @raise [KeyError] if no store has the key and no default is given
+      #
+      # @api public
+      # @since 3.0.0
+      def fetch(name, *args, &block)
+        @stores.each do |store|
+          value = store.fetch(name, Undefined)
+          return value unless value.equal?(Undefined)
+        end
+
+        return args.first unless args.empty?
+        return yield(name) if block
+
+        raise KeyError, "key not found: #{name.inspect}"
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/settings/env_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # The default store for {Hanami::Settings}, loading setting values from `ENV`.
+    #
+    # If your app loads the dotenv gem, then `ENV` will also be populated from various `.env` files when
+    # you subclass `Hanami::App`.
+    #
+    # @since 2.0.0
+    # @api private
+    class EnvStore
+      NO_ARG = Object.new.freeze
+
+      attr_reader :store, :hanami_env
+
+      def initialize(store: ENV, hanami_env: Hanami.env)
+        @store = store
+        @hanami_env = hanami_env
+      end
+
+      def fetch(name, default_value = NO_ARG, &block)
+        name = name.to_s.upcase
+        args = default_value.eql?(NO_ARG) ? [name] : [name, default_value]
+
+        store.fetch(*args, &block)
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/settings.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require "dry/configurable"
+require_relative "errors"
+
+module Hanami
+  # Provides user-defined settings for an Hanami app or slice.
+  #
+  # Define your own settings by inheriting from this class in `config/settings.rb` within an app or
+  # slice. Your settings will be loaded from matching ENV vars (with upper-cased names) and be
+  # registered as a component as part of the Hanami app {Hanami::Slice::ClassMethods#prepare
+  # prepare} step.
+  #
+  # The settings instance is registered in your app and slice containers as a `"settings"`
+  # component. You can use the `Deps` mixin to inject this dependency and make settings available to
+  # your other components as required.
+  #
+  # @example
+  #   # config/settings.rb
+  #   # frozen_string_literal: true
+  #
+  #   module MyApp
+  #     class Settings < Hanami::Settings
+  #       Secret = Types::String.constrained(min_size: 20)
+  #
+  #       setting :database_url, constructor: Types::String
+  #       setting :session_secret, constructor: Secret
+  #       setting :some_flag, default: false, constructor: Types::Params::Bool
+  #     end
+  #   end
+  #
+  # Settings are defined with [dry-configurable][dry-c]'s `setting` method. You may likely want to
+  # provide `default:` and `constructor:` options for your settings.
+  #
+  # If you have [dry-types][dry-t] bundled, then a nested `Types` module will be available for type
+  # checking your setting values. Pass type objects to the setting `constructor:` options to ensure
+  # their values meet your type expectations. You can use dry-types' default type objects or define
+  # your own.
+  #
+  # When the settings are initialized, all type errors will be collected and presented together for
+  # correction. Settings are loaded early, as part of the Hanami app's
+  # {Hanami::Slice::ClassMethods#prepare prepare} step, to ensure that the app boots only when valid
+  # settings are present.
+  #
+  # Setting values are loaded from a configurable store, which defaults to
+  # {Hanami::Settings::EnvStore}, which fetches the values from equivalent upper-cased keys in
+  # `ENV`. You can configure an alternative store via {Hanami::Config#settings_store}. Setting stores
+  # must implement a `#fetch` method with the same signature as `Hash#fetch`.
+  #
+  # [dry-c]: https://dry-rb.org/gems/dry-configurable/
+  # [dry-t]: https://dry-rb.org/gems/dry-types/
+  #
+  # @see Hanami::Settings::DotenvStore
+  #
+  # @api public
+  # @since 2.0.0
+  class Settings
+    # Error raised when setting values do not meet their type expectations.
+    #
+    # Its message collects all the individual errors that can be raised for each setting.
+    #
+    # @api public
+    # @since 2.0.0
+    class InvalidSettingsError < Hanami::Error
+      # @api private
+      def initialize(errors)
+        super()
+        @errors = errors
+      end
+
+      # Returns the exception's message.
+      #
+      # @return [String]
+      #
+      # @api public
+      # @since 2.0.0
+      def to_s
+        <<~STR.strip
+          Could not initialize settings. The following settings were invalid:
+
+          #{@errors.map { |setting, message| "#{setting}: #{message}" }.join("\n")}
+        STR
+      end
+    end
+
+    class << self
+      # Defines a nested `Types` constant in `Settings` subclasses if dry-types is bundled.
+      #
+      # @see https://dry-rb.org/gems/dry-types
+      #
+      # @api private
+      def inherited(subclass)
+        super
+
+        if Hanami.bundled?("dry-types")
+          require "dry/types"
+          subclass.const_set(:Types, Dry.Types())
+        end
+      end
+
+      # Loads the settings for a slice.
+      #
+      # Returns nil if no settings class is defined.
+      #
+      # @return [Settings, nil]
+      #
+      # @api private
+      def load_for_slice(slice)
+        return unless settings_defined?(slice)
+
+        require_slice_settings(slice) unless slice_settings_class?(slice)
+
+        slice_settings_class(slice).new(slice.config.settings_store)
+      end
+
+      private
+
+      # Returns true if settings are defined for the slice.
+      #
+      # Settings are considered defined if a `Settings` class is already defined in the slice
+      # namespace, or a `config/settings.rb` exists under the slice root.
+      def settings_defined?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME) ||
+          slice.root.join("#{SETTINGS_PATH}#{RB_EXT}").file?
+      end
+
+      def slice_settings_class?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME)
+      end
+
+      def slice_settings_class(slice)
+        slice.namespace.const_get(SETTINGS_CLASS_NAME)
+      end
+
+      def require_slice_settings(slice)
+        require "hanami/settings"
+
+        slice_settings_require_path = File.join(slice.root, SETTINGS_PATH)
+
+        begin
+          require slice_settings_require_path
+        rescue LoadError => exception
+          raise exception unless exception.path == slice_settings_require_path
+        end
+      end
+    end
+
+    # @api private
+    Undefined = Dry::Core::Constants::Undefined
+
+    # @api private
+    EMPTY_STORE = Dry::Core::Constants::EMPTY_HASH
+
+    include Dry::Configurable
+
+    # @api private
+    def initialize(store = EMPTY_STORE)
+      errors = config._settings.map(&:name).each_with_object({}) do |name, errs|
+        value = store.fetch(name, Undefined)
+
+        if value.eql?(Undefined)
+          # When a key is missing entirely from the store, _read_ its value from the config instead.
+          # This ensures its setting constructor runs (with a `nil` argument given) and raises any
+          # necessary errors.
+          public_send(name)
+        else
+          public_send("#{name}=", value)
+        end
+      rescue => exception # rubocop:disable Style/RescueStandardError
+        errs[name] = exception
+      end
+
+      raise InvalidSettingsError, errors if errors.any?
+
+      config.finalize!
+    end
+
+    # Returns a string containing a human-readable representation of the settings.
+    #
+    # This includes setting names only, not any values, to ensure that sensitive values do not
+    # inadvertently leak.
+    #
+    # Use {#inspect_values} to inspect settings with their values.
+    #
+    # @example
+    #   settings.inspect
+    #   # => #<MyApp::Settings [database_url, session_secret, some_flag]>
+    #
+    # @return [String]
+    #
+    # @see #inspect_values
+    #
+    # @api public
+    # @since 2.0.0
+    def inspect
+      "#<#{self.class} [#{config._settings.map(&:name).join(", ")}]>"
+    end
+
+    # rubocop:disable Layout/LineLength
+
+    # Returns a string containing a human-readable representation of the settings and their values.
+    #
+    # @example
+    #   settings.inspect_values
+    #   # => #<MyApp::Settings database_url="postgres://localhost/my_db", session_secret="xxx", some_flag=true]>
+    #
+    # @return [String]
+    #
+    # @see #inspect
+    #
+    # @api public
+    # @since 2.0.0
+    def inspect_values
+      "#<#{self.class} #{config._settings.map { |setting| "#{setting.name}=#{config[setting.name].inspect}" }.join(" ")}>"
+    end
+
+    # rubocop:enable Layout/LineLength
+
+    private
+
+    def method_missing(name, *args, &block)
+      if config.respond_to?(name)
+        config.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, _include_all = false)
+      config.respond_to?(name) || super
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/setup.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami"
+
+Hanami.setup