hanami 2.0.0.alpha7.1 → 2.0.0.beta1.1

data/lib/hanami/application.rb

@@ -1,299 +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 "application/slice_registrar"
-
-module Hanami
-  # Hanami application class
-  #
-  # @since 2.0.0
-  class Application
-    @_mutex = Mutex.new
-
-    class << self
-      def inherited(klass)
-        super
-        @_mutex.synchronize do
-          klass.class_eval do
-            @_mutex = Mutex.new
-            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
-            @autoloader = Zeitwerk::Loader.new
-            @container = Class.new(Dry::System::Container)
-
-            extend ClassMethods
-          end
-
-          klass.send :prepare_base_load_path
-
-          Hanami.application = klass
-        end
-      end
-    end
-
-    # Application class interface
-    #
-    # rubocop:disable Metrics/ModuleLength
-    module ClassMethods
-      attr_reader :autoloader, :container
-
-      def self.extended(klass)
-        klass.class_eval do
-          @prepared = @booted = false
-        end
-      end
-
-      def configuration
-        @_configuration
-      end
-
-      alias_method :config, :configuration
-
-      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
-        configuration.namespace
-      end
-
-      def namespace_name
-        namespace.name
-      end
-
-      def namespace_path
-        inflector.underscore(namespace)
-      end
-
-      def application_name
-        configuration.application_name
-      end
-
-      def root
-        configuration.root
-      end
-
-      def inflector
-        configuration.inflector
-      end
-
-      # @api private
-      def component_provider(component)
-        raise "Hanami.application must be prepared before detecting providers" unless prepared?
-
-        # e.g. [Admin, Main, MyApp]
-        providers = slices.to_a + [self]
-
-        component_class = component.is_a?(Class) ? component : component.class
-        component_name = component_class.name
-
-        return unless component_name
-
-        providers.detect { |provider| component_name.include?(provider.namespace.to_s) }
-      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", namespace_path).directory?
-          autoloader.push_dir(root.join("lib", namespace_path), 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", namespace_path).directory?
-          autoloader.push_dir(root.join("lib", namespace_path), 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([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/boot/source_dirs.rb

@@ -1,44 +0,0 @@
-module Hanami
-  module Boot
-    module SourceDirs
-      def self.setup_component_dir!(component_dir, slice, container)
-        # TODO: this `== "lib"` check should be codified into a method somewhere
-        if component_dir.path == "lib"
-          # Expect component files in the root of the lib
-          # component dir to define classes inside the slice's namespace.
-          #
-          # e.g. "lib/foo.rb" should define SliceNamespace::Foo, and will be
-          # registered as "foo"
-          component_dir.namespaces.root(key: nil, const: slice.namespace_path)
-
-          slice.application.autoloader.push_dir(slice.root.join("lib"), namespace: slice.namespace)
-
-          container.config.component_dirs.add(component_dir)
-        else
-          # Expect component files in the root of these component dirs to define
-          # classes inside a namespace matching the dir.
-          #
-          # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, and
-          # will be registered as "actions.foo"
-
-          dir_namespace_path = File.join(slice.namespace_path, component_dir.path)
-
-          autoloader_namespace = begin
-            slice.inflector.constantize(slice.inflector.camelize(dir_namespace_path))
-          rescue NameError
-            slice.namespace.const_set(slice.inflector.camelize(component_dir.path), Module.new)
-          end
-
-          # TODO: do we need to do something special to clear out any previously configured root namespace here?
-          component_dir.namespaces.root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
-          container.config.component_dirs.add(component_dir)
-
-          slice.application.autoloader.push_dir(
-            slice.root.join(component_dir.path),
-            namespace: autoloader_namespace
-          )
-        end
-      end
-    end
-  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