hanami-cli 2.0.0 → 2.1.0

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
@@ -59,6 +56,14 @@ module Hanami
           }.freeze
           private_constant :ROUTE_RESTFUL_URL_SUFFIXES
 
+          # @api private
+          # @since 2.1.0
+          RESTFUL_COUNTERPART_VIEWS = {
+            "create" => "new",
+            "update" => "edit"
+          }.freeze
+          private_constant :RESTFUL_COUNTERPART_VIEWS
+
           PATH_SEPARATOR = "/"
           private_constant :PATH_SEPARATOR
 
@@ -66,7 +71,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 +85,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
+            if generate_view?(skip_view, action, directory)
+              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 +104,20 @@ module Hanami
 
             fs.mkdir(directory = fs.join("app", "actions", controller))
             fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
+
+            view = action
+            view_directory = fs.join("app", "views", controller)
+
+            if generate_view?(skip_view, view, view_directory)
+              fs.mkdir(view_directory)
+              fs.write(fs.join(view_directory, "#{view}.rb"), t("view.erb", context))
+
+              fs.mkdir(template_directory = fs.join("app", "templates", controller))
+              fs.write(fs.join(template_directory, "#{view}.#{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 +128,52 @@ 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
+          # @api private
+          # @since 2.1.0
+          def generate_view?(skip_view, view, directory)
+            return false if skip_view
+            return generate_restful_view?(view, directory) if rest_view?(view)
+
+            true
+          end
+
+          # @api private
+          # @since 2.1.0
+          def generate_restful_view?(view, directory)
+            corresponding_action = corresponding_restful_view(view)
+
+            !fs.exist?(fs.join(directory, "#{corresponding_action}.rb"))
+          end
+
+          # @api private
+          # @since 2.1.0
+          def rest_view?(view)
+            RESTFUL_COUNTERPART_VIEWS.keys.include?(view)
+          end
+
+          # @api private
+          # @since 2.1.0
+          def corresponding_restful_view(view)
+            RESTFUL_COUNTERPART_VIEWS.fetch(view, nil)
+          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/part/app_base_part.erb

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Views
+    class Part < Hanami::View::Part
+    end
+  end
+end

data/lib/hanami/cli/generators/app/part/app_part.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Views
+    module Parts
+<%= module_namespace_declaration -%>
+  <%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::Views::Part
+  <%= module_namespace_offset %>end
+<%= module_namespace_end -%>
+    end
+  end
+end

data/lib/hanami/cli/generators/app/part/slice_base_part.erb

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Views
+    class Part < <%= camelized_app_name %>::Views::Part
+    end
+  end
+end

data/lib/hanami/cli/generators/app/part/slice_part.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Views
+    module Parts
+<%= module_namespace_declaration -%>
+  <%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_slice_name %>::Views::Part
+  <%= module_namespace_offset %>end
+<%= module_namespace_end -%>
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.1.0
+        # @api private
+        class Part
+          # @since 2.1.0
+          # @api private
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          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
+          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))
+          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))
+          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)
+          end
+
+          # @since 2.1.0
+          # @api private
+          alias_method :t, :template
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "slice_context"
+require "dry/files/path"
+
+module Hanami
+  module CLI
+    module Generators
+      # @since 2.1.0
+      # @api private
+      module App
+        # @since 2.1.0
+        # @api private
+        class PartContext < SliceContext
+          # TODO: move these constants somewhere that will let us reuse them
+
+          # @since 2.1.0
+          # @api private
+          KEY_SEPARATOR = "."
+          private_constant :KEY_SEPARATOR
+
+          # @since 2.1.0
+          # @api private
+          INDENTATION = "  "
+          private_constant :INDENTATION
+
+          # @since 2.1.0
+          # @api private
+          OFFSET = INDENTATION * 2
+          private_constant :OFFSET
+
+          # @since 2.1.0
+          # @api private
+          attr_reader :key
+
+          # @since 2.1.0
+          # @api private
+          def initialize(inflector, app, slice, key)
+            @key = key
+            super(inflector, app, slice, nil)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def namespaces
+            @namespaces ||= key.split(KEY_SEPARATOR)[..-2]
+          end
+
+          # @since 2.1.0
+          # @api private
+          def name
+            @name ||= key.split(KEY_SEPARATOR)[-1]
+          end
+
+          # @since 2.1.0
+          # @api private
+          def camelized_name
+            inflector.camelize(name)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def underscored_namespace
+            namespaces.map { inflector.underscore(_1) }
+          end
+
+          # @since 2.1.0
+          # @api private
+          def underscored_name
+            inflector.underscore(name)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def module_namespace_declaration
+            namespaces.each_with_index.map { |token, i|
+              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+            }.join($/)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def module_namespace_end
+            namespaces.each_with_index.map { |_, i|
+              "#{OFFSET}#{INDENTATION * i}end"
+            }.reverse.join($/)
+          end
+
+          # @since 2.1.0
+          # @api private
+          def module_namespace_offset
+            "#{OFFSET}#{INDENTATION * namespaces.count}"
+          end
+        end
+      end
+    end
+  end
+end

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_tag %>
+    <%= 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