Revert "Prevent generating operation without namespace"

This reverts commit a5bd2f3.

Author: cllns

lib/hanami/cli/errors.rb

@@ -91,9 +91,5 @@ def initialize(scheme)
         super("`#{scheme}' is not a supported db scheme")
       end
     end
-
-    # @since x.x.x
-    # @api public
-    class NameNeedsNamespaceError < Error; end
   end
 end

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

@@ -42,18 +42,20 @@ def generate_for_slice(context, slice)
 
             if context.namespaces.any?
               fs.mkdir(directory = fs.join(slice_directory, context.namespaces))
-              fs.write(fs.join(directory, "#{context.name}.rb"), t("slice_operation.erb", context))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_slice_operation.erb", context))
             else
-              print_error_message_about_naming(context.name, slice_directory)
+              fs.mkdir(directory = fs.join(slice_directory))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("top_level_slice_operation.erb", context))
             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("app_operation.erb", context))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_app_operation.erb", context))
             else
-              print_error_message_about_naming(context.name, "app")
+              fs.mkdir(directory = fs.join("app"))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("top_level_app_operation.erb", context))
             end
           end
 
@@ -65,16 +67,6 @@ def template(path, context)
             ).result(context.ctx)
           end
 
-          def print_error_message_about_naming(provided_name, base_location)
-            raise NameNeedsNamespaceError.new(
-              "Failed to create operation `#{provided_name}'. " \
-              "This would create the operation directly in the `#{base_location}/' folder. " \
-              "Instead, you should provide a namespace for the folder where this operation will live. " \
-              "NOTE: We recommend giving it a name that's specific to your domain, " \
-              "but you can also use `operations.#{provided_name}' in the meantime if you're unsure."
-            )
-          end
-
           alias_method :t, :template
         end
       end

lib/hanami/cli/generators/app/operation/app_operation.erb lib/hanami/cli/generators/app/operation/nested_app_operation.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::Operation
+<%= module_namespace_offset %>  def call
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+end

lib/hanami/cli/generators/app/operation/slice_operation.erb lib/hanami/cli/generators/app/operation/nested_slice_operation.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_slice_name %>::Operation
+<%= module_namespace_offset %>  def call
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+end

lib/hanami/cli/generators/app/operation/top_level_app_operation.erb

@@ -18,23 +18,21 @@ def output
 
   context "generating for app" do
     it "generates an operation" do
-      subject.call(name: "operations/add_book")
+      subject.call(name: "add_book")
 
       operation_file = <<~EXPECTED
         # frozen_string_literal: true
 
         module Test
-          module Operations
-            class AddBook < Test::Operation
-              def call
-              end
+          class AddBook < Test::Operation
+            def call
             end
           end
         end
       EXPECTED
 
-      expect(fs.read("app/operations/add_book.rb")).to eq(operation_file)
-      expect(output).to include("Created app/operations/add_book.rb")
+      expect(fs.read("app/add_book.rb")).to eq(operation_file)
+      expect(output).to include("Created app/add_book.rb")
     end
 
     it "generates a operation in a deep namespace with default separator" do
@@ -59,7 +57,7 @@ def call
       expect(output).to include("Created app/admin/books/add.rb")
     end
 
-    it "generates an operation in a deep namespace with slash separator" do
+    it "generates an operation in a deep namespace with slash separators" do
       subject.call(name: "admin/books/add")
 
       operation_file = <<~EXPECTED
@@ -80,78 +78,26 @@ def call
       expect(fs.read("app/admin/books/add.rb")).to eq(operation_file)
       expect(output).to include("Created app/admin/books/add.rb")
     end
-
-    it "outputs an error if trying to generate an operation without a separator" do
-      expect {
-        subject.call(name: "add_book")
-      }.to raise_error(Hanami::CLI::NameNeedsNamespaceError).with_message(
-        "Failed to create operation `add_book'. " \
-        "This would create the operation directly in the `app/' folder. " \
-        "Instead, you should provide a namespace for the folder where this operation will live. " \
-        "NOTE: We recommend giving it a name that's specific to your domain, " \
-        "but you can also use `operations.add_book' in the meantime if you're unsure."
-      )
-      expect(fs.exist?("app/add_book.rb")).to be(false)
-    end
   end
 
   context "generating for a slice" do
-    it "generates a operation" do
-      fs.mkdir("slices/main")
-      subject.call(name: "operations.add_book", slice: "main")
-
-      operation_file = <<~EXPECTED
-        # frozen_string_literal: true
-
-        module Main
-          module Operations
-            class AddBook < Main::Operation
-              def call
-              end
-            end
-          end
-        end
-      EXPECTED
-
-      expect(fs.read("slices/main/operations/add_book.rb")).to eq(operation_file)
-      expect(output).to include("Created slices/main/operations/add_book.rb")
-    end
-
-    it "generates a operation in a deep namespace with default separator" do
+    it "generates a operation in a top-level namespace" do
       fs.mkdir("slices/main")
-      subject.call(name: "admin.books.add", slice: "main")
+      subject.call(name: "add_book", slice: "main")
 
       operation_file = <<~EXPECTED
         # frozen_string_literal: true
 
         module Main
-          module Admin
-            module Books
-              class Add < Main::Operation
-                def call
-                end
-              end
+          class AddBook < Main::Operation
+            def call
             end
           end
         end
       EXPECTED
 
-      expect(fs.read("slices/main/admin/books/add.rb")).to eq(operation_file)
-      expect(output).to include("Created slices/main/admin/books/add.rb")
-    end
-
-    it "outputs an error if trying to generate an operation without a separator" do
-      fs.mkdir("slices/main")
-      expect {
-        subject.call(name: "add_book", slice: "main")
-      }.to raise_error(Hanami::CLI::NameNeedsNamespaceError).with_message(
-        "Failed to create operation `add_book'. " \
-        "This would create the operation directly in the `slices/main/' folder. " \
-        "Instead, you should provide a namespace for the folder where this operation will live. " \
-        "NOTE: We recommend giving it a name that's specific to your domain, " \
-        "but you can also use `operations.add_book' in the meantime if you're unsure."
-      )
-      expect(fs.exist?("app/add_book.rb")).to be(false)
+      expect(fs.read("slices/main/add_book.rb")).to eq(operation_file)
+      expect(output).to include("Created slices/main/add_book.rb")
     end
   end
 end