hanami-cli 0.2.0 → 2.0.0.alpha2

data/lib/hanami/cli/generators/gem/application/monolith/functions.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/transformer"
+
+module <%= classified_app_name %>
+  module Functions
+    extend Dry::Transformer::Registry
+
+    import Dry::Transformer::ArrayTransformations
+    import Dry::Transformer::HashTransformations
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/gemfile.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "rake"
+
+gem "hanami-router", "<%= hanami_version %>"
+gem "hanami-controller", "<%= hanami_version %>"
+gem "hanami-validations", "<%= hanami_version %>"
+gem "hanami-view", git: "https://github.com/hanami/view.git", branch: "master"
+gem "dry-cli", "~> 0.6", require: false, git: "https://github.com/dry-rb/dry-cli.git", branch: "feature/file-utils-class"
+gem "hanami-cli", git: "https://github.com/hanami/cli.git", branch: "main"
+gem "hanami", require: false, git: "https://github.com/hanami/hanami.git", branch: "feature/hanami-2-cli"
+
+gem "puma"
+
+group :cli, :development, :test do
+  gem "hanami-rspec", git: "https://github.com/hanami/rspec.git", branch: "main"
+end

data/lib/hanami/cli/generators/gem/application/monolith/operation.erb

@@ -0,0 +1,18 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/monads"
+require "dry/matcher/result_matcher"
+
+module <%= classified_app_name %>
+  class Operation
+    include Dry::Monads[:result, :try]
+
+    class << self
+      def inherited(klass)
+        klass.include Dry::Monads[:do]
+        klass.include Dry::Matcher::ResultMatcher.for(:call)
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/rakefile.erb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hanami/application/rake_tasks"

data/lib/hanami/cli/generators/gem/application/monolith/readme.erb

@@ -0,0 +1 @@
+# <%= classified_app_name %>

data/lib/hanami/cli/generators/gem/application/monolith/repository.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "rom-repository"
+require_relative "entities"
+
+module <%= classified_app_name %>
+  class Repository < ROM::Repository::Root
+    include Deps[container: "persistence.rom"]
+
+    struct_namespace Entities
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/routes.erb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Hanami.application.routes do
+end

data/lib/hanami/cli/generators/gem/application/monolith/settings.erb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/types"
+
+Hanami.application.settings do
+end

data/lib/hanami/cli/generators/gem/application/monolith/types.erb

@@ -0,0 +1,10 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/types"
+
+module <%= classified_app_name %>
+  module Types
+    include Dry.Types
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/validation_contract.erb

@@ -0,0 +1,14 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "dry/validation"
+require "dry/schema/messages/i18n"
+
+module <%= classified_app_name %>
+  module Validation
+    class Contract < Dry::Validation::Contract
+      config.messages.backend = :i18n
+      config.messages.top_namespace = "validation"
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application/monolith/view_context.erb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "hanami/view/context"
+
+module <%= classified_app_name %>
+  module View
+    class Context < Hanami::View::Context
+      def initialize(**args)
+        defaults = {content: {}}
+
+        super(**defaults.merge(args))
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/monolith/action.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require "hanami/cli/generators/monolith/action_context"
+require "hanami/cli/url"
+
+module Hanami
+  module CLI
+    module Generators
+      module Monolith
+        class Action
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/ParameterLists
+          # rubocop:disable Layout/LineLength
+          def call(slice, controller, action, url, http, format, skip_view, context: ActionContext.new(inflector, slice, controller, action))
+            slice_directory = fs.join("slices", slice)
+            raise ArgumentError.new("slice not found `#{slice}'") unless fs.directory?(slice_directory)
+
+            fs.inject_line_at_block_bottom(
+              fs.join("config", "routes.rb"),
+              slice_matcher(slice),
+              route(controller, action, url, http)
+            )
+
+            fs.chdir(slice_directory) do
+              fs.mkdir(directory = fs.join("actions", controller))
+              fs.write(fs.join(directory, "#{action}.rb"), t("action.erb", context))
+
+              unless skip_view
+                fs.mkdir(directory = fs.join("views", controller))
+                fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
+
+                fs.mkdir(directory = fs.join("templates", controller))
+                fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
+              end
+            end
+          end
+          # rubocop:enable Layout/LineLength
+          # rubocop:enable Metrics/ParameterLists
+          # rubocop:enable Metrics/AbcSize
+
+          private
+
+          ROUTE_HTTP_METHODS = %w[get post delete put patch trace options link unlink].freeze
+          private_constant :ROUTE_HTTP_METHODS
+
+          ROUTE_DEFAULT_HTTP_METHOD = "get"
+          private_constant :ROUTE_DEFAULT_HTTP_METHOD
+
+          ROUTE_RESTFUL_HTTP_METHODS = {
+            "create" => "post",
+            "update" => "patch",
+            "destroy" => "delete"
+          }.freeze
+          private_constant :ROUTE_RESTFUL_HTTP_METHODS
+
+          ROUTE_RESTFUL_URL_SUFFIXES = {
+            "index" => "",
+            "new" => "/new",
+            "create" => "",
+            "edit" => "/:id/edit",
+            "update" => "/:id",
+            "show" => "/:id",
+            "destroy" => "/:id"
+          }.freeze
+          private_constant :ROUTE_RESTFUL_URL_SUFFIXES
+
+          attr_reader :fs
+
+          attr_reader :inflector
+
+          def slice_matcher(slice)
+            /slice[[:space:]]*:#{slice}/
+          end
+
+          def route(controller, action, url, http)
+            %(#{route_http(action,
+                           http)} "#{route_url(controller, action, url)}", to: "#{controller.join('.')}.#{action}")
+          end
+
+          def template_format(format)
+            case format.to_sym
+            when :html
+              "template.html.erb"
+            else
+              "template.erb"
+            end
+          end
+
+          def template(path, context)
+            require "erb"
+
+            ERB.new(
+              File.read(__dir__ + "/action/#{path}")
+            ).result(context.ctx)
+          end
+
+          alias_method :t, :template
+
+          def route_url(controller, action, url)
+            CLI::URL.call(url || "/#{controller.join('/')}" + ROUTE_RESTFUL_URL_SUFFIXES.fetch(action))
+          end
+
+          def route_http(action, http)
+            result = (http ||= ROUTE_RESTFUL_HTTP_METHODS.fetch(action, ROUTE_DEFAULT_HTTP_METHOD)).downcase
+
+            unless ROUTE_HTTP_METHODS.include?(result)
+              raise ArgumentError.new("unknown HTTP method: `#{http}'")
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/monolith/action/action.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "<%= underscored_slice_name %>/action"
+
+module <%= classified_slice_name %>
+  module Actions
+<%= module_controller_declaration %>
+<%= module_controller_offset %>class <%= classified_action_name %> < <%= classified_slice_name %>::Action
+<%= module_controller_offset %>end
+<%= module_controller_end %>
+  end
+end

data/lib/hanami/cli/generators/monolith/action/template.html.erb

@@ -0,0 +1,2 @@
+<h1><%= classified_slice_name %>::Views::<%= classified_controller_name %>::<%= classified_action_name %></h1>
+<h2><%= template_path %></h2>

data/lib/hanami/cli/generators/monolith/action/view.erb

@@ -0,0 +1,13 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "<%= underscored_slice_name %>/view"
+
+module <%= classified_slice_name %>
+  module Views
+<%= module_controller_declaration %>
+<%= module_controller_offset %>class <%= classified_action_name %> < <%= classified_slice_name %>::View
+<%= module_controller_offset %>end
+<%= module_controller_end %>
+  end
+end

data/lib/hanami/cli/generators/monolith/action_context.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "./slice_context"
+require "dry/files/path"
+
+module Hanami
+  module CLI
+    module Generators
+      module Monolith
+        class ActionContext < SliceContext
+          def initialize(inflector, slice, controller, action)
+            @controller = controller
+            @action = action
+            super(inflector, nil, slice, nil)
+          end
+
+          def classified_controller_name
+            controller.map do |token|
+              inflector.camelize(token)
+            end.join(NAMESPACE_SEPARATOR)
+          end
+
+          def classified_action_name
+            inflector.classify(action)
+          end
+
+          def underscored_controller_name
+            controller.map do |token|
+              inflector.underscore(token)
+            end
+          end
+
+          def underscored_action_name
+            inflector.underscore(action)
+          end
+
+          def module_controller_declaration
+            controller.each_with_index.map do |token, i|
+              "#{OFFSET}#{INDENTATION * i}module #{inflector.camelize(token)}"
+            end.join($/)
+          end
+
+          def module_controller_end
+            controller.each_with_index.map do |_, i|
+              "#{OFFSET}#{INDENTATION * i}end"
+            end.reverse.join($/)
+          end
+
+          def module_controller_offset
+            "#{OFFSET}#{INDENTATION * controller.count}"
+          end
+
+          def template_path
+            Dry::Files::Path["slices", underscored_slice_name, "templates", *underscored_controller_name,
+                             "#{underscored_action_name}.html.erb"]
+          end
+
+          private
+
+          NAMESPACE_SEPARATOR = "::"
+          private_constant :NAMESPACE_SEPARATOR
+
+          INDENTATION = "  "
+          private_constant :INDENTATION
+
+          OFFSET = INDENTATION * 2
+          private_constant :OFFSET
+
+          attr_reader :controller
+
+          attr_reader :action
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/monolith/slice.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "erb"
+require "dry/files"
+require "hanami/cli/generators/monolith/slice_context"
+
+module Hanami
+  module CLI
+    module Generators
+      module Monolith
+        class Slice
+          def initialize(fs:, inflector:)
+            @fs = fs
+            @inflector = inflector
+          end
+
+          def call(app, slice, slice_url_prefix, context: SliceContext.new(inflector, app, slice, slice_url_prefix)) # rubocop:disable Metrics/AbcSize
+            fs.inject_line_before_last(fs.join("config", "routes.rb"), /end/, t("routes.erb", context).chomp)
+
+            fs.mkdir(directory = "slices/#{slice}")
+
+            fs.chdir(directory) do
+              fs.write("action.rb", t("action.erb", context))
+              fs.write("view.rb", t("view.erb", context))
+              fs.write("entities.rb", t("entities.erb", context))
+              fs.write("repository.rb", t("repository.erb", context))
+
+              fs.write("actions/.keep", t("keep.erb", context))
+              fs.write("views/.keep", t("keep.erb", context))
+              fs.write("templates/.keep", t("keep.erb", context))
+              fs.write("templates/layouts/.keep", t("keep.erb", context))
+              fs.write("entities/.keep", t("keep.erb", context))
+              fs.write("repositories/.keep", t("keep.erb", context))
+            end
+          end
+
+          private
+
+          attr_reader :fs
+
+          attr_reader :inflector
+
+          def template(path, context)
+            require "erb"
+
+            ERB.new(
+              File.read(__dir__ + "/slice/#{path}")
+            ).result(context.ctx)
+          end
+
+          alias_method :t, :template
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/monolith/slice/action.erb

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/action"
+
+module <%= classified_slice_name %>
+  class Action < <%= classified_app_name %>::Action
+  end
+end