hanami 2.0.2 → 2.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '099623ad9ce0088b28fc658340d85094d493f27e4320df725d4dfc062ee4939c'
-  data.tar.gz: 759492d76fb078f025d00e57d8c81cc5840ca769e5a20a0e50d20a0221c9a599
+  metadata.gz: 5b7770e05814c2c09affa6bb627a563f56f64601e2587c474f5139c42a17d25c
+  data.tar.gz: 67e7f5b426b6e50023f5c3baad3b91d422b1c82dcc25213f4d6fe4efab0ff681
 SHA512:
-  metadata.gz: fa25a5f37d22c1faf03906914f1c0a4f5d119ae39088df6878d75ef5c830b7be7632b2b633aa915619ff44990784016da4df666b5343b56166cb31a1f613a4ea
-  data.tar.gz: ff70c18b250591af4c2fbaf32532a7ca5cb00adbc17ab87a03e0bb0dddd0ca5a19a7440aa63d0abc9c1570d9784027a4981d2d097632852e7b69f150ebd56328
+  metadata.gz: eeb3695b89718d12ca4d6376b997af52a21fe39e39e8b8e2e932422d291314a9b8bc1f11ade96279737847283234a783039e8e7e0364fc488def2ab18f8efaf5
+  data.tar.gz: 63cf7e291a0b6789eb16430ce0c1945ce945787fab250c8e804869276428045404d0f98205fdf481c9a80e48cf89b38a243bff00b52a900349fcffef5cc62254

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 The web, with simplicity.
 
+## 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
+
+### Added
+
+- [Luca Guidi] Official support for Ruby 3.2
+
+### Fixed
+
+- [Adam Lassek] Ensure to setup a logger in a non-default Hanami env
+- [R Gibim] Use production logger settings for non-default Hanami env
+- [Adam Lassek] Allow slices to have a default for registrations directory
+
 ## v2.0.2 - 2022-12-25
 
 ### Added

data/LICENSE.md

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

data/README.md

@@ -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/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

data/lib/hanami/config/logger.rb

@@ -126,7 +126,7 @@ module Hanami
           config.level = :debug
           config.stream = File.join("log", "#{env}.log") if env == :test
           config.logger_constructor = method(:development_logger)
-        when :production
+        else
           config.level = :info
           config.formatter = :json
           config.logger_constructor = method(:production_logger)

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

@@ -127,6 +127,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.
@@ -217,6 +269,8 @@ module Hanami
 
       # 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)

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

@@ -101,13 +101,13 @@ module Hanami
         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

data/lib/hanami/extensions/view/context.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/view"
-require "hanami/view/context"
 require_relative "../../errors"
 
 module Hanami
@@ -13,88 +11,159 @@ module Hanami
       #
       # @api private
       module Context
-        def self.included(context_class)
-          super
-
-          context_class.extend(Hanami::SliceConfigurable)
-          context_class.extend(ClassMethods)
-          context_class.prepend(InstanceMethods)
-        end
+        class << self
+          # Returns a context class for the given slice. If a context class is not defined, defines
+          # a class named `Views::Context` within the slice's namespace.
+          #
+          # @api private
+          def context_class(slice)
+            views_namespace = views_namespace(slice)
+
+            if views_namespace.const_defined?(:Context)
+              return views_namespace.const_get(:Context)
+            end
 
-        module ClassMethods
-          def configure_for_slice(slice)
-            extend SliceConfiguredContext.new(slice)
+            views_namespace.const_set(:Context, Class.new(context_superclass(slice)).tap { |klass|
+              klass.configure_for_slice(slice)
+            })
           end
-        end
 
-        module InstanceMethods
-          # @see SliceConfiguredContext#define_new
-          def initialize(**kwargs)
-            defaults = {content: {}}
+          private
 
-            super(**kwargs, **defaults)
+          def context_superclass(slice)
+            return Hanami::View::Context if Hanami.app.equal?(slice)
+
+            begin
+              slice.inflector.constantize(
+                slice.inflector.camelize("#{slice.app.slice_name.name}/views/context")
+              )
+            rescue NameError => e
+              raise e unless %i[Views Context].include?(e.name)
+
+              Hanami::View::Context
+            end
           end
 
-          def inflector
-            _options.fetch(:inflector)
+          # TODO: this could be moved into the top-level Extensions::View
+          def views_namespace(slice)
+            if slice.namespace.const_defined?(:Views)
+              slice.namespace.const_get(:Views)
+            else
+              slice.namespace.const_set(:Views, Module.new)
+            end
           end
+        end
 
-          def routes
-            _options.fetch(:routes)
+        module ClassExtension
+          def self.included(context_class)
+            super
+
+            context_class.extend(Hanami::SliceConfigurable)
+            context_class.extend(ClassMethods)
+            context_class.prepend(InstanceMethods)
           end
 
-          def settings
-            _options.fetch(:settings)
+          module ClassMethods
+            def configure_for_slice(slice)
+              extend SliceConfiguredContext.new(slice)
+            end
           end
 
-          def assets
-            unless _options[:assets]
-              raise Hanami::ComponentLoadError, "hanami-assets gem is required to access assets"
+          module InstanceMethods
+            attr_reader :inflector
+
+            attr_reader :settings
+
+            # @see SliceConfiguredContext#define_new
+            def initialize( # rubocop:disable Metrics/ParameterLists
+              inflector: nil,
+              settings: nil,
+              routes: nil,
+              assets: nil,
+              request: nil,
+              **args
+            )
+              @inflector = inflector
+              @settings = settings
+              @routes = routes
+              @assets = assets
+              @request = request
+
+              @content_for = {}
+
+              super(**args)
             end
 
-            _options[:assets]
-          end
+            def initialize_copy(source)
+              # The standard implementation of initialize_copy will make shallow copies of all
+              # instance variables from the source. This is fine for most of our ivars.
+              super
 
-          def content_for(key, value = nil, &block)
-            content = _options[:content]
-            output = nil
+              # Dup any objects that will be mutated over a given rendering to ensure no leakage of
+              # state across distinct view renderings.
+              @content_for = source.instance_variable_get(:@content_for).dup
+            end
 
-            if block
-              content[key] = yield
-            elsif value
-              content[key] = value
-            else
-              output = content[key]
+            def with(**args)
+              self.class.new(
+                inflector: @inflector,
+                settings: @settings,
+                assets: @assets,
+                routes: @routes,
+                request: @request,
+                **args
+              )
             end
 
-            output
-          end
+            def assets
+              unless @assets
+                raise Hanami::ComponentLoadError, "the hanami-assets gem is required to access assets"
+              end
 
-          def current_path
-            request.fullpath
-          end
+              @assets
+            end
 
-          def csrf_token
-            request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
-          end
+            def request
+              unless @request
+                raise Hanami::ComponentLoadError, "only views rendered from Hanami::Action instances have a request"
+              end
 
-          def request
-            _options.fetch(:request)
-          end
+              @request
+            end
 
-          def session
-            request.session
-          end
+            def routes
+              unless @routes
+                raise Hanami::ComponentLoadError, "the hanami-router gem is required to access routes"
+              end
 
-          def flash
-            response.flash
-          end
+              @routes
+            end
 
-          private
+            def content_for(key, value = nil)
+              if block_given?
+                @content_for[key] = yield
+              elsif value
+                @content_for[key] = value
+              else
+                @content_for[key]
+              end
+            end
+
+            def current_path
+              request.fullpath
+            end
+
+            def csrf_token
+              request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
+            end
+
+            def session
+              request.session
+            end
 
-          # TODO: create `Request#flash` so we no longer need the `response`
-          def response
-            _options.fetch(:response)
+            def flash
+              request.flash
+            end
           end
         end
       end
@@ -102,4 +171,4 @@ module Hanami
   end
 end
 
-Hanami::View::Context.include(Hanami::Extensions::View::Context)
+Hanami::View::Context.include(Hanami::Extensions::View::Context::ClassExtension)

data/lib/hanami/extensions/view/part.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      module Part
+        def self.included(part_class)
+          super
+
+          part_class.extend(Hanami::SliceConfigurable)
+          part_class.include(StandardHelpers)
+          part_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredHelpers.new(slice)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Part.include(Hanami::Extensions::View::Part)

data/lib/hanami/extensions/view/scope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      module Scope
+        def self.included(scope_class)
+          super
+
+          scope_class.extend(Hanami::SliceConfigurable)
+          scope_class.include(StandardHelpers)
+          scope_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredHelpers.new(slice)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Scope.include(Hanami::Extensions::View::Scope)

data/lib/hanami/extensions/view/slice_configured_context.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/view"
-
 module Hanami
   module Extensions
     module View