Add dry-operation generators

lib/hanami/cli/commands/app.rb

@@ -41,11 +41,12 @@ def self.extended(base)
             end
 
             register "generate", aliases: ["g"] do |prefix|
-              prefix.register "slice", Generate::Slice
               prefix.register "action", Generate::Action
-              prefix.register "view", Generate::View
-              prefix.register "part", Generate::Part
               prefix.register "component", Generate::Component
+              prefix.register "slice", Generate::Slice
+              prefix.register "operation", Generate::Operation
+              prefix.register "part", Generate::Part
+              prefix.register "view", Generate::View
             end
           end
         end

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 2.2.0
+          # @api private
+          class Operation < App::Command
+            argument :name, required: true, desc: "Operation name"
+            option :slice, required: false, desc: "Slice name"
+
+            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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Generators
+      module App
+        # @since 2.2.0
+        # @api private
+        class Operation
+          # @since 2.2.0
+          # @api private
+          def initialize(fs:, inflector:, out: $stdout)
+            @fs = fs
+            @inflector = inflector
+            @out = out
+          end
+
+          # @since 2.2.0
+          # @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, :inflector, :out
+
+          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, context.namespaces))
+              fs.write(fs.join(directory, "#{context.name}.rb"), t("nested_slice_operation.erb", context))
+            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}`")
+            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
+          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,10 @@
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+<%= module_namespace_declaration %>
+<%= module_namespace_offset %>class <%= camelized_name %> < <%= camelized_app_name %>::Operation
+<%= module_namespace_offset %>  def call
+<%= module_namespace_offset %>  end
+<%= module_namespace_offset %>end
+<%= module_namespace_end %>
+end

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

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

lib/hanami/cli/generators/app/operation/top_level_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/top_level_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_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 2.2.0
+      # @api private
+      module App
+        # @since 2.2.0
+        # @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
+          private_constant :OFFSET
+
+          # @since 2.2.0
+          # @api private
+          attr_reader :key
+
+          # @since 2.2.0
+          # @api private
+          def initialize(inflector, app, slice, key)
+            @key = key
+            super(inflector, app, slice, nil)
+          end
+
+          # @since 2.2.0
+          # @api private
+          def namespaces
+            @namespaces ||= key.split(KEY_SEPARATOR)[..-2]
+          end
+
+          # @since 2.2.0
+          # @api private
+          def name
+            @name ||= key.split(KEY_SEPARATOR)[-1]
+          end
+
+          # @api private
+          # @since 2.2.0
+          # @api private
+          def camelized_name
+            inflector.camelize(name)
+          end
+
+          # @since 2.2.0
+          # @api private
+          def module_namespace_declaration
+            namespaces.each_with_index.map { |token, i|
+              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+            }.join($/)
+          end
+
+          # @since 2.2.0
+          # @api private
+          def module_namespace_end
+            namespaces.each_with_index.map { |_, i|
+              "#{OFFSET}#{INDENTATION * i}end"
+            }.reverse.join($/)
+          end
+
+          # @since 2.2.0
+          # @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/context.rb

@@ -92,6 +92,12 @@ def bundled_assets?
           Hanami.bundled?("hanami-assets")
         end
 
+        # @since 2.2.0
+        # @api private
+        def bundled_dry_monads?
+          Hanami.bundled?("dry-monads")
+        end
+
         # @since 2.1.0
         # @api private
         #

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/action.erb

@@ -2,8 +2,11 @@
 # frozen_string_literal: true
 
 require "hanami/action"
+require "dry/monads"
 
 module <%= camelized_app_name %>
   class Action < Hanami::Action
+    # Provide `Success` and `Failure` for pattern matching on operation results
+    include Dry::Monads[:result]
   end
 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