piko-lite-box 0.0.1

data/hanami-3.0.1/lib/hanami/helpers/form_helper/values.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Helpers
+    module FormHelper
+      # Values from params and form helpers.
+      #
+      # It's responsible to populate input values with data coming from params
+      # and inline values specified via form helpers like `text_field`.
+      #
+      # @since 2.1.0
+      # @api private
+      class Values
+        # @since 2.1.0
+        # @api private
+        GET_SEPARATOR = "."
+
+        # @api private
+        # @since 2.1.0
+        attr_reader :csrf_token
+
+        # @since 2.1.0
+        # @api private
+        def initialize(values: {}, params: {}, csrf_token: nil)
+          @values = values.to_h
+          @params = params.to_h
+          @csrf_token = csrf_token
+        end
+
+        # Returns the value (if present) for the given key.
+        # Nested values are expressed with an array if symbols.
+        #
+        # @since 2.1.0
+        # @api private
+        def get(*keys)
+          get_from_params(*keys) || get_from_values(*keys)
+        end
+
+        private
+
+        # @since 2.1.0
+        # @api private
+        def get_from_params(*keys)
+          keys.map! { |key| /\A\d+\z/.match?(key.to_s) ? key.to_s.to_i : key }
+          @params.dig(*keys)
+        end
+
+        # @since 2.1.0
+        # @api private
+        def get_from_values(*keys)
+          head, *tail = *keys
+          result = @values[head]
+
+          tail.each do |k|
+            break if result.nil?
+
+            result = dig(result, k)
+          end
+
+          result
+        end
+
+        # @since 2.1.0
+        # @api private
+        def dig(base, key)
+          case base
+          when ::Hash then base[key]
+          when Array then base[key.to_s.to_i]
+          when ->(r) { r.respond_to?(key) } then base.public_send(key)
+          end
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/helpers/form_helper.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module Hanami
+  module Helpers
+    # Helper methods for generating HTML forms.
+    #
+    # These helpers will be automatically available in your view templates, part classes and scope
+    # classes.
+    #
+    # This module provides one primary method: {#form_for}, yielding an HTML form builder. This
+    # integrates with request params and template locals to populate the form with appropriate
+    # values.
+    #
+    # @api public
+    # @since 2.1.0
+    module FormHelper
+      require_relative "form_helper/form_builder"
+
+      # Default HTTP method for form
+      #
+      # @since 2.1.0
+      # @api private
+      DEFAULT_METHOD = "POST"
+
+      # Default charset
+      #
+      # @since 2.1.0
+      # @api private
+      DEFAULT_CHARSET = "utf-8"
+
+      # CSRF Token session key
+      #
+      # This name of this key is shared with the hanami and hanami-action gems.
+      #
+      # @since 2.1.0
+      # @api private
+      CSRF_TOKEN = :_csrf_token
+
+      include Hanami::View::Helpers::TagHelper
+
+      # Yields a form builder for constructing an HTML form and returns the resulting form string.
+      #
+      # See {FormHelper::FormBuilder} for the methods for building the form's fields.
+      #
+      # @overload form_for(base_name, url, values: _form_for_values, params: _form_for_params, **attributes)
+      #   Builds the form using the given base name for all fields.
+      #
+      #   @param base_name [String] the base
+      #   @param url [String] the URL for submitting the form
+      #   @param values [Hash] values to be used for populating form field values; optional,
+      #     defaults to the template's locals or to a part's `{name => self}`
+      #   @param params [Hash] request param values to be used for populating form field values;
+      #     these are used in preference over the `values`; optional, defaults to the current
+      #     request's params
+      #   @param attributes [Hash] the HTML attributes for the form tag
+      #   @yieldparam [FormHelper::FormBuilder] f the form builder
+      #
+      # @overload form_for(url, values: _form_for_values, params: _form_for_params, **attributes)
+      #   @param url [String] the URL for submitting the form
+      #   @param values [Hash] values to be used for populating form field values; optional,
+      #     defaults to the template's locals or to a part's `{name => self}`
+      #   @param params [Hash] request param values to be used for populating form field values;
+      #     these are used in preference over the `values`; optional, defaults to the current
+      #     request's params
+      #   @param attributes [Hash] the HTML attributes for the form tag
+      #   @yieldparam [FormHelper::FormBuilder] f the form builder
+      #
+      # @return [String] the form HTML
+      #
+      # @see FormHelper
+      # @see FormHelper::FormBuilder
+      #
+      # @example Basic usage
+      #   <%= form_for("book", "/books", class: "form-horizontal") do |f| %>
+      #     <div>
+      #       <%= f.label "title" %>
+      #       <%= f.text_field "title", class: "form-control" %>
+      #     </div>
+      #
+      #     <%= f.submit "Create" %>
+      #   <% end %>
+      #
+      #   =>
+      #   <form action="/books" method="POST" accept-charset="utf-8" class="form-horizontal">
+      #     <input type="hidden" name="_csrf_token" value="920cd5bfaecc6e58368950e790f2f7b4e5561eeeab230aa1b7de1b1f40ea7d5d">
+      #     <div>
+      #       <label for="book-title">Title</label>
+      #       <input type="text" name="book[title]" id="book-title" value="Test Driven Development">
+      #     </div>
+      #
+      #     <button type="submit">Create</button>
+      #   </form>
+      #
+      # @example Without base name
+      #
+      #   <%= form_for("/books", class: "form-horizontal") do |f| %>
+      #     <div>
+      #       <%= f.label "books.title" %>
+      #       <%= f.text_field "books.title", class: "form-control" %>
+      #     </div>
+      #
+      #     <%= f.submit "Create" %>
+      #   <% end %>
+      #
+      #   =>
+      #   <form action="/books" method="POST" accept-charset="utf-8" class="form-horizontal">
+      #     <input type="hidden" name="_csrf_token" value="920cd5bfaecc6e58368950e790f2f7b4e5561eeeab230aa1b7de1b1f40ea7d5d">
+      #     <div>
+      #       <label for="book-title">Title</label>
+      #       <input type="text" name="book[title]" id="book-title" value="Test Driven Development">
+      #     </div>
+      #
+      #     <button type="submit">Create</button>
+      #   </form>
+      #
+      # @example Method override
+      #   <%= form_for("/books/123", method: :put) do |f|
+      #     <%= f.text_field "book.title" %>
+      #     <%= f.submit "Update" %>
+      #   <% end %>
+      #
+      #   =>
+      #   <form action="/books/123" accept-charset="utf-8" method="POST">
+      #     <input type="hidden" name="_method" value="PUT">
+      #     <input type="hidden" name="_csrf_token" value="920cd5bfaecc6e58368950e790f2f7b4e5561eeeab230aa1b7de1b1f40ea7d5d">
+      #     <input type="text" name="book[title]" id="book-title" value="Test Driven Development">
+      #
+      #     <button type="submit">Update</button>
+      #   </form>
+      #
+      # @example Overriding values
+      #   <%= form_for("/songs", values: {song: {title: "Envision"}}) do |f| %>
+      #     <%= f.text_field "song.title" %>
+      #     <%= f.submit "Create" %>
+      #   <%= end %>
+      #
+      #   =>
+      #   <form action="/songs" accept-charset="utf-8" method="POST">
+      #     <input type="hidden" name="_csrf_token" value="920cd5bfaecc6e58368950e790f2f7b4e5561eeeab230aa1b7de1b1f40ea7d5d">
+      #     <input type="text" name="song[title]" id="song-title" value="Envision">
+      #
+      #     <button type="submit">Create</button>
+      #   </form>
+      #
+      # @api public
+      # @since 2.1.0
+      def form_for(base_name, url = nil, values: _form_for_values, params: _form_for_params, **attributes)
+        url, base_name = base_name, nil if url.nil?
+
+        values = Values.new(values: values, params: params, csrf_token: _form_csrf_token)
+
+        builder = FormBuilder.new(
+          base_name: base_name,
+          values: values,
+          inflector: _context.inflector,
+          form_attributes: attributes
+        )
+
+        content = (block_given? ? yield(builder) : "").html_safe
+
+        builder.call(content, action: url, **attributes)
+      end
+
+      # Returns CSRF meta tags for use via unobtrusive JavaScript (UJS) libraries.
+      #
+      # @return [String, nil] the tags, if a CSRF token is available, or nil
+      #
+      # @example
+      #   csrf_meta_tags
+      #
+      #   =>
+      #   <meta name="csrf-param" content="_csrf_token">
+      #   <meta name="csrf-token" content="4a038be85b7603c406dcbfad4b9cdf91ec6ca138ed6441163a07bb0fdfbe25b5">
+      #
+      # @api public
+      # @since 2.1.0
+      def csrf_meta_tags
+        return unless (token = _form_csrf_token)
+
+        tag.meta(name: "csrf-param", content: CSRF_TOKEN) +
+          tag.meta(name: "csrf-token", content: token)
+      end
+
+      # @api private
+      # @since 2.1.0
+      def _form_for_values
+        if respond_to?(:_locals) # Scope
+          _locals
+        elsif respond_to?(:_name) # Part
+          {_name => self}
+        else
+          {}
+        end
+      end
+
+      # @api private
+      # @since 2.1.0
+      def _form_for_params
+        _context.request.params
+      end
+
+      # @since 2.1.0
+      # @api private
+      def _form_csrf_token
+        return unless _context.request.session_enabled?
+
+        _context.csrf_token
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/helpers/i18n_helper.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "cgi/escape"
+
+module Hanami
+  module Helpers
+    # View-layer translation and localization helpers.
+    #
+    # These helpers are automatically available in your view templates, part classes, and scope
+    # classes when the `i18n` gem is bundled. They provide `translate`/`t`, `translate!`/`t!`, and
+    # `localize`/`l`, sourcing the i18n backend from the view context and expanding relative
+    # (leading-dot) translation keys against the currently-rendering template name.
+    #
+    # The shared `translate`/`localize` logic lives in {Methods}, which is also included by the
+    # action-layer i18n helper ({Hanami::Extensions::Action::I18nHelper}). This module supplies
+    # the two view-specific concrete implementations of {Methods}'s abstract hooks: {#_i18n}
+    # returns the i18n backend from the view context, and {#_resolve_i18n_key} expands relative
+    # keys against the template name.
+    #
+    # @example Basic translation
+    #   <%= translate("messages.welcome") %>
+    #   # => "Welcome"
+    #
+    # @example HTML-safe translation
+    #   # en.yml
+    #   #   greeting_html: "Hello, <strong>%{name}</strong>!"
+    #   <%= translate("greeting_html", name: "<script>") %>
+    #   # => "Hello, <strong>&lt;script&gt;</strong>!" (marked HTML-safe)
+    #
+    # @example Missing translation
+    #   <%= translate("missing.key") %>
+    #   # => '<span class="translation_missing" title="...">missing.key</span>'
+    #
+    # @example Relative key lookup
+    #   # In app/templates/users/index.html.erb:
+    #   <%= translate(".title") %>
+    #   # Looks up "users.index.title"
+    #
+    #   # In app/templates/users/_form.html.erb (a partial):
+    #   <%= translate(".label") %>
+    #   # Looks up "users._form.label"
+    #
+    # @api public
+    # @since 3.0.0
+    module I18nHelper
+      # Shared `translate` / `localize` (and shorthand) helper methods used by both view-layer
+      # consumers and action-layer consumers.
+      #
+      # **This module is abstract.** Including modules must override two private hooks:
+      #
+      # - {#_i18n} — returns the i18n backend to delegate to.
+      # - {#_resolve_i18n_key} — expands relative (leading-dot) keys against the consumer's
+      #   context, and is a no-op for absolute keys.
+      #
+      # @api public
+      # @since 3.0.0
+      module Methods
+        # Matches keys whose final segment is `html` or whose final segment ends in `_html`. These
+        # translated values are treated as HTML-safe and any string interpolation values are
+        # HTML-escaped before substitution.
+        #
+        # @api private
+        HTML_SAFE_TRANSLATION_KEY = /(\b|_)html\z/
+
+        # Translates the given key using the slice's i18n backend.
+        #
+        # When the key's final segment is `html` or ends in `_html`, the result is marked HTML-safe
+        # and any string interpolation values are HTML-escaped first.
+        #
+        # When a translation is missing and neither `:default` nor `:raise` was supplied, returns a
+        # `<span class="translation_missing">` element containing the missing key, useful for
+        # spotting missing translations during development.
+        #
+        # When the key begins with a `.`, it is treated as relative to the consumer's context and
+        # expanded by {#_resolve_i18n_key}.
+        #
+        # @param key [String, Symbol] the translation key to look up
+        # @param options [Hash] translation options forwarded to the backend (`:locale`, `:scope`,
+        #   `:default`, `:count`, `:raise`, etc.), plus any interpolation values
+        #
+        # @return [String] the translated string (marked HTML-safe when hanami-view is bundled and
+        #   the key ends in `_html` or `html`)
+        #
+        # @api public
+        # @since 3.0.0
+        def translate(key, **options)
+          key = _resolve_i18n_key(key)
+
+          html_safe = _html_safe_translation_key?(key)
+
+          options = _escape_translation_options(options) if html_safe
+
+          result =
+            if options.key?(:default) || options[:raise]
+              _i18n.translate(key, **options)
+            else
+              begin
+                _i18n.translate(key, **options, raise: true)
+              rescue ::I18n::MissingTranslationData => exception
+                return _missing_translation_markup(key, exception)
+              end
+            end
+
+          html_safe ? _i18n_mark_html_safe(result.to_s) : result
+        end
+
+        # @api public
+        # @since 3.0.0
+        alias_method :t, :translate
+
+        # Translates the given key, raising an exception if the translation is missing.
+        #
+        # @param (see #translate)
+        #
+        # @return [String] the translated string (marked HTML-safe when hanami-view is bundled and
+        #   the key ends in `_html` or `html`)
+        #
+        # @raise [I18n::MissingTranslationData] if the translation is missing
+        #
+        # @api public
+        # @since 3.0.0
+        def translate!(key, **options)
+          translate(key, **options, raise: true)
+        end
+
+        # @api public
+        # @since 3.0.0
+        alias_method :t!, :translate!
+
+        # Localizes the given object (e.g. a date, time, or number) using the slice's i18n backend.
+        #
+        # @param object [Date, Time, DateTime, Numeric] the object to localize
+        # @param options [Hash] localization options forwarded to the backend (`:locale`, `:format`,
+        #   etc.)
+        #
+        # @return [String] the localized string
+        #
+        # @api public
+        # @since 3.0.0
+        def localize(object, **options)
+          _i18n.localize(object, **options)
+        end
+
+        # @api public
+        # @since 3.0.0
+        alias_method :l, :localize
+
+        private
+
+        # Returns the i18n backend the helper methods delegate to.
+        #
+        # Including modules must override this method to return an I18n backend instance.
+        #
+        # @return [Hanami::Providers::I18n::Backend]
+        def _i18n
+          raise NoMethodError, "#{self.class} must implement #_i18n to return an i18n backend"
+        end
+
+        # Resolves the given key, returning it unchanged by default.
+        #
+        # Override this hook to expand relative (leading-dot) keys against a context.
+        #
+        # @param key [String, Symbol]
+        #
+        # @return [String, Symbol] the resolved key
+        def _resolve_i18n_key(key)
+          key
+        end
+
+        def _html_safe_translation_key?(key)
+          HTML_SAFE_TRANSLATION_KEY.match?(key.to_s)
+        end
+
+        def _escape_translation_options(options)
+          options.each_with_object({}) do |(key, value), result|
+            result[key] =
+              if ::I18n::RESERVED_KEYS.include?(key) || !value.is_a?(String) || _i18n_html_safe?(value)
+                value
+              else
+                _i18n_html_escape(value)
+              end
+          end
+        end
+
+        def _missing_translation_markup(key, error)
+          title = _i18n_html_escape(error.message)
+          body = _i18n_html_escape(key.to_s)
+          _i18n_mark_html_safe(%(<span class="translation_missing" title="#{title}">#{body}</span>))
+        end
+
+        # Escapes `value` for HTML. Prefers `Hanami::View::Helpers::EscapeHelper#escape_html` when
+        # Hanami View's EscapeHelper is included, falling back to stdlib `CGI.escapeHTML` so the
+        # helper works in API-only apps that don't bundle hanami-view.
+        def _i18n_html_escape(value)
+          if respond_to?(:escape_html)
+            escape_html(value)
+          else
+            CGI.escapeHTML(value.to_s)
+          end
+        end
+
+        # Marks the given string as HTML-safe when Hanami View is loaded, otherwise returns the
+        # string unchanged.
+        #
+        # The HTML-safe marker is only meaningful to Hanami View's template rendering, so there's
+        # nothing to do in its absence.
+        def _i18n_mark_html_safe(str)
+          str.respond_to?(:html_safe) ? str.html_safe : str
+        end
+
+        def _i18n_html_safe?(value)
+          value.respond_to?(:html_safe?) && value.html_safe?
+        end
+      end
+
+      include Methods
+
+      private
+
+      def _i18n
+        _context.i18n
+      end
+
+      def _resolve_i18n_key(key)
+        return key unless key.to_s.start_with?(".")
+
+        template_name = _context.current_template_name
+
+        unless template_name
+          raise(
+            ::I18n::ArgumentError,
+            "Cannot use relative translation key #{key.inspect} outside of a template render. " \
+            "Use an absolute key (without a leading dot) instead."
+          )
+        end
+
+        "#{template_name.tr("/", ".")}#{key}"
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/logger/rack_formatter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "dry/logger"
+
+module Hanami
+  module Logger
+    # Rack request log formatter for Dry Logger.
+    #
+    # Formats rack request log entries with colorized output for HTTP verbs, status codes, and
+    # request paths, making it easier to visually scan logs in development.
+    #
+    # HTTP verbs each have a distinct color. Status codes follow traffic-light coloring (2xx green,
+    # 3xx cyan, 4xx yellow, 5xx red), and the request path echoes the status color so both signals
+    # reinforce each other at a glance.
+    #
+    # Colorization is only active when `colorize: true` is set in the logger options (the default
+    # in development).
+    #
+    # @api private
+    class RackFormatter < Dry::Logger::Formatters::String
+      RACK_TEMPLATE = <<~TEXT
+        [%<progname>s] [%<severity>s] [%<time>s] \
+        %<verb>s %<status>s %<elapsed>s %<ip>s %<path>s %<length>s %<payload>s
+          %<params>s
+      TEXT
+
+      VERB_COLORS = {
+        "GET" => :green,
+        "POST" => :yellow,
+        "PUT" => :blue,
+        "PATCH" => :blue,
+        "DELETE" => :red,
+        "HEAD" => :cyan
+      }.freeze
+
+      Colors = Dry::Logger::Formatters::Colors
+      private_constant :Colors
+
+      def initialize(**options)
+        super
+        @template = Dry::Logger::Formatters::Template[RACK_TEMPLATE]
+      end
+
+      private
+
+      def format_values(entry)
+        return super unless colorize?
+
+        status_color = status_color(entry.to_h[:status])
+
+        super.merge(
+          verb: Colors.call(VERB_COLORS.fetch(entry.to_h[:verb].to_s.upcase, :gray), entry.to_h[:verb]),
+          status: Colors.call(status_color, entry.to_h[:status]),
+          path: Colors.call(status_color, entry.to_h[:path])
+        )
+      end
+
+      def format_params(value)
+        value unless value.empty?
+      end
+
+      def status_color(status)
+        case status.to_i
+        when 200..299 then :green
+        when 300..399 then :cyan
+        when 400..499 then :yellow
+        when 500..599 then :red
+        else :gray
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/logger/sql_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "dry/logger"
+
+module Hanami
+  module Logger
+    # SQL query log formatter for Dry Logger.
+    #
+    # Formats SQL query log entries with a template that mirrors the structure of the built-in rack
+    # log formatter, providing consistent visual formatting across both HTTP request and database
+    # query logs.
+    #
+    # For example, in development, SQL logs alongside Rack logs:
+    #
+    #   [my_app] [INFO] [2026-03-04 10:15:32] SQL sqlite 1.234ms SELECT * FROM users
+    #   [my_app] [INFO] [2026-03-04 10:15:32] GET 200 1ms 127.0.0.1 /users -
+    #
+    # In production, the default JSON formatter handles SQL entries automatically via the structured
+    # payload.
+    #
+    # Supports colorization via Dry Logger's template color tags. When `colorize: true` is set in
+    # the logger options (the default in development), the "SQL" label is colorized, and severity
+    # is colorized per-level by the parent formatter (e.g. INFO => magenta, ERROR => red).
+    #
+    # When colorization is enabled and the "rouge" gem is available, SQL queries are syntax
+    # highlighted using Rouge's SQL lexer. This is a soft dependency; if Rouge is not installed,
+    # queries output as plain, unhighlighted text.
+    #
+    # The Rouge theme defaults to "pastie" and can be customized by setting the
+    # `HANAMI_LOG_SYNTAX_THEME` environment variable to any Rouge theme name. See
+    # `Rouge::Theme.registry` for available themes.
+    #
+    # @see Hanami::Logger::SQLLogger
+    #
+    # @api private
+    class SQLFormatter < Dry::Logger::Formatters::String
+      SQL_TEMPLATE = <<~TEXT
+        [%<progname>s] [%<severity>s] [%<time>s] SQL %<db>s %<elapsed>s%<elapsed_unit>s %<query>s
+      TEXT
+
+      SQL_TEMPLATE_COLORIZED = <<~TEXT
+        [%<progname>s] [%<severity>s] [%<time>s] <blue>SQL</blue> %<db>s %<elapsed>s%<elapsed_unit>s %<query>s
+      TEXT
+
+      def initialize(**options)
+        super
+        @template = Dry::Logger::Formatters::Template[
+          colorize? ? SQL_TEMPLATE_COLORIZED : SQL_TEMPLATE
+        ]
+        @sql_colorizer = build_sql_colorizer if colorize?
+      end
+
+      private
+
+      def format_query(value)
+        if @sql_colorizer
+          @sql_colorizer.call(value)
+        else
+          value
+        end
+      end
+
+      def build_sql_colorizer
+        begin
+          require "rouge"
+        rescue LoadError
+          return nil
+        end
+
+        theme_name = ENV.fetch("HANAMI_LOG_SYNTAX_THEME", "pastie")
+        theme_class = Rouge::Theme.find(theme_name) || Rouge::Themes::Pastie
+        formatter = Rouge::Formatters::Terminal256.new(theme_class.new)
+
+        lexer = Rouge::Lexers::SQL.new
+
+        ->(sql) { formatter.format(lexer.lex(sql)) }
+      end
+    end
+  end
+end