Convert component generator to use RubyFileWriter (#277)

Author: cllns

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

@@ -39,10 +39,13 @@ def generator_class
             # @api private
             def call(name:, slice: nil, **)
               if slice
+                base_path = fs.join("slices", inflector.underscore(slice))
+                raise MissingSliceError.new(slice) unless fs.exist?(base_path)
+
                 generator.call(
                   key: name,
                   namespace: slice,
-                  base_path: fs.join("slices", inflector.underscore(slice))
+                  base_path: base_path,
                 )
               else
                 generator.call(

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

@@ -3,43 +3,28 @@
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+
 module Hanami
   module CLI
     module Commands
       module App
         module Generate
           # @api private
           # @since 2.2.0
-          class Component < App::Command
+          class Component < Command
             argument :name, required: true, desc: "Component name"
-            option :slice, required: false, desc: "Slice name"
 
             example [
               %(isbn_decoder               (MyApp::IsbnDecoder)),
               %(recommenders.fiction       (MyApp::Recommenders::Fiction)),
               %(isbn_decoder --slice=admin (Admin::IsbnDecoder)),
               %(Exporters::Complete::CSV   (MyApp::Exporters::Complete::CSV)),
             ]
-            attr_reader :generator
-            private :generator
 
-            # @api private
             # @since 2.2.0
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::Component.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              @generator = generator
-              super(fs: fs, inflector: inflector, **opts)
-            end
-
             # @api private
-            # @since 2.2.0
-            def call(name:, slice: nil, **)
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-
-              generator.call(app.namespace, name, slice)
+            def generator_class
+              Generators::App::Component
             end
           end
         end

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

@@ -12,49 +12,29 @@ module App
         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:)
+            RubyFileWriter.new(
+              fs: fs,
+              inflector: inflector,
+            ).call(
+              namespace: namespace,
+              key: inflector.underscore(key),
+              base_path: base_path,
+              relative_parent_class: nil,
+            )
           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

lib/hanami/cli/generators/app/component/component.erb

@@ -128,7 +128,7 @@ def class_definition(class_name:, local_namespaces:)
               .compact
               .prepend(container_module)
 
-            parent_class = [container_module, relative_parent_class].join("::")
+            parent_class = [container_module, relative_parent_class].join("::") if relative_parent_class
 
             RubyFileGenerator.class(
               normalize(class_name),

lib/hanami/cli/generators/app/component/slice_component.erb

@@ -4,12 +4,11 @@
 require "ostruct"
 
 RSpec.describe Hanami::CLI::Commands::App::Generate::Component, :app do
-  subject { described_class.new(fs: fs, inflector: inflector, generator: generator) }
+  subject { described_class.new(fs: fs, inflector: inflector, out: out) }
 
   let(:out) { StringIO.new }
   let(:fs) { Hanami::CLI::Files.new(memory: true, out: out) }
   let(:inflector) { Dry::Inflector.new }
-  let(:generator) { Hanami::CLI::Generators::App::Component.new(fs: fs, inflector: inflector) }
   let(:app) { Hanami.app.namespace }
   let(:underscored_app) { inflector.underscore(app) }
   let(:dir) { underscored_app }
@@ -119,7 +118,7 @@ class WelcomeEmail
     end
   end
 
-  context "with constantized name for component given" do
+  context "with namespaced constant name for component given" do
     it "generates the component" do
       subject.call(name: "Operations::SendWelcomeEmail")