hanami 2.0.0.alpha6 → 2.0.0.alpha8

data/lib/hanami/slice.rb

@@ -1,130 +1,187 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
+require "hanami/errors"
 require "pathname"
+require_relative "constants"
+require_relative "slice_name"
 
 module Hanami
   # Distinct area of concern within an Hanami application
   #
   # @since 2.0.0
   class Slice
-    attr_reader :application, :name, :namespace, :root
-
-    def initialize(application, name:, namespace: nil, root: nil, container: nil)
-      @application = application
-      @name = name.to_sym
-      @namespace = namespace
-      @root = root ? Pathname(root) : root
-      @container = container
-    end
+    def self.inherited(subclass)
+      super
 
-    def inflector
-      application.inflector
-    end
+      subclass.extend(ClassMethods)
 
-    def namespace_path
-      @namespace_path ||= inflector.underscore(namespace.to_s)
+      # Eagerly initialize any variables that may be accessed inside the subclass body
+      subclass.instance_variable_set(:@application, Hanami.application)
+      subclass.instance_variable_set(:@container, Class.new(Dry::System::Container))
     end
 
-    def prepare(provider_name = nil)
-      if provider_name
-        container.prepare(provider_name)
-        return self
+    # rubocop:disable Metrics/ModuleLength
+    module ClassMethods
+      attr_reader :application, :container
+
+      def slice_name
+        @slice_name ||= SliceName.new(self, inflector: method(:inflector))
       end
 
-      @container ||= define_container
+      def namespace
+        slice_name.namespace
+      end
 
-      container.import from: application.container, as: :application
+      def root
+        application.root.join(SLICES_DIR, slice_name.to_s)
+      end
 
-      slice_block = application.configuration.slices[name]
-      instance_eval(&slice_block) if slice_block
+      def inflector
+        application.inflector
+      end
 
-      # This is here and not inside define_container to allow for the slice block to
-      # interact with container config
-      container.configured!
+      def prepare(provider_name = nil)
+        container.prepare(provider_name) and return self if provider_name
 
-      self
-    end
+        return self if prepared?
 
-    def boot
-      container.finalize!
+        ensure_slice_name
+        ensure_slice_consts
 
-      @booted = true
-      self
-    end
+        prepare_all
 
-    # rubocop:disable Style/DoubleNegation
-    def booted?
-      !!@booted
-    end
-    # rubocop:enable Style/DoubleNegation
+        @prepared = true
+        self
+      end
 
-    def container
-      @container ||= define_container
-    end
+      def prepare_container(&block)
+        @prepare_container_block = block
+      end
 
-    def import(from:, **kwargs)
-      # TODO: This should be handled via dry-system (see dry-rb/dry-system#228)
-      raise "Cannot import after booting" if booted?
+      def boot
+        return self if booted?
 
-      if from.is_a?(Symbol) || from.is_a?(String)
-        slice_name = from
-        # TODO: better error than the KeyError from fetch if the slice doesn't exist
-        from = application.slices.fetch(from.to_sym).container
+        container.finalize!
+
+        @booted = true
+
+        self
       end
 
-      as = kwargs[:as] || slice_name
+      def shutdown
+        container.shutdown!
+        self
+      end
 
-      container.import(from: from, as: as, **kwargs)
-    end
+      def prepared?
+        !!@prepared
+      end
 
-    def register(*args, &block)
-      container.register(*args, &block)
-    end
+      def booted?
+        !!@booted
+      end
 
-    def register_provider(...)
-      container.register_provider(...)
-    end
+      def register(...)
+        container.register(...)
+      end
 
-    def start(...)
-      container.start(...)
-    end
+      def register_provider(...)
+        container.register_provider(...)
+      end
 
-    def key?(...)
-      container.key?(...)
-    end
+      def start(...)
+        container.start(...)
+      end
 
-    def keys
-      container.keys
-    end
+      def key?(...)
+        container.key?(...)
+      end
 
-    def [](...)
-      container.[](...)
-    end
+      def keys
+        container.keys
+      end
 
-    def resolve(...)
-      container.resolve(...)
-    end
+      def [](...)
+        container.[](...)
+      end
 
-    private
+      def resolve(...)
+        container.resolve(...)
+      end
+
+      def export(keys)
+        container.config.exports = keys
+      end
+
+      def import(from:, **kwargs)
+        # TODO: This should be handled via dry-system (see dry-rb/dry-system#228)
+        raise "Cannot import after booting" if booted?
+
+        application = self.application
+
+        container.after(:configure) do
+          if from.is_a?(Symbol) || from.is_a?(String)
+            slice_name = from
+            from = application.slices[from.to_sym].container
+          end
+
+          as = kwargs[:as] || slice_name
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def define_container
-      container = Class.new(Dry::System::Container)
+          import(from: from, as: as, **kwargs)
+        end
+      end
 
-      container.use :env
-      container.use :zeitwerk,
-        loader: application.autoloader,
-        run_setup: false,
-        eager_load: false
+      private
+
+      def ensure_slice_name
+        unless name
+          raise SliceLoadError, "Slice must have a class name before it can be prepared"
+        end
+      end
 
-      container.config.name = name
-      container.config.env = application.configuration.env
-      container.config.inflector = application.configuration.inflector
+      def ensure_slice_consts
+        if namespace.const_defined?(:Container) || namespace.const_defined?(:Deps)
+          raise(
+            SliceLoadError,
+            "#{namespace}::Container and #{namespace}::Deps constants must not already be defined"
+          )
+        end
+      end
 
-      if root&.directory?
+      def prepare_all
+        prepare_container_plugins
+        prepare_container_base_config
+        prepare_container_component_dirs
+        prepare_autoloader
+        prepare_container_imports
+        prepare_container_consts
+        instance_exec(container, &@prepare_container_block) if @prepare_container_block
+        container.configured!
+      end
+
+      def prepare_container_plugins
+        container.use(:env, inferrer: -> { Hanami.env })
+
+        container.use(
+          :zeitwerk,
+          loader: application.autoloader,
+          run_setup: false,
+          eager_load: false
+        )
+      end
+
+      def prepare_container_base_config
+        container.config.name = slice_name.to_sym
         container.config.root = root
-        container.config.provider_dirs = ["config/providers"]
+        container.config.provider_dirs = [File.join("config", "providers")]
+
+        container.config.env = application.configuration.env
+        container.config.inflector = application.configuration.inflector
+      end
+
+      def prepare_container_component_dirs # rubocop:disable Metrics/AbcSize
+        return unless root&.directory?
 
         # Add component dirs for each configured component path
         application.configuration.source_dirs.component_dirs.each do |component_dir|
@@ -132,17 +189,14 @@ module Hanami
 
           component_dir = component_dir.dup
 
-          # TODO: this `== "lib"` check should be codified into a method somewhere
-          if component_dir.path == "lib"
+          if component_dir.path == LIB_DIR
             # 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, to be registered as
             # "foo"
             component_dir.namespaces.delete_root
-            component_dir.namespaces.add_root(key: nil, const: namespace_path)
-
-            container.config.component_dirs.add(component_dir)
+            component_dir.namespaces.add_root(key: nil, const: slice_name.name)
           else
             # Expect component files in the root of non-lib/ component dirs to define
             # classes inside a namespace matching that dir.
@@ -150,22 +204,24 @@ module Hanami
             # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, to be
             # registered as "actions.foo"
 
-            dir_namespace_path = File.join(namespace_path, component_dir.path)
+            dir_namespace_path = File.join(slice_name.name, component_dir.path)
 
             component_dir.namespaces.delete_root
             component_dir.namespaces.add_root(const: dir_namespace_path, key: component_dir.path)
-
-            container.config.component_dirs.add(component_dir)
           end
+
+          container.config.component_dirs.add(component_dir)
         end
       end
 
-      if root&.directory?
+      def prepare_autoloader # rubocop:disable Metrics/AbcSize
+        return unless root&.directory?
+
         # Pass configured autoload dirs to the autoloader
         application.configuration.source_dirs.autoload_paths.each do |autoload_path|
           next unless root.join(autoload_path).directory?
 
-          dir_namespace_path = File.join(namespace_path, autoload_path)
+          dir_namespace_path = File.join(slice_name.name, autoload_path)
 
           autoloader_namespace = begin
             inflector.constantize(inflector.camelize(dir_namespace_path))
@@ -180,13 +236,15 @@ module Hanami
         end
       end
 
-      if namespace
+      def prepare_container_imports
+        container.import from: application.container, as: :application
+      end
+
+      def prepare_container_consts
         namespace.const_set :Container, container
         namespace.const_set :Deps, container.injector
       end
-
-      container
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/slice_configurable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Hanami
+  # Calls `configure_for_slice(slice)` on the extended class whenever it is first
+  # subclassed within a module namespace corresponding to a slice.
+  #
+  # @example
+  #   class BaseClass
+  #     extend Hanami::SliceConfigurable
+  #   end
+  #
+  #   # slices/main/lib/my_class.rb
+  #   module Main
+  #     class MyClass < BaseClass
+  #       # Will be called with `Main::Slice`
+  #       def self.configure_for_slice(slice)
+  #         # ...
+  #       end
+  #     end
+  #   end
+  #
+  # @api private
+  # @since 2.0.0
+  module SliceConfigurable
+    class << self
+      def extended(klass)
+        slice_for = method(:slice_for)
+
+        inherited_mod = Module.new do
+          define_method(:inherited) do |subclass|
+            unless Hanami.application?
+              raise ComponentLoadError, "Class #{klass} must be defined within an Hanami application"
+            end
+
+            super(subclass)
+
+            subclass.instance_variable_set(:@configured_for_slices, configured_for_slices.dup)
+
+            slice = slice_for.(subclass)
+            return unless slice
+
+            unless subclass.configured_for_slice?(slice)
+              subclass.configure_for_slice(slice)
+              subclass.configured_for_slices << slice
+            end
+          end
+        end
+
+        klass.singleton_class.prepend(inherited_mod)
+      end
+
+      private
+
+      def slice_for(klass)
+        return unless klass.name
+
+        slices = Hanami.application.slices.to_a + [Hanami.application]
+
+        slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
+      end
+    end
+
+    def configure_for_slice(slice); end
+
+    def configured_for_slice?(slice)
+      configured_for_slices.include?(slice)
+    end
+
+    def configured_for_slices
+      @configured_for_slices ||= []
+    end
+  end
+end

data/lib/hanami/slice_name.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Hanami
+  # Represents the name of an {Application} or {Slice}.
+  #
+  # @see Application::ClassMethods#application_name
+  # @see Slice::ClassMethods#slice_name
+  #
+  # @api public
+  # @since 2.0.0
+  class SliceName
+    # Returns a new SliceName for the slice or application.
+    #
+    # You must provide an inflector for the manipulation of the name into various formats.
+    # This should be given in the form of a Proc that returns the inflector when called.
+    # The reason for this is that the inflector may be replaced by the user during the
+    # application configuration phase, so the proc should ensure that the current instance
+    # of the inflector is returned whenever needed.
+    #
+    # @param slice [#name] the slice or application object
+    # @param inflector [Proc] Proc returning the application's inflector when called
+    #
+    # @api private
+    def initialize(slice, inflector:)
+      @slice = slice
+      @inflector = inflector
+    end
+
+    # Returns the name of the slice as a downcased, underscored string.
+    #
+    # This is considered the canonical name of the slice.
+    #
+    # @example
+    #   slice_name.name # => "main"
+    #
+    # @return [String] the slice name
+    #
+    # @api public
+    # @since 2.0.0
+    def name
+      inflector.underscore(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :path, :name
+
+    # Returns the name of the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_name # => "Main"
+    #
+    # @return [String] the namespace name
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_name
+      slice_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+    end
+
+    # Returns the constant for the slice's module namespace.
+    #
+    # @example
+    #   slice_name.namespace_const # => Main
+    #
+    # @return [Module] the namespace module constant
+    #
+    # @api public
+    # @since 2.0.0
+    def namespace_const
+      inflector.constantize(namespace_name)
+    end
+
+    # @api public
+    # @since 2.0.0
+    alias_method :namespace, :namespace_const
+
+    # @api public
+    # @since 2.0.0
+    alias_method :to_s, :name
+
+    # Returns the name of a slice as a downcased, underscored symbol.
+    #
+    # @example
+    #   slice_name.name # => :main
+    #
+    # @return [Symbol] the slice name
+    #
+    # @see name, to_s
+    #
+    # @api public
+    # @since 2.0.0
+    def to_sym
+      name.to_sym
+    end
+
+    private
+
+    def slice_name
+      @slice.name
+    end
+
+    # The inflector is callable to allow for it to be configured/replaced after this
+    # object has been initialized
+    def inflector
+      @inflector.()
+    end
+  end
+end

data/lib/hanami/version.rb

@@ -8,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = "2.0.0.alpha6"
+    VERSION = "2.0.0.alpha8"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -1,19 +1,25 @@
 # frozen_string_literal: true
 
+require_relative "hanami/application"
+require_relative "hanami/errors"
+require_relative "hanami/version"
+
+
 # A complete web framework for Ruby
 #
 # @since 0.1.0
 #
 # @see http://hanamirb.org
 module Hanami
-  require "hanami/version"
-  require "hanami/application"
-
   @_mutex = Mutex.new
 
   def self.application
     @_mutex.synchronize do
-      raise "Hanami.application not configured" unless defined?(@_application)
+      unless defined?(@_application)
+        raise ApplicationLoadError,
+          "Hanami.application is not yet configured. " \
+          "You may need to `require \"hanami/setup\"` to load your config/application.rb file."
+      end
 
       @_application
     end
@@ -25,7 +31,9 @@ module Hanami
 
   def self.application=(klass)
     @_mutex.synchronize do
-      raise "Hanami.application already configured" if defined?(@_application)
+      if defined?(@_application)
+        raise ApplicationLoadError, "Hanami.application is already configured."
+      end
 
       @_application = klass unless klass.name.nil?
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha6
+  version: 2.0.0.alpha8
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -217,6 +217,8 @@ files:
 - hanami.gemspec
 - lib/hanami.rb
 - lib/hanami/application.rb
+- lib/hanami/application/action.rb
+- lib/hanami/application/action/slice_configured_action.rb
 - lib/hanami/application/container/providers/inflector.rb
 - lib/hanami/application/container/providers/logger.rb
 - lib/hanami/application/container/providers/rack_logger.rb
@@ -230,8 +232,15 @@ files:
 - lib/hanami/application/routing/resolver.rb
 - lib/hanami/application/routing/resolver/node.rb
 - lib/hanami/application/routing/resolver/trie.rb
+- lib/hanami/application/routing/router.rb
 - lib/hanami/application/settings.rb
 - lib/hanami/application/settings/dotenv_store.rb
+- lib/hanami/application/slice_registrar.rb
+- lib/hanami/application/view.rb
+- lib/hanami/application/view/context.rb
+- lib/hanami/application/view/slice_configured_context.rb
+- lib/hanami/application/view/slice_configured_view.rb
+- lib/hanami/application/view_name_inferrer.rb
 - lib/hanami/assets/application_configuration.rb
 - lib/hanami/assets/configuration.rb
 - lib/hanami/boot.rb
@@ -244,16 +253,25 @@ files:
 - lib/hanami/cli/commands/command.rb
 - lib/hanami/cli/commands/server.rb
 - lib/hanami/configuration.rb
+- lib/hanami/configuration/actions.rb
+- lib/hanami/configuration/actions/content_security_policy.rb
+- lib/hanami/configuration/actions/cookies.rb
+- lib/hanami/configuration/actions/sessions.rb
 - lib/hanami/configuration/logger.rb
 - lib/hanami/configuration/middleware.rb
 - lib/hanami/configuration/null_configuration.rb
 - lib/hanami/configuration/router.rb
 - lib/hanami/configuration/sessions.rb
 - lib/hanami/configuration/source_dirs.rb
+- lib/hanami/configuration/views.rb
+- lib/hanami/constants.rb
+- lib/hanami/errors.rb
 - lib/hanami/prepare.rb
 - lib/hanami/server.rb
 - lib/hanami/setup.rb
 - lib/hanami/slice.rb
+- lib/hanami/slice_configurable.rb
+- lib/hanami/slice_name.rb
 - lib/hanami/version.rb
 - lib/hanami/web/rack_logger.rb
 homepage: http://hanamirb.org
@@ -277,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: The web, with simplicity