hanami-cli 2.0.0 → 2.1.0

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

@@ -20,12 +20,20 @@ module Hanami
               migration_code, migration_name = find_migration(target)
 
               if migration_name.nil?
-                out.puts "==> migration file for target #{target} was not found"
+                output = if 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
 
               run_command Structure::Dump if dump
@@ -33,14 +41,30 @@ module Hanami
 
             private
 
-            def find_migration(code)
-              migration = database.applied_migrations.then { |migrations|
+            def find_migration(code) # rubocop:disable Metrics/PerceivedComplexity
+              applied_migrations = database.applied_migrations
+
+              return if applied_migrations.empty?
+
+              # Rollback to initial state if we have only one migration and
+              # no target is specified. In this case the rollback target
+              # will be the current migration timestamp minus 1
+              if applied_migrations.one? && code.nil?
+                migration = applied_migrations.first
+
+                migration_code = Integer(migration.split("_").first) - 1
+                migration_name = "initial state"
+
+                return [migration_code, migration_name]
+              end
+
+              # Otherwise rollback to target or to previous migration
+              migration =
                 if code
-                  migrations.detect { |m| m.split("_").first == code }
+                  applied_migrations.detect { |m| m.split("_").first == code }
                 else
-                  migrations.last
+                  applied_migrations[-2]
                 end
-              }
 
               return unless migration
 

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

@@ -139,7 +139,11 @@ module Hanami
                 @sequel_migrator ||= begin
                   require "sequel"
                   Sequel.extension :migration
-                  Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
+
+                  require "rom/sql"
+                  ROM::SQL.with_gateway(gateway) do
+                    Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
+                  end
                 end
               end
 

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../../interactive_system_call"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        # @since 2.1.0
+        # @api private
+        class Dev < App::Command
+          # @since 2.1.0
+          # @api private
+          desc "Start the application in development mode"
+
+          # @since 2.1.0
+          # @api private
+          def initialize(
+            out:, err:,
+            system_call: InteractiveSystemCall.new(out: out, err: err),
+            **opts
+          )
+            super(out: out, err: err, **opts)
+
+            @system_call = system_call
+          end
+
+          # @since 2.1.0
+          # @api private
+          def call(**)
+            bin, args = executable
+            system_call.call(bin, *args)
+          end
+
+          private
+
+          # @since 2.1.0
+          # @api private
+          attr_reader :system_call
+
+          # @since 2.1.0
+          # @api private
+          def executable
+            [::File.join("bin", "dev")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+require_relative "../../../naming"
 require_relative "../../../errors"
 
 module Hanami
@@ -21,12 +22,25 @@ module Hanami
             DEFAULT_SKIP_VIEW = false
             private_constant :DEFAULT_SKIP_VIEW
 
+            DEFAULT_SKIP_TESTS = false
+            private_constant :DEFAULT_SKIP_TESTS
+
             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 :skip_view, required: false, type: :boolean, default: DEFAULT_SKIP_VIEW,
-            #                    desc: "Skip view and template generation"
+            option \
+              :skip_view,
+              required: false,
+              type: :boolean,
+              default: DEFAULT_SKIP_VIEW,
+              desc: "Skip view and template generation"
+            option \
+              :skip_tests,
+              required: false,
+              type: :boolean,
+              default: DEFAULT_SKIP_TESTS,
+              desc: "Skip test generation"
             option :slice, required: false, desc: "Slice name"
 
             # rubocop:disable Layout/LineLength
@@ -47,33 +61,48 @@ module Hanami
 
             # @since 2.0.0
             # @api private
-            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
-                           generator: Generators::App::Action.new(fs: fs, inflector: inflector), **)
+            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
-              super(fs: fs)
             end
 
             # rubocop:disable Metrics/ParameterLists
 
             # @since 2.0.0
             # @api private
-            def call(name:, url: nil, http: nil, format: DEFAULT_FORMAT, skip_view: DEFAULT_SKIP_VIEW, slice: nil, **)
+            def call(
+              name:,
+              url: nil,
+              http: nil,
+              format: DEFAULT_FORMAT,
+              skip_view: DEFAULT_SKIP_VIEW,
+              skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument
+              slice: nil,
+              context: nil, **
+            )
               slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-              name = inflector.underscore(Shellwords.shellescape(name))
+              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, slice)
+              generator.call(app.namespace, controller, action, url, http, format, skip_view, slice, context: context)
             end
 
             # rubocop:enable Metrics/ParameterLists
 
             private
 
-            attr_reader :generator
+            attr_reader :naming, :generator
           end
         end
       end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.1.0
+          # @api private
+          class Part < App::Command
+            DEFAULT_SKIP_TESTS = false
+            private_constant :DEFAULT_SKIP_TESTS
+
+            argument :name, required: true, desc: "Part name"
+            option :slice, required: false, desc: "Slice name"
+            option \
+              :skip_tests,
+              required: false,
+              type: :boolean,
+              default: DEFAULT_SKIP_TESTS,
+              desc: "Skip test generation"
+
+            example [
+              %(book               (MyApp::Views::Parts::Book)),
+              %(book --slice=admin (Admin::Views::Parts::Book)),
+            ]
+            attr_reader :generator
+            private :generator
+
+            # @since 2.0.0
+            # @api private
+            def initialize(
+              fs:, inflector:,
+              generator: Generators::App::Part.new(fs: fs, inflector: inflector),
+              **opts
+            )
+              super(fs: fs, inflector: inflector, **opts)
+              @generator = generator
+            end
+
+            # @since 2.0.0
+            # @api private
+            def call(name:, slice: nil, skip_tests: DEFAULT_SKIP_TESTS, **) # rubocop:disable Lint/UnusedMethodArgument
+              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
+
+              generator.call(app.namespace, name, slice)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,10 +23,13 @@ module Hanami
 
             # @since 2.0.0
             # @api private
-            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
-                           generator: Generators::App::Slice.new(fs: fs, inflector: inflector), **)
+            def initialize(
+              fs:, inflector:,
+              generator: Generators::App::Slice.new(fs: fs, inflector: inflector),
+              **opts
+            )
+              super(fs: fs, inflector: inflector, **opts)
               @generator = generator
-              super(fs: fs)
             end
 
             # @since 2.0.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+require_relative "../../../naming"
+require_relative "../../../errors"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.0.0
+          # @api private
+          class View < App::Command
+            # TODO: make this configurable
+            DEFAULT_FORMAT = "html"
+            private_constant :DEFAULT_FORMAT
+
+            # TODO: make engine configurable
+
+            argument :name, required: true, desc: "View name"
+            option :slice, required: false, desc: "Slice name"
+
+            example [
+              %(books.index               (MyApp::Actions::Books::Index)),
+              %(books.index --slice=admin (Admin::Actions::Books::Index)),
+            ]
+            attr_reader :generator
+            private :generator
+
+            # @since 2.0.0
+            # @api private
+            def initialize(
+              fs:, inflector:,
+              generator: Generators::App::View.new(fs: fs, inflector: inflector),
+              **opts
+            )
+              super(fs: fs, inflector: inflector, **opts)
+              @generator = generator
+            end
+
+            # @since 2.0.0
+            # @api private
+            def call(name:, format: DEFAULT_FORMAT, slice: nil, **)
+              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
+
+              generator.call(app.namespace, name, format, slice)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,8 +7,8 @@ module Hanami
         # @since 2.0.0
         # @api private
         module Generate
-          require_relative "./generate/slice"
-          require_relative "./generate/action"
+          require_relative "generate/slice"
+          require_relative "generate/action"
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../system_call"
+
 module Hanami
   module CLI
     module Commands
@@ -18,9 +20,22 @@ module Hanami
         # @since 2.0.0
         # @api private
         class Install < Command
+          # @since 2.1.0
+          # @api private
+          DEFAULT_HEAD = false
+          private_constant :DEFAULT_HEAD
+
+          # @since 2.1.0
+          # @api private
           desc "Install Hanami third-party plugins"
 
-          def call(*)
+          # @since 2.1.0
+          # @api private
+          option :head, type: :boolean, desc: "Install head deps", default: DEFAULT_HEAD
+
+          # @since 2.0.0
+          # @api private
+          def call(head: DEFAULT_HEAD, **)
           end
         end
       end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack"
+require "hanami/port"
 require_relative "../app"
 require_relative "../../server"
 
@@ -28,11 +29,6 @@ module Hanami
         # @since 2.0.0
         # @api private
         class Server < Command
-          # @since 2.0.0
-          # @api private
-          DEFAULT_PORT = 2300
-          private_constant :DEFAULT_PORT
-
           # @since 2.0.0
           # @api private
           DEFAULT_CONFIG_PATH = "config.ru"
@@ -42,7 +38,7 @@ module Hanami
 
           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,
+          option :port, default: Hanami::Port::DEFAULT, required: false,
                         desc: "The port to run the server on (falls back to the rack handler)"
           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
@@ -50,15 +46,15 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def initialize(server: Hanami::CLI::Server.new)
-            super()
+          def initialize(server: Hanami::CLI::Server.new, **opts)
+            super(**opts)
             @server = server
           end
 
           # @since 2.0.0
           # @api private
-          def call(port: DEFAULT_PORT, **kwargs)
-            server.call(port: port, **kwargs)
+          def call(port: Hanami::Port::DEFAULT, **kwargs)
+            server.call(port: Hanami::Port[port], **kwargs)
           end
 
           private

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

@@ -14,14 +14,24 @@ module Hanami
           base.module_eval do
             register "version", Commands::App::Version, aliases: ["v", "-v", "--version"]
             register "install", Commands::App::Install
+            register "dev", Commands::App::Dev
             register "console", Commands::App::Console, aliases: ["c"]
             register "server", Commands::App::Server, aliases: ["s"]
             register "routes", Commands::App::Routes
             register "middleware", Commands::App::Middleware
 
+            if Hanami.bundled?("hanami-assets")
+              register "assets" do |prefix|
+                prefix.register "compile", Assets::Compile
+                prefix.register "watch", Assets::Watch
+              end
+            end
+
             register "generate", aliases: ["g"] do |prefix|
               prefix.register "slice", Generate::Slice
               prefix.register "action", Generate::Action
+              prefix.register "view", Generate::View
+              prefix.register "part", Generate::Part
             end
           end
         end

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

@@ -10,66 +10,124 @@ module Hanami
         # @since 2.0.0
         # @api private
         class New < Command
+          # @since 2.0.0
+          # @api private
           SKIP_INSTALL_DEFAULT = false
           private_constant :SKIP_INSTALL_DEFAULT
 
+          # @since 2.1.0
+          # @api private
+          HEAD_DEFAULT = false
+          private_constant :HEAD_DEFAULT
+
+          # @since 2.1.0
+          # @api private
+          SKIP_ASSETS_DEFAULT = false
+          private_constant :SKIP_ASSETS_DEFAULT
+
           desc "Generate a new Hanami app"
 
+          # @since 2.0.0
+          # @api private
           argument :app, required: true, desc: "App name"
 
+          # @since 2.0.0
+          # @api private
           option :skip_install, type: :boolean, required: false,
                                 default: SKIP_INSTALL_DEFAULT,
                                 desc: "Skip app installation (Bundler, third-party Hanami plugins)"
 
+          # @since 2.1.0
+          # @api private
+          option :head, type: :boolean, required: false,
+                        default: HEAD_DEFAULT,
+                        desc: "Use Hanami HEAD version (from GitHub `main` branches)"
+
+          # @since 2.1.0
+          # @api private
+          option :skip_assets, type: :boolean, required: false,
+                               default: SKIP_ASSETS_DEFAULT,
+                               desc: "Skip assets"
+
+          # rubocop:disable Layout/LineLength
           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"
+            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace",
+            "bookshelf --head         # Generate a new Hanami app, using Hanami HEAD version from GitHub `main' branches",
+            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation",
+            "bookshelf --skip-assets  # Generate a new Hanami app without assets"
           ]
+          # rubocop:enable Layout/LineLength
+
+          # rubocop:disable Metrics/ParameterLists
 
           # @since 2.0.0
           # @api private
           def initialize(
-            fs: Hanami::CLI::Files.new,
-            inflector: Dry::Inflector.new,
+            fs:, inflector:,
             bundler: CLI::Bundler.new(fs: fs),
             generator: Generators::Gem::App.new(fs: fs, inflector: inflector),
-            **other
+            system_call: SystemCall.new,
+            **opts
           )
+            super(fs: fs, inflector: inflector, **opts)
             @bundler = bundler
             @generator = generator
-            super(fs: fs, inflector: inflector, **other)
+            @system_call = system_call
           end
 
+          # rubocop:enable Metrics/ParameterLists
+
+          # rubocop:disable Metrics/AbcSize
+
           # @since 2.0.0
           # @api private
-          def call(app:, skip_install: SKIP_INSTALL_DEFAULT, **)
+          def call(app:, head: HEAD_DEFAULT, skip_install: SKIP_INSTALL_DEFAULT, skip_assets: SKIP_ASSETS_DEFAULT, **)
             app = inflector.underscore(app)
 
             raise PathAlreadyExistsError.new(app) if fs.exist?(app)
 
             fs.mkdir(app)
             fs.chdir(app) do
-              generator.call(app) do
+              context = Generators::Context.new(inflector, app, head: head, skip_assets: skip_assets)
+              generator.call(app, context: context) do
                 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!
+
+                  unless skip_assets
+                    out.puts "Running NPM install..."
+                    system_call.call("npm", ["install"]).tap do |result|
+                      unless result.successful?
+                        puts "NPM ERROR:"
+                        puts(result.err.lines.map { |line| line.prepend("    ") })
+                      end
+                    end
+                  end
+
                   out.puts "Running Hanami install..."
-                  run_install_commmand!
+                  run_install_command!(head: head)
                 end
               end
             end
           end
+          # rubocop:enable Metrics/AbcSize
 
           private
 
           attr_reader :bundler
           attr_reader :generator
+          attr_reader :system_call
 
-          def run_install_commmand!
-            bundler.exec("hanami install").tap do |result|
-              raise HanamiInstallError.new(result.err) unless result.successful?
+          def run_install_command!(head:)
+            head_flag = head ? " --head" : ""
+            bundler.exec("hanami install#{head_flag}").tap do |result|
+              if result.successful?
+                bundler.exec("check").successful? || bundler.exec("install")
+              else
+                raise HanamiInstallError.new(result.err)
+              end
             end
           end
         end