hanami 2.0.2 → 2.1.0.beta1

data/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.0.0
+      # @api private
+      class Values
+        # @since 2.0.0
+        # @api private
+        GET_SEPARATOR = "."
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :csrf_token
+
+        # @since 2.0.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.0.0
+        # @api private
+        def get(*keys)
+          get_from_params(*keys) || get_from_values(*keys)
+        end
+
+        private
+
+        # @since 2.0.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.0.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.0.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/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.0.0
+    module FormHelper
+      require_relative "form_helper/form_builder"
+
+      # Default HTTP method for form
+      #
+      # @since 2.0.0
+      # @api private
+      DEFAULT_METHOD = "POST"
+
+      # Default charset
+      #
+      # @since 2.0.0
+      # @api private
+      DEFAULT_CHARSET = "utf-8"
+
+      # CSRF Token session key
+      #
+      # This name of this key is shared with the hanami and hanami-controller gems.
+      #
+      # @since 2.0.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.0.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.0.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.0.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.0.0
+      def _form_for_params
+        _context.request.params
+      end
+
+      # @since 2.0.0
+      # @api private
+      def _form_csrf_token
+        return unless _context.request.session_enabled?
+
+        _context.csrf_token
+      end
+    end
+  end
+end

data/lib/hanami/middleware/public_errors_app.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Hanami
+  module Middleware
+    # The errors app given to {Hanami::Middleware::RenderErrors}, which renders a error responses
+    # from HTML pages kept in `public/` or as simple JSON structures.
+    #
+    # @see Hanami::Middleware::RenderErrors
+    #
+    # @api private
+    # @since 2.1.0
+    class PublicErrorsApp
+      # @api private
+      # @since 2.1.0
+      attr_reader :public_path
+
+      # @api private
+      # @since 2.1.0
+      def initialize(public_path)
+        @public_path = public_path
+      end
+
+      # @api private
+      # @since 2.1.0
+      def call(env)
+        request = Rack::Request.new(env)
+        status = request.path_info[1..].to_i
+        content_type = request.get_header("HTTP_ACCEPT")
+
+        default_body = {
+          status: status,
+          error: Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500])
+        }
+
+        render(status, content_type, default_body)
+      end
+
+      private
+
+      def render(status, content_type, default_body)
+        body, rendered_content_type = render_content(status, content_type, default_body)
+
+        [
+          status,
+          {
+            "Content-Type" => "#{rendered_content_type}; charset=utf-8",
+            "Content-Length" => body.bytesize.to_s
+          },
+          [body]
+        ]
+      end
+
+      def render_content(status, content_type, default_body)
+        if content_type.to_s.start_with?("application/json")
+          require "json"
+          [JSON.generate(default_body), "application/json"]
+        else
+          [render_html_content(status, default_body), "text/html"]
+        end
+      end
+
+      def render_html_content(status, default_body)
+        path = "#{public_path}/#{status}.html"
+
+        if File.exist?(path)
+          File.read(path)
+        else
+          default_body[:error]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/middleware/render_errors.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "rack"
+
+# rubocop:disable Lint/RescueException
+
+module Hanami
+  module Middleware
+    # Rack middleware that rescues errors raised by the app renders friendly error responses, via a
+    # given "errors app".
+    #
+    # By default, this is enabled only in production mode.
+    #
+    # @see Hanami::Config#render_errors
+    # @see Hanani::Middleware::PublicErrorsApp
+    #
+    # @api private
+    # @since 2.1.0
+    class RenderErrors
+      # @api private
+      # @since 2.1.0
+      class RenderableException
+        attr_reader :exception
+        attr_reader :responses
+
+        # @api private
+        # @since 2.1.0
+        def initialize(exception, responses:)
+          @exception = exception
+          @responses = responses
+        end
+
+        # @api private
+        # @since 2.1.0
+        def rescue_response?
+          responses.key?(exception.class.name)
+        end
+
+        # @api private
+        # @since 2.1.0
+        def status_code
+          Rack::Utils.status_code(responses[exception.class.name])
+        end
+      end
+
+      # @api private
+      # @since 2.1.0
+      def initialize(app, config, errors_app)
+        @app = app
+        @config = config
+        @errors_app = errors_app
+      end
+
+      # @api private
+      # @since 2.1.0
+      def call(env)
+        @app.call(env)
+      rescue Exception => exception
+        request = Rack::Request.new(env)
+
+        if @config.render_errors
+          render_exception(request, exception)
+        else
+          raise exception
+        end
+      end
+
+      private
+
+      def render_exception(request, exception)
+        renderable = RenderableException.new(exception, responses: @config.render_error_responses)
+
+        status = renderable.status_code
+        request.path_info = "/#{status}"
+        request.set_header(Rack::REQUEST_METHOD, "GET")
+
+        @errors_app.call(request.env)
+      rescue Exception => failsafe_error
+        # rubocop:disable Style/StderrPuts
+        $stderr.puts "Error during exception rendering: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
+        # rubocop:enable Style/StderrPuts
+
+        [
+          500,
+          {"Content-Type" => "text/plain; charset=utf-8"},
+          ["Internal Server Error"]
+        ]
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/RescueException

data/lib/hanami/slice.rb

@@ -843,6 +843,7 @@ module Hanami
         container.config.name = slice_name.to_sym
         container.config.root = root
         container.config.provider_dirs = [File.join("config", "providers")]
+        container.config.registrations_dir = File.join("config", "registrations")
 
         container.config.env = config.env
         container.config.inflector = config.inflector
@@ -947,6 +948,7 @@ module Hanami
 
         require_relative "slice/router"
 
+        slice = self
         config = self.config
         rack_monitor = self["rack.monitor"]
 
@@ -954,17 +956,41 @@ module Hanami
           inspector: inspector,
           routes: routes,
           resolver: config.router.resolver.new(slice: self),
+          not_allowed: ROUTER_NOT_ALLOWED_HANDLER,
+          not_found: ROUTER_NOT_FOUND_HANDLER,
           **config.router.options
         ) do
           use(rack_monitor)
-          if Hanami.bundled?("hanami-controller")
-            use(*config.actions.sessions.middleware) if config.actions.sessions.enabled?
+
+          use(
+            Hanami::Middleware::RenderErrors,
+            config,
+            Hanami::Middleware::PublicErrorsApp.new(slice.root.join("public"))
+          )
+
+          if config.render_detailed_errors && Hanami.bundled?("hanami-webconsole")
+            require "hanami/webconsole"
+            use(Hanami::Webconsole::Middleware)
+          end
+
+          if Hanami.bundled?("hanami-controller") && config.actions.sessions.enabled?
+            use(*config.actions.sessions.middleware)
           end
 
           middleware_stack.update(config.middleware_stack)
         end
       end
 
+      ROUTER_NOT_ALLOWED_HANDLER = -> env, allowed_http_methods {
+        raise Hanami::Router::NotAllowedError.new(env, allowed_http_methods)
+      }.freeze
+      private_constant :ROUTER_NOT_ALLOWED_HANDLER
+
+      ROUTER_NOT_FOUND_HANDLER = -> env {
+        raise Hanami::Router::NotFoundError.new(env)
+      }.freeze
+      private_constant :ROUTER_NOT_FOUND_HANDLER
+
       # rubocop:enable Metrics/AbcSize
     end
     # rubocop:enable Metrics/ModuleLength

data/lib/hanami/slice_configurable.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "constants"
 require_relative "errors"
 
 module Hanami
@@ -43,7 +44,7 @@ module Hanami
 
             unless subclass.configured_for_slice?(slice)
               subclass.configure_for_slice(slice)
-              subclass.configured_for_slices << slice # WIP
+              subclass.configured_for_slices << slice
             end
           end
         end
@@ -58,7 +59,7 @@ module Hanami
 
         slices = Hanami.app.slices.with_nested + [Hanami.app]
 
-        slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
+        slices.detect { |slice| klass.name.start_with?("#{slice.namespace}#{MODULE_DELIMITER}") }
       end
     end
 

data/lib/hanami/version.rb

@@ -7,7 +7,7 @@ module Hanami
   # @api private
   module Version
     # @api public
-    VERSION = "2.0.2"
+    VERSION = "2.1.0.beta1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -29,7 +29,7 @@ module Hanami
       ROUTER_PARAMS = "router.params"
       private_constant :ROUTER_PARAMS
 
-      CONTENT_LENGTH = "Content-Length"
+      CONTENT_LENGTH = "CONTENT_LENGTH"
       private_constant :CONTENT_LENGTH
 
       MILISECOND = "ms"
@@ -38,30 +38,16 @@ module Hanami
       MICROSECOND = "µs"
       private_constant :MICROSECOND
 
-      # Dynamic extension used in production environments
-      # @api private
-      module Production
-        private
-
-        # @since 1.0.0
-        # @api private
-        def data(env, status:, elapsed:)
-          payload = super
-          payload[:elapsed] = elapsed
-          payload[:elapsed_unit] = MICROSECOND
-          payload
-        end
-      end
-
-      # Dynamic extension used in non-production environments
+      # Dynamic extension used in development and test environments
       # @api private
       module Development
         private
 
-        # @since 1.0.0
+        # @since 2.0.0
         # @api private
         def data(env, status:, elapsed:)
           payload = super
+          payload.delete(:elapsed_unit)
           payload[:elapsed] = elapsed > 1000 ? "#{elapsed / 1000}ms" : "#{elapsed}#{MICROSECOND}"
           payload
         end
@@ -71,7 +57,7 @@ module Hanami
       # @since 2.0.0
       def initialize(logger, env: :development)
         @logger = logger
-        extend(env == :production ? Production : Development)
+        extend(Development) if %i[development test].include?(env)
       end
 
       # @api private
@@ -116,7 +102,9 @@ module Hanami
           ip: env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR],
           path: "#{env[SCRIPT_NAME]}#{env[PATH_INFO]}",
           length: extract_content_length(env),
-          params: env.fetch(ROUTER_PARAMS, EMPTY_PARAMS)
+          params: env.fetch(ROUTER_PARAMS, EMPTY_PARAMS),
+          elapsed: elapsed,
+          elapsed_unit: MICROSECOND,
         }
       end
 

data/lib/hanami.rb

@@ -18,7 +18,7 @@ module Hanami
   def self.loader
     @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
       loader.ignore(
-        "#{loader.dirs.first}/hanami/{constants,boot,errors,prepare,rake_tasks,setup}.rb"
+        "#{loader.dirs.first}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb"
       )
     end
   end