hanami 2.3.0.beta1 → 2.3.0

data/lib/hanami/slice/router.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "hanami/router"
+require_relative "routing/resolver"
+require_relative "routing/middleware/stack"
 
 module Hanami
   class Slice
@@ -10,27 +12,27 @@ module Hanami
     # {Hanami::Slice::ClassMethods#router router}.
     #
     # @api private
-    # @since 2.0.0
     class Router < ::Hanami::Router
       # @api private
-      # @since 2.0.0
+      attr_reader :inflector
+
+      # @api private
       attr_reader :middleware_stack
 
       # @api private
-      # @since 2.0.0
       attr_reader :path_prefix
 
       # @api private
-      # @since 2.0.0
-      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, prefix: ::Hanami::Router::DEFAULT_PREFIX, **kwargs, &blk)
+      def initialize(routes:, inflector:, middleware_stack: Routing::Middleware::Stack.new, prefix: ::Hanami::Router::DEFAULT_PREFIX, **kwargs, &blk)
         @path_prefix = Hanami::Router::Prefix.new(prefix)
+        @inflector = inflector
         @middleware_stack = middleware_stack
+        @resource_scope = []
         instance_eval(&blk)
         super(**kwargs, &routes)
       end
 
       # @api private
-      # @since 2.0.0
       def freeze
         return self if frozen?
 
@@ -39,7 +41,11 @@ module Hanami
       end
 
       # @api private
-      # @since 2.0.0
+      def to_rack_app
+        middleware_stack.to_rack_app(self)
+      end
+
+      # @api private
       def use(*args, **kwargs, &blk)
         middleware_stack.use(*args, **kwargs.merge(path_prefix: path_prefix.to_s), &blk)
       end
@@ -65,21 +71,204 @@ module Hanami
       #
       # @api public
       # @since 2.0.0
-      def slice(slice_name, at:, &blk)
+      def slice(slice_name, at:, as: nil, &blk)
         blk ||= @resolver.find_slice(slice_name).routes
 
         prev_resolver = @resolver
         @resolver = @resolver.to_slice(slice_name)
 
-        scope(at, &blk)
+        scope(at, as:, &blk)
       ensure
         @resolver = prev_resolver
       end
 
+      # Generates RESTful routes for a plural resource.
+      #
+      # @param name [Symbol] the resource name (plural)
+      # @param options [Hash] options for customizing the routes
+      # @option options [Array<Symbol>] :only Limit to specific actions
+      # @option options [Array<Symbol>] :except Exclude specific actions
+      # @option options [String] :to the action key namespace, e.g. "namespace.action"
+      # @option options [String] :path the URL path
+      # @option options [String, Symbol] :as the route name prefix
+      #
+      # @example
+      #   resources :users
+      #   # Generates:
+      #   # GET    /users          users.index
+      #   # GET    /users/new      users.new
+      #   # POST   /users          users.create
+      #   # GET    /users/:id      users.show
+      #   # GET    /users/:id/edit users.edit
+      #   # PATCH  /users/:id      users.update
+      #   # DELETE /users/:id      users.destroy
+      #
+      # @api public
+      # @since 2.3.0
+      def resources(name, **options, &block)
+        build_resource(name, :plural, options, &block)
+      end
+
+      # Generates RESTful routes for a singular resource.
+      #
+      # @param name [Symbol] the resource name (singular)
+      # @param options [Hash] options for customizing the routes
+      # @option options [Array<Symbol>] :only limit to specific actions
+      # @option options [Array<Symbol>] :except exclude specific actions
+      # @option options [String] :to the action key namespace, e.g. "namespace.action"
+      # @option options [String] :path the URL path
+      # @option options [String, Symbol] :as the route name prefix
+      #
+      # @example
+      #   resource :profile
+      #   # Generates (singular, no index):
+      #   # GET    /profile/new    profile.new
+      #   # POST   /profile        profile.create
+      #   # GET    /profile        profile.show
+      #   # GET    /profile/edit   profile.edit
+      #   # PATCH  /profile        profile.update
+      #   # DELETE /profile        profile.destroy
+      #
+      # @api public
+      # @since 2.3.0
+      def resource(name, **options, &block)
+        build_resource(name, :singular, options, &block)
+      end
+
+      private
+
+      def build_resource(name, type, options, &block)
+        resource_builder = ResourceBuilder.new(
+          name: name,
+          type: type,
+          resource_scope: @resource_scope,
+          options: options,
+          inflector: inflector
+        )
+
+        resource_builder.add_routes(self)
+        resource_builder.scope(self, &block) if block
+      end
+
+      # Builds RESTful routes for a resource
+      #
       # @api private
-      # @since 2.0.0
-      def to_rack_app
-        middleware_stack.to_rack_app(self)
+      class ResourceBuilder
+        ROUTE_OPTIONS = {
+          index: {method: :get},
+          new: {method: :get, path_suffix: "/new", name_prefix: "new"},
+          create: {method: :post},
+          show: {method: :get, path_suffix: "/:id"},
+          edit: {method: :get, path_suffix: "/:id/edit", name_prefix: "edit"},
+          update: {method: :patch, path_suffix: "/:id"},
+          destroy: {method: :delete, path_suffix: "/:id"}
+        }.freeze
+
+        PLURAL_ACTIONS = %i[index new create show edit update destroy].freeze
+        SINGULAR_ACTIONS = (PLURAL_ACTIONS - %i[index]).freeze
+
+        def initialize(name:, type:, resource_scope:, options:, inflector:)
+          @name = name
+          @type = type
+          @resource_scope = resource_scope
+          @options = options
+          @inflector = inflector
+
+          @path = options[:path] || name.to_s
+        end
+
+        def scope(router, &block)
+          @resource_scope.push(@name)
+          router.scope(scope_path, as: scope_name, &block)
+        ensure
+          @resource_scope.pop
+        end
+
+        def add_routes(router)
+          actions.each do |action|
+            add_route(router, action, ROUTE_OPTIONS.fetch(action))
+          end
+        end
+
+        private
+
+        def plural?
+          @type == :plural
+        end
+
+        def singular?
+          !plural?
+        end
+
+        def scope_path
+          if plural?
+            "#{@path}/:#{@inflector.singularize(@path.to_s)}_id"
+          else
+            @path
+          end
+        end
+
+        def scope_name
+          @inflector.singularize(@name)
+        end
+
+        def actions
+          default_actions = plural? ? PLURAL_ACTIONS : SINGULAR_ACTIONS
+          if @options[:only]
+            Array(@options[:only]) & default_actions
+          elsif @options[:except]
+            default_actions - Array(@options[:except])
+          else
+            default_actions
+          end
+        end
+
+        def add_route(router, action, route_options)
+          path = "/#{@path}#{route_suffix(route_options[:path_suffix])}"
+          to = "#{key_path_base}#{CONTAINER_KEY_DELIMITER}#{action}"
+          as = route_name(action, route_options[:name_prefix])
+
+          router.public_send(route_options[:method], path, to:, as:)
+        end
+
+        def route_suffix(suffix)
+          return suffix.sub(LEADING_ID_REGEX, "") if suffix && singular?
+          suffix
+        end
+        LEADING_ID_REGEX = %r{\A/:id}
+
+        def key_path_base
+          @key_path_base ||=
+            if @options[:to]
+              @options[:to]
+            else
+              @name.to_s.then { |name|
+                next name unless @resource_scope.any?
+
+                prefix = @resource_scope.join(CONTAINER_KEY_DELIMITER)
+                "#{prefix}#{CONTAINER_KEY_DELIMITER}#{name}"
+              }
+            end
+        end
+
+        def route_name(action, prefix)
+          name = route_name_base
+          name = @inflector.pluralize(name) if plural? && PLURALIZED_NAME_ACTIONS.include?(action)
+
+          [prefix, name]
+        end
+        PLURALIZED_NAME_ACTIONS = %i[index create].freeze
+
+        def route_name_base
+          @route_name_base ||=
+            if @options[:as]
+              @options[:as].to_s
+            elsif plural?
+              @inflector.singularize(@name.to_s)
+            else
+              @name.to_s
+            end
+        end
       end
     end
   end

data/lib/hanami/slice.rb

@@ -223,6 +223,18 @@ module Hanami
         app? ? root.join(APP_DIR) : root
       end
 
+      # Returns the slice's root component directory, as a path relative to the app's root.
+      #
+      # @return [Pathname]
+      #
+      # @see #source_path
+      #
+      # @api public
+      # @since 2.3.0
+      def relative_source_path
+        source_path.relative_path_from(app.root)
+      end
+
       # Returns the slice's configured inflector.
       #
       # Unless explicitly re-configured for the slice, this will be the app's inflector.
@@ -1032,6 +1044,7 @@ module Hanami
 
         Slice::Router.new(
           inspector: inspector,
+          inflector: inflector,
           routes: routes,
           resolver: config.router.resolver.new(slice: self),
           **error_handlers,

data/lib/hanami/slice_configurable.rb

@@ -43,7 +43,7 @@ module Hanami
             return unless slice
 
             unless subclass.configured_for_slice?(slice)
-              subclass.configure_for_slice(slice)
+              subclass.configure_for_slice(slice) if subclass.respond_to?(:configure_for_slice)
               subclass.configured_for_slices << slice
             end
           end
@@ -63,8 +63,6 @@ module Hanami
       end
     end
 
-    def configure_for_slice(slice); end
-
     def configured_for_slice?(slice)
       configured_for_slices.include?(slice)
     end

data/lib/hanami/version.rb

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

data/lib/hanami/web/rack_logger.rb

@@ -106,18 +106,30 @@ module Hanami
         #
         # @since 2.1.0
         # @api private
-        def info(message = nil, **payload)
-          payload[:message] = message if message
-          logger.info(JSON.fast_generate(payload))
+        def info(message = nil, **payload, &blk)
+          logger.info do
+            if blk
+              JSON.generate(blk.call)
+            else
+              payload[:message] = message if message
+              JSON.generate(payload)
+            end
+          end
         end
 
         # @see info
         #
         # @since 2.1.0
         # @api private
-        def error(message = nil, **payload)
-          payload[:message] = message if message
-          logger.info(JSON.fast_generate(payload))
+        def error(message = nil, **payload, &blk)
+          logger.error do
+            if blk
+              JSON.generate(blk.call)
+            else
+              payload[:message] = message if message
+              JSON.generate(payload)
+            end
+          end
         end
       end
 
@@ -145,7 +157,10 @@ module Hanami
       # @since 2.0.0
       def log_request(env, status, elapsed)
         logger.tagged(:rack) do
-          logger.info(**data(env, status: status, elapsed: elapsed))
+
+          logger.info do
+            data(env, status: status, elapsed: elapsed)
+          end
         end
       end
 
@@ -153,7 +168,9 @@ module Hanami
       # @since 2.0.0
       def log_exception(env, exception, status, elapsed)
         logger.tagged(:rack) do
-          logger.error(exception, **data(env, status: status, elapsed: elapsed))
+          logger.error(exception) do
+            data(env, status: status, elapsed: elapsed)
+          end
         end
       end
 

data/lib/hanami.rb

@@ -19,10 +19,24 @@ module Hanami
     @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
       loader.inflector.inflect "db" => "DB"
       loader.inflector.inflect "db_logging" => "DBLogging"
+      loader.inflector.inflect "slice_configured_db_operation" => "SliceConfiguredDBOperation"
       loader.inflector.inflect "sql_adapter" => "SQLAdapter"
+
+      gem_lib = loader.dirs.first
       loader.ignore(
-        "#{loader.dirs.first}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb"
+        "#{gem_lib}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb",
+        # Ignore conditionally-loaded classes dependent on gems that may not be included in the
+        # user's Gemfile
+        "#{gem_lib}/hanami/config/{assets,router,views}.rb",
+        "#{gem_lib}/hanami/slice/router.rb",
+        "#{gem_lib}/hanami/slice/routing/resolver.rb",
+        "#{gem_lib}/hanami/slice/routing/middleware/stack.rb",
+        "#{gem_lib}/hanami/extensions/**/*"
       )
+
+      unless Hanami.bundled?("hanami-router")
+        loader.ignore("#{gem_lib}/hanami/routes.rb")
+      end
     end
   end
 

data/spec/integration/action/format_config_spec.rb

@@ -20,7 +20,7 @@ RSpec.describe "App action / Format config", :app_integration do
         class App < Hanami::App
           config.logger.stream = StringIO.new
 
-          config.actions.format :json
+          config.actions.formats.accept :json
         end
       end
     RUBY
@@ -68,71 +68,6 @@ RSpec.describe "App action / Format config", :app_integration do
     expect(last_response.body).to eql("jane-john-jade-joe")
   end
 
-  specify "adds a body parser middleware configured to parse any custom content type for the accepted formats" do
-    write "config/app.rb", <<~RUBY
-      require "hanami"
-
-      module TestApp
-        class App < Hanami::App
-          config.logger.stream = StringIO.new
-
-          config.actions.formats.add :json, ["application/json+scim", "application/json"]
-        end
-      end
-    RUBY
-
-    write "config/routes.rb", <<~RUBY
-      module TestApp
-        class Routes < Hanami::Routes
-          post "/users", to: "users.create"
-        end
-      end
-    RUBY
-
-    write "app/action.rb", <<~RUBY
-      # auto_register: false
-
-      module TestApp
-        class Action < Hanami::Action
-        end
-      end
-    RUBY
-
-    write "app/actions/users/create.rb", <<~RUBY
-      module TestApp
-        module Actions
-          module Users
-            class Create < TestApp::Action
-              def handle(req, res)
-                res.body = req.params[:users].join("-")
-              end
-            end
-          end
-        end
-      end
-    RUBY
-
-    require "hanami/boot"
-
-    post(
-      "/users",
-      JSON.generate("users" => %w[jane john jade joe]),
-      "CONTENT_TYPE" => "application/json+scim"
-    )
-
-    expect(last_response).to be_successful
-    expect(last_response.body).to eql("jane-john-jade-joe")
-
-    post(
-      "/users",
-      JSON.generate("users" => %w[jane john jade joe]),
-      "CONTENT_TYPE" => "application/json"
-    )
-
-    expect(last_response).to be_successful
-    expect(last_response.body).to eql("jane-john-jade-joe")
-  end
-
   it "does not add a body parser middleware if one is already added" do
     write "config/app.rb", <<~RUBY
       require "hanami"
@@ -141,7 +76,7 @@ RSpec.describe "App action / Format config", :app_integration do
         class App < Hanami::App
           config.logger.stream = StringIO.new
 
-          config.actions.format :json
+          config.actions.formats.accept :json
           config.middleware.use :body_parser, [json: "application/json+custom"]
         end
       end