Add dry-operation generators

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

@@ -0,0 +1,50 @@
+# 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 x.x.x
+          # @api private
+          class Operation < App::Command
+            argument :name, required: true, desc: "Operation name"
+            option :slice, required: false, desc: "Slice name"
+
+            example [
+              %(add_book               (MyApp::Operations::AddBook)),
+              %(add_book --slice=admin (Admin::Operations::AddBook)),
+            ]
+            attr_reader :generator
+            private :generator
+
+            # @since x.x.x
+            # @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 x.x.x
+            # @api private
+            def call(name:, slice: nil, **)
+              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
+
+              generator.call(app.namespace, name, slice)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since x.x.x
+        # @api private
+        class Operation
+          # @since x.x.x
+          # @api private
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # @since x.x.x
+          # @api private
+          def call(app, key, slice)
+            context = OperationContext.new(inflector, app, slice, key)
+
+            if slice
+              generate_for_slice(context, slice)
+            else
+              generate_for_app(context)
+            end
+          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)
+
+            if context.namespaces.any?
+              fs.mkdir(directory = fs.join(slice_directory, "operations", context.namespaces))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_slice_operation.erb", context))
+            else
+              fs.mkdir(directory = fs.join(slice_directory, "operations"))
+              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", "operations", context.namespaces))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_app_operation.erb", context))
+            else
+              fs.mkdir(directory = fs.join("app", "operations"))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("top_level_app_operation.erb", context))
+            end
+          end
+
+          def template(path, context)
+            require "erb"
+
+            ERB.new(
+              File.read(__dir__ + "/operation/#{path}")
+            ).result(context.ctx)
+          end
+
+          alias_method :t, :template
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Operations
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::Operation
+<%= module_namespace_offset %>  def call(input)
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Operations
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_slice_name %>::Operation
+<%= module_namespace_offset %>  def call(input)
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Operations
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::Operation
+<%= module_namespace_offset %>  def call(input)
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  module Operations
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_slice_name %>::Operation
+<%= module_namespace_offset %>  def call(input)
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "slice_context"
+require "dry/files/path"
+
+module Hanami
+  module CLI
+    module Generators
+      # @since x.x.x
+      # @api private
+      module App
+        # @since x.x.x
+        # @api private
+        class OperationContext < SliceContext
+          # TODO: move these constants somewhere that will let us reuse them
+          KEY_SEPARATOR = %r{\.|/}
+          private_constant :KEY_SEPARATOR
+
+          NAMESPACE_SEPARATOR = "::"
+          private_constant :NAMESPACE_SEPARATOR
+
+          INDENTATION = "  "
+          private_constant :INDENTATION
+
+          OFFSET = INDENTATION * 2
+          private_constant :OFFSET
+
+          # @since x.x.x
+          # @api private
+          attr_reader :key
+
+          # @since x.x.x
+          # @api private
+          def initialize(inflector, app, slice, key)
+            @key = key
+            super(inflector, app, slice, nil)
+          end
+
+          # @since x.x.x
+          # @api private
+          def namespaces
+            @namespaces ||= key.split(KEY_SEPARATOR)[..-2]
+          end
+
+          # @since x.x.x
+          # @api private
+          def name
+            @name ||= key.split(KEY_SEPARATOR)[-1]
+          end
+
+          # @api private
+          # @since x.x.x
+          # @api private
+          def camelized_name
+            inflector.camelize(name)
+          end
+
+          # @since x.x.x
+          # @api private
+          def module_namespace_declaration
+            namespaces.each_with_index.map { |token, i|
+              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+            }.join($/)
+          end
+
+          # @since x.x.x
+          # @api private
+          def module_namespace_end
+            namespaces.each_with_index.map { |_, i|
+              "#{OFFSET}#{INDENTATION * i}end"
+            }.reverse.join($/)
+          end
+
+          # @since x.x.x
+          # @api private
+          def module_namespace_offset
+            "#{OFFSET}#{INDENTATION * namespaces.count}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,6 +31,7 @@ def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url))
             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"), t("app_layout.erb", context))
+            fs.write(fs.join(directory, "operation.rb"), t("operation.erb", context))
 
             if context.bundled_assets?
               fs.write(fs.join(directory, "assets", "js", "app.js"), t("app_js.erb", context))

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

@@ -0,0 +1,7 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_slice_name %>
+  class Operation < <%= camelized_app_name %>::Operation
+  end
+end

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

@@ -68,6 +68,8 @@ def generate_app(app, context) # rubocop:disable Metrics/AbcSize
               fs.write("app/assets/images/favicon.ico", file("favicon.ico"))
             end
 
+            fs.write("app/operation.rb", t("operation.erb", context))
+
             fs.write("public/404.html", file("404.html"))
             fs.write("public/500.html", file("500.html"))
           end

lib/hanami/cli/generators/gem/app/gemfile.erb

@@ -12,6 +12,7 @@ source "https://rubygems.org"
 <%= hanami_gem("view") %>
 
 gem "dry-types", "~> 1.0", ">= 1.6.1"
+gem "dry-operation", github: "dry-rb/dry-operation"
 gem "puma"
 gem "rake"
 

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/operation"
+
+module <%= camelized_app_name %>
+  class Operation < Dry::Operation
+  end
+end