hanami 2.0.0.alpha6 → 2.0.0.alpha8

data/lib/hanami/application/view.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require_relative "../slice_configurable"
+require_relative "view/slice_configured_view"
+
+module Hanami
+  class Application
+    # Superclass for views intended for use within an Hanami application.
+    #
+    # @see Hanami::View
+    #
+    # @api public
+    # @since 2.0.0
+    class View < Hanami::View
+      extend Hanami::SliceConfigurable
+
+      # @api private
+      def self.configure_for_slice(slice)
+        extend SliceConfiguredView.new(slice)
+      end
+    end
+  end
+end

data/lib/hanami/application/view_name_inferrer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  class Application
+    # Infers a view name for automatically rendering within actions.
+    #
+    # @api private
+    # @since 2.0.0
+    class ViewNameInferrer
+      ALTERNATIVE_NAMES = {
+        "create" => "new",
+        "update" => "edit"
+      }.freeze
+
+      class << self
+        # Returns an array of container keys for views matching the given action.
+        #
+        # Also provides alternative view keys for common RESTful actions.
+        #
+        # @example
+        #   ViewNameInferrer.call(action_name: "Main::Actions::Posts::Create", slice: Main::Slice)
+        #   # => ["views.posts.create", "views.posts.new"]
+        #
+        # @param action_name [String] action class name
+        # @param slice [Hanami::Slice, Hanami::Application] Hanami slice containing the action
+        #
+        # @return [Array<string>] array of paired view container keys
+        def call(action_class_name:, slice:)
+          action_key_base = slice.application.config.actions.name_inference_base
+          view_key_base = slice.application.config.actions.view_name_inference_base
+
+          action_name_key = action_name_key(action_class_name, slice, action_key_base)
+
+          view_key = [view_key_base, action_name_key].compact.join(CONTAINER_KEY_DELIMITER)
+
+          [view_key, alternative_view_key(view_key)].compact
+        end
+
+        private
+
+        def action_name_key(action_name, slice, key_base)
+          slice
+            .inflector
+            .underscore(action_name)
+            .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+            .sub(%r{^#{key_base}#{PATH_DELIMITER}}, "")
+            .gsub("/", CONTAINER_KEY_DELIMITER)
+        end
+
+        def alternative_view_key(view_key)
+          parts = view_key.split(CONTAINER_KEY_DELIMITER)
+
+          alternative_name = ALTERNATIVE_NAMES[parts.last]
+          return unless alternative_name
+
+          [parts[0..-2], alternative_name].join(CONTAINER_KEY_DELIMITER)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
-require "dry/system/loader/autoloading"
 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
@@ -16,19 +18,25 @@ module Hanami
     @_mutex = Mutex.new
 
     class << self
-      def inherited(klass)
+      def inherited(subclass)
         super
+
         @_mutex.synchronize do
-          klass.class_eval do
-            @_mutex         = Mutex.new
-            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
+          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
 
-          klass.send :prepare_base_load_path
+          subclass.send :prepare_base_load_path
 
-          Hanami.application = klass
+          Hanami.application = subclass
         end
       end
     end
@@ -37,39 +45,24 @@ module Hanami
     #
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
-      def self.extended(klass)
-        klass.class_eval do
-          @prepared = @booted = false
-        end
-      end
+      attr_reader :application_name, :configuration, :autoloader, :container
 
-      def configuration
-        @_configuration
-      end
+      alias_method :slice_name, :application_name
 
       alias_method :config, :configuration
 
+      def application
+        self
+      end
+
       def prepare(provider_name = nil)
-        if provider_name
-          container.prepare(provider_name)
-          return self
-        end
+        container.prepare(provider_name) and return self if provider_name
 
         return self if prepared?
 
         configuration.finalize!
 
-        load_settings
-
-        @autoloader = Zeitwerk::Loader.new
-        @container = prepare_container
-        @deps_module = prepare_deps_module
-
-        load_slices
-        slices.each_value(&:prepare)
-        slices.freeze
-
-        @autoloader.setup
+        prepare_all
 
         @prepared = true
         self
@@ -82,40 +75,24 @@ module Hanami
 
         container.finalize!(&block)
 
-        slices.values.each(&:boot)
+        slices.each(&:boot)
 
         @booted = true
         self
       end
 
       def shutdown
+        slices.each(&:shutdown)
         container.shutdown!
+        self
       end
 
       def prepared?
-        @prepared
+        !!@prepared
       end
 
       def booted?
-        @booted
-      end
-
-      def autoloader
-        raise "Application not yet prepared" unless defined?(@autoloader)
-
-        @autoloader
-      end
-
-      def container
-        raise "Application not yet prepared" unless defined?(@container)
-
-        @container
-      end
-
-      def deps
-        raise "Application not yet prepared" unless defined?(@deps_module)
-
-        @deps_module
+        !!@booted
       end
 
       def router
@@ -131,15 +108,11 @@ module Hanami
       end
 
       def slices
-        @slices ||= {}
+        @slices ||= SliceRegistrar.new(self)
       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
+      def register_slice(...)
+        slices.register(...)
       end
 
       def register(...)
@@ -175,19 +148,7 @@ module Hanami
       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
+        application_name.namespace
       end
 
       def root
@@ -198,21 +159,6 @@ module Hanami
         configuration.inflector
       end
 
-      # @api private
-      def component_provider(component)
-        raise "Hanami.application must be prepared before detecting providers" unless prepared?
-
-        # [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
@@ -220,20 +166,25 @@ module Hanami
         $LOAD_PATH.unshift base_path unless $LOAD_PATH.include?(base_path)
       end
 
-      # rubocop:disable Metrics/AbcSize
-      def prepare_container
-        container =
-          begin
-            require "#{application_name}/container"
-            namespace.const_get :Container
-          rescue LoadError, NameError
-            namespace.const_set :Container, Class.new(Dry::System::Container)
-          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
 
-        container.use :env, inferrer: -> { Hanami.env }
-        container.use :zeitwerk, loader: autoloader, run_setup: false, eager_load: false
-        container.use :notifications
+      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
 
@@ -241,63 +192,32 @@ module Hanami
           "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?
-          container.autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
+        if root.join("lib", application_name.name).directory?
+          autoloader.push_dir(root.join("lib", application_name.name), namespace: namespace)
         end
-
-        # Add lib/ to to the $LOAD_PATH so any files there (outside the app namespace) can
-        # be required
-        container.add_to_load_path!("lib") if root.join("lib").directory?
-
-        container.configured!
-
-        container
       end
-      # rubocop:enable Metrics/AbcSize
 
-      def prepare_deps_module
-        define_deps_module
-      end
-
-      def define_deps_module
-        require "#{application_name}/deps"
-        namespace.const_get :Deps
-      rescue LoadError, NameError
+      def prepare_container_consts
+        namespace.const_set :Container, container
         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)
+      def prepare_slices
+        slices.load_slices.each(&:prepare)
+        slices.freeze
       end
 
-      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
+      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
 
-        register_slice(
-          slice_name,
-          namespace: slice_module,
-          root: slice_path.realpath
-        )
+        autoloader.setup
       end
 
       def load_settings
@@ -311,11 +231,8 @@ module Hanami
         Settings.new
       end
 
-      MODULE_DELIMITER = "::"
-      private_constant :MODULE_DELIMITER
-
       def autodiscover_application_constant(constants)
-        inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
+        inflector.constantize([application_name.namespace_name, *constants].join(MODULE_DELIMITER))
       end
 
       def load_router

data/lib/hanami/configuration/actions/content_security_policy.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Configuration
+    class Actions
+      # Configuration for Content Security Policy in Hanami applications
+      #
+      # @since 2.0.0
+      class ContentSecurityPolicy
+        # @since 2.0.0
+        # @api private
+        def initialize(&blk)
+          @policy = {
+            base_uri: "'self'",
+            child_src: "'self'",
+            connect_src: "'self'",
+            default_src: "'none'",
+            font_src: "'self'",
+            form_action: "'self'",
+            frame_ancestors: "'self'",
+            frame_src: "'self'",
+            img_src: "'self' https: data:",
+            media_src: "'self'",
+            object_src: "'none'",
+            plugin_types: "application/pdf",
+            script_src: "'self'",
+            style_src: "'self' 'unsafe-inline' https:"
+          }
+
+          blk&.(self)
+        end
+
+        # @since 2.0.0
+        # @api private
+        def initialize_copy(original_object)
+          @policy = original_object.instance_variable_get(:@policy).dup
+          super
+        end
+
+        # Get a CSP setting
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        # @return [String,NilClass] the CSP setting, if any
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example
+        #   module MyApp
+        #     class Application < Hanami::Application
+        #       config.actions.content_security_policy[:base_uri] # => "'self'"
+        #     end
+        #   end
+        def [](key)
+          @policy[key]
+        end
+
+        # Set a CSP setting
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        # @param value [String] the CSP setting value
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example Replace a default value
+        #   module MyApp
+        #     class Application < Hanami::Application
+        #       config.actions.content_security_policy[:plugin_types] = nil
+        #     end
+        #   end
+        #
+        # @example Append to a default value
+        #   module MyApp
+        #     class Application < Hanami::Application
+        #       config.actions.content_security_policy[:script_src] += " https://my.cdn.test"
+        #     end
+        #   end
+        def []=(key, value)
+          @policy[key] = value
+        end
+
+        # Deletes a CSP key
+        #
+        # @param key [Symbol] the underscored name of the CPS setting
+        #
+        # @since 2.0.0
+        # @api public
+        #
+        # @example
+        #   module MyApp
+        #     class Application < Hanami::Application
+        #       config.actions.content_security_policy.delete(:object_src)
+        #     end
+        #   end
+        def delete(key)
+          @policy.delete(key)
+        end
+
+        # @since 2.0.0
+        # @api private
+        def to_str
+          @policy.map do |key, value|
+            "#{dasherize(key)} #{value}"
+          end.join(";\n")
+        end
+
+        private
+
+        # @since 2.0.0
+        # @api private
+        def dasherize(key)
+          key.to_s.gsub("_", "-")
+        end
+      end
+    end
+  end
+end

data/lib/hanami/configuration/actions/cookies.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Configuration
+    class Actions
+      # Wrapper for application-level configuration of HTTP cookies for Hanami actions.
+      # This decorates the hash of cookie options that is otherwise directly configurable
+      # on actions, and adds the `enabled?` method to allow `ApplicationAction` to
+      # determine whether to include the `Action::Cookies` module.
+      #
+      # @since 2.0.0
+      class Cookies
+        attr_reader :options
+
+        def initialize(options)
+          @options = options
+        end
+
+        def enabled?
+          !options.nil?
+        end
+
+        def to_h
+          options.to_h
+        end
+      end
+    end
+  end
+end

data/lib/hanami/configuration/actions/sessions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require "hanami/utils/string"
+require "hanami/utils/class"
+
+module Hanami
+  class Configuration
+    class Actions
+      # Configuration for HTTP sessions in Hanami actions
+      #
+      # @since 2.0.0
+      class Sessions
+        attr_reader :storage, :options
+
+        def initialize(storage = nil, *options)
+          @storage = storage
+          @options = options
+        end
+
+        def enabled?
+          !storage.nil?
+        end
+
+        def middleware
+          return [] if !enabled?
+
+          [[storage_middleware, options]]
+        end
+
+        private
+
+        def storage_middleware
+          require_storage
+
+          name = Utils::String.classify(storage)
+          Utils::Class.load!(name, ::Rack::Session)
+        end
+
+        def require_storage
+          require "rack/session/#{storage}"
+        end
+      end
+    end
+  end
+end