hanami-cli 2.2.0.beta1 → 2.2.0.rc1

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

@@ -17,17 +17,14 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(_app_namespace, name, slice, **_opts)
-            normalized_name = inflector.underscore(name)
-            ensure_valid_name(normalized_name)
+          def call(key:, base_path:, gateway: nil, **_opts)
+            name = inflector.underscore(key)
+            ensure_valid_name(name)
 
-            base = if slice
-                     fs.join("slices", slice, "config", "db", "migrate")
-                   else
-                     fs.join("config", "db", "migrate")
-                   end
+            base_path = nil if base_path == "app" # Migrations are in the root dir, not app/
+            migrate_dir = gateway ? "#{gateway}_migrate" : "migrate"
 
-            path = fs.join(base, file_name(normalized_name))
+            path = fs.join(*[base_path, "config", "db", migrate_dir, file_name(name)].compact)
 
             fs.write(path, FILE_CONTENTS)
           end
@@ -59,6 +56,8 @@ module Hanami
               # Add your migration here.
               #
               # See https://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html for details.
+              change do
+              end
             end
           RUBY
           private_constant :FILE_CONTENTS

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

@@ -19,16 +19,17 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
+              namespace: namespace,
+              base_path: base_path,
               key: key,
-              slice: slice,
               relative_parent_class: "Operation",
               body: ["def call", "end"],
-            ).call
+            )
 
             unless key.match?(KEY_SEPARATOR)
               out.puts(

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

@@ -19,19 +19,20 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             schema_name = key.split(KEY_SEPARATOR).last
 
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
+              namespace: namespace,
               key: key,
-              slice: slice,
+              base_path: base_path,
               extra_namespace: "Relations",
               relative_parent_class: "DB::Relation",
               body: ["schema :#{schema_name}, infer: true"],
-            ).call
+            )
           end
 
           private

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

@@ -17,17 +17,18 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
               key: key,
-              slice: slice,
+              namespace: namespace,
+              base_path: base_path,
               extra_namespace: "Repos",
               relative_parent_class: "DB::Repo",
               body: [],
-            ).call
+            )
           end
 
           private

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

@@ -14,31 +14,55 @@ module Hanami
         class RubyFileWriter
           # @since 2.2.0
           # @api private
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # @since 2.2.0
+          # @api private
+          def call(key:, namespace:, base_path:, relative_parent_class:, extra_namespace: nil, body: [])
+            ClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+              relative_parent_class: relative_parent_class,
+              extra_namespace: extra_namespace,
+              body: body,
+            ).write
+          end
+
+          private
+
+          # @since 2.2.0
+          # @api private
+          attr_reader :fs, :inflector
+        end
+
+        class ClassFile
           def initialize(
             fs:,
             inflector:,
-            app_namespace:,
             key:,
-            slice:,
+            namespace:,
+            base_path:,
             relative_parent_class:,
             extra_namespace: nil,
             body: []
           )
             @fs = fs
             @inflector = inflector
-            @app_namespace = app_namespace
             @key = key
-            @slice = slice
+            @namespace = namespace
+            @base_path = base_path
             @extra_namespace = extra_namespace&.downcase
             @relative_parent_class = relative_parent_class
             @body = body
-            raise_missing_slice_error_if_missing(slice) if slice
           end
 
-          # @since 2.2.0
-          # @api private
-          def call
-            fs.mkdir(directory)
+          def write
             fs.write(path, file_contents)
           end
 
@@ -49,9 +73,9 @@ module Hanami
           attr_reader(
             :fs,
             :inflector,
-            :app_namespace,
             :key,
-            :slice,
+            :namespace,
+            :base_path,
             :extra_namespace,
             :relative_parent_class,
             :body,
@@ -62,7 +86,6 @@ module Hanami
           def file_contents
             class_definition(
               class_name: class_name,
-              container_namespace: container_namespace,
               local_namespaces: local_namespaces,
             )
           end
@@ -73,12 +96,6 @@ module Hanami
             key.split(KEY_SEPARATOR)[-1]
           end
 
-          # @since 2.2.0
-          # @api private
-          def container_namespace
-            slice || app_namespace
-          end
-
           # @since 2.2.0
           # @api private
           def local_namespaces
@@ -88,16 +105,10 @@ module Hanami
           # @since 2.2.0
           # @api private
           def directory
-            base = if slice
-                     fs.join("slices", slice)
-                   else
-                     fs.join("app")
-                   end
-
             @directory ||= if local_namespaces.any?
-                             fs.join(base, local_namespaces)
+                             fs.join(base_path, local_namespaces)
                            else
-                             fs.join(base)
+                             base_path
                            end
           end
 
@@ -109,8 +120,8 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def class_definition(class_name:, container_namespace:, local_namespaces:)
-            container_module = normalize(container_namespace)
+          def class_definition(class_name:, local_namespaces:)
+            container_module = normalize(namespace)
 
             modules = local_namespaces
               .map { normalize(_1) }
@@ -133,15 +144,6 @@ module Hanami
           def normalize(name)
             inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
           end
-
-          # @since 2.2.0
-          # @api private
-          def raise_missing_slice_error_if_missing(slice)
-            if slice
-              slice_directory = fs.join("slices", slice)
-              raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-            end
-          end
         end
       end
     end

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

@@ -22,9 +22,11 @@ module Hanami
           def call(app, slice, url, context: nil, **opts)
             context ||= SliceContext.new(inflector, app, slice, url, **opts)
 
-            fs.inject_line_at_class_bottom(
-              fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
-            )
+            if context.generate_route?
+              fs.inject_line_at_class_bottom(
+                fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
+              )
+            end
 
             fs.mkdir(directory = "slices/#{slice}")
 

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

@@ -54,6 +54,12 @@ module Hanami
             !options.fetch(:skip_db, false)
           end
 
+          # @since 2.2.0
+          # @api private
+          def generate_route?
+            !options.fetch(:skip_route, false)
+          end
+
           private
 
           attr_reader :slice

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

@@ -17,16 +17,17 @@ module Hanami
 
           # @since 2.2.0
           # @api private
-          def call(app_namespace, key, slice)
+          def call(key:, namespace:, base_path:)
             RubyFileWriter.new(
               fs: fs,
               inflector: inflector,
-              app_namespace: app_namespace,
+            ).call(
               key: key,
-              slice: slice,
+              namespace: namespace,
+              base_path: base_path,
               extra_namespace: "Structs",
               relative_parent_class: "DB::Struct",
-            ).call
+            )
           end
 
           private

data/lib/hanami/cli/generators/context.rb

@@ -89,19 +89,19 @@ module Hanami
         # @since 2.2.0
         # @api private
         def generate_sqlite?
-          database_option == Commands::Gem::New::DATABASE_SQLITE
+          generate_db? && database_option == Commands::Gem::New::DATABASE_SQLITE
         end
 
         # @since 2.2.0
         # @api private
         def generate_postgres?
-          database_option == Commands::Gem::New::DATABASE_POSTGRES
+          generate_db? && database_option == Commands::Gem::New::DATABASE_POSTGRES
         end
 
         # @since 2.2.0
         # @api private
         def generate_mysql?
-          database_option == Commands::Gem::New::DATABASE_MYSQL
+          generate_db? && database_option == Commands::Gem::New::DATABASE_MYSQL
         end
 
         # @since 2.2.0
@@ -112,7 +112,7 @@ module Hanami
           elsif generate_postgres?
             "postgres://localhost/#{app}"
           elsif generate_mysql?
-            "mysql://localhost/#{app}"
+            "mysql2://root@localhost/#{app}"
           else
             raise "Unknown database option: #{database_option}"
           end

data/lib/hanami/cli/generators/gem/app/gitignore.erb

@@ -4,3 +4,6 @@ log/*
 public/
 node_modules/
 <%- end -%>
+<%- if generate_sqlite? -%>
+db/*.sqlite
+<%- end -%>

data/lib/hanami/cli/generators/gem/app/operation.erb

@@ -5,9 +5,5 @@ require "dry/operation"
 
 module <%= camelized_app_name %>
   class Operation < Dry::Operation
-    <%- if generate_db? -%>
-    # Provide `transaction do ... end` method for database transactions
-    include Dry::Operation::Extensions::ROM
-    <%- end -%>
   end
 end

data/lib/hanami/cli/generators/gem/app/seeds.erb

@@ -0,0 +1,15 @@
+# This seeds file should create the database records required to run the app.
+#
+# The code should be idempotent so that it can be executed at any time.
+#
+# To load the seeds, run `hanami db seed`. Seeds are also loaded as part of `hanami db prepare`.
+
+# For example, if you have appropriate repos available:
+#
+#   category_repo = Hanami.app["repos.category_repo"]
+#   category_repo.create(title: "General")
+#
+# Alternatively, you can use relations directly:
+#
+#   categories = Hanami.app["relations.categories"]
+#   categories.insert(title: "General")

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

@@ -78,10 +78,11 @@ module Hanami
               fs.write("app/db/struct.rb", t("struct.erb", context))
               fs.write("app/structs/.keep", t("keep.erb", context))
 
-              fs.write("config/db/migrate/.keep" , t("keep.erb", context))
+              fs.write("config/db/seeds.rb", t("seeds.erb", context))
+              fs.write("config/db/migrate/.keep", t("keep.erb", context))
 
               if context.generate_sqlite?
-                fs.write("db/.keep" , t("keep.erb", context))
+                fs.write("db/.keep", t("keep.erb", context))
               end
             end
 

data/lib/hanami/cli/repl/irb.rb

@@ -24,8 +24,8 @@ module Hanami
             AUTO_INDENT: true,
             PROMPT_I: "#{prompt}> ",
             PROMPT_N: "#{prompt}> ",
-            PROMPT_S: "#{prompt} %l> ",
-            PROMPT_C: "#{prompt} ?> ",
+            PROMPT_S: "#{prompt}%l ",
+            PROMPT_C: "#{prompt}* ",
             RETURN: "=> %s\n"
           }
 

data/lib/hanami/cli/version.rb

@@ -6,6 +6,6 @@ module Hanami
     #
     # @api public
     # @since 2.0.0
-    VERSION = "2.2.0.beta1"
+    VERSION = "2.2.0.rc1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-cli
 version: !ruby/object:Gem::Version
-  version: 2.2.0.beta1
+  version: 2.2.0.rc1
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -263,7 +263,6 @@ files:
 - lib/hanami/cli/generators/app/slice/app_css.erb
 - lib/hanami/cli/generators/app/slice/app_js.erb
 - lib/hanami/cli/generators/app/slice/app_layout.erb
-- lib/hanami/cli/generators/app/slice/entities.erb
 - lib/hanami/cli/generators/app/slice/favicon.ico
 - lib/hanami/cli/generators/app/slice/helpers.erb
 - lib/hanami/cli/generators/app/slice/keep.erb
@@ -309,6 +308,7 @@ files:
 - lib/hanami/cli/generators/gem/app/relation.erb
 - lib/hanami/cli/generators/gem/app/repo.erb
 - lib/hanami/cli/generators/gem/app/routes.erb
+- lib/hanami/cli/generators/gem/app/seeds.erb
 - lib/hanami/cli/generators/gem/app/settings.erb
 - lib/hanami/cli/generators/gem/app/struct.erb
 - lib/hanami/cli/generators/gem/app/types.erb
@@ -354,7 +354,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Hanami CLI

data/lib/hanami/cli/generators/app/slice/entities.erb

@@ -1,9 +0,0 @@
-# auto_register: false
-# frozen_string_literal: true
-
-module <%= camelized_slice_name %>
-  module Entities
-  end
-end
-
-Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))