hanami 2.0.3 → 2.1.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4e96c0b8ba475c9f256fa14b1af20a353804df3f0db3847b814899f7cdd394
-  data.tar.gz: 8bc463f8095b0bff1ac433fe1869f90e5d7a98e88198546e2fd78ac0caf13639
+  metadata.gz: 06d7766d5bdb4f510945a2065cc15457acbf00f43970d691afda74219f0aeb02
+  data.tar.gz: 58935ca7f23c3d3612a91b277827ed941c30839d04c9bf577e35a095fa667f6f
 SHA512:
-  metadata.gz: 5fc16cc328fc1756b03875d8e6ce6383771b432d85deab7c9fb55c77f9e9a573c0ed449312456c322dd202c0402dd40f5eb126d25b3d6c2b6666e6ff4d9d69c1
-  data.tar.gz: 903eaccd76b79b10d1ff1197fa6f12d99ce824d41a66be2579549884a9d45d25d3d186fc6f56e33b7badafec427b64da1455443ff674488f2bfb5e3502ca65f4
+  metadata.gz: 50a785250f4cf249c5721dd37a5e5a7a240282e5d3820fe848a53c133b1727ea57e5beb351429e636bb4a7d89812bfc53794b5357865b134598a5d54e60666db
+  data.tar.gz: 677f40136e0477c57e493e41ed9a25666d9b53d6dd4ae4c23ee6e61d062f9537c39d86eb16d264f194eda4209e5eb0e38fa0554fd3efaf2d39ea23afa1ead27b

data/CHANGELOG.md

@@ -2,11 +2,46 @@
 
 The web, with simplicity.
 
-## v2.0.3 - 2023-02-01
+## v2.1.0.beta2 - 2023-10-04
 
 ### Added
 
-- [Luca Guidi] Official support for Ruby 3.2
+- [Luca Guidi, Tim Riley] Reimplement assets integration (#1319, #1332, #1333, #1336)
+- [Tim Riley] Introduce `Hanami::Helpers::AssetsHelper`, automatically included in view templates, scopes and parts when hanami-assets is bundled (#1319)
+- [Tim Riley] Renamed assets helpers (#1319):
+  - Removed `#asset_path` in favour of `#asset_url` only
+  - Renamed `#javascript` to `#javascript_tag`, retaining `#js` alias
+  - Renamed `#stylesheet` to `#stylesheet_link_tag`, retaining `#css` alias
+  - Renamed `#image` to `#image_tag`
+  - Renamed `#favicon` to `#favicon_link_tag`, with `#favicon` retained as an alias
+  - Renamed `#video` to `#video_tag`
+  - Renamed `#audio` to `#audio_tag`
+
+
+### Fixed
+
+- [Tim Riley] Return appropriate response statuses based on error type (#1330)
+
+## v2.1.0.beta1 - 2023-06-29
+
+### Added
+
+- [Tim Riley] Introduce `Hanami::View` extensions to use alongside hanami-view v2.1.0.beta1 (#1292)
+- [Tim Riley] Enable standard helpers (from hanami-view) for all view parts and scopes (#1303,
+  #1307)
+- [Tim Riley] Add `Hanami::Helpers::FormHelper` and include in all view parts and scopes (#1305,
+  #1307)
+- [Tim Riley] Include user defined helpers (at `MyApp::Views::Helpers` or `MySlice::Views::Helpers`)
+  in all view parts and scopes (#1307)
+- [Tim Riley] Introduce `Hanami::Middleware::RenderErrors` middleware to render error responses (in HTML or JSON) when errors are raised. For HTML responses, the error pages are expected to be found in `public/{404,500}.html` (#1309)
+- [Tim Riley] Use hanami-webconsole (if bundled) to render detailed error pages in development mode (#1311).
+
+### Fixed
+
+- [Tim Riley] Prevent matching incorrect slice names (due to partial matches) in `Hanami::SliceConfigurable`. This ensures appropriate config is applied to actions and views within their respective slices. (#1302)
+- [Masanori Ohnishi] Ensure content-length properly appears in rack logs (#1306)
+
+## v2.0.3 - 2023-02-01
 
 ### Fixed
 

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright © 2014-2021 Luca Guidi
+Copyright © 2014 Hanami Team
 
 MIT License
 

data/README.md

@@ -62,7 +62,7 @@ You can give back to Open Source, by supporting Hanami development via [GitHub S
 * Guides: https://guides.hanamirb.org
 * Snippets: https://snippets.hanamirb.org
 * Mailing List: http://hanamirb.org/mailing-list
-* API Doc: http://rdoc.info/gems/hanami
+* API Doc: https://gemdocs.org/gems/hanami/latest
 * Bugs/Issues: https://github.com/hanami/hanami/issues
 * Stack Overflow: http://stackoverflow.com/questions/tagged/hanami
 * Forum: https://discourse.hanamirb.org
@@ -82,26 +82,42 @@ We strive for an inclusive and helpful community. We have a [Code of Conduct](ht
 
 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).
 
-### Development Requirements
+### Tests
 
-  * Ruby >= 3.0
-  * Bundler
-  * Node.js (MacOS)
+To run all test suite:
+
+```shell
+$ bundle exec rake
+```
 
-### Testing
+To run all the unit tests:
 
-In order to simulate installed gems on developers' computers, the build installs all the gems locally in `vendor/cache`, including `hanami` code from `lib/`.
+```shell
+$ bundle exec rspec spec/unit
+```
 
-**Before running a test, please make sure you have a fresh version of the code:**
+To run all the integration tests:
 
 ```shell
-bundle exec rspec spec/path/to/file_spec.rb
+$ bundle exec rspec spec/integration
 ```
 
+To run a single test:
+
+```shell
+$ bundle exec rspec path/to/spec.rb
+```
+
+### Development Requirements
+
+  * Ruby >= 3.0
+  * Bundler
+  * Node.js (MacOS)
+
 ## Versioning
 
 __Hanami__ uses [Semantic Versioning 2.0.0](http://semver.org)
 
 ## Copyright
 
-Copyright © 2014-2022 Hanami Team – Released under MIT License.
+Copyright © 2014 Hanami Team – Released under MIT License.

data/hanami.gemspec

@@ -38,8 +38,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "dry-monitor",      "~> 1.0", ">= 1.0.1", "< 2"
   spec.add_dependency "dry-system",       "~> 1.0", "< 2"
   spec.add_dependency "dry-logger",       "~> 1.0", "< 2"
-  spec.add_dependency "hanami-cli",       "~> 2.0"
-  spec.add_dependency "hanami-utils",     "~> 2.0"
+  spec.add_dependency "hanami-cli",       "~> 2.1.beta"
+  spec.add_dependency "hanami-utils",     "~> 2.1.beta"
   spec.add_dependency "zeitwerk",         "~> 2.6"
 
   spec.add_development_dependency "rspec",     "~> 3.8"

data/lib/hanami/app.rb

@@ -161,6 +161,11 @@ module Hanami
           require_relative "providers/rack"
           register_provider(:rack, source: Hanami::Providers::Rack, namespace: true)
         end
+
+        if Hanami.bundled?("hanami-assets")
+          require_relative "providers/assets"
+          register_provider(:assets, source: Providers::Assets.for_slice(self))
+        end
       end
 
       def prepare_autoloader

data/lib/hanami/config/actions.rb

@@ -82,10 +82,6 @@ module Hanami
       #   @api private
       setting :name_inference_base, default: "actions"
 
-      # @!attribute [rw] view_context_identifier
-      #   @api private
-      setting :view_context_identifier, default: "views.context"
-
       # @!attribute [rw] view_name_inferrer
       #   @api private
       setting :view_name_inferrer, default: Slice::ViewNameInferrer
@@ -103,12 +99,7 @@ module Hanami
         super()
 
         @base_config = Hanami::Action.config.dup
-        @content_security_policy = ContentSecurityPolicy.new do |csp|
-          if assets_server_url = options[:assets_server_url]
-            csp[:script_src] += " #{assets_server_url}"
-            csp[:style_src] += " #{assets_server_url}"
-          end
-        end
+        @content_security_policy = ContentSecurityPolicy.new
 
         configure_defaults
       end
@@ -122,7 +113,9 @@ module Hanami
       private :initialize_copy
 
       # @api private
-      def finalize!
+      def finalize!(app_config)
+        @base_config.root_directory = app_config.root
+
         # A nil value for `csrf_protection` means it has not been explicitly configured
         # (neither true nor false), so we can default it to whether sessions are enabled
         self.csrf_protection = sessions.enabled? if csrf_protection.nil?

data/lib/hanami/config/assets.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/assets"
+
+module Hanami
+  class Config
+    # Hanami assets config
+    #
+    # This exposes all the settings from the standalone `Hanami::Assets` class, pre-configured with
+    # sensible defaults for actions within a full Hanami app. It also provides additional settings
+    # for further integration of actions with other full stack app components.
+    #
+    # @since 2.1.0
+    # @api public
+    class Assets
+      include Dry::Configurable
+
+      # @!attribute [rw] serve
+      #   Serve static assets.
+      #
+      #   When this is `true`, the app will serve static assets.
+      #
+      #   If not set, this will:
+      #
+      #     * Check if the `HANAMI_SERVE_ASSETS` environment variable is set to `"true"`.
+      #     * If not, it will check if the app is running in the `development` or `test` environment.
+      #
+      #   @example
+      #     config.assets.serve = true
+      #
+      #   @return [Hanami::Config::Actions::Cookies]
+      #
+      #   @api public
+      #   @since 2.1.0
+      setting :serve
+
+      # @api private
+      attr_reader :base_config
+      protected :base_config
+
+      # @api private
+      def initialize(*, **options)
+        super()
+
+        @base_config = Hanami::Assets::Config.new(**options)
+
+        configure_defaults
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @base_config = source.base_config.dup
+      end
+      private :initialize_copy
+
+      private
+
+      def configure_defaults
+        self.serve =
+          if ENV.key?("HANAMI_SERVE_ASSETS")
+            ENV["HANAMI_SERVE_ASSETS"] == "true"
+          else
+            Hanami.env?(:development, :test)
+          end
+      end
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        elsif base_config.respond_to?(name)
+          base_config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || base_config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/config/null_config.rb

@@ -9,6 +9,9 @@ module Hanami
     # loaded)
     class NullConfig
       include Dry::Configurable
+
+      def finalize!(*)
+      end
     end
   end
 end

data/lib/hanami/config/views.rb

@@ -13,8 +13,6 @@ module Hanami
     class Views
       include Dry::Configurable
 
-      setting :parts_path, default: "views/parts"
-
       attr_reader :base_config
       protected :base_config
 
@@ -46,8 +44,6 @@ module Hanami
       private
 
       def configure_defaults
-        self.paths = ["templates"]
-        self.template_inference_base = "views"
         self.layout = "app"
       end
 

data/lib/hanami/config.rb

@@ -99,6 +99,7 @@ module Hanami
       rack.monitor
       routes
       settings
+      assets
     ]
 
     # @!attribute [rw] no_auto_register_paths
@@ -127,6 +128,58 @@ module Hanami
     #   @since 2.0.0
     setting :base_url, default: "http://0.0.0.0:2300", constructor: ->(url) { URI(url) }
 
+    # @!attribute [rw] render_errors
+    #   Sets whether to catch exceptions and render error pages.
+    #
+    #   For HTML responses, these error pages are in `public/{404,500}.html`.
+    #
+    #   Defaults to `true` in production mode, `false` in all others.
+    #
+    #   @return [Boolean]
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_errors, default: false
+
+    # @!attribute [rw] render_detailed_errors
+    #   Sets whether to catch exceptions and render detailed, interactive error pages.
+    #
+    #   Requires the hanami-webconsole gem to be available.
+    #
+    #   Defaults to `false` in production mode, `true` in all others.
+    #
+    #   @return [Boolean]
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_detailed_errors, default: false
+
+    # @!attribute [rw] render_error_responses
+    #   Sets a mapping of exception class names (as strings) to symbolic response status codes used
+    #   for rendering error responses.
+    #
+    #   The response status codes will be passed to `Rack::Utils.status_code`.
+    #
+    #   In ordinary usage, you should not replace this hash. Instead, add keys and values for the
+    #   errors you want handled.
+    #
+    #   @example
+    #     config.render_error_responses
+    #     # => {"Hanami::Router::NotFoundError" => :not_found}
+    #
+    #     config.render_error_responses["MyNotFoundError"] = :not_found
+    #
+    #   @return [Hash{String => Symbol}]
+    #
+    #   @see #render_errors
+    #
+    #   @api public
+    #   @since 2.1.0
+    setting :render_error_responses, default: Hash.new(:internal_server_error).merge!(
+      "Hanami::Router::NotAllowedError" => :not_found,
+      "Hanami::Router::NotFoundError" => :not_found,
+    )
+
     # Returns the app or slice's {Hanami::SliceName slice_name}.
     #
     # This is useful for default config values that depend on this name.
@@ -211,20 +264,19 @@ module Hanami
     attr_reader :assets
 
     # @api private
+    # rubocop:disable Metrics/AbcSize
     def initialize(app_name:, env:)
       @app_name = app_name
       @env = env
 
       # Apply default values that are only knowable at initialize-time (vs require-time)
       self.root = Dir.pwd
+      self.render_errors = (env == :production)
+      self.render_detailed_errors = (env != :production)
       load_from_env
 
       @logger = Config::Logger.new(env: env, app_name: app_name)
 
-      # TODO: Make assets config dependent
-      require "hanami/assets/app_config"
-      @assets = Hanami::Assets::AppConfig.new
-
       @actions = load_dependent_config("hanami-controller") {
         require_relative "config/actions"
         Actions.new
@@ -241,8 +293,22 @@ module Hanami
         Views.new
       }
 
+      @assets = load_dependent_config("hanami-assets") {
+        require_relative "config/assets"
+
+        public_dir = root.join("public")
+
+        Hanami::Config::Assets.new(
+          # TODO: check if `sources` are still needed
+          sources: root.join("app", "assets"),
+          destination: public_dir.join("assets"),
+          manifest_path: public_dir.join("assets.json")
+        )
+      }
+
       yield self if block_given?
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @api private
     def initialize_copy(source)
@@ -269,7 +335,7 @@ module Hanami
     def finalize!
       # Finalize nested configs
       assets.finalize!
-      actions.finalize!
+      actions.finalize!(self)
       views.finalize!
       logger.finalize!
       router.finalize!

data/lib/hanami/extensions/action/slice_configured_action.rb

@@ -121,18 +121,26 @@ module Hanami
             slice: slice,
           )
 
-          view_identifiers.detect do |identifier|
-            break slice[identifier] if slice.key?(identifier)
+          view_identifiers.each do |identifier|
+            return slice[identifier] if slice.key?(identifier)
           end
+
+          nil
         end
 
         def resolve_view_context
-          identifier = actions_config.view_context_identifier
+          if Hanami.bundled?("hanami-view")
+            return Extensions::View::Context.context_class(slice).new
+          end
+
+          # If hanami-view isn't bundled, try and find a possible third party context class with the
+          # same `Views::Context` name (but don't fall back to automatically defining one).
+          if slice.namespace.const_defined?(:Views)
+            views_namespace = slice.namespace.const_get(:Views)
 
-          if slice.key?(identifier)
-            slice[identifier]
-          elsif slice.app.key?(identifier)
-            slice.app[identifier]
+            if views_namespace.const_defined?(:Context)
+              views_namespace.const_get(:Context).new
+            end
           end
         end
 

data/lib/hanami/extensions/action.rb

@@ -94,20 +94,22 @@ module Hanami
         end
 
         # @api private
-        def _handle_exception(request, _response, exception)
+        def _handle_exception(request, _response, _exception)
+          super
+        rescue StandardError => exception
           rack_monitor&.instrument(:error, exception: exception, env: request.env)
 
-          super
+          raise
         end
 
         # @api private
-        def view_options(req, res)
-          {context: view_context&.with(**view_context_options(req, res))}.compact
+        def view_options(request, response)
+          {context: view_context&.with(**view_context_options(request, response))}.compact
         end
 
         # @api private
-        def view_context_options(req, res)
-          {request: req, response: res}
+        def view_context_options(request, response) # rubocop:disable Lint:UnusedMethodArgument
+          {request: request}
         end
 
         # Returns true if a view should automatically be rendered onto the response body.

data/lib/hanami/extensions/router/errors.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+
+module Hanami
+  class Router
+    # Error raised when a request is made for a missing route.
+    #
+    # Raised only when using hanami-router as part of a full Hanami app. When using hanami-router
+    # standalone, the behavior for such requests is to return a "Not Found" response.
+    #
+    # @api public
+    # @since 2.1.0
+    class NotFoundError < Hanami::Router::Error
+      # @return [Hash] the Rack environment for the request
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+
+        message = "No route found for #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+        super(message)
+      end
+    end
+
+    # Error raised when a request is made for a route using a HTTP method not allowed on the route.
+    #
+    # Raised only when using hanami-router as part of a full Hanami app. When using hanami-router
+    # standalone, the behavior for such requests is to return a "Method Not Allowed" response.
+    #
+    # @api public
+    # @since 2.1.0
+    class NotAllowedError < Hanami::Router::Error
+      # @return [Hash] the Rack environment for the request
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :env
+
+      # @return [Array<String>] the allowed methods for the route
+      #
+      # @api public
+      # @since 2.1.0
+      attr_reader :allowed_methods
+
+      def initialize(env, allowed_methods)
+        @env = env
+        @allowed_methods = allowed_methods
+
+        message = "Only #{allowed_methods.join(', ')} requests are allowed at #{env["PATH_INFO"]}"
+        super(message)
+      end
+    end
+  end
+end