hanami 2.3.0.beta2 → 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

@@ -1044,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.beta2"
+    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

@@ -68,74 +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.register :json, "application/json",
-            accept_types: ["application/json", "application/json+scim"],
-            content_types: ["application/json", "application/json+scim"]
-          config.actions.formats.accept :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"

data/spec/integration/logging/request_logging_spec.rb

@@ -11,10 +11,13 @@ RSpec.describe "Logging / Request logging", :app_integration do
 
   let(:logger_stream) { StringIO.new }
 
+  let(:logger_level) { nil }
+
   let(:root) { make_tmp_directory }
 
   def configure_logger
     Hanami.app.config.logger.stream = logger_stream
+    Hanami.app.config.logger.level = logger_level if logger_level
   end
 
   def logs
@@ -84,6 +87,19 @@ RSpec.describe "Logging / Request logging", :app_integration do
         )
       end
     end
+
+    context "log level error" do
+      let(:logger_level) { :error }
+      before do
+        expect_any_instance_of(Hanami::Web::RackLogger).to_not receive(:data)
+      end
+
+      it "does not log info" do
+        get "/"
+
+        expect(logs.split("\n").length).to eq 0
+      end
+    end
   end
 
   describe "slice router" do

data/spec/integration/operations/extension_spec.rb

@@ -56,4 +56,67 @@ RSpec.describe "Operation / Extensions", :app_integration do
       expect(main.rom).to be Main::Slice["db.rom"]
     end
   end
+
+  context "hanami-db bundled, but no db configured" do
+    it "does not extend the operation class" do
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~RUBY
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "app/operation.rb", <<~RUBY
+          module TestApp
+            class Operation < Dry::Operation
+            end
+          end
+        RUBY
+
+        require "hanami/prepare"
+
+        operation = TestApp::Operation.new
+
+        expect(operation.rom).to be nil
+        expect { operation.transaction }.to raise_error Hanami::ComponentLoadError, "A configured db for TestApp::App is required to run transactions."
+      end
+    end
+  end
+
+  context "hanami-db not bundled" do
+    before do
+      allow(Hanami).to receive(:bundled?).and_call_original
+      allow(Hanami).to receive(:bundled?).with("hanami-db").and_return false
+    end
+
+    it "does not extend the operation class" do
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~RUBY
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "app/operation.rb", <<~RUBY
+          module TestApp
+            class Operation < Dry::Operation
+            end
+          end
+        RUBY
+
+        require "hanami/prepare"
+
+        operation = TestApp::Operation.new
+
+        expect { operation.rom }.to raise_error NoMethodError
+        expect { operation.transaction }.to raise_error NoMethodError
+      end
+    end
+  end
 end

data/spec/integration/rack_app/body_parser_spec.rb

@@ -12,14 +12,13 @@ RSpec.describe "Hanami web app", :app_integration do
     with_tmp_directory(Dir.mktmpdir, &example)
   end
 
-  specify "Setting middlewares in the config" do
+  specify "Default body parser" do
     write "config/app.rb", <<~RUBY
       require "hanami"
 
       module TestApp
         class App < Hanami::App
           config.actions.format :json
-          config.middleware.use :body_parser, :json
           config.logger.stream = StringIO.new
         end
       end