hanami-cli 2.2.1 → 2.3.0.beta1

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/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,12 +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 ForbiddenAppNameError.new(app) if FORBIDDEN_APP_NAMES.include?(app)
 
             normalized_database ||= normalize_database(database)
 
@@ -137,6 +154,7 @@ 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
@@ -158,6 +176,9 @@ module Hanami
 
                   out.puts "Running hanami install..."
                   run_install_command!(head: head)
+
+                  out.puts "Initializing git repository..."
+                  init_git_repository
                 end
               end
             end
@@ -193,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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "erb"
 require "dry/files"
+require_relative "../constants"
 require_relative "../../errors"
 
 # rubocop:disable Metrics/ParameterLists
@@ -14,20 +14,25 @@ module Hanami
         class Action
           # @since 2.0.0
           # @api private
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
+            @view_generator = Generators::App::View.new(
+              fs: fs,
+              inflector: inflector,
+              out: out
+            )
           end
 
           # @since 2.0.0
           # @api private
-          def call(app, controller, action, url, http, format, skip_view, skip_route, slice, context: nil)
-            context ||= ActionContext.new(inflector, app, slice, controller, action)
-            if slice
-              generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
-            else
-              generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
-            end
+          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:)
+            insert_route(key:, namespace:, url_path:, http_method:) unless skip_route
+
+            generate_action(key:, namespace:, base_path:, include_placeholder_body: skip_view)
+
+            generate_view(key:, namespace:, base_path:) unless skip_view
           end
 
           private
@@ -67,86 +72,76 @@ module Hanami
           PATH_SEPARATOR = "/"
           private_constant :PATH_SEPARATOR
 
-          attr_reader :fs
-
-          attr_reader :inflector
-
-          # rubocop:disable Metrics/AbcSize
-          def generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-
-            if generate_route?(skip_route)
-              fs.inject_line_at_block_bottom(
-                fs.join("config", "routes.rb"),
-                slice_matcher(slice),
-                route(controller, action, url, http)
-              )
-            end
-
-            fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
-            fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
+          attr_reader :fs, :inflector, :out, :view_generator
 
-            if generate_view?(skip_view, action, directory)
-              fs.mkdir(directory = fs.join(slice_directory, "views", controller))
-              fs.write(fs.join(directory, "#{action}.rb"), t("slice_view.erb", context))
+          # @api private
+          # @since 2.2.2
+          def insert_route(key:, namespace:, url_path:, http_method:)
+            routes_location = fs.join("config", "routes.rb")
+            route = route_definition(key:, url_path:, http_method:)
 
-              fs.mkdir(directory = fs.join(slice_directory, "templates", controller))
-              fs.write(fs.join(directory, "#{action}.#{format}.erb"),
-                       t(template_with_format_ext("slice_template", format), context))
+            if namespace == Hanami.app.namespace
+              fs.inject_line_at_class_bottom(routes_location, "class Routes", route)
+            else
+              slice_matcher = /slice[[:space:]]*:#{namespace}/
+              fs.inject_line_at_block_bottom(routes_location, slice_matcher, route)
             end
           end
 
-          def generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
-            if generate_route?(skip_route)
-              fs.inject_line_at_class_bottom(
-                fs.join("config", "routes.rb"),
-                "class Routes",
-                route(controller, action, url, http)
-              )
-            end
-
-            fs.mkdir(directory = fs.join("app", "actions", controller))
-            fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
+          # @api private
+          # @since 2.2.2
+          def generate_action(key:, namespace:, base_path:, include_placeholder_body:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: namespace,
+              key: inflector.underscore(key),
+              base_path: base_path,
+              parent_class_name: "#{inflector.camelize(namespace)}::Action",
+              extra_namespace: "Actions",
+              body: [
+                "def handle(request, response)",
+                ("  response.body = self.class.name" if include_placeholder_body),
+                "end"
+              ].compact
+            ).create
+          end
 
-            view = action
-            view_directory = fs.join("app", "views", controller)
+          # @api private
+          # @since 2.2.2
+          def generate_view(key:, namespace:, base_path:)
+            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
 
-            if generate_view?(skip_view, view, view_directory)
-              fs.mkdir(view_directory)
-              fs.write(fs.join(view_directory, "#{view}.rb"), t("view.erb", context))
+            view_directory = fs.join(base_path, "views", controller_name_parts)
 
-              fs.mkdir(template_directory = fs.join("app", "templates", controller))
-              fs.write(fs.join(template_directory, "#{view}.#{format}.erb"),
-                       t(template_with_format_ext("template", format), context))
+            if generate_view?(action_name, view_directory)
+              view_generator.call(
+                key: key,
+                namespace: namespace,
+                base_path: base_path,
+              )
             end
           end
-          # rubocop:enable Metrics/AbcSize
-
-          def slice_matcher(slice)
-            /slice[[:space:]]*:#{slice}/
-          end
-
-          def route(controller, action, url, http)
-            %(#{route_http(action,
-                           http)} "#{route_url(controller, action, url)}", to: "#{controller.join('.')}.#{action}")
-          end
 
           # @api private
-          # @since 2.1.0
-          def generate_view?(skip_view, view, directory)
-            return false if skip_view
-            return generate_restful_view?(view, directory) if rest_view?(view)
+          # @since 2.2.2
+          def route_definition(key:, url_path:, http_method:)
+            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
+
+            method = route_http(action_name, http_method)
+            path = route_url(controller_name_parts, action_name, url_path)
 
-            true
+            %(#{method} "#{path}", to: "#{key}")
           end
 
           # @api private
-          # @since 2.2.0
-          def generate_route?(skip_route)
-            return false if skip_route
-
-            true
+          # @since 2.1.0
+          def generate_view?(action_name, directory)
+            if rest_view?(action_name)
+              generate_restful_view?(action_name, directory)
+            else
+              true
+            end
           end
 
           # @api private
@@ -169,40 +164,22 @@ module Hanami
             RESTFUL_COUNTERPART_VIEWS.fetch(view, nil)
           end
 
-          def template_with_format_ext(name, format)
-            ext =
-              case format.to_sym
-              when :html
-                ".html.erb"
-              else
-                ".erb"
-              end
-
-            "#{name}#{ext}"
-          end
-
-          def template(path, context)
-            require "erb"
-
-            ERB.new(
-              File.read(__dir__ + "/action/#{path}"), trim_mode: "-",
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
-
-          def route_url(controller, action, url)
+          # @api private
+          # @since 2.1.0
+          def route_url(controller, action, url_path)
             action = ROUTE_RESTFUL_URL_SUFFIXES.fetch(action) { [action] }
-            url ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
+            url_path ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
 
-            CLI::URL.call(url)
+            CLI::URL.call(url_path)
           end
 
-          def route_http(action, http)
-            result = (http ||= ROUTE_RESTFUL_HTTP_METHODS.fetch(action, ROUTE_DEFAULT_HTTP_METHOD)).downcase
+          # @api private
+          # @since 2.1.0
+          def route_http(action, http_method)
+            result = (http_method ||= ROUTE_RESTFUL_HTTP_METHODS.fetch(action, ROUTE_DEFAULT_HTTP_METHOD)).downcase
 
             unless ROUTE_HTTP_METHODS.include?(result)
-              raise UnknownHTTPMethodError.new(http)
+              raise UnknownHTTPMethodError.new(http_method)
             end
 
             result

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

@@ -12,49 +12,27 @@ module Hanami
         class Component
           # @api private
           # @since 2.2.0
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
           end
 
           # @api private
           # @since 2.2.0
-          def call(app, key, slice)
-            context = ComponentContext.new(inflector, app, slice, key)
-
-            if slice
-              generate_for_slice(context, slice)
-            else
-              generate_for_app(context)
-            end
+          def call(key:, namespace:, base_path:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              key: inflector.underscore(key),
+              namespace: namespace,
+              base_path: base_path,
+            ).create
           end
 
           private
 
-          attr_reader :fs
-
-          attr_reader :inflector
-
-          def generate_for_slice(context, slice)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-
-            fs.mkdir(directory = fs.join(slice_directory, context.namespaces))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("slice_component.erb", context))
-          end
-
-          def generate_for_app(context)
-            fs.mkdir(directory = fs.join("app", context.namespaces))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("component.erb", context))
-          end
-
-          def template(path, context)
-            ERB.new(
-              File.read(__dir__ + "/component/#{path}")
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
+          attr_reader :fs, :inflector, :out
         end
       end
     end