Add Hanami::CLI::RubyFileGenerator, convert Operation to use it instead of ERB

lib/hanami/cli/command.rb

@@ -27,7 +27,7 @@ def self.new(
         inflector: Dry::Inflector.new,
         **opts
       )
-        super(out: out, err: err, fs: fs, inflector: inflector, **opts)
+        super
       end
 
       # Returns a new command.

lib/hanami/cli/commands/app/generate/command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/files"
+require "shellwords"
+require_relative "../../../naming"
+require_relative "../../../errors"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        module Generate
+          # @since 2.2.0
+          # @api private
+          class Command < App::Command
+            argument :name, required: true, desc: "Name"
+            option :slice, required: false, desc: "Slice name"
+
+            attr_reader :generator
+            private :generator
+
+            # @since 2.2.0
+            # @api private
+            def initialize(
+              fs:,
+              inflector:,
+              generator_class: nil,
+              **opts
+            )
+              raise "Provide a generator class (that takes fs and inflector)" if generator_class.nil?
+
+              super(fs: fs, inflector: inflector, **opts)
+              @generator = generator_class.new(fs: fs, inflector: inflector, out: out)
+            end
+
+            # @since 2.2.0
+            # @api private
+            def call(name:, slice: nil, **)
+              normalized_slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
+              generator.call(app.namespace, name, normalized_slice)
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/hanami/cli/commands/app/generate/operation.rb

@@ -13,34 +13,16 @@ module App
         module Generate
           # @since 2.2.0
           # @api private
-          class Operation < App::Command
-            argument :name, required: true, desc: "Operation name"
-            option :slice, required: false, desc: "Slice name"
-
+          class Operation < Generate::Command
             example [
               %(books.add               (MyApp::Books::Add)),
               %(books.add --slice=admin (Admin::Books::Add)),
             ]
-            attr_reader :generator
-            private :generator
-
-            # @since 2.2.0
-            # @api private
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::Operation.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              super(fs: fs, inflector: inflector, **opts)
-              @generator = generator
-            end
 
             # @since 2.2.0
             # @api private
-            def call(name:, slice: nil, **)
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-
-              generator.call(app.namespace, name, slice)
+            def initialize(**opts)
+              super(generator_class: Generators::App::Operation, **opts)
             end
           end
         end

lib/hanami/cli/commands/app/generate/slice.rb

@@ -12,7 +12,7 @@ module App
         module Generate
           # @since 2.0.0
           # @api private
-          class Slice < Command
+          class Slice < App::Command
             argument :name, required: true, desc: "The slice name"
             option :url, required: false, type: :string, desc: "The slice URL prefix"
 

lib/hanami/cli/generators/app/operation.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "dry/files"
+require_relative "../constants"
 require_relative "../../errors"
 
 module Hanami
@@ -21,54 +22,80 @@ def initialize(fs:, inflector:, out: $stdout)
 
           # @since 2.2.0
           # @api private
-          def call(app, key, slice)
-            context = OperationContext.new(inflector, app, slice, key)
+          def call(app_namespace, key, slice)
+            operation_name = key.split(KEY_SEPARATOR)[-1]
+            local_namespaces = key.split(KEY_SEPARATOR)[..-2]
+            container_namespace = slice || app_namespace
 
-            if slice
-              generate_for_slice(context, slice)
-            else
-              generate_for_app(context)
-            end
+            raise_missing_slice_error_if_missing(slice) if slice
+            print_namespace_recommendation(operation_name) if local_namespaces.none?
+
+            directory = directory(slice, local_namespaces: local_namespaces)
+            path = fs.join(directory, "#{operation_name}.rb")
+            fs.mkdir(directory)
+
+            file_contents = class_definition(
+              operation_name: operation_name,
+              container_namespace: container_namespace,
+              local_namespaces: local_namespaces,
+            )
+            fs.write(path, file_contents)
           end
 
           private
 
           attr_reader :fs, :inflector, :out
 
-          def generate_for_slice(context, slice)
-            slice_directory = fs.join("slices", slice)
-            raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
+          def directory(slice = nil, local_namespaces:)
+            base = if slice
+                     fs.join("slices", slice)
+                   else
+                     fs.join("app")
+                   end
 
-            if context.namespaces.any?
-              fs.mkdir(directory = fs.join(slice_directory, context.namespaces))
-              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_slice_operation.erb", context))
+            if local_namespaces.any?
+              fs.join(base, local_namespaces)
             else
-              fs.mkdir(directory = fs.join(slice_directory))
-              fs.write(fs.join(directory, "#{context.name}.rb"), t("top_level_slice_operation.erb", context))
-              out.puts("  Note: We generated a top-level operation. To generate into a directory, add a namespace: `my_namespace.#{context.name}`")
+              fs.join(base)
             end
           end
 
-          def generate_for_app(context)
-            if context.namespaces.any?
-              fs.mkdir(directory = fs.join("app", context.namespaces))
-              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_app_operation.erb", context))
-            else
-              fs.mkdir(directory = fs.join("app"))
-              out.puts("  Note: We generated a top-level operation. To generate into a directory, add a namespace: `my_namespace.#{context.name}`")
-              fs.write(fs.join(directory, "#{context.name}.rb"), t("top_level_app_operation.erb", context))
-            end
+          def class_definition(operation_name:, container_namespace:, local_namespaces:)
+            container_module = normalize(container_namespace)
+
+            modules = local_namespaces
+              .map { normalize(_1) }
+              .compact
+              .prepend(container_module)
+
+            parent_class = [container_module, "Operation"].join("::")
+
+            RubyFileGenerator.class(
+              normalize(operation_name),
+              parent_class: parent_class,
+              modules: modules,
+              body: ["def call", "end"],
+              header: ["# frozen_string_literal: true"],
+            )
           end
 
-          def template(path, context)
-            require "erb"
+          def normalize(name)
+            inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
+          end
 
-            ERB.new(
-              File.read(__dir__ + "/operation/#{path}")
-            ).result(context.ctx)
+          def print_namespace_recommendation(operation_name)
+            out.puts(
+              "  Note: We generated a top-level operation. " \
+              "To generate into a directory, add a namespace: `my_namespace.#{operation_name}`"
+            )
           end
 
-          alias_method :t, :template
+          def raise_missing_slice_error_if_missing(slice)
+            if slice
+              slice_directory = fs.join("slices", slice)
+              raise MissingSliceError.new(slice) unless fs.directory?(slice_directory)
+            end
+          end
         end
       end
     end