hanami-cli 2.0.0.beta3 → 2.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2652fcd9f660db53b10864142c4a96a0acf3991330b5a5d1b3f0270b5dcbc8ff
-  data.tar.gz: 983957c43ad1d96d7e77db6924346a6021928229eca699d0aafc28c7fcc41cd8
+  metadata.gz: 9e5786ce0557b00c863e145560473293d2d172f96c4bcdd10e7dcc32484a32a3
+  data.tar.gz: 036fb11ad8f805173889beb755daa50d8de1da678d74e853f9f8ddf65fa3dde1
 SHA512:
-  metadata.gz: 9ad2064d1634dfae55848d8e318a7e6b4a0022c56e50b7ed83634e0bc29b5bcd18ba8a8adad14d764125e219827955cbbeef2dc8cc7b788da5543e7f263f5c56
-  data.tar.gz: e911ef639b84a76e24a7b30ed7d778a0f4deb43fee8bd406cc52d44188f1ddc0de16622db87f406f42f6551c8fccc67e8fbe9ae4c6b7b8947610df06dfd21d32
+  metadata.gz: 3bde684529fa1ae28f86bee5aa8b9fb42297a7e112ff272751c0a234f5cb22cb13ea6a3bf46d580a56d9804225fd2d0834e131eb53fd60184cb0d6096f8f2a08
+  data.tar.gz: de2d099cfe069f4fd6c85aa23c5ce60f0133e9a6c1858c9f237f9c104ee5f2e56ab11965a7b979de754d6cdcefc8cbb9b5abfc9b0acc58cda2e2402cb570c546

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 Hanami Command Line Interface
 
+## v2.0.0.beta4 - 2022-10-24
+
+### Changed
+
+- [Sean Collins] Show output when generating files (e.g. in `hanami new`) (#49)
+- [Luca Guidi] Advertise Bundler and Hanami install steps when running `hanami new` (#54)
+
 ## v2.0.0.beta3 - 2022-09-21
 
 ### Added

data/lib/hanami/cli/command.rb

@@ -7,9 +7,10 @@ require "dry/inflector"
 module Hanami
   module CLI
     class Command < Dry::CLI::Command
-      def initialize(out: $stdout, fs: Dry::Files.new, inflector: Dry::Inflector.new)
+      def initialize(out: $stdout, err: $stderr, fs: Dry::Files.new, inflector: Dry::Inflector.new)
         super()
         @out = out
+        @err = err
         @fs = fs
         @inflector = inflector
       end
@@ -18,6 +19,8 @@ module Hanami
 
       attr_reader :out
 
+      attr_reader :err
+
       attr_reader :fs
 
       attr_reader :inflector

data/lib/hanami/cli/commands/app/console.rb

@@ -10,37 +10,47 @@ module Hanami
       module App
         # @api public
         class Console < App::Command
-          REPLS = {
+          ENGINES = {
             "pry" => -> (*args) {
               begin
                 require "hanami/cli/repl/pry"
                 Repl::Pry.new(*args)
-              rescue LoadError; end # rubocop:disable Lint/SuppressedException
+              rescue LoadError # rubocop:disable Lint/SuppressedException
+              end
             },
             "irb" => -> (*args) {
               require "hanami/cli/repl/irb"
               Repl::Irb.new(*args)
             },
           }.freeze
+          private_constant :ENGINES
 
-          desc "App REPL"
+          DEFAULT_ENGINE = "irb"
+          private_constant :DEFAULT_ENGINE
 
-          option :env, required: false, desc: "Application environment"
-          option :repl, required: false, desc: "REPL gem that should be used ('pry' or 'irb')"
+          desc "Start app console (REPL)"
+
+          option :engine, required: false, desc: "Console engine", values: ENGINES.keys
 
           # @api private
-          def call(repl: nil, **opts)
-            engine = resolve_engine(repl, opts)
-            engine.start
+          def call(engine: nil, **opts)
+            console_engine = resolve_engine(engine, opts)
+
+            if console_engine.nil?
+              err.puts "`#{engine}' is not bundled. Please run `bundle add #{engine}' and retry."
+              exit(1)
+            end
+
+            console_engine.start
           end
 
           private
 
-          def resolve_engine(repl, opts)
-            if repl
-              REPLS.fetch(repl).(app, opts)
+          def resolve_engine(engine, opts)
+            if engine
+              ENGINES.fetch(engine).(app, opts)
             else
-              REPLS.map { |(_, loader)| loader.(app, opts) }.compact.first
+              ENGINES.map { |(_, loader)| loader.(app, opts) }.compact.first
             end
           end
         end

data/lib/hanami/cli/commands/app/generate/action.rb

@@ -28,7 +28,23 @@ module Hanami
             #                    desc: "Skip view and template generation"
             option :slice, required: false, desc: "Slice name"
 
-            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+            # rubocop:disable Layout/LineLength
+            example [
+              %(books.index               # GET    /books          to: "books.index"    (MyApp::Actions::Books::Index)),
+              %(books.new                 # GET    /books/new      to: "books.new"      (MyApp::Actions::Books::New)),
+              %(books.create              # POST   /books          to: "books.create"   (MyApp::Actions::Books::Create)),
+              %(books.edit                # GET    /books/:id/edit to: "books.edit"     (MyApp::Actions::Books::Edit)),
+              %(books.update              # PATCH  /books/:id      to: "books.update"   (MyApp::Actions::Books::Update)),
+              %(books.show                # GET    /books/:id      to: "books.show"     (MyApp::Actions::Books::Show)),
+              %(books.destroy             # DELETE /books/:id      to: "books.destroy"  (MyApp::Actions::Books::Destroy)),
+              %(books.sale                # GET    /books/sale     to: "books.sale"     (MyApp::Actions::Books::Sale)),
+              %(sessions.new --url=/login # GET    /login          to: "sessions.new"   (MyApp::Actions::Sessions::New)),
+              %(authors.update --http=put # PUT    /authors/:id    to: "authors.update" (MyApp::Actions::Authors::Update)),
+              %(users.index --slice=admin # GET    /admin/users    to: "users.index"    (Admin::Actions::Users::Update))
+            ]
+            # rubocop:enable Layout/LineLength
+
+            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Action.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)

data/lib/hanami/cli/commands/app/generate/slice.rb

@@ -5,6 +5,7 @@ require "hanami/cli/generators/app/slice"
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+require "hanami/cli/files"
 require "hanami/cli/url"
 
 module Hanami
@@ -14,22 +15,27 @@ module Hanami
         module Generate
           class Slice < Command
             argument :name, required: true, desc: "The slice name"
-            option :url_prefix, required: false, type: :string, desc: "The slice URL prefix"
+            option :url, required: false, type: :string, desc: "The slice URL prefix"
 
-            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+            example [
+              "admin          # Admin slice (/admin URL prefix)",
+              "users --url=/u # Users slice (/u URL prefix)",
+            ]
+
+            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Slice.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)
             end
 
-            def call(name:, url_prefix: nil, **)
+            def call(name:, url: nil, **)
               require "hanami/setup"
 
               app = inflector.underscore(Hanami.app.namespace)
               name = inflector.underscore(Shellwords.shellescape(name))
-              url_prefix = sanitize_url_prefix(name, url_prefix)
+              url = sanitize_url_prefix(name, url)
 
-              generator.call(app, name, url_prefix)
+              generator.call(app, name, url)
             end
 
             private
@@ -39,14 +45,14 @@ module Hanami
 
             attr_reader :generator
 
-            def sanitize_url_prefix(name, url_prefix)
-              result = url_prefix
+            def sanitize_url_prefix(name, url)
+              result = url
               result = inflector.underscore(Shellwords.shellescape(result)) unless result.nil?
 
               result ||= DEFAULT_URL_PREFIX + name
               CLI::URL.call(result)
             rescue ArgumentError
-              raise ArgumentError.new("invalid URL prefix: `#{url_prefix}'")
+              raise ArgumentError.new("invalid URL prefix: `#{url}'")
             end
 
             def valid_url?(url)

data/lib/hanami/cli/commands/app/install.rb

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module App
         class Install < Command
+          desc "Install Hanami third-party plugins"
+
           def call(*)
           end
         end

data/lib/hanami/cli/commands/app/{middlewares.rb → middleware.rb}

@@ -7,30 +7,35 @@ module Hanami
   module CLI
     module Commands
       module App
-        # List registered middlewares in the app router
+        # List registered middleware in the app router
         #
-        # It outputs middlewares registered along with the paths where they
+        # It outputs middleware registered along with the paths where they
         # apply:
         #
         # ```
-        # $ hanami middlewares
+        # $ bundle exec hanami middleware
         # /    Rack::Session::Cookie
         # ```
         #
         # Given arguments can be inspected:
         #
         # ```
-        # $ hanami middlewares --with-arguments
+        # $ bundle exec hanami middleware --with-arguments
         # /    Rack::Session::Cookie args: [{:secret=>"foo"}]
         # ```
-        class Middlewares < Hanami::CLI::Command
-          desc "List all the registered middlewares"
+        class Middleware < Hanami::CLI::Command
+          desc "Print app Rack middleware stack"
 
           DEFAULT_WITH_ARGUMENTS = false
 
           option :with_arguments, default: DEFAULT_WITH_ARGUMENTS, required: false,
                                   desc: "Include inspected arguments", type: :boolean
 
+          example [
+            "middleware                  # Print app Rack middleware stack",
+            "middleware --with-arguments # Print app Rack middleware stack, including initialize arguments",
+          ]
+
           # @api private
           def call(with_arguments: DEFAULT_WITH_ARGUMENTS)
             require "hanami/prepare"

data/lib/hanami/cli/commands/app/routes.rb

@@ -11,14 +11,14 @@ module Hanami
         # All the formatters available from `hanami-router` are available:
         #
         # ```
-        # $ hanami routes --format=csv
+        # $ bundle exec hanami routes --format=csv
         # ```
         #
         # Experimental: You can also use a custom formatter registered in the
         # application container. You can identify it by its key:
         #
         # ```
-        # $ hanami routes --format=custom_routes_formatter
+        # $ bundle exec hanami routes --format=custom_routes_formatter
         # ```
         class Routes < Hanami::CLI::Command
           DEFAULT_FORMAT = "human_friendly"
@@ -30,13 +30,18 @@ module Hanami
           ].freeze
           private_constant :VALID_FORMATS
 
-          desc "Inspect application"
+          desc "Print app routes"
 
           option :format,
                  default: DEFAULT_FORMAT,
                  required: false,
                  desc: "Output format"
 
+          example [
+            "routes              # Print app routes",
+            "routes --format=csv # Print app routes, using CSV format",
+          ]
+
           # @api private
           def call(format: DEFAULT_FORMAT, **)
             require "hanami/router/inspector"

data/lib/hanami/cli/commands/app/server.rb

@@ -28,13 +28,16 @@ module Hanami
           DEFAULT_PORT = 2300
           private_constant :DEFAULT_PORT
 
-          desc "Start Hanami server"
+          DEFAULT_CONFIG_PATH = "config.ru"
+          private_constant :DEFAULT_CONFIG_PATH
+
+          desc "Start Hanami app server"
 
           option :host, default: nil, required: false,
                         desc: "The host address to bind to (falls back to the rack handler)"
           option :port, default: DEFAULT_PORT, required: false,
                         desc: "The port to run the server on (falls back to the rack handler)"
-          option :config, default: "config.ru", required: false, desc: "Rack configuration file"
+          option :config, default: DEFAULT_CONFIG_PATH, required: false, desc: "Rack configuration file"
           option :debug, default: false, required: false, desc: "Turn on/off debug output", type: :boolean
           option :warn, default: false, required: false, desc: "Turn on/off warnings", type: :boolean
 

data/lib/hanami/cli/commands/app/version.rb

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module App
         class Version < Command
+          desc "Print Hanami app version"
+
           def call(*)
             require "hanami/version"
             out.puts "v#{Hanami::VERSION}"

data/lib/hanami/cli/commands/app.rb

@@ -10,7 +10,7 @@ module Hanami
         require_relative "app/server"
         require_relative "app/routes"
         require_relative "app/generate"
-        require_relative "app/middlewares"
+        require_relative "app/middleware"
         # require_relative "app/db/create"
         # require_relative "app/db/create_migration"
         # require_relative "app/db/drop"
@@ -30,7 +30,7 @@ module Hanami
             register "console", Commands::App::Console, aliases: ["c"]
             register "server", Commands::App::Server, aliases: ["s"]
             register "routes", Commands::App::Routes
-            register "middlewares", Commands::App::Middlewares
+            register "middleware", Commands::App::Middleware
 
             register "generate", aliases: ["g"] do |prefix|
               prefix.register "slice", Generate::Slice

data/lib/hanami/cli/commands/gem/new.rb

@@ -4,7 +4,7 @@ require "hanami/cli/command"
 require "hanami/cli/bundler"
 require "hanami/cli/command_line"
 require "hanami/cli/generators/gem/app"
-require "dry/files"
+require "hanami/cli/files"
 require "dry/inflector"
 
 module Hanami
@@ -12,17 +12,25 @@ module Hanami
     module Commands
       module Gem
         class New < Command
-          SKIP_BUNDLE_DEFAULT = false
-          private_constant :SKIP_BUNDLE_DEFAULT
+          SKIP_INSTALL_DEFAULT = false
+          private_constant :SKIP_INSTALL_DEFAULT
+
+          desc "Generate a new Hanami app"
 
           argument :app, required: true, desc: "App name"
 
-          option :skip_bundle, type: :boolean, required: false,
-                               default: SKIP_BUNDLE_DEFAULT, desc: "Skip bundle install"
+          option :skip_install, type: :boolean, required: false,
+                                default: SKIP_INSTALL_DEFAULT,
+                                desc: "Skip app installation (Bundler, third-party Hanami plugins)"
+
+          example [
+            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace", # rubocop:disable Layout/LineLength
+            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation"
+          ]
 
           # rubocop:disable Metrics/ParameterLists
           def initialize(
-            fs: Dry::Files.new,
+            fs: Hanami::CLI::Files.new,
             inflector: Dry::Inflector.new,
             bundler: CLI::Bundler.new(fs: fs),
             command_line: CLI::CommandLine.new(bundler: bundler),
@@ -36,14 +44,18 @@ module Hanami
           end
           # rubocop:enable Metrics/ParameterLists
 
-          def call(app:, skip_bundle: SKIP_BUNDLE_DEFAULT, **)
+          def call(app:, skip_install: SKIP_INSTALL_DEFAULT, **)
             app = inflector.underscore(app)
 
             fs.mkdir(app)
             fs.chdir(app) do
               generator.call(app) do
-                unless skip_bundle
+                if skip_install
+                  out.puts "Skipping installation, please enter `#{app}' directory and run `bundle exec hanami install'"
+                else
+                  out.puts "Running Bundler install..."
                   bundler.install!
+                  out.puts "Running Hanami install..."
                   run_install_commmand!
                 end
               end

data/lib/hanami/cli/commands/gem/version.rb

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module Gem
         class Version < Command
+          desc "Hanami version"
+
           def call(*)
             version = detect_version
             out.puts "v#{version}"

data/lib/hanami/cli/files.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    class Files < Dry::Files
+      def initialize(out: $stdout, **args)
+        super(**args)
+        @out = out
+      end
+
+      def write(path, *content)
+        already_exists = exist?(path)
+        super
+        if already_exists
+          updated(path)
+        else
+          created(path)
+        end
+      end
+
+      def mkdir(path)
+        unless exist?(path)
+          super
+          created("#{path}/")
+        end
+      end
+
+      def chdir(path, &blk)
+        within_folder(path)
+        super
+      end
+
+      private
+
+      attr_reader :out
+
+      def updated(path)
+        out.puts "Updated #{path}"
+      end
+
+      def created(path)
+        out.puts "Created #{path}"
+      end
+
+      def within_folder(path)
+        out.puts "-> Within #{path}/"
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/action.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "dry/files"
+require "hanami/cli/files"
 require "hanami/cli/generators/app/action_context"
 require "hanami/cli/url"
 
@@ -69,18 +70,16 @@ module Hanami
               route(controller, action, url, http)
             )
 
-            fs.chdir(slice_directory) do
-              fs.mkdir(directory = fs.join("actions", controller))
-              fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
-
-              # unless skip_view
-              #   fs.mkdir(directory = fs.join("views", controller))
-              #   fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
-              #
-              #   fs.mkdir(directory = fs.join("templates", controller))
-              #   fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
-              # end
-            end
+            fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
+            fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
+
+            # unless skip_view
+            #   fs.mkdir(directory = fs.join(slice_directory, "views", controller))
+            #   fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
+            #
+            #   fs.mkdir(directory = fs.join(slice_directory, "templates", controller))
+            #   fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
+            # end
           end
 
           def generate_for_app(controller, action, url, http, _format, _skip_view, context)

data/lib/hanami/cli/generators/app/slice/routes.erb

@@ -1,3 +1,3 @@
 
-slice :<%= underscored_slice_name %>, at: "<%= slice_url_prefix %>" do
+slice :<%= underscored_slice_name %>, at: "<%= url %>" do
 end

data/lib/hanami/cli/generators/app/slice.rb

@@ -14,27 +14,25 @@ module Hanami
             @inflector = inflector
           end
 
-          def call(app, slice, slice_url_prefix, context: SliceContext.new(inflector, app, slice, slice_url_prefix))
+          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url))
             fs.inject_line_at_class_bottom(
               fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
             )
 
             fs.mkdir(directory = "slices/#{slice}")
 
-            fs.chdir(directory) do
-              # fs.write("config/slice.rb", t("slice.erb", context))
-              fs.write("action.rb", t("action.erb", context))
-              # fs.write("view.rb", t("view.erb", context))
-              # fs.write("entities.rb", t("entities.erb", context))
-              # fs.write("repository.rb", t("repository.erb", context))
-
-              fs.write("actions/.keep", t("keep.erb", context))
-              # fs.write("views/.keep", t("keep.erb", context))
-              # fs.write("templates/.keep", t("keep.erb", context))
-              # fs.write("templates/layouts/.keep", t("keep.erb", context))
-              # fs.write("entities/.keep", t("keep.erb", context))
-              # fs.write("repositories/.keep", t("keep.erb", context))
-            end
+            # fs.write("#{directory}/config/slice.rb", t("slice.erb", context))
+            fs.write(fs.join(directory, "action.rb"), t("action.erb", context))
+            # fs.write(fs.join(directory, "/view.rb"), t("view.erb", context))
+            # fs.write(fs.join(directory, "/entities.rb"), t("entities.erb", context))
+            # fs.write(fs.join(directory, "/repository.rb"), t("repository.erb", context))
+
+            fs.write(fs.join(directory, "actions/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, views/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, templates/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, templates/layouts/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, entities/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, repositories/.keep"), t("keep.erb", context))
           end
 
           private

data/lib/hanami/cli/generators/app/slice_context.rb

@@ -7,9 +7,9 @@ module Hanami
     module Generators
       module App
         class SliceContext < Generators::Context
-          def initialize(inflector, app, slice, slice_url_prefix)
+          def initialize(inflector, app, slice, url)
             @slice = slice
-            @slice_url_prefix = slice_url_prefix
+            @url = url
             super(inflector, app)
           end
 
@@ -25,7 +25,7 @@ module Hanami
 
           attr_reader :slice
 
-          attr_reader :slice_url_prefix
+          attr_reader :url
         end
       end
     end

data/lib/hanami/cli/generators/gem/app/gemfile.erb

@@ -7,7 +7,7 @@ gem "hanami-router", "<%= hanami_version %>"
 gem "hanami-controller", "<%= hanami_version %>"
 gem "hanami-validations", "<%= hanami_version %>"
 
-gem "dry-types"
+gem "dry-types", "~> 1.0", ">= 1.6.1"
 gem "puma"
 gem "rake"
 

data/lib/hanami/cli/generators/gem/app/settings.erb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "<%= underscored_app_name %>/types"
-
 module <%= camelized_app_name %>
   class Settings < Hanami::Settings
     # Define your app settings here, for example:

data/lib/hanami/cli/middleware_stack_inspector.rb

@@ -11,9 +11,9 @@ module Hanami
       def inspect(include_arguments: false)
         max_path_length = @stack.map { |(path)| path.length }.max
 
-        @stack.map { |path, middlewares|
-          middlewares.map { |(middleware, arguments)|
-            "#{path.ljust(max_path_length + 3)} #{format_middleware(middleware)}".tap { |line|
+        @stack.map { |path, middleware|
+          middleware.map { |(mware, arguments)|
+            "#{path.ljust(max_path_length + 3)} #{format_middleware(mware)}".tap { |line|
               line << " #{format_arguments(arguments)}" if include_arguments
             }
           }

data/lib/hanami/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Hanami
   module CLI
-    VERSION = "2.0.0.beta3"
+    VERSION = "2.0.0.beta4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-cli
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta3
+  version: 2.0.0.beta4
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-21 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -175,7 +175,7 @@ files:
 - lib/hanami/cli/commands/app/generate/action.rb
 - lib/hanami/cli/commands/app/generate/slice.rb
 - lib/hanami/cli/commands/app/install.rb
-- lib/hanami/cli/commands/app/middlewares.rb
+- lib/hanami/cli/commands/app/middleware.rb
 - lib/hanami/cli/commands/app/routes.rb
 - lib/hanami/cli/commands/app/server.rb
 - lib/hanami/cli/commands/app/version.rb
@@ -188,6 +188,7 @@ files:
 - lib/hanami/cli/commands/gem/new.rb
 - lib/hanami/cli/commands/gem/version.rb
 - lib/hanami/cli/error.rb
+- lib/hanami/cli/files.rb
 - lib/hanami/cli/generators/app/action.rb
 - lib/hanami/cli/generators/app/action/action.erb
 - lib/hanami/cli/generators/app/action/slice_action.erb
@@ -256,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Hanami CLI