hanami-cli 2.0.3 → 2.1.0.beta2

data/lib/hanami/cli/commands/app.rb

@@ -14,14 +14,23 @@ module Hanami
           base.module_eval do
             register "version", Commands::App::Version, aliases: ["v", "-v", "--version"]
             register "install", Commands::App::Install
+            register "dev", Commands::App::Dev
             register "console", Commands::App::Console, aliases: ["c"]
             register "server", Commands::App::Server, aliases: ["s"]
             register "routes", Commands::App::Routes
             register "middleware", Commands::App::Middleware
 
+            if Hanami.bundled?("hanami-assets")
+              register "assets" do |prefix|
+                prefix.register "compile", Assets::Compile
+                prefix.register "watch", Assets::Watch
+              end
+            end
+
             register "generate", aliases: ["g"] do |prefix|
               prefix.register "slice", Generate::Slice
               prefix.register "action", Generate::Action
+              prefix.register "view", Generate::View
             end
           end
         end

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

@@ -10,21 +10,53 @@ module Hanami
         # @since 2.0.0
         # @api private
         class New < Command
+          # @since 2.0.0
+          # @api private
           SKIP_INSTALL_DEFAULT = false
           private_constant :SKIP_INSTALL_DEFAULT
 
+          # @since 2.1.0
+          # @api private
+          HEAD_DEFAULT = false
+          private_constant :HEAD_DEFAULT
+
+          # @since 2.1.0
+          # @api private
+          SKIP_ASSETS_DEFAULT = false
+          private_constant :SKIP_ASSETS_DEFAULT
+
           desc "Generate a new Hanami app"
 
+          # @since 2.0.0
+          # @api private
           argument :app, required: true, desc: "App name"
 
+          # @since 2.0.0
+          # @api private
           option :skip_install, type: :boolean, required: false,
                                 default: SKIP_INSTALL_DEFAULT,
                                 desc: "Skip app installation (Bundler, third-party Hanami plugins)"
 
+          # @since 2.1.0
+          # @api private
+          option :head, type: :boolean, required: false,
+                        default: HEAD_DEFAULT,
+                        desc: "Use Hanami HEAD version (from GitHub `main` branches)"
+
+          # @since 2.1.0
+          # @api private
+          option :skip_assets, type: :boolean, required: false,
+                               default: SKIP_ASSETS_DEFAULT,
+                               desc: "Skip assets"
+
+          # rubocop:disable Layout/LineLength
           example [
-            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace", # rubocop:disable Layout/LineLength
-            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation"
+            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace",
+            "bookshelf --head         # Generate a new Hanami app, using Hanami HEAD version from GitHub `main' branches",
+            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation",
+            "bookshelf --skip-assets  # Generate a new Hanami app without assets"
           ]
+          # rubocop:enable Layout/LineLength
 
           # @since 2.0.0
           # @api private
@@ -42,21 +74,22 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(app:, skip_install: SKIP_INSTALL_DEFAULT, **)
+          def call(app:, head: HEAD_DEFAULT, skip_install: SKIP_INSTALL_DEFAULT, skip_assets: SKIP_ASSETS_DEFAULT, **)
             app = inflector.underscore(app)
 
             raise PathAlreadyExistsError.new(app) if fs.exist?(app)
 
             fs.mkdir(app)
             fs.chdir(app) do
-              generator.call(app) do
+              context = Generators::Context.new(inflector, app, head: head, skip_assets: skip_assets)
+              generator.call(app, context: context) do
                 if skip_install
                   out.puts "Skipping installation, please enter `#{app}' directory and run `bundle exec hanami install'"
                 else
                   out.puts "Running Bundler install..."
                   bundler.install!
                   out.puts "Running Hanami install..."
-                  run_install_commmand!
+                  run_install_commmand!(head: head)
                 end
               end
             end
@@ -67,8 +100,9 @@ module Hanami
           attr_reader :bundler
           attr_reader :generator
 
-          def run_install_commmand!
-            bundler.exec("hanami install").tap do |result|
+          def run_install_commmand!(head:)
+            head_flag = head ? " --head" : ""
+            bundler.exec("hanami install#{head_flag}").tap do |result|
               raise HanamiInstallError.new(result.err) unless result.successful?
             end
           end

data/lib/hanami/cli/errors.rb

@@ -2,60 +2,90 @@
 
 module Hanami
   module CLI
+    # @since 0.1.0
+    # @api public
     class Error < StandardError
     end
 
+    # @since 2.0.0
+    # @api public
     class NotImplementedError < Error
     end
 
+    # @since 2.0.0
+    # @api public
     class BundleInstallError < Error
       def initialize(message)
         super("`bundle install' failed\n\n\n#{message.inspect}")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class HanamiInstallError < Error
       def initialize(message)
         super("`hanami install' failed\n\n\n#{message.inspect}")
       end
     end
 
+    # @since 2.1.0
+    # @api public
+    class HanamiExecError < Error
+      def initialize(cmd, message)
+        super("`bundle exec hanami #{cmd}' failed\n\n\n#{message.inspect}")
+      end
+    end
+
+    # @since 2.0.0
+    # @api public
     class PathAlreadyExistsError < Error
       def initialize(path)
         super("Cannot create new Hanami app in an existing path: `#{path}'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class MissingSliceError < Error
       def initialize(slice)
         super("slice `#{slice}' is missing, please generate with `hanami generate slice #{slice}'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class InvalidURLError < Error
       def initialize(url)
         super("invalid URL: `#{url}'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class InvalidURLPrefixError < Error
       def initialize(url)
         super("invalid URL prefix: `#{url}'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class InvalidActionNameError < Error
       def initialize(name)
         super("cannot parse controller and action name: `#{name}'\n\texample: `hanami generate action users.show'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class UnknownHTTPMethodError < Error
       def initialize(name)
         super("unknown HTTP method: `#{name}'")
       end
     end
 
+    # @since 2.0.0
+    # @api public
     class UnsupportedDatabaseSchemeError < Error
       def initialize(scheme)
         super("`#{scheme}' is not a supported db scheme")

data/lib/hanami/cli/files.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "dry/files"
+
 module Hanami
   module CLI
     # @since 2.0.0
@@ -29,7 +31,7 @@ module Hanami
       def mkdir(path)
         unless exist?(path)
           super
-          created("#{path}/")
+          created(_path(path))
         end
       end
 
@@ -53,7 +55,11 @@ module Hanami
       end
 
       def within_folder(path)
-        out.puts "-> Within #{path}/"
+        out.puts "-> Within #{_path(path)}"
+      end
+
+      def _path(path)
+        path + ::File::SEPARATOR
       end
     end
   end

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

@@ -4,8 +4,12 @@ module <%= camelized_app_name %>
   module Actions
 <%= module_controller_declaration %>
 <%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_app_name %>::Action
-<%= module_controller_offset %>  def handle(*, response)
+<%- if bundled_views? -%>
+<%= module_controller_offset %>  def handle(request, response)
+<%- else -%>
+<%= module_controller_offset %>  def handle(request, response)
 <%= module_controller_offset %>    response.body = self.class.name
+<%- end -%>
 <%= module_controller_offset %>  end
 <%= module_controller_offset %>end
 <%= module_controller_end %>

data/lib/hanami/cli/generators/app/action/slice_action.erb

@@ -4,8 +4,12 @@ module <%= camelized_slice_name %>
   module Actions
 <%= module_controller_declaration %>
 <%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_slice_name %>::Action
-<%= module_controller_offset %>  def handle(*, response)
+<%- if bundled_views?  -%>
+<%= module_controller_offset %>  def handle(request, response)
+<%- else -%>
+<%= module_controller_offset %>  def handle(request, response)
 <%= module_controller_offset %>    response.body = self.class.name
+<%- end -%>
 <%= module_controller_offset %>  end
 <%= module_controller_offset %>end
 <%= module_controller_end %>

data/lib/hanami/cli/generators/app/action/slice_template.html.erb

@@ -0,0 +1 @@
+<h1><%= camelized_slice_name %>::Views::<%= camelized_controller_name %>::<%= camelized_action_name %></h1>

data/lib/hanami/cli/generators/app/action/slice_view.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Views
+<%= module_controller_declaration %>
+<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_slice_name %>::View
+<%= module_controller_offset %>end
+<%= module_controller_end %>
+  end
+end

data/lib/hanami/cli/generators/app/action/template.html.erb

@@ -1,2 +1 @@
-<h1><%= camelized_slice_name %>::Views::<%= camelized_controller_name %>::<%= camelized_action_name %></h1>
-<h2><%= template_path %></h2>
+<h1><%= camelized_app_name %>::Views::<%= camelized_controller_name %>::<%= camelized_action_name %></h1>

data/lib/hanami/cli/generators/app/action/view.erb

@@ -1,12 +1,9 @@
-# auto_register: false
 # frozen_string_literal: true
 
-require "<%= underscored_slice_name %>/view"
-
-module <%= camelized_slice_name %>
+module <%= camelized_app_name %>
   module Views
 <%= module_controller_declaration %>
-<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_slice_name %>::View
+<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_app_name %>::View
 <%= module_controller_offset %>end
 <%= module_controller_end %>
   end

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

@@ -19,11 +19,10 @@ module Hanami
             @inflector = inflector
           end
 
-          # rubocop:disable Layout/LineLength
-
           # @since 2.0.0
           # @api private
-          def call(app, controller, action, url, http, format, skip_view, slice, context: ActionContext.new(inflector, app, slice, controller, action))
+          def call(app, controller, action, url, http, format, skip_view, slice, context: nil)
+            context ||= ActionContext.new(inflector, app, slice, controller, action)
             if slice
               generate_for_slice(controller, action, url, http, format, skip_view, slice, context)
             else
@@ -31,8 +30,6 @@ module Hanami
             end
           end
 
-          # rubocop:enable Layout/LineLength
-
           private
 
           ROUTE_HTTP_METHODS = %w[get post delete put patch trace options link unlink].freeze
@@ -66,7 +63,8 @@ module Hanami
 
           attr_reader :inflector
 
-          def generate_for_slice(controller, action, url, http, _format, _skip_view, slice, context)
+          # rubocop:disable Metrics/AbcSize
+          def generate_for_slice(controller, action, url, http, format, skip_view, slice, context)
             slice_directory = fs.join("slices", slice)
             raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
 
@@ -79,16 +77,17 @@ module Hanami
             fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
             fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
 
-            # unless skip_view
-            #   fs.mkdir(directory = fs.join(slice_directory, "views", controller))
-            #   fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
-            #
-            #   fs.mkdir(directory = fs.join(slice_directory, "templates", controller))
-            #   fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
-            # end
+            unless skip_view
+              fs.mkdir(directory = fs.join(slice_directory, "views", controller))
+              fs.write(fs.join(directory, "#{action}.rb"), t("slice_view.erb", context))
+
+              fs.mkdir(directory = fs.join(slice_directory, "templates", controller))
+              fs.write(fs.join(directory, "#{action}.#{format}.erb"),
+                       t(template_with_format_ext("slice_template", format), context))
+            end
           end
 
-          def generate_for_app(controller, action, url, http, _format, _skip_view, context)
+          def generate_for_app(controller, action, url, http, format, skip_view, context)
             fs.inject_line_at_class_bottom(
               fs.join("config", "routes.rb"),
               "class Routes",
@@ -97,7 +96,17 @@ module Hanami
 
             fs.mkdir(directory = fs.join("app", "actions", controller))
             fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
+
+            unless skip_view
+              fs.mkdir(directory = fs.join("app", "views", controller))
+              fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
+
+              fs.mkdir(directory = fs.join("app", "templates", controller))
+              fs.write(fs.join(directory, "#{action}.#{format}.erb"),
+                       t(template_with_format_ext("template", format), context))
+            end
           end
+          # rubocop:enable Metrics/AbcSize
 
           def slice_matcher(slice)
             /slice[[:space:]]*:#{slice}/
@@ -108,20 +117,23 @@ module Hanami
                            http)} "#{route_url(controller, action, url)}", to: "#{controller.join('.')}.#{action}")
           end
 
-          def template_format(format)
-            case format.to_sym
-            when :html
-              "template.html.erb"
-            else
-              "template.erb"
-            end
+          def template_with_format_ext(name, format)
+            ext =
+              case format.to_sym
+              when :html
+                ".html.erb"
+              else
+                ".erb"
+              end
+
+            "#{name}#{ext}"
           end
 
           def template(path, context)
             require "erb"
 
             ERB.new(
-              File.read(__dir__ + "/action/#{path}")
+              File.read(__dir__ + "/action/#{path}"), trim_mode: "-",
             ).result(context.ctx)
           end
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "./slice_context"
+require_relative "slice_context"
 require "dry/files/path"
 
 module Hanami

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

@@ -0,0 +1,5 @@
+body {
+  background-color: #fff;
+  color: #000;
+  font-family: sans-serif;
+}

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

@@ -0,0 +1 @@
+import "../css/app.css";

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

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><%= humanized_app_name %> - <%= humanized_slice_name %></title>
+    <%- if bundled_assets? -%>
+    <%%= favicon %>
+    <%= stylesheet_erb_tag %>
+    <%- end -%>
+  </head>
+  <body>
+    <%%= yield %>
+    <%- if bundled_assets? -%>
+    <%= javascript_erb_tag %>
+    <%- end -%>
+  </body>
+</html>

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

@@ -0,0 +1,10 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Views
+    module Helpers
+      # Add your view helpers here
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 # auto_register: false
 # frozen_string_literal: true
 
-require "<%= underscored_app_name %>/view"
-
 module <%= camelized_slice_name %>
   class View < <%= camelized_app_name %>::View
   end

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

@@ -19,7 +19,7 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url))
+          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url)) # rubocop:disable Metrics/AbcSize
             fs.inject_line_at_class_bottom(
               fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
             )
@@ -28,14 +28,22 @@ module Hanami
 
             # 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, "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))
+
+            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))
+            end
+
             # fs.write(fs.join(directory, "/entities.rb"), t("entities.erb", context))
             # fs.write(fs.join(directory, "/repository.rb"), t("repository.erb", context))
 
             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, "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
@@ -50,7 +58,8 @@ module Hanami
             require "erb"
 
             ERB.new(
-              File.read(__dir__ + "/slice/#{path}")
+              File.read(__dir__ + "/slice/#{path}"),
+              trim_mode: "-"
             ).result(context.ctx)
           end
 

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

@@ -29,6 +29,24 @@ module Hanami
             inflector.underscore(slice)
           end
 
+          # @since 2.1.0
+          # @api private
+          def humanized_slice_name
+            inflector.humanize(slice)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def stylesheet_erb_tag
+            %(<%= css "#{slice}/app" %>)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def javascript_erb_tag
+            %(<%= js "#{slice}/app" %>)
+          end
+
           private
 
           attr_reader :slice

data/lib/hanami/cli/generators/app/view/app_template.html.erb

@@ -0,0 +1 @@
+<h1><%= camelized_app_name %>::Views::<%= camelized_namespace %>::<%= camelized_name %></h1>

data/lib/hanami/cli/generators/app/view/app_view.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Views
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::View
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+  end
+end

data/lib/hanami/cli/generators/app/view/slice_template.html.erb

@@ -0,0 +1 @@
+<h1><%= camelized_slice_name %>::Views::<%= camelized_namespace %>::<%= camelized_name %></h1>

data/lib/hanami/cli/generators/app/view/slice_view.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Views
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_slice_name %>::View
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.0.0
+        # @api private
+        class View
+          # @since 2.0.0
+          # @api private
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          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)
+            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))
+          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))
+          end
+
+          # rubocop:enable Metrics/AbcSize
+
+          def template_with_format_ext(name, format)
+            ext =
+              case format.to_sym
+              when :html
+                ".html.erb"
+              else
+                ".erb"
+              end
+
+            "#{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
+  end
+end