hanami 2.0.3 → 2.1.0.beta2

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/assets.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rack/static"
+
+module Hanami
+  module Middleware
+    class Assets < Rack::Static
+      def initialize(app, options = {}, config: Hanami.app.config)
+        root = config.actions.public_directory
+        urls = [config.assets.path_prefix]
+
+        defaults = {
+          root: root,
+          urls: urls
+        }
+
+        super(app, defaults.merge(options))
+      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,90 @@
+# 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
+        raise unless @config.render_errors
+
+        render_exception(env, exception)
+      end
+
+      private
+
+      def render_exception(env, exception)
+        request = Rack::Request.new(env)
+        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/providers/assets.rb

@@ -0,0 +1,44 @@
+# 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 Assets < Dry::System::Provider::Source
+      # @api private
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      # @api private
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      # @api private
+      def prepare
+        require "hanami/assets"
+      end
+
+      # @api private
+      def start
+        assets = Hanami::Assets.new(config: slice.config.assets)
+
+        register(:assets, assets)
+      end
+
+      private
+
+      def slice
+        self.class.slice
+      end
+    end
+  end
+end

data/lib/hanami/rake_tasks.rb

@@ -10,7 +10,7 @@ Hanami::CLI::RakeTasks.register_tasks do
 
   # Ruby ecosystem compatibility
   #
-  # Most of the SaaS automatic tasks are designed after Ruby on Rails.
+  # Most of the hosting SaaS automatic tasks are designed after Ruby on Rails.
   # They expect the following Rake tasks to be present:
   #
   #   * db:migrate
@@ -20,31 +20,32 @@ Hanami::CLI::RakeTasks.register_tasks do
   #
   # ===
   #
-  # These Rake tasks aren't listed when someone runs `rake -T`, because we
-  # want to encourage developers to use `hanami` commands.
+  # 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 precompile assets a developer should
-  # use:
+  # In order to migrate the database or compile assets a developer should use:
   #
   #   * hanami db migrate
-  #   * hanami assets precompile
+  #   * 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 to solve this only specific problem.
-  namespace :db do
-    task :migrate do
-      # TODO(@jodosha): Enable when we'll integrate with ROM
-      # run_hanami_command("db migrate")
-    end
-  end
-
-  namespace :assets do
-    task :precompile do
-      # TODO(@jodosha): Enable when we'll integrate with hanami-assets
-      # run_hanami_command("assets precompile")
+  #
+  # namespace :db do
+  #   task :migrate do
+  #     # TODO(@jodosha): Enable when we'll integrate with ROM
+  #     # run_hanami_command("db migrate")
+  #   end
+  # end
+
+  if Hanami.bundled?("hanami-assets")
+    namespace :assets do
+      task :precompile do
+        run_hanami_command("assets compile")
+      end
     end
   end
 
@@ -53,7 +54,7 @@ Hanami::CLI::RakeTasks.register_tasks do
   @_hanami_cli_bundler = Hanami::CLI::Bundler.new
 
   def run_hanami_command(command)
-    @_hanami_cli_bundler.exec(command)
+    @_hanami_cli_bundler.hanami_exec(command)
   end
 end
 

data/lib/hanami/settings.rb

@@ -45,7 +45,7 @@ module Hanami
   #
   # 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 configue an alternative store via {Hanami::Config#settings_store}. Setting stores
+  # `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/

data/lib/hanami/slice.rb

@@ -948,24 +948,70 @@ module Hanami
 
         require_relative "slice/router"
 
+        slice = self
         config = self.config
         rack_monitor = self["rack.monitor"]
 
+        render_errors = render_errors?
+        render_detailed_errors = render_detailed_errors?
+
+        error_handlers = {}.tap do |hsh|
+          if render_errors || render_detailed_errors
+            hsh[:not_allowed] = ROUTER_NOT_ALLOWED_HANDLER
+            hsh[:not_found] = ROUTER_NOT_FOUND_HANDLER
+          end
+        end
+
         Slice::Router.new(
           inspector: inspector,
           routes: routes,
           resolver: config.router.resolver.new(slice: self),
+          **error_handlers,
           **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 render_detailed_errors
+            require "hanami/webconsole"
+            use(Hanami::Webconsole::Middleware, config)
+          end
+
+          if Hanami.bundled?("hanami-controller") && config.actions.sessions.enabled?
+            use(*config.actions.sessions.middleware)
+          end
+
+          if Hanami.bundled?("hanami-assets") && config.assets.serve
+            use(Hanami::Middleware::Assets)
           end
 
           middleware_stack.update(config.middleware_stack)
         end
       end
 
+      def render_errors?
+        config.render_errors
+      end
+
+      def render_detailed_errors?
+        config.render_detailed_errors && Hanami.bundled?("hanami-webconsole")
+      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