piko-lite-box 0.0.1

data/hanami-3.0.1/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2026 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/hanami-3.0.1/README.md

@@ -0,0 +1,89 @@
+<!--- This file is synced from hanakai-rb/repo-sync -->
+
+[actions]: https://github.com/hanami/hanami/actions
+[chat]: https://discord.gg/naQApPAsZB
+[forum]: https://discourse.hanamirb.org
+[rubygem]: https://rubygems.org/gems/hanami
+
+# Hanami [![Gem Version](https://badge.fury.io/rb/hanami.svg)][rubygem] [![CI Status](https://github.com/hanami/hanami/workflows/CI/badge.svg)][actions]
+
+[![Forum](https://img.shields.io/badge/Forum-dc360f?logo=discourse&logoColor=white)][forum]
+[![Chat](https://img.shields.io/badge/Chat-717cf8?logo=discord&logoColor=white)][chat]
+
+**A flexible framework for maintainable Ruby apps.**
+
+Hanami is a **full-stack** Ruby web framework. It's made up of smaller, single-purpose libraries.
+
+This repository is for the full-stack framework, which provides the glue that ties all the parts together:
+
+* [**Hanami::Router**](https://github.com/hanami/router) - Rack compatible HTTP router for Ruby
+* [**Hanami::Action**](https://github.com/hanami/hanami-action) - Full featured, fast and testable actions for Rack
+* [**Hanami::View**](https://github.com/hanami/view) - Presentation with a separation between views and templates
+* [**Hanami::DB**](https://github.com/hanami/db) - Database integration, complete with migrations, repositories, relations, and structs
+* [**Hanami::Assets**](https://github.com/hanami/assets) - Assets management for Ruby
+
+These components are designed to be used independently or together in a Hanami application.
+
+## Installation
+
+```shell
+gem install hanami
+```
+
+## Usage
+
+```shell
+hanami new bookshelf
+cd bookshelf && bundle
+bundle exec hanami dev
+# Now visit http://localhost:2300
+```
+
+Please follow along with the [Getting Started guide](https://guides.hanamirb.org/getting-started/).
+
+## Contributing
+
+1. Fork it (https://github.com/hanami/hanami/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+In addition to contributing code, you can help to triage issues. This can include reproducing bug reports, or asking for vital information such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to [subscribe to hanami on CodeTriage](https://www.codetriage.com/hanami/hanami).
+
+### Tests
+
+To run all test suite:
+
+```shell
+$ bundle exec rake
+```
+
+To run all the unit tests:
+
+```shell
+$ bundle exec rspec spec/unit
+```
+
+To run all the integration tests:
+
+```shell
+$ bundle exec rspec spec/integration
+```
+
+To run a single test:
+
+```shell
+$ bundle exec rspec path/to/spec.rb
+```
+
+## Links
+
+- [User documentation](https://hanamirb.org)
+- [API documentation](http://rubydoc.info/gems/hanami)
+
+
+## License
+
+See `LICENSE` file.
+

data/hanami-3.0.1/hanami.gemspec

@@ -0,0 +1,49 @@
+# 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 "hanami/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hanami"
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
+  spec.license       = "MIT"
+  spec.version       = Hanami::VERSION.dup
+
+  spec.summary       = "A flexible framework for maintainable Ruby apps"
+  spec.description   = spec.summary
+  spec.homepage      = "https://hanamirb.org"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "hanami.gemspec", "lib/**/*"]
+  spec.bindir        = "exe"
+  spec.executables   = Dir["exe/*"].map { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["changelog_uri"]     = "https://github.com/hanami/hanami/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/hanami/hanami"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/hanami/hanami/issues"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.3"
+
+  spec.add_runtime_dependency "bundler", ">= 2.0"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.0", ">= 1.2.0", "< 2"
+  spec.add_runtime_dependency "dry-core", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "dry-inflector", "~> 1.0", ">= 1.1.0", "< 2"
+  spec.add_runtime_dependency "dry-monitor", "~> 1.0", ">= 1.0.1", "< 2"
+  spec.add_runtime_dependency "dry-system", "~> 1.1"
+  spec.add_runtime_dependency "dry-logger", "~> 1.2", "< 2"
+  spec.add_runtime_dependency "hanami-cli", ">= 2.3.1"
+  spec.add_runtime_dependency "hanami-utils", "~> 3.0.0"
+  spec.add_runtime_dependency "json", ">= 2.7.2"
+  spec.add_runtime_dependency "zeitwerk", "~> 2.6"
+  spec.add_runtime_dependency "rack-session"
+  spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "rack-test", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end
+

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "env"
+
+module Hanami
+  # The Hanami app is a singular slice tasked with managing the core components of the app and
+  # coordinating overall app boot.
+  #
+  # For smaller apps, the app may be the only slice present, whereas larger apps may consist of many
+  # slices, with the app reserved for holding a small number of shared components only.
+  #
+  # @see Slice
+  #
+  # @api public
+  # @since 2.0.0
+  class App < Slice
+    @_mutex = Mutex.new
+
+    # @api private
+    # @since 2.0.0
+    def self.inherited(subclass)
+      super
+
+      Hanami.app = subclass
+
+      subclass.extend(ClassMethods)
+
+      @_mutex.synchronize do
+        subclass.class_eval do
+          @config = Hanami::Config.new(app_name: slice_name, env: Hanami.env)
+          Hanami::Env.load
+        end
+      end
+    end
+
+    # App class interface
+    module ClassMethods
+      # Returns the app's config.
+      #
+      # @return [Hanami::Config]
+      #
+      # @api public
+      # @since 2.0.0
+      attr_reader :config
+
+      # Returns the app's {SliceName}.
+      #
+      # @return [Hanami::SliceName]
+      #
+      # @see Slice::ClassMethods#slice_name
+      #
+      # @api public
+      # @since 2.0.0
+      def app_name
+        slice_name
+      end
+
+      # Prepares the $LOAD_PATH based on the app's configured root, prepending the `lib/` directory
+      # if it exists. If the lib directory is already added, this will do nothing.
+      #
+      # In ordinary circumstances, you should never have to call this method: this method is called
+      # immediately upon subclassing {Hanami::App}, as a convenicence to put lib/ (under the default
+      # root of `Dir.pwd`) on the load path automatically. This is helpful if you need to require
+      # files inside the subclass body for performing certain app configuration steps.
+      #
+      # If you change your app's `config.root` and you need to require files from its `lib/`
+      # directory within your {App} subclass body, you should call {.prepare_load_path} explicitly
+      # after setting the new root.
+      #
+      # Otherwise, this method is called again as part of the app {.prepare} step, so if you've
+      # changed your app's root and do _not_ need to require files within your {App} subclass body,
+      # then you don't need to call this method.
+      #
+      # @example
+      #   module MyApp
+      #     class App < Hanami::App
+      #       config.root = Pathname(__dir__).join("../src")
+      #       prepare_load_path
+      #
+      #       # You can make requires for your files here
+      #     end
+      #   end
+      #
+      # @return [self]
+      #
+      # @api public
+      # @since 2.0.0
+      def prepare_load_path
+        if (lib_path = root.join(LIB_DIR)).directory?
+          path = lib_path.realpath.to_s
+          $LOAD_PATH.prepend(path) unless $LOAD_PATH.include?(path)
+        end
+
+        self
+      end
+
+      private
+
+      def prepare_all
+        prepare_load_path
+
+        # Make app-wide notifications available as early as possible
+        container.use(:notifications)
+
+        # Ensure all basic slice preparation is complete before we make adjustments below (which
+        # rely on the basic prepare steps having already run)
+        super
+
+        # Run specific prepare steps for the app slice. Note also that some standard steps have been
+        # skipped via the empty method overrides below.
+        prepare_app_component_dirs
+        prepare_app_providers
+      end
+
+      # Skip standard slice prepare steps that do not apply to the app
+      def prepare_container_component_dirs; end
+      def prepare_container_imports; end
+
+      # rubocop:disable Metrics/AbcSize
+
+      def prepare_app_component_dirs
+        # Component files in both `app/` and `app/lib/` define classes in the
+        # app's namespace
+
+        if root.join(APP_DIR, LIB_DIR).directory?
+          container.config.component_dirs.add(File.join(APP_DIR, LIB_DIR)) do |dir|
+            dir.namespaces.add_root(key: nil, const: app_name.name)
+          end
+        end
+
+        # When auto-registering components in `app/`, ignore files in `app/lib/` (these will be
+        # auto-registered as above), as well as the configured no_auto_register_paths
+        no_auto_register_paths = ([LIB_DIR] + config.no_auto_register_paths)
+          .map { |path|
+            path.end_with?(File::SEPARATOR) ? path : "#{path}#{File::SEPARATOR}"
+          }
+
+        if root.join(APP_DIR).directory?
+          container.config.component_dirs.add(APP_DIR) do |dir|
+            dir.namespaces.add_root(key: nil, const: app_name.name)
+            dir.auto_register = -> component {
+              relative_path = component.file_path.relative_path_from(root.join(APP_DIR)).to_s
+              !relative_path.start_with?(*no_auto_register_paths)
+            }
+          end
+        end
+      end
+
+      def prepare_app_providers
+        require_relative "providers/inflector"
+        register_provider(:inflector, source: Hanami::Providers::Inflector)
+
+        # Allow the logger to be replaced by users with a manual provider, for advanced cases.
+        #
+        # Require the logger provider source up front, to make `configure_provider(:logger)`
+        # possible.
+        require_relative "providers/logger"
+        unless container.providers[:logger]
+          register_provider(:logger, source: Hanami::Providers::Logger)
+        end
+
+        # Ensure the logger is wrapped by `Hanami::UniversalLogger`, even if manually registered in a
+        # user-defined provider, guaranteeing Hanami's structured and tagged logging interface across
+        # the framework.
+        container.providers[:logger].source.after(:start) do
+          container.decorate(:logger) { |logger| Hanami::UniversalLogger[logger] }
+        end
+
+        if Hanami.bundled?("rack")
+          require_relative "providers/rack"
+          register_provider(:rack, source: Hanami::Providers::Rack, namespace: true)
+        end
+
+        if Hanami.bundled?("hanami-db")
+          register_provider(:db_logging, source: Hanami::Providers::DBLogging)
+        end
+      end
+
+      def prepare_autoloader
+        autoloader.tag = "hanami.app.#{slice_name.name}"
+
+        # Component dirs are automatically pushed to the autoloader by dry-system's zeitwerk plugin.
+        # This method adds other dirs that are not otherwise configured as component dirs.
+
+        # Autoload classes from `lib/[app_namespace]/`
+        if root.join(LIB_DIR, app_name.name).directory?
+          autoloader.push_dir(root.join(LIB_DIR, app_name.name), namespace: namespace)
+        end
+
+        autoloader.setup
+      end
+
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+Hanami.boot

data/hanami-3.0.1/lib/hanami/config/actions/content_security_policy.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Config
+    class Actions
+      # Config for Content Security Policy in Hanami apps
+      #
+      # @since 2.0.0
+      class ContentSecurityPolicy
+        # @since 2.0.0
+        # @api private
+        def initialize(&blk)
+          @policy = {
+            base_uri: "'self'",
+            child_src: "'self'",
+            connect_src: "'self'",
+            default_src: "'none'",
+            font_src: "'self'",
+            form_action: "'self'",
+            frame_ancestors: "'self'",
+            frame_src: "'self'",
+            img_src: "'self' https: data:",
+            media_src: "'self'",
+            object_src: "'none'",
+            script_src: "'self'",
+            style_src: "'self' 'unsafe-inline' https:"
+          }
+
+          blk&.(self)
+        end
+
+        # @since 2.0.0
+        # @api private
+        def initialize_copy(original_object)
+          @policy = original_object.instance_variable_get(:@policy).dup
+          super
+        end
+
+        # Get a CSP setting
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        # @return [String,NilClass] the CSP setting, if any
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example
+        #   module MyApp
+        #     class App < Hanami::App
+        #       config.actions.content_security_policy[:base_uri] # => "'self'"
+        #     end
+        #   end
+        def [](key)
+          @policy[key]
+        end
+
+        # Set a CSP setting
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        # @param value [String] the CSP setting value
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example Replace a default value
+        #   module MyApp
+        #     class App < Hanami::App
+        #       config.actions.content_security_policy[:plugin_types] = nil
+        #     end
+        #   end
+        #
+        # @example Append to a default value
+        #   module MyApp
+        #     class App < Hanami::App
+        #       config.actions.content_security_policy[:script_src] += " https://my.cdn.test"
+        #     end
+        #   end
+        def []=(key, value)
+          @policy[key] = value
+        end
+
+        # Deletes a CSP key
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example
+        #   module MyApp
+        #     class App < Hanami::App
+        #       config.actions.content_security_policy.delete(:object_src)
+        #     end
+        #   end
+        def delete(key)
+          @policy.delete(key)
+        end
+
+        # Returns true if 'nonce' is used in any of the policies.
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        # @since 2.3.0
+        def nonce?
+          @policy.any? { _2.match?(/'nonce'/) }
+        end
+
+        # Returns an array of middleware name to support 'nonce' in
+        # policies, or an empty array if 'nonce' is not used.
+        #
+        # @return [Array<(Symbol, Array)>]
+        #
+        # @api public
+        # @since 2.3.0
+        def middleware
+          return [] unless nonce?
+
+          [Hanami::Middleware::ContentSecurityPolicyNonce]
+        end
+
+        # @since 2.0.0
+        # @api private
+        def to_s
+          @policy.map do |key, value|
+            "#{dasherize(key)} #{value}"
+          end.join(";")
+        end
+
+        private
+
+        # @since 2.0.0
+        # @api private
+        def dasherize(key)
+          key.to_s.gsub("_", "-")
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/config/actions/cookies.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Config
+    class Actions
+      # Wrapper for app-level config of HTTP cookies for Hanami actions.
+      #
+      # This decorates the hash of cookie options that is otherwise directly configurable on
+      # actions, and adds the `enabled?` method to allow app base action to determine whether to
+      # include the `Action::Cookies` module.
+      #
+      # @api public
+      # @since 2.0.0
+      class Cookies
+        # Returns the cookie options.
+        #
+        # @return [Hash]
+        #
+        # @api public
+        # @since 2.0.0
+        attr_reader :options
+
+        # Returns a new `Cookies`.
+        #
+        # You should not need to initialize this class directly. Instead use
+        # {Hanami::Config::Actions#cookies}.
+        #
+        # @api private
+        # @since 2.0.0
+        def initialize(options)
+          @options = options
+        end
+
+        # Returns true if any cookie options have been provided.
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        # @since 2.0.0
+        def enabled?
+          !options.nil?
+        end
+
+        # Returns the cookie options.
+        #
+        # If no options have been provided, returns an empty hash.
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def to_h
+          options.to_h
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/config/actions/sessions.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "hanami/utils/string"
+require "hanami/utils/class"
+
+module Hanami
+  class Config
+    class Actions
+      # Config for HTTP session middleware in Hanami actions.
+      #
+      # @api public
+      # @since 2.0.0
+      class Sessions
+        # Returns the configured session storage
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        # @since 2.0.0
+        attr_reader :storage
+
+        # Returns the configured session storage options
+        #
+        # @return [Array]
+        #
+        # @api public
+        # @since 2.0.0
+        attr_reader :options
+
+        # Returns a new `Sessions`.
+        #
+        # You should not need to initialize this class directly. Instead use
+        # {Hanami::Config::Actions#sessions=}.
+        #
+        # @example
+        #   config.actions.sessions = :cookie, {secret: "xyz"}
+        #
+        # @api private
+        # @since 2.0.0
+        def initialize(storage = nil, *options)
+          @storage = storage
+          @options = options
+        end
+
+        # Returns true if sessions have been enabled.
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        # @since 2.0.0
+        def enabled?
+          !storage.nil?
+        end
+
+        # Returns an array of the session storage middleware name and its options, or an empty array
+        # if sessions have not been enabled.
+        #
+        # @return [Array<(Symbol, Array)>]
+        #
+        # @api public
+        # @since 2.0.0
+        def middleware
+          return [] unless enabled?
+
+          [storage_middleware, options].flatten(1)
+        end
+
+        private
+
+        def storage_middleware
+          require_storage
+
+          name = Utils::String.classify(storage)
+          Utils::Class.load!(name, ::Rack::Session)
+        end
+
+        def require_storage
+          require "rack/session/#{storage}"
+        end
+      end
+    end
+  end
+end