hanami 2.0.0.alpha1 → 2.0.0.alpha5

data/lib/hanami/application.rb

@@ -1,70 +1,366 @@
 # frozen_string_literal: true
 
+require "dry/system/container"
+require "dry/system/loader/autoloading"
 require "hanami/configuration"
-require "hanami/routes"
-require "hanami/router"
+require "pathname"
+require "rack"
+require "zeitwerk"
+require_relative "slice"
+require_relative "application/autoloader/inflector_adapter"
 
 module Hanami
-  # Hanami application
+  # Hanami application class
   #
   # @since 2.0.0
   class Application
     @_mutex = Mutex.new
 
-    def self.inherited(app)
-      @_mutex.synchronize do
-        app.class_eval do
-          @_mutex         = Mutex.new
-          @_configuration = Hanami::Configuration.new(env: Hanami.env)
+    class << self
+      def inherited(klass)
+        @_mutex.synchronize do
+          klass.class_eval do
+            @_mutex         = Mutex.new
+            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
 
-          extend ClassMethods
-          include InstanceMethods
-        end
+            extend ClassMethods
+          end
 
-        Hanami.application = app
+          klass.send :prepare_base_load_path
+
+          Hanami.application = klass
+        end
       end
     end
 
-    # Class method interface
+    # Application class interface
     #
-    # @since 2.0.0
+    # rubocop:disable Metrics/ModuleLength
     module ClassMethods
+      def self.extended(klass)
+        klass.class_eval do
+          @inited = @booted = false
+        end
+      end
+
       def configuration
         @_configuration
       end
 
       alias config configuration
 
-      def routes(&blk)
+      def init # rubocop:disable Metrics/MethodLength
+        return self if inited?
+
+        configuration.finalize!
+
+        @autoloader = Zeitwerk::Loader.new
+        autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
+
+        load_settings
+
+        @container = prepare_container
+        @deps_module = prepare_deps_module
+
+        load_slices
+        slices.values.each(&:init)
+        slices.freeze
+
+        autoloader.setup
+
+        @inited = true
+        self
+      end
+
+      def boot(&block)
+        return self if booted?
+
+        init
+
+        container.finalize!(&block)
+
+        slices.values.each(&:boot)
+
+        @booted = true
+        self
+      end
+
+      def shutdown
+        container.shutdown!
+      end
+
+      def inited?
+        @inited
+      end
+
+      def booted?
+        @booted
+      end
+
+      def autoloader
+        raise "Application not init'ed" unless defined?(@autoloader)
+
+        @autoloader
+      end
+
+      def container
+        raise "Application not init'ed" unless defined?(@container)
+
+        @container
+      end
+
+      def deps
+        raise "Application not init'ed" unless defined?(@deps_module)
+
+        @deps_module
+      end
+
+      def router
+        raise "Application not init'ed" unless inited?
+
         @_mutex.synchronize do
-          if blk.nil?
-            raise "Hanami.application.routes not configured" unless defined?(@_routes)
+          @_router ||= load_router
+        end
+      end
 
-            @_routes
-          else
-            @_routes = Routes.new(&blk)
-          end
+      def rack_app
+        @rack_app ||= router.to_rack_app
+      end
+
+      def slices
+        @slices ||= {}
+      end
+
+      def register_slice(name, **slice_args)
+        raise "Slice +#{name}+ already registered" if slices.key?(name.to_sym)
+
+        slice = Slice.new(self, name: name, **slice_args)
+        slice.namespace.const_set :Slice, slice if slice.namespace # rubocop:disable Style/SafeNavigation
+        slices[name.to_sym] = slice
+      end
+
+      def register(*args, **opts, &block)
+        container.register(*args, **opts, &block)
+      end
+
+      def register_bootable(*args, **opts, &block)
+        container.boot(*args, **opts, &block)
+      end
+
+      def init_bootable(*args)
+        container.init(*args)
+      end
+
+      def start_bootable(*args)
+        container.start(*args)
+      end
+
+      def key?(*args)
+        container.key?(*args)
+      end
+
+      def keys
+        container.keys
+      end
+
+      def [](*args)
+        container[*args]
+      end
+
+      def resolve(*args)
+        container.resolve(*args)
+      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 inited before detecting providers" unless inited?
+
+        # [Admin, Main, MyApp] or [MyApp::Admin, MyApp::Main, MyApp]
+        providers = slices.values + [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_container
+        define_container.tap do |container|
+          configure_container container
         end
       end
-    end
 
-    # Instance method interface
-    #
-    # @since 2.0.0
-    module InstanceMethods
-      def initialize(configuration: self.class.configuration, routes: self.class.routes)
-        @app = Rack::Builder.new do
-          configuration.for_each_middleware do |m, *args|
-            use m, *args
-          end
+      def prepare_deps_module
+        define_deps_module
+      end
+
+      def define_container
+        require "#{application_name}/container"
+        namespace.const_get :Container
+      rescue LoadError, NameError
+        namespace.const_set :Container, Class.new(Dry::System::Container)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def configure_container(container)
+        container.use :env, inferrer: -> { Hanami.env }
+        container.use :notifications
+
+        container.configure do |config|
+          config.inflector = configuration.inflector
+
+          config.root = configuration.root
+          config.bootable_dirs = [
+            "config/boot",
+            Pathname(__dir__).join("application/container/boot").realpath,
+          ]
 
-          run Hanami::Router.new(**configuration.router_settings, &routes)
+          config.component_dirs.loader = Dry::System::Loader::Autoloading
+          config.component_dirs.add_to_load_path = false
         end
+
+        # 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
+
+        # Add lib/ to to the $LOAD_PATH so other files there (outside the app namespace)
+        # are require-able
+        container.add_to_load_path!("lib") if root.join("lib").directory?
+
+        container
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def define_deps_module
+        require "#{application_name}/deps"
+        namespace.const_get :Deps
+      rescue LoadError, NameError
+        namespace.const_set :Deps, container.injector
+      end
+
+      def load_slices
+        Dir[File.join(slices_path, "*")]
+          .select(&File.method(:directory?))
+          .each(&method(:load_slice))
+      end
+
+      def slices_path
+        File.join(root, config.slices_dir)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def load_slice(slice_path)
+        slice_path = Pathname(slice_path)
+
+        slice_name = slice_path.relative_path_from(Pathname(slices_path)).to_s
+        slice_const_name = inflector.camelize(slice_name)
+
+        if config.slices_namespace.const_defined?(slice_const_name)
+          slice_module = config.slices_namespace.const_get(slice_const_name)
+
+          raise "Cannot use slice +#{slice_const_name}+ since it is not a module" unless slice_module.is_a?(Module)
+        else
+          slice_module = Module.new
+          config.slices_namespace.const_set inflector.camelize(slice_name), slice_module
+        end
+
+        register_slice(
+          slice_name,
+          namespace: slice_module,
+          root: slice_path.realpath
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      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
+
+      MODULE_DELIMITER = "::"
+      private_constant :MODULE_DELIMITER
+
+      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 call(env)
-        @app.call(env)
+      def router_resolver
+        config.router.resolver.new(
+          slices: slices,
+          inflector: inflector
+        )
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/assets/application_configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "hanami/assets/configuration"
+require "dry/configurable"
+
+module Hanami
+  module Assets
+    # @since 2.0.0
+    # @api public
+    class ApplicationConfiguration
+      include Dry::Configurable
+
+      setting :server_url, default: "http://localhost:8080"
+
+      # @since 2.0.0
+      # @api private
+      def initialize(*)
+        super
+
+        @base_configuration = Assets::Configuration.new
+      end
+
+      # @since 2.0.0
+      # @api private
+      def finalize!
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        base_configuration.settings + self.class.settings
+      end
+
+      private
+
+      # @since 2.0.0
+      # @api private
+      attr_reader :base_configuration
+
+      # @since 2.0.0
+      # @api private
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        elsif base_configuration.respond_to?(name)
+          base_configuration.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # @since 2.0.0
+      # @api private
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/assets/configuration.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  module Assets
+    # @since 2.0.0
+    # @api public
+    class Configuration
+      include Dry::Configurable
+
+      # Initialize the Configuration
+      #
+      # @yield [config] the configuration object
+      #
+      # @return [Configuration]
+      #
+      # @since 2.0.0
+      # @api private
+      def initialize(*)
+        super
+        yield self if block_given?
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        self.class.settings
+      end
+
+      private
+
+      # @since 2.0.0
+      # @api private
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # @since 2.0.0
+      # @api private
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/boot/source_dirs.rb

@@ -0,0 +1,44 @@
+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/boot.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "hanami"
+require_relative "setup"
 
 Hanami.boot

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

@@ -0,0 +1,40 @@
+# 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/init"
+            application = Hanami.application
+
+            [command.with_application(application), arguments]
+          else
+            [command, arguments]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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