hanami 2.0.0.alpha8 → 2.0.0.beta1

data/lib/hanami/application.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system/container"
-require "hanami/configuration"
-require "pathname"
-require "rack"
-require "zeitwerk"
-require_relative "constants"
-require_relative "slice"
-require_relative "slice_name"
-require_relative "application/slice_registrar"
-
-module Hanami
-  # Hanami application class
-  #
-  # @since 2.0.0
-  class Application
-    @_mutex = Mutex.new
-
-    class << self
-      def inherited(subclass)
-        super
-
-        @_mutex.synchronize do
-          subclass.class_eval do
-            @_mutex = Mutex.new
-            @application_name = SliceName.new(subclass, inflector: -> { subclass.inflector })
-            @configuration = Hanami::Configuration.new(application_name: @application_name, env: Hanami.env)
-            @autoloader = Zeitwerk::Loader.new
-            @container = Class.new(Dry::System::Container)
-
-            @prepared = @booted = false
-
-            extend ClassMethods
-          end
-
-          subclass.send :prepare_base_load_path
-
-          Hanami.application = subclass
-        end
-      end
-    end
-
-    # Application class interface
-    #
-    # rubocop:disable Metrics/ModuleLength
-    module ClassMethods
-      attr_reader :application_name, :configuration, :autoloader, :container
-
-      alias_method :slice_name, :application_name
-
-      alias_method :config, :configuration
-
-      def application
-        self
-      end
-
-      def prepare(provider_name = nil)
-        container.prepare(provider_name) and return self if provider_name
-
-        return self if prepared?
-
-        configuration.finalize!
-
-        prepare_all
-
-        @prepared = true
-        self
-      end
-
-      def boot(&block)
-        return self if booted?
-
-        prepare
-
-        container.finalize!(&block)
-
-        slices.each(&:boot)
-
-        @booted = true
-        self
-      end
-
-      def shutdown
-        slices.each(&:shutdown)
-        container.shutdown!
-        self
-      end
-
-      def prepared?
-        !!@prepared
-      end
-
-      def booted?
-        !!@booted
-      end
-
-      def router
-        raise "Application not yet prepared" unless prepared?
-
-        @_mutex.synchronize do
-          @_router ||= load_router
-        end
-      end
-
-      def rack_app
-        @rack_app ||= router.to_rack_app
-      end
-
-      def slices
-        @slices ||= SliceRegistrar.new(self)
-      end
-
-      def register_slice(...)
-        slices.register(...)
-      end
-
-      def register(...)
-        container.register(...)
-      end
-
-      def register_provider(...)
-        container.register_provider(...)
-      end
-
-      def start(...)
-        container.start(...)
-      end
-
-      def key?(...)
-        container.key?(...)
-      end
-
-      def keys
-        container.keys
-      end
-
-      def [](...)
-        container.[](...)
-      end
-
-      def resolve(...)
-        container.resolve(...)
-      end
-
-      def settings
-        @_settings ||= load_settings
-      end
-
-      def namespace
-        application_name.namespace
-      end
-
-      def root
-        configuration.root
-      end
-
-      def inflector
-        configuration.inflector
-      end
-
-      private
-
-      def prepare_base_load_path
-        base_path = File.join(root, "lib")
-        $LOAD_PATH.unshift base_path unless $LOAD_PATH.include?(base_path)
-      end
-
-      def prepare_all
-        load_settings
-        prepare_container_plugins
-        prepare_container_base_config
-        prepare_container_consts
-        container.configured!
-        prepare_slices
-        # For the application, the autoloader must be prepared after the slices, since
-        # they'll be configuring the autoloader with their own dirs
-        prepare_autoloader
-      end
-
-      def prepare_container_plugins
-        container.use(:env, inferrer: -> { Hanami.env })
-        container.use(:zeitwerk, loader: autoloader, run_setup: false, eager_load: false)
-        container.use(:notifications)
-      end
-
-      def prepare_container_base_config
-        container.config.root = configuration.root
-        container.config.inflector = configuration.inflector
-
-        container.config.provider_dirs = [
-          "config/providers",
-          Pathname(__dir__).join("application/container/providers").realpath,
-        ]
-      end
-
-      def prepare_autoload_paths
-        # Autoload classes defined in lib/[app_namespace]/
-        if root.join("lib", application_name.name).directory?
-          autoloader.push_dir(root.join("lib", application_name.name), namespace: namespace)
-        end
-      end
-
-      def prepare_container_consts
-        namespace.const_set :Container, container
-        namespace.const_set :Deps, container.injector
-      end
-
-      def prepare_slices
-        slices.load_slices.each(&:prepare)
-        slices.freeze
-      end
-
-      def prepare_autoloader
-        # Autoload classes defined in lib/[app_namespace]/
-        if root.join("lib", application_name.name).directory?
-          autoloader.push_dir(root.join("lib", application_name.name), namespace: namespace)
-        end
-
-        autoloader.setup
-      end
-
-      def load_settings
-        require_relative "application/settings"
-
-        prepare_base_load_path
-        require File.join(configuration.root, configuration.settings_path)
-        settings_class = autodiscover_application_constant(configuration.settings_class_name)
-        settings_class.new(configuration.settings_store)
-      rescue LoadError
-        Settings.new
-      end
-
-      def autodiscover_application_constant(constants)
-        inflector.constantize([application_name.namespace_name, *constants].join(MODULE_DELIMITER))
-      end
-
-      def load_router
-        require_relative "application/router"
-
-        Router.new(
-          routes: load_routes,
-          resolver: router_resolver,
-          **configuration.router.options,
-        ) do
-          use Hanami.application[:rack_monitor]
-
-          Hanami.application.config.for_each_middleware do |m, *args, &block|
-            use(m, *args, &block)
-          end
-        end
-      end
-
-      def load_routes
-        require_relative "application/routes"
-
-        require File.join(configuration.root, configuration.router.routes_path)
-        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
-        routes_class.routes
-      rescue LoadError
-        proc {}
-      end
-
-      def router_resolver
-        config.router.resolver.new(
-          slices: slices,
-          inflector: inflector
-        )
-      end
-    end
-    # rubocop:enable Metrics/ModuleLength
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/cli"
-require_relative "commands"
-
-module Hanami
-  class CLI
-    module Application
-      # Hanami application CLI
-      class CLI < Hanami::CLI
-        attr_reader :application
-
-        def initialize(application: nil, commands: Commands)
-          super(commands)
-          @application = application
-        end
-
-        private
-
-        # TODO: we should make a prepare_command method upstream
-        def parse(result, out)
-          command, arguments = super
-
-          if command.respond_to?(:with_application)
-            # Set HANAMI_ENV before the application inits to ensure all aspects
-            # of the boot process respect the provided env
-            ENV["HANAMI_ENV"] = arguments[:env] if arguments[:env]
-
-            require "hanami/prepare"
-            application = Hanami.application
-
-            [command.with_application(application), arguments]
-          else
-            [command, arguments]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hanami/cli/application/command.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../base_command"
-
-module Hanami
-  class CLI
-    module Application
-      # Hanami application CLI command (intended to run inside application directory)
-      class Command < BaseCommand
-        def self.inherited(klass)
-          super
-
-          klass.option :env, aliases: ["-e"], default: nil, desc: "Application environment"
-        end
-
-        attr_reader :application
-
-        def initialize(application: nil, **opts)
-          super(**opts)
-          @application = application
-        end
-
-        def with_application(application)
-          self.class.new(
-            command_name: @command_name,
-            application: application,
-            out: out,
-            inflector: application.inflector,
-            files: files,
-          )
-        end
-
-        private
-
-        def run_command(klass, *args)
-          klass.new(
-            command_name: klass.name,
-            application: application,
-            out: out,
-            inflector: application.inflector,
-            files: files,
-          ).call(*args)
-        end
-      end
-    end
-  end
-end

data/lib/hanami/cli/application/commands/console.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/cli"
-require "hanami/cli/application/command"
-require "hanami/console/context"
-
-module Hanami
-  class CLI
-    module Application
-      module Commands # rubocop:disable Style/Documentation
-        # Hanami application `console` CLI command
-        class Console < Command
-          REPL =
-            begin
-              require "pry"
-              Pry
-            rescue LoadError
-              require "irb"
-              IRB
-            end
-
-          desc "Open interactive console"
-
-          def call(**)
-            measure "#{prompt_prefix} booted in" do
-              out.puts "=> starting #{prompt_prefix} console"
-              application.init
-            end
-
-            start_repl
-          end
-
-          private
-
-          def start_repl
-            context = Hanami::Console::Context.new(application)
-
-            case REPL.name.to_sym
-            when :Pry
-              start_pry(context)
-            when :IRB
-              start_irb(context)
-            end
-          end
-
-          def start_pry(context)
-            # https://github.com/pry/pry/pull/1877
-            if Gem.loaded_specs["pry"].version >= Gem::Version.new("0.13.0")
-              Pry.prompt = Pry::Prompt.new(:hanami, "Hanami Console prompt.", prompt_procs)
-              Pry.start(context)
-            else
-              Pry.start(context, prompt_procs)
-            end
-          end
-
-          def start_irb(context)
-            IRB.start(context, prompt_procs)
-          end
-
-          def prompt_procs
-            [proc { default_prompt }, proc { indented_prompt }]
-          end
-
-          def default_prompt
-            "#{prompt_prefix}> "
-          end
-
-          def indented_prompt
-            "#{prompt_prefix}* "
-          end
-
-          def prompt_prefix
-            "#{inflector.underscore(application.application_name)}[#{application.config.env}]"
-          end
-        end
-
-        register "console", Console
-      end
-    end
-  end
-end

data/lib/hanami/cli/application/commands.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/cli/registry"
-
-module Hanami
-  class CLI
-    module Application
-      # Hanami application CLI commands registry
-      module Commands
-        extend Hanami::CLI::Registry
-
-        require_relative "commands/console"
-      end
-    end
-  end
-end

data/lib/hanami/cli/base_command.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/inflector"
-require "hanami/cli/command"
-require "hanami/utils/files"
-
-module Hanami
-  class CLI
-    # Base class for Hanami application CLI commands
-    class BaseCommand < Hanami::CLI::Command
-      attr_reader :out
-      attr_reader :inflector
-      attr_reader :files
-
-      def initialize(
-        command_name:,
-        out: $stdout,
-        inflector: Dry::Inflector.new,
-        files: Hanami::Utils::Files
-      )
-        super(command_name: command_name)
-
-        @out = out
-        @inflector = inflector
-        @files = files
-      end
-
-      private
-
-      def run_command(klass, *args)
-        klass.new(
-          command_name: klass.name,
-          application: application,
-          out: out,
-          files: files,
-        ).call(*args)
-      end
-
-      def measure(desc)
-        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        yield
-        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-        out.puts "=> #{desc} in #{(stop - start).round(1)}s"
-      end
-    end
-  end
-end

data/lib/hanami/cli/commands/command.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami"
-require "hanami/cli/command"
-require "concurrent"
-require "hanami/utils/files"
-require "erb"
-
-module Hanami
-  # Hanami CLI
-  #
-  # @since 1.1.0
-  class CLI
-    module Commands
-      # Abstract command
-      #
-      # @since 1.1.0
-      class Command < Dry::CLI::Command
-        # @since 1.1.0
-        # @api private
-        def self.inherited(component)
-          super
-
-          component.class_eval do
-            @_requirements = Concurrent::Array.new
-            extend ClassMethods
-            prepend InstanceMethods
-          end
-        end
-
-        # Class level interface
-        #
-        # @since 1.1.0
-        module ClassMethods
-          # Requires an internal Hanami component
-          #
-          # @param names [Array<String>] the name of one or more components
-          #
-          # @since 1.1.0
-          #
-          # @example
-          #   require "hanami/cli/commands"
-          #
-          #   module HanamiDatabaseHelpers
-          #     class TruncateTables < Hanami::CLI::Commands::Command
-          #       requires "model.configuration"
-          #
-          #       def call(*)
-          #         url = requirements["model.configuration"].url
-          #         # ...
-          #       end
-          #     end
-          #   end
-          #
-          #   Hanami::CLI.register "db truncate", HanamiDatabaseHelpers::TruncateTables
-          def requires(*names)
-            requirements.concat(names)
-          end
-
-          # @since 1.1.0
-          # @api private
-          def requirements
-            @_requirements
-          end
-        end
-
-        # @since 1.1.0
-        # @api private
-        module InstanceMethods
-          # @since 1.1.0
-          # @api private
-          def call(**options)
-            # FIXME: merge ENV vars (like HANAMI_ENV) into **options
-            super(options)
-          rescue StandardError => exception
-            warn exception.message
-            warn exception.backtrace.join("\n\t")
-            exit(1)
-          end
-        end
-
-        # @since 1.1.0
-        # @api private
-        def initialize(command_name:, out: $stdout, files: Utils::Files)
-          super(command_name: command_name)
-
-          @out   = out
-          @files = files
-        end
-
-        private
-
-        # Template renderer
-        #
-        # @since 1.1.0
-        # @api private
-        class Renderer
-          # @since 1.1.0
-          # @api private
-          TRIM_MODE = "-"
-
-          # @since 1.1.0
-          # @api private
-          def initialize
-            freeze
-          end
-
-          # @since 1.1.0
-          # @api private
-          def call(template, context)
-            ::ERB.new(template, nil, TRIM_MODE).result(context)
-          end
-        end
-
-        # @since 1.1.0
-        # @api private
-        SAY_FORMATTER = "%<operation>12s  %<path>s\n"
-
-        # @since 1.1.0
-        # @api private
-        attr_reader :out
-
-        # @since 1.1.0
-        # @api private
-        attr_reader :files
-
-        # @since 1.1.0
-        # @api private
-        attr_reader :templates
-
-        # @since 1.1.0
-        # @api private
-        def render(path, context)
-          template = File.read(path)
-          renderer = Renderer.new
-
-          renderer.call(template, context.binding)
-        end
-
-        # @since 1.1.0
-        # @api private
-        def generate_file(source, destination, context)
-          files.write(
-            destination,
-            render(source, context)
-          )
-        end
-
-        # @since 1.1.0
-        # @api private
-        def say(operation, path)
-          out.puts(SAY_FORMATTER % { operation: operation, path: path }) # rubocop:disable Style/FormatString
-        end
-
-        # @since 1.1.0
-        # @api private
-        def project
-          # FIXME: is this still useful?
-          raise "it used to be implemented as Project"
-        end
-
-        # @since 1.1.0
-        # @api private
-        def requirements
-          # FIXME: require components via the new Hanami::Container
-          raise "it used to be implemented as Hanami::Components"
-        end
-      end
-    end
-  end
-end