hanami-cli 2.1.0.beta1 → 2.1.0.rc1

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.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
 
@@ -80,7 +85,7 @@ 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
+            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))
 
@@ -100,12 +105,15 @@ 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))
+            view = action
+            view_directory = fs.join("app", "views", controller)
 
-              fs.mkdir(directory = fs.join("app", "templates", controller))
-              fs.write(fs.join(directory, "#{action}.#{format}.erb"),
+            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
@@ -120,6 +128,35 @@ module Hanami
                            http)} "#{route_url(controller, action, url)}", to: "#{controller.join('.')}.#{action}")
           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
@@ -136,7 +173,7 @@ module Hanami
             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/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 %>
+    <%= stylesheet_erb_tag %>
+    <%- end -%>
+  </head>
+  <body>
+    <%%= yield %>
+    <%- if bundled_assets? -%>
+    <%= javascript_erb_tag %>
+    <%- end -%>
+  </body>
+</html>

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

@@ -30,8 +30,13 @@ module Hanami
             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"),
-                     File.read(File.join(__dir__, "slice", "layouts_app.html.erb")))
+            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))
 
@@ -53,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