Generate db files during hanami generate slice (#197)

* Add .keep file for app/relations, reorder expectations

* Fix comment

* Create db/.keep

* Alphabetize DB generations

* Add base Repo and repos folder

* Add base Relation and relations folder

* Add base Struct and structs folder

* Only generate db/.keep if sqlite

* Add --skip-db to generate slice

* Add --app-db to generate slice

* Add --slice-db to generate slice

* Disallow incompatible options

* Simplify comment

* Separate default value and conflicting options logic

* Remove db options

* Remove spurious requires

Our Zeitwerk autoloading will take care of making these constants available for us.

---------

Co-authored-by: Tim Riley <[email protected]>

Author: cllns

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

@@ -85,7 +85,8 @@ def call(
               skip_view: DEFAULT_SKIP_VIEW,
               skip_tests: DEFAULT_SKIP_TESTS, # rubocop:disable Lint/UnusedMethodArgument
               slice: nil,
-              context: nil, **
+              context: nil,
+              **
             )
               slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
               name = naming.action_name(name)

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

@@ -16,6 +16,19 @@ class Slice < Command
             argument :name, required: true, desc: "The slice name"
             option :url, required: false, type: :string, desc: "The slice URL prefix"
 
+            # @since 2.2.0
+            # @api private
+            SKIP_DB_DEFAULT = false
+            private_constant :SKIP_DB_DEFAULT
+
+            # @since 2.2.0
+            # @api private
+            option :skip_db,
+              type: :boolean,
+              required: false,
+              default: SKIP_DB_DEFAULT,
+              desc: "Skip database"
+
             example [
               "admin          # Admin slice (/admin URL prefix)",
               "users --url=/u # Users slice (/u URL prefix)",
@@ -34,14 +47,18 @@ def initialize(
 
             # @since 2.0.0
             # @api private
-            def call(name:, url: nil, **)
+            def call(
+              name:,
+              url: nil,
+              skip_db: SKIP_DB_DEFAULT
+            )
               require "hanami/setup"
 
               app = inflector.underscore(Hanami.app.namespace)
               name = inflector.underscore(Shellwords.shellescape(name))
               url = sanitize_url_prefix(name, url)
 
-              generator.call(app, name, url)
+              generator.call(app, name, url, skip_db: skip_db)
             end
 
             private

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

@@ -19,14 +19,15 @@ def initialize(fs:, inflector:)
 
           # @since 2.0.0
           # @api private
-          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url)) # rubocop:disable Metrics/AbcSize
+          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
             )
 
             fs.mkdir(directory = "slices/#{slice}")
 
-            # fs.write("#{directory}/config/slice.rb", t("slice.erb", context))
             fs.write(fs.join(directory, "action.rb"), t("action.erb", context))
             fs.write(fs.join(directory, "view.rb"), t("view.erb", context))
             fs.write(fs.join(directory, "views", "helpers.rb"), t("helpers.erb", context))
@@ -39,15 +40,21 @@ def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url))
               fs.write(fs.join(directory, "assets", "images", "favicon.ico"), file("favicon.ico"))
             end
 
-            # fs.write(fs.join(directory, "/entities.rb"), t("entities.erb", context))
-            # fs.write(fs.join(directory, "/repository.rb"), t("repository.erb", context))
+            if context.generate_db?
+              fs.write(fs.join(directory, "db", "relation.rb"), t("relation.erb", context))
+              fs.write(fs.join(directory, "relations", ".keep"), t("keep.erb", context))
+
+              fs.write(fs.join(directory, "db", "repo.rb"), t("repo.erb", context))
+              fs.write(fs.join(directory, "repos", ".keep"), t("keep.erb", context))
+
+              fs.write(fs.join(directory, "db", "struct.rb"), t("struct.erb", context))
+              fs.write(fs.join(directory, "structs", ".keep"), t("keep.erb", context))
+            end
 
             fs.write(fs.join(directory, "actions/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "views/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "templates/.keep"), t("keep.erb", context))
             fs.write(fs.join(directory, "templates/layouts/.keep"), t("keep.erb", context))
-            # fs.write(fs.join(directory, entities/.keep"), t("keep.erb", context))
-            # fs.write(fs.join(directory, repositories/.keep"), t("keep.erb", context))
           end
 
           private

lib/hanami/cli/generators/app/slice/relation.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module DB
+    class Relation < <%= camelized_app_name %>::DB::Relation
+    end
+  end
+end

lib/hanami/cli/generators/app/slice/slice.erb lib/hanami/cli/generators/app/slice/repo.erb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module <%= camelized_slice_name %>
-  class Slice < Hanami::Slice
+  module DB
+    class Repo < <%= camelized_app_name %>::DB::Repo
+    end
   end
 end

lib/hanami/cli/generators/app/slice/repository.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module DB
+    class Struct < <%= camelized_app_name %>::DB::Struct
+    end
+  end
+end

lib/hanami/cli/generators/app/slice/struct.erb

@@ -12,10 +12,10 @@ module App
         class SliceContext < Generators::Context
           # @since 2.0.0
           # @api private
-          def initialize(inflector, app, slice, url)
+          def initialize(inflector, app, slice, url, **options)
             @slice = slice
             @url = url
-            super(inflector, app)
+            super(inflector, app, **options)
           end
 
           # @since 2.0.0
@@ -48,6 +48,12 @@ def javascript_erb_tag
             %(<%= javascript_tag "app" %>)
           end
 
+          # @since 2.2.0
+          # @api private
+          def generate_db?
+            !options.fetch(:skip_db, false)
+          end
+
           private
 
           attr_reader :slice

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

@@ -53,17 +53,6 @@ class Routes < Hanami::Routes
       expect(fs.directory?("slices/#{slice}")).to be(true)
       expect(output).to include("Created slices/#{slice}/")
 
-      # # Slice
-      # slice_class = <<~CODE
-      #   # frozen_string_literal: true
-      #
-      #   module Admin
-      #     class Slice < Hanami::Slice
-      #     end
-      #   end
-      # CODE
-      # expect(fs.read("slices/#{slice}/config/slice.rb")).to eq(slice_class)
-
       # Action
       action = <<~CODE
         # auto_register: false
@@ -77,10 +66,57 @@ class Action < #{app}::Action
 
       expect(fs.read("slices/#{slice}/action.rb")).to eq(action)
       expect(output).to include("Created slices/#{slice}/action.rb")
-
       expect(fs.read("slices/#{slice}/actions/.keep")).to eq("")
       expect(output).to include("Created slices/#{slice}/actions/.keep")
 
+      # Relation
+      relation = <<~EXPECTED
+        # frozen_string_literal: true
+
+        module Admin
+          module DB
+            class Relation < Bookshelf::DB::Relation
+            end
+          end
+        end
+      EXPECTED
+      expect(fs.read("slices/admin/db/relation.rb")).to eq(relation)
+      expect(output).to include("Created slices/admin/db/relation.rb")
+      expect(fs.read("slices/admin/relations/.keep")).to eq("")
+      expect(output).to include("Created slices/admin/relations/.keep")
+
+      # Repo
+      repo = <<~EXPECTED
+        # frozen_string_literal: true
+
+        module Admin
+          module DB
+            class Repo < Bookshelf::DB::Repo
+            end
+          end
+        end
+      EXPECTED
+      expect(fs.read("slices/admin/db/repo.rb")).to eq(repo)
+      expect(output).to include("Created slices/admin/db/repo.rb")
+      expect(fs.read("slices/admin/repos/.keep")).to eq("")
+      expect(output).to include("Created slices/admin/repos/.keep")
+
+      # Struct
+      struct = <<~EXPECTED
+        # frozen_string_literal: true
+
+        module Admin
+          module DB
+            class Struct < Bookshelf::DB::Struct
+            end
+          end
+        end
+      EXPECTED
+      expect(fs.read("slices/admin/db/struct.rb")).to eq(struct)
+      expect(output).to include("Created slices/admin/db/struct.rb")
+      expect(fs.read("slices/admin/structs/.keep")).to eq("")
+      expect(output).to include("Created slices/admin/structs/.keep")
+
       view = <<~RUBY
         # auto_register: false
         # frozen_string_literal: true
@@ -267,6 +303,19 @@ class Action < #{app}::Action
     end
   end
 
+  context "with --skip-db" do
+    it "generates a slice without hanami-db files" do
+      within_application_directory do
+        subject.call(name: slice, skip_db: true)
+
+        expect(fs.exist?("slices/admin/db")).to be(false)
+        expect(fs.exist?("slices/admin/repos")).to be(false)
+        expect(fs.exist?("slices/admin/relations")).to be(false)
+        expect(fs.exist?("slices/admin/structs")).to be(false)
+      end
+    end
+  end
+
   private
 
   def within_application_directory