hanami-cli 2.2.0 → 2.3.0.beta1

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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "erb"
 require "dry/files"
+require_relative "../constants"
 require_relative "../../errors"
 
 module Hanami
@@ -11,57 +11,62 @@ module Hanami
         # @since 2.0.0
         # @api private
         class View
+          DEFAULT_FORMAT = "html"
+          private_constant :DEFAULT_FORMAT
+
+          TEMPLATES_FOLDER = "templates"
+          private_constant :TEMPLATES_FOLDER
+
           # @since 2.0.0
           # @api private
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
           end
 
           # @since 2.0.0
           # @api private
-          def call(app, key, format, slice)
-            context = ViewContext.new(inflector, app, slice, key)
-
-            if slice
-              generate_for_slice(context, format, slice)
-            else
-              generate_for_app(context, format, slice)
+          def call(key:, namespace:, base_path:)
+            view_class_file(key:, namespace:, base_path:).then do |view_class|
+              view_class.create
+              view_class_name = view_class.fully_qualified_name
+              create_template_file(key:, base_path:, view_class_name:)
             end
           end
 
           private
 
-          attr_reader :fs
-
-          attr_reader :inflector
-
-          # rubocop:disable Metrics/AbcSize
-
-          def generate_for_slice(context, format, slice)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-
-            fs.mkdir(directory = fs.join(slice_directory, "views", context.namespaces))
-            fs.write(fs.join(directory, "#{context.name}.rb"), t("slice_view.erb", context))
-
-            fs.mkdir(directory = fs.join(slice_directory, "templates", context.namespaces))
-            fs.write(fs.join(directory, "#{context.name}.#{format}.erb"),
-                     t(template_with_format_ext("slice_template", format), context))
+          attr_reader :fs, :inflector, :out
+
+          def view_class_file(key:, namespace:, base_path:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: namespace,
+              key: inflector.underscore(key),
+              base_path: base_path,
+              parent_class_name: "#{inflector.camelize(namespace)}::View",
+              extra_namespace: "Views",
+            )
           end
 
-          def generate_for_app(context, format, _slice)
-            fs.mkdir(directory = fs.join("app", "views", context.namespaces))
-            fs.write(fs.join(directory, "#{context.name}.rb"), t("app_view.erb", context))
-
-            fs.mkdir(directory = fs.join("app", "templates", context.namespaces))
-            fs.write(fs.join(directory, "#{context.name}.#{format}.erb"),
-                     t(template_with_format_ext("app_template", format), context))
+          def create_template_file(key:, base_path:, view_class_name:)
+            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
+
+            file_path = fs.join(
+              base_path,
+              TEMPLATES_FOLDER,
+              module_names_from_key,
+              template_file_name(class_name_from_key, DEFAULT_FORMAT),
+            )
+            body = "<h1>#{view_class_name}</h1>\n"
+            fs.create(file_path, body)
           end
 
-          # rubocop:enable Metrics/AbcSize
-
-          def template_with_format_ext(name, format)
+          def template_file_name(name, format)
             ext =
               case format.to_sym
               when :html
@@ -72,16 +77,6 @@ module Hanami
 
             "#{name}#{ext}"
           end
-
-          def template(path, context)
-            require "erb"
-
-            ERB.new(
-              File.read(__dir__ + "/view/#{path}")
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
         end
       end
     end

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

@@ -86,6 +86,12 @@ module Hanami
           !options.fetch(:skip_db, false)
         end
 
+        # @since 2.2.0
+        # @api private
+        def generate_view?
+          !options.fetch(:skip_view, false)
+        end
+
         # @since 2.2.0
         # @api private
         def generate_sqlite?

data/lib/hanami/cli/generators/gem/app/assets.js

@@ -1,16 +1,17 @@
 import * as assets from "hanami-assets";
 
-await assets.run();
-
-// To provide additional esbuild (https://esbuild.github.io) options, use the following:
-//
-// Read more at: https://guides.hanamirb.org/assets/customization/
-//
-// await assets.run({
-//   esbuildOptionsFn: (args, esbuildOptions) => {
-//     // Add to esbuildOptions here. Use `args.watch` as a condition for different options for
-//     // compile vs watch.
+// Assets are managed by esbuild (https://esbuild.github.io), and can be
+// customized below.
 //
-//     return esbuildOptions;
-//   }
-// });
+// Learn more at https://guides.hanamirb.org/assets/customization/.
+
+await assets.run({
+  esbuildOptionsFn: (args, esbuildOptions) => {
+    // Customize your `esbuildOptions` here.
+    //
+    // Use the `args.watch` boolean as a condition to apply diffierent options
+    // when running `hanami assets watch` vs `hanami assets compile`.
+
+    return esbuildOptions;
+  },
+});

data/lib/hanami/cli/generators/gem/app/dev

@@ -5,4 +5,4 @@ if ! gem list foreman -i --silent; then
   gem install foreman
 fi
 
-exec foreman start -f Procfile.dev "$@"
+exec foreman start -f Procfile.dev --env=/dev/null "$@"

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

@@ -3,6 +3,9 @@
 source "https://rubygems.org"
 
 <%= hanami_gem("hanami") %>
+<%- if hanami_head? -%>
+<%= hanami_gem("cli") %>
+<%- end -%>
 <%- if generate_assets? -%>
 <%= hanami_gem("assets") %>
 <%- end -%>
@@ -12,7 +15,9 @@ source "https://rubygems.org"
 <%- end -%>
 <%= hanami_gem("router") %>
 <%= hanami_gem("validations") %>
+<%- if generate_view? -%>
 <%= hanami_gem("view") %>
+<%- end -%>
 
 gem "dry-types", "~> 1.7"
 gem "dry-operation"

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

@@ -1,7 +1,9 @@
 .env*.local
 log/*
 <%- if generate_assets? -%>
-public/
+public/*
+!public/404.html
+!public/500.html
 node_modules/
 <%- end -%>
 <%- if generate_sqlite? -%>

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

@@ -1,3 +1,6 @@
 # frozen_string_literal: true
 
 require "hanami/rake_tasks"
+
+# Add your custom rake tasks to the lib/tasks directory
+Rake.add_rakelib "lib/tasks"

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

@@ -1 +1,15 @@
 # <%= camelized_app_name %>
+
+Welcome to your Hanami app!
+
+## Getting Started
+
+- Run the server with `bin/dev`
+- View the app at [http://localhost:2300](http://localhost:2300)
+- Run the tests with `bundle exec rake`
+
+## Useful Links
+
+- [Hanami Home](http://hanamirb.org)
+- [Hanami Guides](https://guides.hanamirb.org/)
+- [Hanami API Doc](https://gemdocs.org/gems/hanami/latest)

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

@@ -34,62 +34,65 @@ module Hanami
           attr_reader :inflector
 
           def generate_app(app, context) # rubocop:disable Metrics/AbcSize
-            fs.write(".gitignore", t("gitignore.erb", context))
-            fs.write(".env", t("env.erb", context))
+            fs.create(".gitignore", t("gitignore.erb", context))
+            fs.create(".env", t("env.erb", context))
 
-            fs.write("README.md", t("readme.erb", context))
-            fs.write("Gemfile", t("gemfile.erb", context))
-            fs.write("Rakefile", t("rakefile.erb", context))
-            fs.write("Procfile.dev", t("procfile.erb", context))
-            fs.write("config.ru", t("config_ru.erb", context))
+            fs.create("README.md", t("readme.erb", context))
+            fs.create("Gemfile", t("gemfile.erb", context))
+            fs.create("Rakefile", t("rakefile.erb", context))
+            fs.create("Procfile.dev", t("procfile.erb", context))
+            fs.create("config.ru", t("config_ru.erb", context))
 
-            fs.write("bin/dev", file("dev"))
+            fs.create("bin/dev", file("dev"))
             fs.chmod("bin/dev", 0o755)
 
-            fs.write("config/app.rb", t("app.erb", context))
-            fs.write("config/settings.rb", t("settings.erb", context))
-            fs.write("config/routes.rb", t("routes.erb", context))
-            fs.write("config/puma.rb", t("puma.erb", context))
+            fs.create("config/app.rb", t("app.erb", context))
+            fs.create("config/settings.rb", t("settings.erb", context))
+            fs.create("config/routes.rb", t("routes.erb", context))
+            fs.create("config/puma.rb", t("puma.erb", context))
 
-            fs.write("lib/tasks/.keep", t("keep.erb", context))
-            fs.write("lib/#{app}/types.rb", t("types.erb", context))
+            fs.create("lib/tasks/.keep", t("keep.erb", context))
+            fs.create("lib/#{app}/types.rb", t("types.erb", context))
 
-            fs.write("app/actions/.keep", t("keep.erb", context))
-            fs.write("app/action.rb", t("action.erb", context))
-            fs.write("app/view.rb", t("view.erb", context))
-            fs.write("app/views/helpers.rb", t("helpers.erb", context))
-            fs.write("app/templates/layouts/app.html.erb", t("app_layout.erb", context))
+            fs.create("app/actions/.keep", t("keep.erb", context))
+            fs.create("app/action.rb", t("action.erb", context))
+
+            if context.generate_view?
+              fs.create("app/view.rb", t("view.erb", context))
+              fs.create("app/views/helpers.rb", t("helpers.erb", context))
+              fs.create("app/templates/layouts/app.html.erb", t("app_layout.erb", context))
+
+              fs.create("public/404.html", file("404.html"))
+              fs.create("public/500.html", file("500.html"))
+            end
 
             if context.generate_assets?
-              fs.write("package.json", t("package.json.erb", context))
-              fs.write("config/assets.js", file("assets.js"))
-              fs.write("app/assets/js/app.js", t("app_js.erb", context))
-              fs.write("app/assets/css/app.css", t("app_css.erb", context))
-              fs.write("app/assets/images/favicon.ico", file("favicon.ico"))
+              fs.create("package.json", t("package.json.erb", context))
+              fs.create("config/assets.js", file("assets.js"))
+              fs.create("app/assets/js/app.js", t("app_js.erb", context))
+              fs.create("app/assets/css/app.css", t("app_css.erb", context))
+              fs.create("app/assets/images/favicon.ico", file("favicon.ico"))
             end
 
             if context.generate_db?
-              fs.write("app/db/relation.rb", t("relation.erb", context))
-              fs.write("app/relations/.keep", t("keep.erb", context))
+              fs.create("app/db/relation.rb", t("relation.erb", context))
+              fs.create("app/relations/.keep", t("keep.erb", context))
 
-              fs.write("app/db/repo.rb", t("repo.erb", context))
-              fs.write("app/repos/.keep", t("keep.erb", context))
+              fs.create("app/db/repo.rb", t("repo.erb", context))
+              fs.create("app/repos/.keep", t("keep.erb", context))
 
-              fs.write("app/db/struct.rb", t("struct.erb", context))
-              fs.write("app/structs/.keep", t("keep.erb", context))
+              fs.create("app/db/struct.rb", t("struct.erb", context))
+              fs.create("app/structs/.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))
+              fs.create("config/db/seeds.rb", t("seeds.erb", context))
+              fs.create("config/db/migrate/.keep", t("keep.erb", context))
 
               if context.generate_sqlite?
-                fs.write("db/.keep", t("keep.erb", context))
+                fs.create("db/.keep", t("keep.erb", context))
               end
             end
 
-            fs.write("app/operation.rb", t("operation.erb", context))
-
-            fs.write("public/404.html", file("404.html"))
-            fs.write("public/500.html", file("500.html"))
+            fs.create("app/operation.rb", t("operation.erb", context))
           end
 
           def template(path, context)

data/lib/hanami/cli/ruby_file_generator.rb

@@ -26,7 +26,7 @@ module Hanami
       INDENT = "  "
 
       def self.class(class_name, **args)
-        new(class_name: class_name, **args).to_s
+        new(class_name: class_name, **args).call
       end
 
       def self.module(*names, **args)
@@ -36,24 +36,33 @@ module Hanami
                          names
                        end
 
-        new(modules: module_names, class_name: nil, parent_class: nil, **args).to_s
+        new(
+          modules: module_names,
+          class_name: nil,
+          parent_class_name: nil,
+          **args,
+        ).call
       end
 
       def initialize(
         class_name: nil,
-        parent_class: nil,
+        parent_class_name: nil,
         modules: [],
         header: [],
         body: []
       )
         @class_name = class_name
-        @parent_class = parent_class
+        @parent_class_name = parent_class_name
         @modules = modules
         @header = header.any? ? (header + [""]) : []
         @body = body
+
+        if parent_class_name && !class_name
+          raise ArgumentError, "class_name is required when parent_class_name is specified"
+        end
       end
 
-      def to_s
+      def call
         definition = lines(modules).map { |line| "#{line}\n" }.join
         source_code = [header, definition].flatten.join("\n")
         ensure_parseable!(source_code)
@@ -64,7 +73,7 @@ module Hanami
 
       attr_reader(
         :class_name,
-        :parent_class,
+        :parent_class_name,
         :modules,
         :header,
         :body
@@ -98,8 +107,8 @@ module Hanami
       end
 
       def class_definition
-        if parent_class
-          "class #{class_name} < #{parent_class}"
+        if parent_class_name
+          "class #{class_name} < #{parent_class_name}"
         else
           "class #{class_name}"
         end