hanami-cli 1.0.0.alpha1 → 2.0.0.alpha6

data/lib/hanami/cli/generators/gem/application/monolith.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "erb"
+require "shellwords"
+require "hanami/cli/generators/context"
+
+module Hanami
+  module CLI
+    module Generators
+      module Gem
+        module Application
+          class Monolith
+            def initialize(fs:, inflector:, command_line:)
+              super()
+              @fs = fs
+              @inflector = inflector
+              @command_line = command_line
+            end
+
+            def call(app, slice, slice_url_prefix, context: Context.new(inflector, app), &blk)
+              generate_app(app, context)
+              blk.call
+              generate_slice!(slice, slice_url_prefix)
+            end
+
+            private
+
+            attr_reader :fs
+
+            attr_reader :inflector
+
+            attr_reader :command_line
+
+            def generate_app(app, context) # rubocop:disable Metrics/AbcSize
+              fs.write(".env", t("env.erb", context))
+
+              fs.write("README.md", t("readme.erb", context))
+              fs.write("Gemfile", t("gemfile.erb", context))
+              fs.write("Rakefile", t("rakefile.erb", context))
+              fs.write("config.ru", t("config_ru.erb", context))
+
+              fs.write("config/application.rb", t("application.erb", context))
+              fs.write("config/settings.rb", t("settings.erb", context))
+              fs.write("config/routes.rb", t("routes.erb", context))
+
+              fs.write("lib/tasks/.keep", t("keep.erb", context))
+
+              fs.write("lib/#{app}/entities/.keep", t("keep.erb", context))
+              fs.write("lib/#{app}/persistence/relations/.keep", t("keep.erb", context))
+              fs.write("lib/#{app}/validation/contract.rb", t("validation_contract.erb", context))
+              fs.write("lib/#{app}/view/context.rb", t("view_context.erb", context))
+              fs.write("lib/#{app}/action.rb", t("action.erb", context))
+              fs.write("lib/#{app}/entities.rb", t("entities.erb", context))
+              fs.write("lib/#{app}/functions.rb", t("functions.erb", context))
+              fs.write("lib/#{app}/operation.rb", t("operation.erb", context))
+              fs.write("lib/#{app}/repository.rb", t("repository.erb", context))
+              fs.write("lib/#{app}/types.rb", t("types.erb", context))
+            end
+
+            def generate_slice!(slice_name, slice_url_prefix)
+              slice_name = Shellwords.shellescape(slice_name)
+              slice_url_prefix = Shellwords.shellescape(slice_url_prefix)
+
+              command_line.call("hanami generate slice #{slice_name} --url-prefix=#{slice_url_prefix}").tap do |result|
+                raise "hanami generate slice #{slice_name} failed\n\n\n#{result.err.inspect}" unless result.successful?
+              end
+            end
+
+            def template(path, context)
+              require "erb"
+
+              ERB.new(
+                File.read(__dir__ + "/monolith/#{path}")
+              ).result(context.ctx)
+            end
+
+            alias_method :t, :template
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/gem/application.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Generators
+      module Gem
+        module Application
+          class << self
+            def call(architecture, fs, inflector, command_line)
+              require_relative "./application/#{architecture}"
+
+              generator_name = inflector.classify(architecture).to_sym
+              const_get(generator_name).new(fs: fs, inflector: inflector, command_line: command_line)
+            end
+            alias_method :[], :call
+          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.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_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/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

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= classified_slice_name %>
+  module Entities
+  end
+end
+
+Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/repository"
+require_relative "entities"
+
+module <%= classified_slice_name %>
+  class Repository < <%= classified_app_name %>::Repository
+    struct_namespace Entities
+  end
+end

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

@@ -0,0 +1,2 @@
+  slice :<%= underscored_slice_name %>, at: "<%= slice_url_prefix %>" do
+  end

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

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "<%= underscored_app_name %>/view"
+
+module <%= classified_slice_name %>
+  class View < <%= classified_app_name %>::View
+  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_context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../context"
+
+module Hanami
+  module CLI
+    module Generators
+      module Monolith
+        class SliceContext < Generators::Context
+          def initialize(inflector, app, slice, slice_url_prefix)
+            @slice = slice
+            @slice_url_prefix = slice_url_prefix
+            super(inflector, app)
+          end
+
+          def classified_slice_name
+            inflector.classify(slice)
+          end
+
+          def underscored_slice_name
+            inflector.underscore(slice)
+          end
+
+          private
+
+          attr_reader :slice
+
+          attr_reader :slice_url_prefix
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/repl/core.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "hanami/console/context"
+
+module Hanami
+  module CLI
+    module Repl
+      # @api private
+      class Core
+        # @api private
+        attr_reader :application
+
+        # @api private
+        attr_reader :opts
+
+        # @api private
+        def initialize(application, opts)
+          @application = application
+          @opts = opts
+        end
+
+        # @api private
+        def start
+          raise NotImplementedError
+        end
+
+        # @api private
+        def context
+          @context ||= Hanami::Console::Context.new(application)
+        end
+
+        # @api private
+        def prompt
+          "#{name}[#{env}]"
+        end
+
+        # @api private
+        def name
+          (application.container.config.name || inflector.underscore(application.name))
+            .to_s.split("/")[0]
+        end
+
+        # @api private
+        def env
+          application.container.env
+        end
+
+        # @api private
+        def inflector
+          application.inflector
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/repl/irb.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "irb"
+require_relative "core"
+
+module Hanami
+  module CLI
+    module Repl
+      # @since 2.0.0
+      # @api public
+      class Irb < Core
+        # @api public
+        def start
+          $stdout.sync = true
+
+          ARGV.shift until ARGV.empty?
+          TOPLEVEL_BINDING.eval("self").extend(context)
+
+          # Initializes the IRB.conf; our own conf changes must be after this
+          IRB.setup(nil)
+
+          IRB.conf[:PROMPT][:HANAMI] = {
+            AUTO_INDENT: true,
+            PROMPT_I: "#{prompt}> ",
+            PROMPT_N: "#{prompt}> ",
+            PROMPT_S: "#{prompt} %l> ",
+            PROMPT_C: "#{prompt} ?> ",
+            RETURN: "=> %s\n"
+          }
+
+          IRB.conf[:PROMPT_MODE] = :HANAMI
+
+          IRB::Irb.new.run
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/repl/pry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pry"
+require_relative "core"
+
+module Hanami
+  module CLI
+    module Repl
+      # @since 2.0.0
+      # @api public
+      class Pry < Core
+        # @api private
+        class Context
+        end
+
+        # @api public
+        def start
+          ::Pry.config.prompt = ::Pry::Prompt.new(
+            "hanami",
+            "my custom prompt",
+            [proc { |*| "#{prompt}> " }]
+          )
+
+          ::Pry.start(Context.new.extend(context))
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/system_call.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    class SystemCall
+      class Result
+        SUCCESSFUL_EXIT_CODE = 0
+        private_constant :SUCCESSFUL_EXIT_CODE
+
+        attr_reader :exit_code, :out, :err
+
+        def initialize(exit_code:, out:, err:)
+          @exit_code = exit_code
+          @out = out
+          @err = err
+        end
+
+        def successful?
+          exit_code == SUCCESSFUL_EXIT_CODE
+        end
+      end
+
+      # Adapted from Bundler source code
+      #
+      # Bundler is released under MIT license
+      # https://github.com/bundler/bundler/blob/master/LICENSE.md
+      #
+      # A special "thank you" goes to Bundler maintainers and contributors.
+      #
+      # Also adapted from `hanami-devtools` source code
+      def call(cmd, env: {})
+        exitstatus = nil
+        out = nil
+        err = nil
+
+        ::Bundler.with_unbundled_env do
+          Open3.popen3(env, cmd) do |stdin, stdout, stderr, wait_thr|
+            yield stdin, stdout, wait_thr if block_given?
+            stdin.close
+
+            exitstatus = wait_thr&.value&.exitstatus
+            out = Thread.new { stdout.read }.value.strip
+            err = Thread.new { stderr.read }.value.strip
+          end
+        end
+
+        Result.new(exit_code: exitstatus, out: out, err: err)
+      end
+    end
+  end
+end