hanami-cli 2.2.1 → 2.3.0.beta1

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

@@ -26,7 +26,7 @@ module Hanami
 
             path = fs.join(*[base_path, "config", "db", migrate_dir, file_name(name)].compact)
 
-            fs.write(path, FILE_CONTENTS)
+            fs.create(path, FILE_CONTENTS)
           end
 
           private

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

@@ -20,16 +20,15 @@ module Hanami
           # @since 2.2.0
           # @api private
           def call(key:, namespace:, base_path:)
-            RubyFileWriter.new(
+            RubyClassFile.new(
               fs: fs,
               inflector: inflector,
-            ).call(
+              key: key,
               namespace: namespace,
               base_path: base_path,
-              key: key,
-              relative_parent_class: "Operation",
+              parent_class_name: "#{inflector.camelize(namespace)}::Operation",
               body: ["def call", "end"],
-            )
+            ).create
 
             unless key.match?(KEY_SEPARATOR)
               out.puts(

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

@@ -2,7 +2,6 @@
 
 require "erb"
 require "dry/files"
-require_relative "../../errors"
 
 module Hanami
   module CLI
@@ -13,87 +12,65 @@ module Hanami
         class Part
           # @since 2.1.0
           # @api private
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
           end
 
           # @since 2.1.0
           # @api private
-          def call(app, key, slice)
-            context = PartContext.new(inflector, app, slice, key)
-
-            if slice
-              generate_for_slice(context, slice)
-            else
-              generate_for_app(context)
-            end
+          def call(key:, namespace:, base_path:, **)
+            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:)
           end
 
           private
 
           # @since 2.1.0
           # @api private
-          attr_reader :fs
-
-          # @since 2.1.0
-          # @api private
-          attr_reader :inflector
-
-          # @since 2.1.0
-          # @api private
-          def generate_for_slice(context, slice)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-
-            generate_base_part_for_app(context)
-            generate_base_part_for_slice(context, slice)
-
-            fs.mkdir(directory = fs.join(slice_directory, "views", "parts", *context.underscored_namespace))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("slice_part.erb", context))
-          end
-
-          # @since 2.1.0
-          # @api private
-          def generate_for_app(context)
-            generate_base_part_for_app(context)
-
-            fs.mkdir(directory = fs.join("app", "views", "parts", *context.underscored_namespace))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("app_part.erb", context))
-          end
-
-          # @since 2.1.0
-          # @api private
-          def generate_base_part_for_app(context)
-            path = fs.join("app", "views", "part.rb")
-            return if fs.exist?(path)
-
-            fs.write(path, t("app_base_part.erb", context))
+          attr_reader :fs, :inflector, :out
+
+          def create_app_base_part_if_missing(key:, namespace:, base_path:)
+            return if fs.exist?(fs.join(base_path, "views", "part.rb"))
+
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: Hanami.app.namespace,
+              key: "views.part",
+              base_path: APP_DIR,
+              parent_class_name: "Hanami::View::Part",
+              auto_register: false
+            ).create
           end
 
-          # @since 2.1.0
-          # @api private
-          def generate_base_part_for_slice(context, slice)
-            path = fs.join("slices", slice, "views", "part.rb")
-            return if fs.exist?(path)
-
-            fs.write(path, t("slice_base_part.erb", context))
+          def create_slice_part_if_missing(key:, namespace:, base_path:)
+            return if fs.exist?(fs.join(base_path, "views", "part.rb"))
+
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: namespace,
+              key: "views.part",
+              base_path: base_path,
+              parent_class_name: "#{Hanami.app.namespace}::Views::Part",
+              auto_register: false
+            ).create
           end
 
-          # @since 2.1.0
-          # @api private
-          def template(path, context)
-            require "erb"
-
-            ERB.new(
-              File.read(__dir__ + "/part/#{path}"),
-              trim_mode: "-"
-            ).result(context.ctx)
+          def create_generated_part(key:, namespace:, base_path:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: namespace,
+              key: inflector.underscore("views.parts.#{key}"),
+              base_path: base_path,
+              parent_class_name: "#{inflector.camelize(namespace)}::Views::Part",
+              auto_register: false
+            ).create
           end
-
-          # @since 2.1.0
-          # @api private
-          alias_method :t, :template
         end
       end
     end

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

@@ -25,17 +25,16 @@ module Hanami
 
             body_content.prepend("gateway :#{gateway}") if gateway
 
-            RubyFileWriter.new(
+            RubyClassFile.new(
               fs: fs,
               inflector: inflector,
-            ).call(
-              namespace: namespace,
               key: key,
+              namespace: namespace,
               base_path: base_path,
               extra_namespace: "Relations",
-              relative_parent_class: "DB::Relation",
+              parent_class_name: "#{inflector.camelize(namespace)}::DB::Relation",
               body: body_content,
-            )
+            ).create
           end
 
           private

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

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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        class RubyClassFile < RubyFile
+          def initialize(parent_class_name: nil, **args)
+            super
+
+            @parent_class_name = parent_class_name
+          end
+
+          private
+
+          attr_reader :parent_class_name
+
+          def class_name
+            constant_name
+          end
+
+          def modules
+            namespace_modules
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        class RubyFile
+          def initialize(
+            fs:,
+            inflector:,
+            key:,
+            namespace:,
+            base_path:,
+            extra_namespace: nil,
+            auto_register: nil,
+            body: [],
+            **opts
+          )
+            @fs = fs
+            @inflector = inflector
+            @key = key
+            @namespace = namespace
+            @base_path = base_path
+            @extra_namespace = extra_namespace&.downcase
+            @auto_register = auto_register
+            @body = body
+          end
+
+          # @api private
+          def create
+            fs.create(path, file_contents)
+          end
+
+          # @api private
+          def write
+            fs.write(path, file_contents)
+          end
+
+          # @api private
+          def fully_qualified_name
+            inflector.camelize(
+              [namespace, extra_namespace, *key_parts].join("/"),
+            )
+          end
+
+          # @api private
+          def path
+            fs.join(directory, "#{key_parts.last}.rb")
+          end
+
+          private
+
+          # @api private
+          attr_reader(
+            :fs,
+            :inflector,
+            :key,
+            :base_path,
+            :namespace,
+            :extra_namespace,
+            :auto_register,
+            :body,
+          )
+
+          # @api private
+          def file_contents
+            RubyFileGenerator.new(
+              # These first three must be implemented by subclasses
+              class_name: class_name,
+              parent_class_name: parent_class_name,
+              modules: modules,
+              header: headers,
+              body: body
+            ).call
+          end
+
+          # @api private
+          def local_namespaces
+            Array(extra_namespace) + key_parts[..-2]
+          end
+
+          # @api private
+          def namespace_modules
+            [namespace, *local_namespaces]
+              .map { normalize(_1) }
+              .compact
+          end
+
+          # @api private
+          def directory
+            @directory ||= if local_namespaces.any?
+                             fs.join(base_path, local_namespaces)
+                           else
+                             base_path
+                           end
+          end
+
+          # @api private
+          def constant_name
+            normalize(key_parts.last)
+          end
+
+          # @api private
+          def headers
+            [
+              # Intentional ternary logic. Skip if nil, else 'true' or 'false'
+              ("# auto_register: #{auto_register}" unless auto_register.nil?),
+              "# frozen_string_literal: true",
+            ].compact
+          end
+
+          # @api private
+          def normalize(name)
+            inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
+          end
+
+          # @api private
+          def key_parts
+            key.split(KEY_SEPARATOR)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @api private
+        class RubyModuleFile < RubyFile
+          private
+
+          def modules
+            namespace_modules + [constant_name]
+          end
+
+          def class_name
+            nil
+          end
+
+          def parent_class_name
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,44 +19,127 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(app, slice, url, context: nil, **opts)
-            context ||= SliceContext.new(inflector, app, slice, url, **opts)
+          def call(app, slice, url, **opts)
+            skip_route = opts.fetch(:skip_route, false)
 
-            if context.generate_route?
+            unless skip_route
               fs.inject_line_at_class_bottom(
-                fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
+                fs.join("config", "routes.rb"),
+                "class Routes",
+                <<~ROUTES.chomp
+
+                  slice :#{inflector.underscore(slice)}, at: "#{url}" do
+                  end
+                ROUTES
               )
             end
 
             fs.mkdir(directory = "slices/#{slice}")
 
-            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))
-            fs.write(fs.join(directory, "templates", "layouts", "app.html.erb"), t("app_layout.erb", context))
-            fs.write(fs.join(directory, "operation.rb"), t("operation.erb", context))
-
-            if context.bundled_assets?
-              fs.write(fs.join(directory, "assets", "js", "app.js"), t("app_js.erb", context))
-              fs.write(fs.join(directory, "assets", "css", "app.css"), t("app_css.erb", context))
-              fs.write(fs.join(directory, "assets", "images", "favicon.ico"), file("favicon.ico"))
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: slice,
+              key: "action",
+              base_path: directory,
+              parent_class_name: "#{Hanami.app.namespace}::Action",
+              auto_register: false
+            ).create
+
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: slice,
+              key: "view",
+              base_path: directory,
+              parent_class_name: "#{Hanami.app.namespace}::View",
+              auto_register: false
+            ).create
+
+            RubyModuleFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: slice,
+              key: "views.helpers",
+              base_path: directory,
+              auto_register: false,
+              body: ["# Add your view helpers here"]
+            ).create
+
+            fs.create(
+              fs.join(directory, "templates", "layouts", "app.html.erb"),
+              app_layout_template(
+                page_title: "#{inflector.humanize(app)} - #{inflector.humanize(slice)}"
+              )
+            )
+
+            if Hanami.bundled?("dry-operation")
+              RubyClassFile.new(
+                fs: fs,
+                inflector: inflector,
+                namespace: slice,
+                key: "operation",
+                base_path: directory,
+                parent_class_name: "#{Hanami.app.namespace}::Operation",
+                auto_register: false
+              ).create
             end
 
-            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))
+            if Hanami.bundled?("hanami-assets")
+              fs.create(
+                fs.join(directory, "assets", "js", "app.js"),
+                %(import "../css/app.css";\n)
+              )
+              fs.create(
+                fs.join(directory, "assets", "css", "app.css"),
+                <<~CSS
+                    body {
+                      background-color: #fff;
+                      color: #000;
+                      font-family: sans-serif;
+                    }
+                CSS
+              )
+              fs.create(fs.join(directory, "assets", "images", "favicon.ico"), file("favicon.ico"))
+            end
 
-              fs.write(fs.join(directory, "db", "struct.rb"), t("struct.erb", context))
-              fs.write(fs.join(directory, "structs", ".keep"), t("keep.erb", context))
+            if Hanami.bundled?("hanami-db") && !opts.fetch(:skip_db, false)
+              RubyClassFile.new(
+                fs: fs,
+                inflector: inflector,
+                namespace: slice,
+                key: "db.relation",
+                base_path: directory,
+                parent_class_name: "#{Hanami.app.namespace}::DB::Relation",
+              ).create
+
+              RubyClassFile.new(
+                fs: fs,
+                inflector: inflector,
+                namespace: slice,
+                key: "db.repo",
+                base_path: directory,
+                parent_class_name: "#{Hanami.app.namespace}::DB::Repo",
+              ).create
+
+              RubyClassFile.new(
+                fs: fs,
+                inflector: inflector,
+                namespace: slice,
+                key: "db.struct",
+                base_path: directory,
+                parent_class_name: "#{Hanami.app.namespace}::DB::Struct",
+              ).create
+
+              fs.touch(fs.join(directory, "relations", ".keep"))
+              fs.touch(fs.join(directory, "repos", ".keep"))
+              fs.touch(fs.join(directory, "structs", ".keep"))
             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.touch(fs.join(directory, "actions/.keep"))
+            fs.touch(fs.join(directory, "views/.keep"))
+            fs.touch(fs.join(directory, "templates/.keep"))
+            fs.touch(fs.join(directory, "templates/layouts/.keep"))
           end
 
           private
@@ -65,20 +148,30 @@ module Hanami
 
           attr_reader :inflector
 
-          def template(path, context)
-            require "erb"
-
-            ERB.new(
-              File.read(__dir__ + "/slice/#{path}"),
-              trim_mode: "-"
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
-
           def file(path)
             File.read(File.join(__dir__, "slice", path))
           end
+
+          def app_layout_template(page_title:)
+            bundled_assets = Hanami.bundled?("hanami-assets")
+
+            <<~LAYOUT
+              <!DOCTYPE html>
+              <html lang="en">
+                <head>
+                  <meta charset="UTF-8">
+                  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                  <title>#{ page_title }</title>
+                  #{'<%= favicon_tag %>' if bundled_assets }
+                  #{'<%= stylesheet_tag "app" %>' if bundled_assets }
+                </head>
+                <body>
+                  <%= yield %>
+                  #{'<%= javascript_tag "app" %>' if bundled_assets}
+                </body>
+              </html>
+            LAYOUT
+          end
         end
       end
     end

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

@@ -18,16 +18,15 @@ module Hanami
           # @since 2.2.0
           # @api private
           def call(key:, namespace:, base_path:)
-            RubyFileWriter.new(
+            RubyClassFile.new(
               fs: fs,
               inflector: inflector,
-            ).call(
               key: key,
               namespace: namespace,
               base_path: base_path,
               extra_namespace: "Structs",
-              relative_parent_class: "DB::Struct",
-            )
+              parent_class_name: "#{inflector.camelize(namespace)}::DB::Struct",
+            ).create
           end
 
           private