hanami-cli 2.2.0 → 2.3.0.beta1

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

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

@@ -3,6 +3,7 @@
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+
 module Hanami
   module CLI
     module Commands
@@ -10,9 +11,8 @@ module Hanami
         module Generate
           # @api private
           # @since 2.2.0
-          class Component < App::Command
+          class Component < Command
             argument :name, required: true, desc: "Component name"
-            option :slice, required: false, desc: "Slice name"
 
             example [
               %(isbn_decoder               (MyApp::IsbnDecoder)),
@@ -20,26 +20,11 @@ module Hanami
               %(isbn_decoder --slice=admin (Admin::IsbnDecoder)),
               %(Exporters::Complete::CSV   (MyApp::Exporters::Complete::CSV)),
             ]
-            attr_reader :generator
-            private :generator
 
-            # @api private
             # @since 2.2.0
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::Component.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              @generator = generator
-              super(fs: fs, inflector: inflector, **opts)
-            end
-
             # @api private
-            # @since 2.2.0
-            def call(name:, slice: nil, **)
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-
-              generator.call(app.namespace, name, slice)
+            def generator_class
+              Generators::App::Component
             end
           end
         end

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

@@ -11,12 +11,12 @@ module Hanami
         module Generate
           # @since 2.1.0
           # @api private
-          class Part < App::Command
+          class Part < 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,
@@ -28,26 +28,9 @@ module Hanami
               %(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)
+            def generator_class
+              Generators::App::Part
             end
           end
         end

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

@@ -49,11 +49,11 @@ module Hanami
             # @since 2.0.0
             # @api private
             def initialize(
-              fs:, inflector:,
+              fs:,
               generator: Generators::App::Slice.new(fs: fs, inflector: inflector),
               **opts
             )
-              super(fs: fs, inflector: inflector, **opts)
+              super(fs: fs, **opts)
               @generator = generator
             end
 

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

@@ -13,40 +13,21 @@ module Hanami
         module Generate
           # @since 2.0.0
           # @api private
-          class View < App::Command
-            # TODO: make this configurable
-            DEFAULT_FORMAT = "html"
-            private_constant :DEFAULT_FORMAT
-
+          class View < Command
+            # TODO: make format configurable
             # 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
+            # @since 2.2.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)
+            def generator_class
+              Generators::App::View
             end
           end
         end

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

@@ -33,9 +33,21 @@ module Hanami
           # @api private
           option :head, type: :flag, desc: "Install head deps", default: DEFAULT_HEAD
 
+          # @api private
+          private attr_reader :bundler
+
+          def initialize(
+            fs:,
+            bundler: CLI::Bundler.new(fs: fs),
+            **opts
+          )
+            @bundler = bundler
+          end
+
           # @since 2.0.0
           # @api private
           def call(head: DEFAULT_HEAD, **)
+            bundler.install!
           end
         end
       end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "rack"
 require "hanami/port"
 require_relative "../app"
 require_relative "../../server"

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

@@ -32,6 +32,7 @@ module Hanami
                 db.register "create", DB::Create
                 db.register "drop", DB::Drop
                 db.register "migrate", DB::Migrate
+                db.register "rollback", DB::Rollback
                 db.register "structure dump", DB::Structure::Dump
                 db.register "structure load", DB::Structure::Load
                 db.register "seed", DB::Seed

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

@@ -30,6 +30,11 @@ module Hanami
           SKIP_DB_DEFAULT = false
           private_constant :SKIP_DB_DEFAULT
 
+          # @since 2.2.0
+          # @api private
+          SKIP_VIEW_DEFAULT = false
+          private_constant :SKIP_VIEW_DEFAULT
+
           # @since 2.2.0
           # @api private
           DATABASE_SQLITE = "sqlite"
@@ -46,6 +51,9 @@ module Hanami
           # @api private
           SUPPORTED_DATABASES = [DATABASE_SQLITE, DATABASE_POSTGRES, DATABASE_MYSQL].freeze
 
+          # @api private
+          FORBIDDEN_APP_NAMES = %w[app slice].freeze
+
           desc "Generate a new Hanami app"
 
           # @since 2.0.0
@@ -76,6 +84,12 @@ module Hanami
                            default: SKIP_DB_DEFAULT,
                            desc: "Skip including hanami-db"
 
+          # @since 2.2.0
+          # @api private
+          option :skip_view, type: :flag, required: false,
+                             default: SKIP_VIEW_DEFAULT,
+                             desc: "Skip including hanami-view"
+
           # @since 2.2.0
           # @api private
           option :database, type: :string, required: false,
@@ -87,8 +101,9 @@ module Hanami
             "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 hanmai-assets",
+            "bookshelf --skip-assets                      # Generate a new Hanami app without hanami-assets",
             "bookshelf --skip-db                          # Generate a new Hanami app without hanami-db",
+            "bookshelf --skip-view                        # Generate a new Hanami app without hanami-view",
             "bookshelf --database={sqlite|postgres|mysql} # Generate a new Hanami app with a specified database (default: sqlite)",
           ]
           # rubocop:enable Layout/LineLength
@@ -98,13 +113,13 @@ module Hanami
           # @since 2.0.0
           # @api private
           def initialize(
-            fs:, inflector:,
+            fs:,
             bundler: CLI::Bundler.new(fs: fs),
             generator: Generators::Gem::App.new(fs: fs, inflector: inflector),
             system_call: SystemCall.new,
             **opts
           )
-            super(fs: fs, inflector: inflector, **opts)
+            super(fs: fs, **opts)
             @bundler = bundler
             @generator = generator
             @system_call = system_call
@@ -120,13 +135,14 @@ module Hanami
             skip_install: SKIP_INSTALL_DEFAULT,
             skip_assets: SKIP_ASSETS_DEFAULT,
             skip_db: SKIP_DB_DEFAULT,
+            skip_view: SKIP_VIEW_DEFAULT,
             database: nil
           )
             # rubocop:enable Metrics/ParameterLists
             app = inflector.underscore(app)
 
             raise PathAlreadyExistsError.new(app) if fs.exist?(app)
-            raise ConflictingOptionsError.new("--skip-db", "--database") if skip_db && database
+            raise ForbiddenAppNameError.new(app) if FORBIDDEN_APP_NAMES.include?(app)
 
             normalized_database ||= normalize_database(database)
 
@@ -138,17 +154,18 @@ module Hanami
                 head: head,
                 skip_assets: skip_assets,
                 skip_db: skip_db,
+                skip_view: skip_view,
                 database: normalized_database
               )
               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..."
+                  out.puts "Running bundle install..."
                   bundler.install!
 
                   unless skip_assets
-                    out.puts "Running NPM install..."
+                    out.puts "Running npm install..."
                     system_call.call("npm", ["install"]).tap do |result|
                       unless result.successful?
                         puts "NPM ERROR:"
@@ -157,8 +174,11 @@ module Hanami
                     end
                   end
 
-                  out.puts "Running Hanami install..."
+                  out.puts "Running hanami install..."
                   run_install_command!(head: head)
+
+                  out.puts "Initializing git repository..."
+                  init_git_repository
                 end
               end
             end
@@ -194,6 +214,16 @@ module Hanami
               end
             end
           end
+
+          # @api private
+          def init_git_repository
+            system_call.call("git", ["init"]).tap do |result|
+              unless result.successful?
+                out.puts "WARNING: Failed to initialize git repository"
+                out.puts(result.err.lines.map { |line| line.prepend("    ") })
+              end
+            end
+          end
         end
       end
     end

data/lib/hanami/cli/errors.rb

@@ -44,6 +44,24 @@ module Hanami
       end
     end
 
+    # @api public
+    class FileAlreadyExistsError < Error
+      ERROR_MESSAGE = <<~ERROR.chomp
+        The file `%{file_path}` could not be generated because it already exists.
+      ERROR
+
+      def initialize(file_path)
+        super(ERROR_MESSAGE % {file_path:})
+      end
+    end
+
+    # @api public
+    class ForbiddenAppNameError < Error
+      def initialize(name)
+        super("Cannot create new Hanami app with the name: `#{name}'")
+      end
+    end
+
     # @since 2.0.0
     # @api public
     class MissingSliceError < Error
@@ -100,6 +118,14 @@ module Hanami
       end
     end
 
+    # @since 2.2.0
+    # @api public
+    class DatabaseExistenceCheckError < Error
+      def initialize(original_message)
+        super("Could not check if the database exists. Error message:\n#{original_message}")
+      end
+    end
+
     # @since 2.2.0
     # @api public
     class ConflictingOptionsError < Error

data/lib/hanami/cli/files.rb

@@ -14,6 +14,13 @@ module Hanami
         @out = out
       end
 
+      # @api private
+      def create(path, *content)
+        raise FileAlreadyExistsError.new(path) if exist?(path)
+
+        write(path, *content)
+      end
+
       # @since 2.0.0
       # @api private
       def write(path, *content)
@@ -33,10 +40,10 @@ module Hanami
       # @since 2.0.0
       # @api private
       def mkdir(path)
-        unless exist?(path)
-          super
-          created(_path(path))
-        end
+        return if exist?(path)
+
+        super
+        created(dir_path(path))
       end
 
       # @since 2.0.0
@@ -46,6 +53,13 @@ module Hanami
         super
       end
 
+      def touch(path)
+        return if exist?(path)
+
+        super
+        created(path)
+      end
+
       private
 
       attr_reader :out
@@ -77,10 +91,10 @@ module Hanami
       end
 
       def within_folder(path)
-        out.puts "-> Within #{_path(path)}"
+        out.puts "-> Within #{dir_path(path)}"
       end
 
-      def _path(path)
+      def dir_path(path)
         path + ::File::SEPARATOR
       end
     end