hanami-cli 2.3.5 → 3.0.0.rc1

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

@@ -7,105 +7,78 @@ module Hanami
   module CLI
     module Commands
       module Gem
-        # @since 2.0.0
         # @api private
         class New < Command
-          # @since 2.1.0
-          # @api private
-          HEAD_DEFAULT = false
-          private_constant :HEAD_DEFAULT
+          FORBIDDEN_APP_NAMES = %w[app slice].freeze
 
-          # @since 2.3.0
-          # @api private
+          HEAD_DEFAULT = false
           GEM_SOURCE_DEFAULT = "rubygems.org"
-          private_constant :GEM_SOURCE_DEFAULT
 
-          # @since 2.0.0
-          # @api private
           SKIP_INSTALL_DEFAULT = false
-          private_constant :SKIP_INSTALL_DEFAULT
-
-          # @since 2.1.0
-          # @api private
           SKIP_ASSETS_DEFAULT = false
-          private_constant :SKIP_ASSETS_DEFAULT
-
-          # @since 2.2.0
-          # @api private
           SKIP_DB_DEFAULT = false
-          private_constant :SKIP_DB_DEFAULT
-
-          # @since 2.2.0
-          # @api private
           SKIP_VIEW_DEFAULT = false
-          private_constant :SKIP_VIEW_DEFAULT
+          SKIP_MAILER_DEFAULT = false
 
-          # @since 2.2.0
-          # @api private
           DATABASE_SQLITE = "sqlite"
-
-          # @since 2.2.0
-          # @api private
           DATABASE_POSTGRES = "postgres"
-
-          # @since 2.2.0
-          # @api private
           DATABASE_MYSQL = "mysql"
-
-          # @since 2.2.0
-          # @api private
           SUPPORTED_DATABASES = [DATABASE_SQLITE, DATABASE_POSTGRES, DATABASE_MYSQL].freeze
 
-          # @api private
-          FORBIDDEN_APP_NAMES = %w[app slice].freeze
+          TEMPLATE_ENGINE_DEFAULT = "erb"
+
+          TEST_FRAMEWORK_DEFAULT = "rspec"
+          TEST_FRAMEWORK_RSPEC = "rspec"
+          TEST_FRAMEWORK_MINITEST = "minitest"
 
           desc "Generate a new Hanami app"
 
-          # @since 2.0.0
-          # @api private
           argument :app, required: true, desc: "App name"
 
-          # @since 2.1.0
-          # @api private
           option :head, type: :flag, required: false,
-                        default: HEAD_DEFAULT,
-                        desc: "Use Hanami HEAD version (from GitHub `main` branches)"
+            default: HEAD_DEFAULT,
+            desc: "Use Hanami HEAD version (from GitHub `main` branches)"
 
-          # @since 2.3.0
-          # @api private
           option :gem_source, required: true,
-                              default: GEM_SOURCE_DEFAULT,
-                              desc: "Where to source Ruby gems from"
+            default: GEM_SOURCE_DEFAULT,
+            desc: "Where to source Ruby gems from"
 
-          # @since 2.0.0
-          # @api private
           option :skip_install, type: :flag, required: false,
-                                default: SKIP_INSTALL_DEFAULT,
-                                desc: "Skip app installation (Bundler, third-party Hanami plugins)"
+            default: SKIP_INSTALL_DEFAULT,
+            desc: "Skip app installation (Bundler, third-party Hanami plugins)"
 
-          # @since 2.1.0
-          # @api private
           option :skip_assets, type: :flag, required: false,
-                               default: SKIP_ASSETS_DEFAULT,
-                               desc: "Skip including hanami-assets"
+            default: SKIP_ASSETS_DEFAULT,
+            desc: "Skip including hanami-assets"
 
-          # @since 2.2.0
-          # @api private
           option :skip_db, type: :flag, required: false,
-                           default: SKIP_DB_DEFAULT,
-                           desc: "Skip including hanami-db"
+            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"
+            default: SKIP_VIEW_DEFAULT,
+            desc: "Skip including hanami-view"
+
+          option :skip_mailer, type: :flag, required: false,
+            default: SKIP_MAILER_DEFAULT,
+            desc: "Skip including hanami-mailer"
 
-          # @since 2.2.0
-          # @api private
           option :database, type: :string, required: false,
-                            default: DATABASE_SQLITE,
-                            desc: "Database adapter (supported: sqlite, mysql, postgres)"
+            default: DATABASE_SQLITE,
+            desc: "Database adapter (supported: sqlite, mysql, postgres)"
+
+          option :name, type: :string, required: false,
+            desc: "App name to use for the module namespace"
+
+          option :template_engine, type: :string, required: false,
+            values: %w[erb haml slim],
+            default: TEMPLATE_ENGINE_DEFAULT,
+            desc: "Default template engine to use with generators"
+
+          option :test, type: :string, required: false,
+            values: %w[rspec minitest],
+            default: TEST_FRAMEWORK_DEFAULT,
+            desc: "Test framework (supported: rspec, minitest)"
 
           # rubocop:disable Layout/LineLength
           example [
@@ -116,12 +89,14 @@ module Hanami
             "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)"
+            "bookshelf --skip-mailer                      # Generate a new Hanami app without hanami-mailer",
+            "bookshelf --database={sqlite|postgres|mysql} # Generate a new Hanami app with a specified database (default: sqlite)",
+            "bookshelf --template-engine={erb|haml|slim}  # Generate a new Hanami app which will use HAML for templates by default (default: erb)",
+            "bookshelf --test={rspec|minitest}            # Generate a new Hanami app with specified test framework (default: rspec)",
+            "my_bookshelf --name=bookshelf                # Generate a new Hanami app in `my_bookshelf/' directory, using `Bookshelf' namespace"
           ]
           # rubocop:enable Layout/LineLength
 
-          # @since 2.0.0
-          # @api private
           def initialize(
             fs:,
             bundler: CLI::Bundler.new(fs: fs),
@@ -137,8 +112,6 @@ module Hanami
 
           # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
 
-          # @since 2.0.0
-          # @api private
           def call(
             app:,
             head: HEAD_DEFAULT,
@@ -147,26 +120,34 @@ module Hanami
             skip_assets: SKIP_ASSETS_DEFAULT,
             skip_db: SKIP_DB_DEFAULT,
             skip_view: SKIP_VIEW_DEFAULT,
-            database: nil
+            skip_mailer: SKIP_MAILER_DEFAULT,
+            database: nil,
+            name: nil,
+            template_engine: TEMPLATE_ENGINE_DEFAULT,
+            test: TEST_FRAMEWORK_DEFAULT
           )
-            app = inflector.underscore(app)
+            directory = inflector.underscore(app)
+            app = inflector.underscore(name || app)
 
-            raise PathAlreadyExistsError.new(app) if fs.exist?(app)
+            raise PathAlreadyExistsError.new(directory) if fs.exist?(directory)
             raise ForbiddenAppNameError.new(app) if FORBIDDEN_APP_NAMES.include?(app)
 
             normalized_database ||= normalize_database(database)
 
-            fs.mkdir(app)
-            fs.chdir(app) do
+            fs.mkdir(directory)
+            fs.chdir(directory) do
               context = Generators::Context.new(
                 inflector,
                 app,
-                head: head,
-                gem_source: gem_source,
-                skip_assets: skip_assets,
-                skip_db: skip_db,
-                skip_view: skip_view,
-                database: normalized_database
+                head:,
+                gem_source:,
+                skip_assets:,
+                skip_db:,
+                skip_view:,
+                skip_mailer:,
+                database: normalized_database,
+                template_engine:,
+                test_framework: test
               )
               generator.call(app, context: context) do
                 if skip_install

data/lib/hanami/cli/errors.rb

@@ -90,7 +90,7 @@ module Hanami
     # @api public
     class InvalidActionNameError < Error
       def initialize(name)
-        super("cannot parse controller and action name: `#{name}'\n\texample: `hanami generate action users.show'")
+        super("cannot parse action name: `#{name}'\n\texample: `hanami generate action users.show'")
       end
     end
 

data/lib/hanami/cli/files.rb

@@ -15,8 +15,8 @@ module Hanami
       end
 
       # @api private
-      def create(path, *content)
-        raise FileAlreadyExistsError.new(path) if exist?(path)
+      def create(path, *content, force: false)
+        raise FileAlreadyExistsError.new(path) if exist?(path) and !force
 
         write(path, *content)
       end
@@ -60,6 +60,13 @@ module Hanami
         created(path)
       end
 
+      def block_contains?(path, target, contents)
+        content = adapter.read(path)
+        class_start = content.index(target)
+        class_end = content.index(/(?:^|\s)#{CLOSE_BLOCK}(?:$|\s)/, class_start)
+        content[class_start..class_end].include? contents
+      end
+
       private
 
       attr_reader :out

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

@@ -11,6 +11,9 @@ module Hanami
         # @since 2.0.0
         # @api private
         class Action
+          DEFAULT_TEMPLATE_ENGINE = "erb"
+          private_constant :DEFAULT_TEMPLATE_ENGINE
+
           # @since 2.0.0
           # @api private
           def initialize(fs:, inflector:, out: $stdout)
@@ -26,12 +29,14 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:, skip_tests:)
+          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:, skip_tests:,
+                   force:, template_engine: DEFAULT_TEMPLATE_ENGINE)
             insert_route(key:, namespace:, url_path:, http_method:) unless skip_route
 
-            generate_action(key: key, namespace: namespace, base_path: base_path, include_placeholder_body: skip_view)
+            generate_action(key: key, namespace: namespace, base_path: base_path, include_placeholder_body: skip_view,
+              force:)
 
-            generate_view(key:, namespace:, base_path:) unless skip_view
+            generate_view(key:, namespace:, base_path:, template_engine:, force:) unless skip_view
           end
 
           private
@@ -80,22 +85,21 @@ module Hanami
             route = route_definition(key:, url_path:, http_method:)
 
             if namespace == Hanami.app.namespace
-              fs.inject_line_at_class_bottom(routes_location, "class Routes", route)
+              add_route_to_file(file: routes_location, route:)
             else
               slice_routes = fs.join("slices", namespace, "config", "routes.rb")
 
               if fs.exist?(slice_routes)
-                fs.inject_line_at_class_bottom(slice_routes, "class Routes", route)
+                add_route_to_file(file: slice_routes, route:)
               else
-                slice_matcher = /slice[[:space:]]*:#{namespace}/
-                fs.inject_line_at_block_bottom(routes_location, slice_matcher, route)
+                add_route_to_block(file: routes_location, namespace:, route:)
               end
             end
           end
 
           # @api private
           # @since 2.2.2
-          def generate_action(key:, namespace:, base_path:, include_placeholder_body:)
+          def generate_action(key:, namespace:, base_path:, include_placeholder_body:, force:)
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
@@ -109,32 +113,28 @@ module Hanami
                 ("  response.body = self.class.name" if include_placeholder_body),
                 "end"
               ].compact
-            ).create
+            ).create(force:)
           end
 
           # @api private
           # @since 2.2.2
-          def generate_view(key:, namespace:, base_path:)
-            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
+          def generate_view(key:, namespace:, base_path:, template_engine:, force:)
+            *namespace_parts, action_name = key.split(KEY_SEPARATOR)
 
-            view_directory = fs.join(base_path, "views", controller_name_parts)
+            view_directory = fs.join(base_path, "views", namespace_parts)
 
             if generate_view?(action_name, view_directory)
-              view_generator.call(
-                key: key,
-                namespace: namespace,
-                base_path: base_path
-              )
+              view_generator.call(key:, namespace:, base_path:, template_engine:, force:)
             end
           end
 
           # @api private
           # @since 2.2.2
           def route_definition(key:, url_path:, http_method:)
-            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
+            *namespace_parts, action_name = key.split(KEY_SEPARATOR)
 
             method = route_http(action_name, http_method)
-            path = route_url(controller_name_parts, action_name, url_path)
+            path = route_url(namespace_parts, action_name, url_path)
 
             %(#{method} "#{path}", to: "#{key}")
           end
@@ -171,9 +171,9 @@ module Hanami
 
           # @api private
           # @since 2.1.0
-          def route_url(controller, action, url_path)
+          def route_url(namespace, action, url_path)
             action = ROUTE_RESTFUL_URL_SUFFIXES.fetch(action) { [action] }
-            url_path ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
+            url_path ||= "#{PATH_SEPARATOR}#{(namespace + action).join(PATH_SEPARATOR)}"
 
             CLI::URL.call(url_path)
           end
@@ -189,6 +189,24 @@ module Hanami
 
             result
           end
+
+          def add_route_to_file(file:, route:)
+            target_class = "class Routes"
+            if fs.block_contains?(file, target_class, route)
+              out.puts "Route (#{route}) already exists, skipping..."
+            else
+              fs.inject_line_at_class_bottom(file, "class Routes", route)
+            end
+          end
+
+          def add_route_to_block(file:, namespace:, route:)
+            slice_matcher = /slice[[:space:]]*:#{namespace}/
+            if fs.block_contains?(file, slice_matcher, route)
+              out.puts "Route (#{route}) already exists, skipping..."
+            else
+              fs.inject_line_at_block_bottom(file, slice_matcher, route)
+            end
+          end
         end
       end
     end

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

@@ -20,14 +20,14 @@ module Hanami
 
           # @api private
           # @since 2.2.0
-          def call(key:, namespace:, base_path:)
+          def call(key:, namespace:, base_path:, force: false)
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
               key: key,
               namespace: namespace,
               base_path: base_path
-            ).create
+            ).create(force:)
           end
 
           private

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "dry/files"
+require_relative "../constants"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        class Mailer
+          TEMPLATES_FOLDER = "templates/mailers"
+          DEFAULT_TEMPLATE_ENGINE = "erb"
+
+          def initialize(fs:, inflector:, out: $stdout)
+            @fs = fs
+            @inflector = inflector
+            @out = out
+          end
+
+          def call(key:, namespace:, base_path:, template_engine: DEFAULT_TEMPLATE_ENGINE, force: false, **)
+            mailer_class_file(key:, namespace:, base_path:).then do |mailer_class|
+              mailer_class.create(force:)
+              mailer_class_name = mailer_class.fully_qualified_name
+              create_template_files(key:, base_path:, mailer_class_name:, template_engine:, force:)
+            end
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+
+          def mailer_class_file(key:, namespace:, base_path:)
+            RubyClassFile.new(
+              fs:, inflector:,
+              namespace:,
+              key:,
+              base_path:,
+              parent_class_name: "#{inflector.camelize(namespace)}::Mailer",
+              extra_namespace: "Mailers"
+            )
+          end
+
+          def create_template_files(key:, base_path:, mailer_class_name:, template_engine:, force:)
+            key_parts = key.split(KEY_SEPARATOR)
+            class_name_from_key = key_parts.pop # takes last segment as the class name
+            module_names_from_key = key_parts # the rest of the segments are the module names
+
+            html_path = template_path(base_path, module_names_from_key, class_name_from_key, "html", template_engine)
+            fs.create(html_path, html_body(mailer_class_name, template_engine), force:)
+
+            text_path = template_path(base_path, module_names_from_key, class_name_from_key, "text", "erb")
+            fs.create(text_path, text_body(mailer_class_name), force:)
+          end
+
+          def template_path(base_path, module_names, name, format, engine)
+            fs.join(
+              base_path,
+              TEMPLATES_FOLDER,
+              module_names,
+              "#{name}.#{format}.#{engine}"
+            )
+          end
+
+          def html_body(mailer_class_name, engine)
+            case engine
+            when "erb" then "<h1>#{mailer_class_name}</h1>\n"
+            when "haml" then "%h1 #{mailer_class_name}\n"
+            when "slim" then "h1 #{mailer_class_name}\n"
+            end
+          end
+
+          def text_body(mailer_class_name)
+            "#{mailer_class_name}\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -55,7 +55,7 @@ module Hanami
             ROM::SQL.migration do
               # Add your migration here.
               #
-              # See https://guides.hanamirb.org/v2.3/database/migrations/ for details.
+              # See https://hanakai.org/learn/hanami/database/migrations/ for details.
               change do
               end
             end

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

@@ -19,7 +19,7 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(key:, namespace:, base_path:)
+          def call(key:, namespace:, base_path:, force: false, **)
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
@@ -28,7 +28,7 @@ module Hanami
               base_path: base_path,
               parent_class_name: "#{inflector.camelize(namespace)}::Operation",
               body: ["def call", "end"]
-            ).create
+            ).create(force:)
 
             unless key.match?(KEY_SEPARATOR)
               out.puts(

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

@@ -20,10 +20,10 @@ module Hanami
 
           # @since 2.1.0
           # @api private
-          def call(key:, namespace:, base_path:, **)
+          def call(key:, namespace:, base_path:, force: false, **)
             create_app_base_part_if_missing(key:, namespace:, base_path:)
             create_slice_part_if_missing(key:, namespace:, base_path:) unless namespace == Hanami.app.namespace
-            create_generated_part(key:, namespace:, base_path:)
+            create_generated_part(key:, namespace:, base_path:, force:)
           end
 
           private
@@ -60,7 +60,7 @@ module Hanami
             ).create
           end
 
-          def create_generated_part(key:, namespace:, base_path:)
+          def create_generated_part(key:, namespace:, base_path:, force: false)
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
@@ -69,7 +69,7 @@ module Hanami
               base_path: base_path,
               parent_class_name: "#{inflector.camelize(namespace)}::Views::Part",
               auto_register: false
-            ).create
+            ).create(force:)
           end
         end
       end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        class Provider
+          def initialize(fs:, inflector:, out: $stdout)
+            @fs = fs
+            @inflector = inflector
+            @out = out
+          end
+
+          def call(key:, namespace:, base_path:, force: false, **_opts)
+            name = inflector.underscore(key)
+
+            registrar =
+              if base_path == "app"
+                "Hanami.app"
+              else
+                "#{inflector.camelize(namespace)}::Slice"
+              end
+
+            base_path = nil if base_path == "app" # Providers live in config/, not app/
+            path = fs.join(*[base_path, "config", "providers", "#{name}.rb"].compact)
+
+            fs.create(path, file_contents(registrar, name), force:)
+          end
+
+          private
+
+          attr_reader :fs, :inflector, :out
+
+          def file_contents(registrar, name)
+            <<~RUBY
+              # frozen_string_literal: true
+
+              #{registrar}.register_provider :#{name} do
+                # Define your provider here.
+                #
+                # See https://hanakai.org/learn/hanami/app/providers for details.
+
+                start do
+                  # Set up and register the provider's components.
+                end
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(key:, namespace:, base_path:, gateway:)
+          def call(key:, namespace:, base_path:, gateway:, force: false)
             schema_name = inflector.underscore(key.split(KEY_SEPARATOR).last)
             body_content = ["schema :#{schema_name}, infer: true"]
 
@@ -34,7 +34,7 @@ module Hanami
               extra_namespace: "Relations",
               parent_class_name: "#{inflector.camelize(namespace)}::DB::Relation",
               body: body_content
-            ).create
+            ).create(force:)
           end
 
           private

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

@@ -17,7 +17,7 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(key:, namespace:, base_path:)
+          def call(key:, namespace:, base_path:, force: false)
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
@@ -26,7 +26,7 @@ module Hanami
               base_path: base_path,
               extra_namespace: "Repos",
               parent_class_name: "#{inflector.camelize(namespace)}::DB::Repo"
-            ).create
+            ).create(force:)
           end
 
           private