hanami-cli 2.2.1 → 2.3.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7c2e2213ec21d8e65e4a07b1f5035d082e58ff8e5f0368112aa58b4be53a4f2
-  data.tar.gz: 7191dcdef8dd7683ada1caf68fab01c6047c3b9368006ce821d01453b77fb00d
+  metadata.gz: c770a27b290fd7bb7fcdd8db847ebd27723088374f8799b59d6e707e59404da0
+  data.tar.gz: 35aeda59b2833925c79d5ca3f604c410bb5512ec608c9f9527d7d8cbd1818c47
 SHA512:
-  metadata.gz: 7ee16c77ac4c7f721c02678ba7bbe1735ba84f66b41a04c738706ab704600230b58ae573c12a3b460851bffb7177403c7df402f8242afdd35949a670b6c30595
-  data.tar.gz: a93f0f48ae108ecdcd0f33812b0c83c09a88e9891c3712edd461c55cba09b3b96df3067828ff3f14cad0bc03e320cb634fc9098fd6777107f4d75b8dfec88c57
+  metadata.gz: e8a06cf2ca8224b1216c62d62356af0dc3ab4620b762fef531f0dec5b2c792816afe7f5a9a828170621a94f58370f04047ce0c86922e2730465417df9793169c
+  data.tar.gz: fb87833f3c11436dd3f313d9a3900d89395f6a8edef49a14a5e7b5c981081ec0bf859c11892d43502a005afd427bff7e8331faa733d1ec016875cef7fe59ad18

data/.github/workflows/ci.yml

@@ -24,9 +24,14 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
+          - "3.4"
           - "3.3"
           - "3.2"
           - "3.1"
+        rack:
+          - "~> 2.0"
+          - "~> 3.0"
+    name: tests (Ruby ${{ matrix.ruby }}, Rack ${{ matrix.rack }})
     env:
       POSTGRES_BASE_URL: postgres://postgres:password@localhost:5432/hanami_cli_test
     steps:
@@ -38,8 +43,12 @@ jobs:
         with:
           ruby-version: ${{matrix.ruby}}
           bundler-cache: true
+        env:
+          RACK_VERSION_CONSTRAINT: ${{matrix.rack}}
       - name: Run all tests
         run: bundle exec rake spec
+        env:
+          RACK_VERSION_CONSTRAINT: ${{matrix.rack}}
     services:
       mysql:
         image: mysql:latest

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 Hanami Command Line Interface
 
+## Unreleased
+
+## v2.3.0.beta1 - 2025-10-03
+
+### Added
+
+- Running `hanami generate` commands within a slice directory will generate the file in that slice (@krzykamil in #298)
+- Add `db rollback` command, supporting rolling back a single database at a time. (@krzykamil in #300)
+- `console` command loads configured extensions from app config. Add these using e.g. `config.console.include MyModule, AnotherModule` (@alassek in #324)
+- `console` command uses REPL engine configured in app config. Set this using e.g. `config.console.engine = :pry`; valid options are `:irb` (default) and `:pry` (@alassek in #324)
+
+### Fixed
+
+- Allow generated `public/400.html` and `public/500.html` to go into source control (@kyleplump in #290)
+- Properly show database errors from failed `db drop` commands (@katafrakt in #281)
+- Ensure consistent env var loading by disallowing Foreman's own env processing in generated `bin/dev` script (@cflipse in #305)
+- Use the configured app inflector (and any custom inflections) for all commands (@timriley in #312)
+- For app generated with `hanami new` with `--head`, include `hanami-cli` in the `Gemfile` (@afomera in #328)
+
+### Changed
+
+- Prevent `hanami new` from creating apps with confusing names (currently: "app" or "slice") (@seven1m in #272)
+- Provide more helpful instructions in generated app README (@hanarimawi in #273)
+- Prevent generators from overwriting files (@maxemitchell in #274, @stephannv in #319)
+- Add irb as a gem dependency to avoid default gem warnings (@y-yagi in #294)
+- Expand on comments `config/assets.js` and enable customization function by default (@robyurkowski in #293)
+- Run `git init` at the end of `hanami new` (@krzykamil in #295)
+- Prevent blank lines from showing when generating classes without deep module nesting (@cllns)
+- Add `--skip-view` flag to `hanami new` (@kyleplump in #308)
+- Support Rack 3 in addition to Rack 2 (for `hanami server` command) (@kyleplump in #289)
+- Ensure compatibility with MySQL 9.4's CLI tools in `db structure load` command (@timriley in #315)
+- Generated `Rakefile` will load tasks defined in `lib/tasks/` (@AlexanderZagaynov in #318)
+
 ## v2.2.1 - 2024-11-12
 
 ### Changed

data/Gemfile

@@ -18,7 +18,9 @@ gem "hanami-utils", github: "hanami/utils", branch: "main"
 
 gem "dry-system", github: "dry-rb/dry-system", branch: "main"
 
-gem "rack"
+if ENV["RACK_VERSION_CONSTRAINT"]
+  gem "rack", ENV["RACK_VERSION_CONSTRAINT"]
+end
 
 gem "mysql2"
 gem "pg"

data/hanami-cli.gemspec

@@ -34,8 +34,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "dry-cli", "~> 1.0", ">= 1.1.0"
   spec.add_dependency "dry-files", "~> 1.0", ">= 1.0.2", "< 2"
   spec.add_dependency "dry-inflector", "~> 1.0", "< 2"
+  spec.add_dependency "irb"
   spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_dependency "rackup"
 
   spec.add_development_dependency "rspec", "~> 3.9"
   spec.add_development_dependency "rubocop", "~> 1.0"

data/lib/hanami/cli/command.rb

@@ -24,7 +24,6 @@ module Hanami
         out: $stdout,
         err: $stderr,
         fs: Hanami::CLI::Files.new(out: out),
-        inflector: Dry::Inflector.new,
         **opts
       )
         super
@@ -46,12 +45,15 @@ module Hanami
       #
       # @since 2.0.0
       # @api public
-      def initialize(out:, err:, fs:, inflector:)
+      def initialize(out:, err:, fs:)
         super()
         @out = out
         @err = err
         @fs = fs
-        @inflector = inflector
+      end
+
+      def inflector
+        @inflector ||= Dry::Inflector.new
       end
 
       private
@@ -79,14 +81,6 @@ module Hanami
       # @since 2.0.0
       # @api public
       attr_reader :fs
-
-      # Returns the inflector.
-      #
-      # @return [Dry::Inflector]
-      #
-      # @since 2.0.0
-      # @api public
-      attr_reader :inflector
     end
   end
 end

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

@@ -14,10 +14,6 @@ module Hanami
         # @since 2.0.0
         # @api public
         class Command < Hanami::CLI::Command
-          # @since 2.0.0
-          # @api private
-          ACTION_SEPARATOR = "." # TODO: rename to container key separator
-
           # Overloads {Hanami::CLI::Commands::App::Command#call} to ensure an appropriate
           # `HANAMI_ENV` environment variable is set.
           #
@@ -44,6 +40,9 @@ module Hanami
               Hanami::Env.load
 
               super
+            rescue FileAlreadyExistsError => error
+              err.puts(error.message)
+              exit(1)
             end
           end
 
@@ -70,6 +69,8 @@ module Hanami
               end
           end
 
+          def inflector = app.inflector
+
           # Runs another CLI command via its command class.
           #
           # @param klass [Hanami::CLI::Command]
@@ -80,7 +81,6 @@ module Hanami
           def run_command(klass, ...)
             klass.new(
               out: out,
-              inflector: app.inflector,
               fs: Hanami::CLI::Files,
             ).call(...)
           end

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

@@ -38,6 +38,7 @@ module Hanami
           # @since 2.0.0
           # @api private
           def call(engine: nil, **opts)
+            engine ||= app.config.console.engine.to_s
             console_engine = resolve_engine(engine, opts)
 
             if console_engine.nil?

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

@@ -39,7 +39,6 @@ module Hanami
             def run_command(klass, ...)
               klass.new(
                 out: out,
-                inflector: inflector,
                 fs: fs,
                 system_call: system_call,
                 test_env_executor: test_env_executor,

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

@@ -11,7 +11,7 @@ module Hanami
 
             option :gateway, required: false, desc: "Use database for gateway"
 
-            def call(app: false, slice: nil, gateway: nil, **)
+            def call(app: false, slice: nil, gateway: nil, command_exit: method(:exit), **)
               exit_codes = []
 
               databases(app: app, slice: slice, gateway: gateway).each do |database|
@@ -27,7 +27,7 @@ module Hanami
               end
 
               exit_codes.each do |code|
-                break exit code if code > 0
+                break command_exit.(code) if code > 0
               end
 
               re_run_development_command_in_test

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+require_relative "../../app/command"
+require_relative "structure/dump"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module DB
+          class Rollback < DB::Command
+            desc "Rollback database to a previous migration"
+
+            argument :steps, desc: "Number of migrations to rollback", required: false
+            option :target, desc: "Target migration number", aliases: ["-t"]
+            option :dump, desc: "Dump structure after rolling back", default: true
+            option :gateway, required: false, desc: "Use database for gateway"
+
+            def call(steps: nil, app: false, slice: nil, gateway: nil, target: nil, dump: true, command_exit: method(:exit), **)
+              # We allow either a number of steps or a target migration number to be provided
+              # If steps is provided and target is not, we use steps as the target migration number, but we also have to
+              # make sure steps is a number, hence some additional logic around checking and converting to number
+              target = steps if steps && !target && !code_is_number?(steps)
+              steps_count = steps && code_is_number?(steps) ? Integer(steps) : 1
+
+              database = resolve_target_database(app: app, slice: slice, gateway: gateway, command_exit: command_exit)
+              return unless database
+
+              migration_code, migration_name = find_migration_target(target, steps_count, database)
+
+              if migration_name.nil?
+                output = if steps && code_is_number?(steps)
+                           "==> migration file for #{steps} steps back was not found"
+                         elsif target
+                           "==> migration file for target #{target} was not found"
+                         else
+                           "==> no migrations to rollback"
+                         end
+
+                out.puts output
+                return
+              end
+
+              measure "database #{database.name} rolled back to #{migration_name}" do
+                database.run_migrations(target: Integer(migration_code))
+                true
+              end
+
+              return unless dump && !re_running_in_test?
+
+              run_command(
+                Structure::Dump,
+                app: database.slice == self.app,
+                slice: database.slice == self.app ? nil : database.slice.slice_name.to_s,
+                gateway: database.gateway_name == :default ? nil : database.gateway_name.to_s,
+                command_exit: command_exit
+              )
+            end
+
+            private
+
+            def resolve_target_database(app:, slice:, gateway:, command_exit:)
+              if gateway && !app && !slice
+                err.puts "When specifying --gateway, an --app or --slice must also be given"
+                command_exit.(1)
+                return
+              end
+
+              if slice
+                resolve_slice_database(slice, gateway, command_exit)
+              elsif app
+                resolve_app_database(gateway, command_exit)
+              else
+                resolve_default_database(command_exit)
+              end
+            end
+
+            def resolve_slice_database(slice_name, gateway, command_exit)
+              slice = resolve_slice(slice_name, command_exit)
+              return unless slice
+
+              databases = build_databases(slice)
+
+              if gateway
+                database = databases[gateway.to_sym]
+                unless database
+                  err.puts %(No gateway "#{gateway}" found in slice "#{slice_name}")
+                  command_exit.(1)
+                  return
+                end
+                database
+              elsif databases.size == 1
+                databases.values.first
+              else
+                err.puts "Multiple gateways found in slice #{slice_name}. Please specify --gateway option."
+                command_exit.(1)
+              end
+            end
+
+            def resolve_app_database(gateway, command_exit)
+              databases = build_databases(app)
+              
+              if gateway
+                database = databases[gateway.to_sym]
+                unless database
+                  err.puts %(No gateway "#{gateway}" found in app)
+                  command_exit.(1)
+                  return
+                end
+                database
+              elsif databases.size == 1
+                databases.values.first
+              else
+                err.puts "Multiple gateways found in app. Please specify --gateway option."
+                command_exit.(1)
+              end
+            end
+
+            def resolve_default_database(command_exit)
+              all_dbs = all_databases
+              
+              if all_dbs.empty?
+                err.puts "No databases found"
+                command_exit.(1)
+              elsif all_dbs.size == 1
+                all_dbs.first
+              else
+                app_databases = build_databases(app)
+                if app_databases.size == 1
+                  app_databases.values.first
+                elsif app_databases.size > 1
+                  err.puts "Multiple gateways found in app. Please specify --gateway option."
+                  command_exit.(1)
+                  return
+                else
+                  err.puts "Multiple database contexts found. Please specify --app or --slice option."
+                  command_exit.(1)
+                  return
+                end
+              end
+            end
+
+            def resolve_slice(slice_name, command_exit)
+              slice_name_sym = inflector.underscore(Shellwords.shellescape(slice_name)).to_sym
+              slice = app.slices[slice_name_sym]
+              
+              unless slice
+                err.puts %(Slice "#{slice_name}" not found)
+                command_exit.(1)
+                return
+              end
+              
+              ensure_database_slice(slice)
+              slice
+            end
+
+            def find_migration_target(target, steps_count, database)
+              applied_migrations = database.applied_migrations
+
+              return if applied_migrations.empty?
+
+              if applied_migrations.one? && target.nil?
+                return initial_state(applied_migrations)
+              end
+
+              if target
+                migration = applied_migrations.detect { |m| m.split("_").first == target }
+                migration_code = migration&.split("_")&.first
+                migration_name = migration ? File.basename(migration, ".*") : nil
+              else
+                # When rolling back N steps, we want to target the migration that is N steps back
+                # If we have migrations [A, B, C, D] and want to rollback 2 steps from D,
+                # we want to target B (index -3, since we go back 2 steps + 1 for the target)
+                target_index = -(steps_count + 1)
+                
+                if target_index.abs > applied_migrations.size
+                  return initial_state(applied_migrations)
+                else
+                  migration = applied_migrations[target_index]
+                  migration_code = migration&.split("_")&.first
+                  migration_name = migration ? File.basename(migration, ".*") : nil
+                end
+              end
+
+              [migration_code, migration_name]
+            end
+
+            def initial_state(applied_migrations)
+              migration = applied_migrations.first
+
+              migration_code = Integer(migration.split("_").first) - 1
+              migration_name = "initial state"
+
+              [migration_code, migration_name]
+            end
+
+            def code_is_number?(code)
+              code&.to_s&.match?(/^\d+$/) && !code.to_s.match?(/^\d{10,}$/)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/db/utils/mysql.rb

@@ -29,8 +29,9 @@ module Hanami
               # @since 2.2.0
               def exists?
                 result = exec_cli("mysql", %(-e "SHOW DATABASES LIKE '#{name}'" --batch))
+                raise Hanami::CLI::DatabaseExistenceCheckError.new(result.err) unless result.successful?
 
-                result.successful? && result.out != ""
+                result.out != ""
               end
 
               # @api private
@@ -47,7 +48,7 @@ module Hanami
               def exec_load_command
                 exec_cli(
                   "mysql",
-                  %(--execute "SET FOREIGN_KEY_CHECKS = 0; SOURCE #{structure_file}; SET FOREIGN_KEY_CHECKS = 1" --database #{escaped_name})
+                  %(--commands --execute "SET FOREIGN_KEY_CHECKS = 0; SOURCE #{structure_file}; SET FOREIGN_KEY_CHECKS = 1" --database #{escaped_name})
                 )
               end
 

data/lib/hanami/cli/commands/app/db/utils/postgres.rb

@@ -33,7 +33,9 @@ module Hanami
               # @since 2.2.0
               def exists?
                 result = system_call.call("psql -t -A -c '\\list #{escaped_name}'", env: cli_env_vars)
-                result.successful? && result.out.include?("#{name}|") # start_with?
+                raise Hanami::CLI::DatabaseExistenceCheckError.new(result.err) unless result.successful?
+
+                result.out.include?("#{name}|") # start_with?
               end
 
               # @api private

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

@@ -13,7 +13,7 @@ module Hanami
         module Generate
           # @since 2.0.0
           # @api private
-          class Action < App::Command
+          class Action < Command
             # TODO: ideally the default format should lookup
             #       slice configuration (Action's `default_response_format`)
             DEFAULT_FORMAT = "html"
@@ -29,29 +29,37 @@ module Hanami
             private_constant :DEFAULT_SKIP_ROUTE
 
             argument :name, required: true, desc: "Action name"
-            option :url, required: false, type: :string, desc: "Action URL"
-            option :http, required: false, type: :string, desc: "Action HTTP method"
-            # option :format, required: false, type: :string, default: DEFAULT_FORMAT, desc: "Template format"
+
+            option :url, as: :url_path, required: false, type: :string, desc: "Action URL path"
+
+            option :http, as: :http_method, required: false, type: :string, desc: "Action HTTP method"
+
             option \
               :skip_view,
               required: false,
               type: :flag,
               default: DEFAULT_SKIP_VIEW,
               desc: "Skip view and template generation"
+
+            # TODO: Implement this
             option \
               :skip_tests,
               required: false,
               type: :flag,
               default: DEFAULT_SKIP_TESTS,
               desc: "Skip test generation"
+
             option \
               :skip_route,
               required: false,
               type: :flag,
               default: DEFAULT_SKIP_ROUTE,
               desc: "Skip route generation"
+
             option :slice, required: false, desc: "Slice name"
 
+            # option :format, required: false, type: :string, default: DEFAULT_FORMAT, desc: "Template format"
+
             # rubocop:disable Layout/LineLength
             example [
               %(books.index               # GET    /books          to: "books.index"    (MyApp::Actions::Books::Index)),
@@ -68,52 +76,36 @@ module Hanami
             ]
             # rubocop:enable Layout/LineLength
 
-            # @since 2.0.0
-            # @api private
-            def initialize(
-              fs:, inflector:,
-              naming: Naming.new(inflector: inflector),
-              generator: Generators::App::Action.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              super(fs: fs, inflector: inflector, **opts)
-
-              @naming = naming
-              @generator = generator
+            def generator_class
+              Generators::App::Action
             end
 
-            # rubocop:disable Metrics/ParameterLists
-
             # @since 2.0.0
             # @api private
+            # rubocop:disable Lint/ParameterLists
             def call(
               name:,
-              url: nil,
-              http: nil,
-              format: DEFAULT_FORMAT,
+              slice: nil,
+              url_path: nil,
+              http_method: nil,
               skip_view: DEFAULT_SKIP_VIEW,
-              skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument,
               skip_route: DEFAULT_SKIP_ROUTE,
-              slice: nil,
-              context: nil,
-              **
+              skip_tests: DEFAULT_SKIP_TESTS # rubocop:disable Lint/UnusedMethodArgument
             )
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-              name = naming.action_name(name)
-              *controller, action = name.split(ACTION_SEPARATOR)
-
-              if controller.empty?
-                raise InvalidActionNameError.new(name)
-              end
-
-              generator.call(app.namespace, controller, action, url, http, format, skip_view, skip_route, slice, context: context)
+              name = Naming.new(inflector:).action_name(name)
+
+              raise InvalidActionNameError.new(name) unless name.include?(".")
+
+              super(
+                name:,
+                slice:,
+                url_path:,
+                skip_route:,
+                http_method:,
+                skip_view: skip_view || !Hanami.bundled?("hanami-view"),
+              )
             end
-
-            # rubocop:enable Metrics/ParameterLists
-
-            private
-
-            attr_reader :naming, :generator
+            # rubocop:enable Lint/ParameterLists
           end
         end
       end

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

@@ -21,36 +21,73 @@ module Hanami
 
             # @since 2.2.0
             # @api private
-            def initialize(
-              fs:,
-              inflector:,
-              **opts
-            )
+            def initialize(fs:, out:, **)
               super
-              @generator = generator_class.new(fs: fs, inflector: inflector, out: out)
+              @generator = generator_class.new(fs:, inflector:, out:)
             end
 
+            # @since 2.2.0
+            # @api private
             def generator_class
-              # Must be implemented by subclasses, with class that takes:
-              # fs:, inflector:, out:
+              # Must be implemented by subclasses, with initialize method that takes:
+              # fs:, out:
             end
 
             # @since 2.2.0
             # @api private
-            def call(name:, slice: nil, **)
-              if slice
-                generator.call(
-                  key: name,
-                  namespace: slice,
-                  base_path: fs.join("slices", inflector.underscore(slice))
-                )
-              else
+            def call(name:, slice: nil, **opts)
+              slice ||= detect_slice_from_cwd
+
+              if slice.nil?
                 generator.call(
                   key: name,
                   namespace: app.namespace,
-                  base_path: "app"
+                  base_path: "app",
+                  **opts,
                 )
+                return
               end
+
+              slice_root = slice.respond_to?(:root) ? slice.root : detect_slice_root(slice)
+              raise MissingSliceError.new(slice) unless fs.exist?(slice_root)
+
+              generator.call(
+                key: name,
+                namespace: slice,
+                base_path: slice_root,
+                **opts,
+              )
+            end
+
+            private
+
+            def detect_slice_from_cwd
+              slices_by_root = app.slices.with_nested.each.to_h { |slice| [slice.root.to_s, slice] }
+              slices_by_root[fs.pwd]
+            end
+
+            # Returns the root for the given slice name.
+            #
+            # This currently works with top-level slices only, and it simply appends the slice's
+            # name onto the "slices/" dir, returning e.g. "slices/main" when given "main".
+            #
+            # TODO: Make this work with nested slices when given slash-delimited slice names like
+            # "parent/child", which should look for "slices/parent/slices/child".
+            #
+            # This method makes two checks for the slice root (building off both `app.root` as well
+            # as `fs`). This is entirely to account for how we test commands, with most tests using
+            # an in-memory `fs` adapter, any files created via which will be invisible to the `app`,
+            # which doesn't know about the `fs`.
+            #
+            # FIXME: It would be better to find a way for this to make one check only. An ideal
+            # approach would be to use the slice_name to find actual slice registered within
+            # `app.slices`. To do this, we'd probably need to stop testing with an in-memory `fs`
+            # here.
+            def detect_slice_root(slice_name)
+              slice_root_in_fs = fs.join("slices", inflector.underscore(slice_name))
+              return slice_root_in_fs if fs.exist?(slice_root_in_fs)
+
+              app.root.join("slices", inflector.underscore(slice_name))
             end
           end
         end