hanami-cli 2.2.1 → 2.3.0.beta2

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "erb"
 require "dry/files"
+require_relative "../constants"
 require_relative "../../errors"
 
 # rubocop:disable Metrics/ParameterLists
@@ -14,20 +14,25 @@ module Hanami
         class Action
           # @since 2.0.0
           # @api private
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
+            @view_generator = Generators::App::View.new(
+              fs: fs,
+              inflector: inflector,
+              out: out
+            )
           end
 
           # @since 2.0.0
           # @api private
-          def call(app, controller, action, url, http, format, skip_view, skip_route, slice, context: nil)
-            context ||= ActionContext.new(inflector, app, slice, controller, action)
-            if slice
-              generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
-            else
-              generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
-            end
+          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:, skip_tests:)
+            insert_route(key:, namespace:, url_path:, http_method:) unless skip_route
+
+            generate_action(key:, namespace:, base_path:, include_placeholder_body: skip_view)
+
+            generate_view(key:, namespace:, base_path:) unless skip_view
           end
 
           private
@@ -67,86 +72,82 @@ module Hanami
           PATH_SEPARATOR = "/"
           private_constant :PATH_SEPARATOR
 
-          attr_reader :fs
-
-          attr_reader :inflector
-
-          # rubocop:disable Metrics/AbcSize
-          def generate_for_slice(controller, action, url, http, format, skip_view, skip_route, slice, context)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
+          attr_reader :fs, :inflector, :out, :view_generator
 
-            if generate_route?(skip_route)
-              fs.inject_line_at_block_bottom(
-                fs.join("config", "routes.rb"),
-                slice_matcher(slice),
-                route(controller, action, url, http)
-              )
-            end
-
-            fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
-            fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
+          # @api private
+          # @since 2.2.2
+          def insert_route(key:, namespace:, url_path:, http_method:)
+            routes_location = fs.join("config", "routes.rb")
+            route = route_definition(key:, url_path:, http_method:)
 
-            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))
+            if namespace == Hanami.app.namespace
+              fs.inject_line_at_class_bottom(routes_location, "class Routes", route)
+            else
+              slice_routes = fs.join("slices", namespace, "config", "routes.rb")
 
-              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))
+              if fs.exist?(slice_routes)
+                fs.inject_line_at_class_bottom(slice_routes, "class Routes", route)
+              else
+                slice_matcher = /slice[[:space:]]*:#{namespace}/
+                fs.inject_line_at_block_bottom(routes_location, slice_matcher, route)
+              end
             end
           end
 
-          def generate_for_app(controller, action, url, http, format, skip_view, skip_route, context)
-            if generate_route?(skip_route)
-              fs.inject_line_at_class_bottom(
-                fs.join("config", "routes.rb"),
-                "class Routes",
-                route(controller, action, url, http)
-              )
-            end
-
-            fs.mkdir(directory = fs.join("app", "actions", controller))
-            fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
+          # @api private
+          # @since 2.2.2
+          def generate_action(key:, namespace:, base_path:, include_placeholder_body:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: namespace,
+              key: key,
+              base_path: base_path,
+              parent_class_name: "#{inflector.camelize(namespace)}::Action",
+              extra_namespace: "Actions",
+              body: [
+                "def handle(request, response)",
+                ("  response.body = self.class.name" if include_placeholder_body),
+                "end"
+              ].compact
+            ).create
+          end
 
-            view = action
-            view_directory = fs.join("app", "views", controller)
+          # @api private
+          # @since 2.2.2
+          def generate_view(key:, namespace:, base_path:)
+            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
 
-            if generate_view?(skip_view, view, view_directory)
-              fs.mkdir(view_directory)
-              fs.write(fs.join(view_directory, "#{view}.rb"), t("view.erb", context))
+            view_directory = fs.join(base_path, "views", controller_name_parts)
 
-              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))
+            if generate_view?(action_name, view_directory)
+              view_generator.call(
+                key: key,
+                namespace: namespace,
+                base_path: base_path,
+              )
             end
           end
-          # rubocop:enable Metrics/AbcSize
-
-          def slice_matcher(slice)
-            /slice[[:space:]]*:#{slice}/
-          end
-
-          def route(controller, action, url, http)
-            %(#{route_http(action,
-                           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)
+          # @since 2.2.2
+          def route_definition(key:, url_path:, http_method:)
+            *controller_name_parts, action_name = key.split(KEY_SEPARATOR)
 
-            true
+            method = route_http(action_name, http_method)
+            path = route_url(controller_name_parts, action_name, url_path)
+
+            %(#{method} "#{path}", to: "#{key}")
           end
 
           # @api private
-          # @since 2.2.0
-          def generate_route?(skip_route)
-            return false if skip_route
-
-            true
+          # @since 2.1.0
+          def generate_view?(action_name, directory)
+            if rest_view?(action_name)
+              generate_restful_view?(action_name, directory)
+            else
+              true
+            end
           end
 
           # @api private
@@ -169,40 +170,22 @@ module Hanami
             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}"), trim_mode: "-",
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
-
-          def route_url(controller, action, url)
+          # @api private
+          # @since 2.1.0
+          def route_url(controller, action, url_path)
             action = ROUTE_RESTFUL_URL_SUFFIXES.fetch(action) { [action] }
-            url ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
+            url_path ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
 
-            CLI::URL.call(url)
+            CLI::URL.call(url_path)
           end
 
-          def route_http(action, http)
-            result = (http ||= ROUTE_RESTFUL_HTTP_METHODS.fetch(action, ROUTE_DEFAULT_HTTP_METHOD)).downcase
+          # @api private
+          # @since 2.1.0
+          def route_http(action, http_method)
+            result = (http_method ||= ROUTE_RESTFUL_HTTP_METHODS.fetch(action, ROUTE_DEFAULT_HTTP_METHOD)).downcase
 
             unless ROUTE_HTTP_METHODS.include?(result)
-              raise UnknownHTTPMethodError.new(http)
+              raise UnknownHTTPMethodError.new(http_method)
             end
 
             result

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

@@ -12,49 +12,27 @@ module Hanami
         class Component
           # @api private
           # @since 2.2.0
-          def initialize(fs:, inflector:)
+          def initialize(fs:, inflector:, out: $stdout)
             @fs = fs
             @inflector = inflector
+            @out = out
           end
 
           # @api private
           # @since 2.2.0
-          def call(app, key, slice)
-            context = ComponentContext.new(inflector, app, slice, key)
-
-            if slice
-              generate_for_slice(context, slice)
-            else
-              generate_for_app(context)
-            end
+          def call(key:, namespace:, base_path:)
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              key: key,
+              namespace: namespace,
+              base_path: base_path,
+            ).create
           end
 
           private
 
-          attr_reader :fs
-
-          attr_reader :inflector
-
-          def generate_for_slice(context, slice)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
-
-            fs.mkdir(directory = fs.join(slice_directory, context.namespaces))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("slice_component.erb", context))
-          end
-
-          def generate_for_app(context)
-            fs.mkdir(directory = fs.join("app", context.namespaces))
-            fs.write(fs.join(directory, "#{context.underscored_name}.rb"), t("component.erb", context))
-          end
-
-          def template(path, context)
-            ERB.new(
-              File.read(__dir__ + "/component/#{path}")
-            ).result(context.ctx)
-          end
-
-          alias_method :t, :template
+          attr_reader :fs, :inflector, :out
         end
       end
     end

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

@@ -20,22 +20,21 @@ module Hanami
           # @since 2.2.0
           # @api private
           def call(key:, namespace:, base_path:, gateway:)
-            schema_name = key.split(KEY_SEPARATOR).last
+            schema_name = inflector.underscore(key.split(KEY_SEPARATOR).last)
             body_content = ["schema :#{schema_name}, infer: true"]
 
             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,123 @@
+# 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_segments = key.split(KEY_SEPARATOR).map { |segment| inflector.underscore(segment) }
+            @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_segments].join("/"),
+            )
+          end
+
+          # @api private
+          def path
+            fs.join(directory, "#{key_segments.last}.rb")
+          end
+
+          private
+
+          # @api private
+          attr_reader(
+            :fs,
+            :inflector,
+            :key_segments,
+            :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_segments[..-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_segments.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
+        end
+      end
+    end
+  end
+end