hanami 2.0.0.alpha7.1 → 2.0.0.alpha8

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

data/lib/hanami/configuration/actions.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
-# require_relative "application_configuration/cookies"
-# require_relative "application_configuration/sessions"
-# require_relative "application_configuration/content_security_policy"
-# require_relative "configuration"
-# require_relative "view_name_inferrer"
+require "dry/configurable"
+require "hanami/action/configuration"
+require_relative "actions/cookies"
+require_relative "actions/sessions"
+require_relative "actions/content_security_policy"
+require_relative "../application/view_name_inferrer"
 
 module Hanami
   class Configuration
+    # Hanami actions configuration
+    #
+    # @since 2.0.0
     class Actions
       include Dry::Configurable
 
@@ -17,15 +21,18 @@ module Hanami
 
       setting :name_inference_base, default: "actions"
       setting :view_context_identifier, default: "view.context"
-      setting :view_name_inferrer, default: ViewNameInferrer
+      setting :view_name_inferrer, default: Application::ViewNameInferrer
       setting :view_name_inference_base, default: "views"
 
       attr_accessor :content_security_policy
 
+      attr_reader :base_configuration
+      private :base_configuration
+
       def initialize(*, **options)
         super()
 
-        @base_configuration = Configuration.new
+        @base_configuration = Hanami::Action::Configuration.new
         @content_security_policy = ContentSecurityPolicy.new do |csp|
           if assets_server_url = options[:assets_server_url]
             csp[:script_src] += " #{assets_server_url}"
@@ -41,8 +48,8 @@ module Hanami
         # (neither true nor false), so we can default it to whether sessions are enabled
         self.csrf_protection = sessions.enabled? if csrf_protection.nil?
 
-        if self.content_security_policy
-          self.default_headers["Content-Security-Policy"] = self.content_security_policy.to_str
+        if content_security_policy
+          default_headers["Content-Security-Policy"] = content_security_policy.to_str
         end
       end
 
@@ -58,8 +65,6 @@ module Hanami
 
       private
 
-      attr_reader :base_configuration
-
       # Apply defaults for base configuration settings
       def configure_defaults
         self.default_request_format = :html

data/lib/hanami/configuration/logger.rb

@@ -11,9 +11,9 @@ module Hanami
     class Logger
       include Dry::Configurable
 
-      protected :config
+      attr_reader :application_name
 
-      setting :application_name
+      protected :config
 
       setting :level
 
@@ -30,7 +30,6 @@ module Hanami
       setting :logger_class, default: Hanami::Logger
 
       def initialize(env:, application_name:)
-        @env = env
         @application_name = application_name
 
         config.level = case env
@@ -58,12 +57,16 @@ module Hanami
                         end
       end
 
-      def finalize!
-        config.application_name = @application_name.call
-      end
-
       def instance
-        logger_class.new(application_name, *options, stream: stream, level: level, formatter: formatter, filter: filters, colorizer: colors)
+        logger_class.new(
+          application_name.name,
+          *options,
+          stream: stream,
+          level: level,
+          formatter: formatter,
+          filter: filters,
+          colorizer: colors
+        )
       end
 
       private

data/lib/hanami/configuration/views.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/view"
+
+module Hanami
+  class Configuration
+    # Hanami actions configuration
+    #
+    # @since 2.0.0
+    class Views
+      include Dry::Configurable
+
+      setting :parts_path, default: "view/parts"
+
+      attr_reader :base_configuration
+      private :base_configuration
+
+      def initialize(*)
+        super
+
+        @base_configuration = Hanami::View.config.dup
+
+        configure_defaults
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        self.class.settings + View.settings - NON_FORWARDABLE_METHODS
+      end
+
+      def finalize!
+        return self if frozen?
+
+        base_configuration.finalize!
+
+        super
+      end
+
+      private
+
+      def configure_defaults
+        self.paths = ["templates"]
+        self.template_inference_base = "views"
+        self.layout = "application"
+      end
+
+      # An inflector for views is not configurable via `config.views.inflector` on an
+      # `Hanami::Application`. The application-wide inflector is already configurable
+      # there as `config.inflector` and will be used as the default inflector for views.
+      #
+      # A custom inflector may still be provided in an `Hanami::View` subclass, via
+      # `config.inflector=`.
+      NON_FORWARDABLE_METHODS = %i[inflector inflector=].freeze
+      private_constant :NON_FORWARDABLE_METHODS
+
+      def method_missing(name, *args, &block)
+        return super if NON_FORWARDABLE_METHODS.include?(name)
+
+        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
+
+      def respond_to_missing?(name, _include_all = false)
+        return false if NON_FORWARDABLE_METHODS.include?(name)
+
+        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration.rb

@@ -19,14 +19,13 @@ module Hanami
   # Hanami application configuration
   #
   # @since 2.0.0
-  #
-  # rubocop:disable Metrics/ClassLength
   class Configuration
     include Dry::Configurable
 
     DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
     private_constant :DEFAULT_ENVIRONMENTS
 
+    attr_reader :application_name
     attr_reader :env
 
     attr_reader :actions
@@ -37,8 +36,9 @@ module Hanami
     attr_reader :environments
     private :environments
 
+    # rubocop:disable Metrics/AbcSize
     def initialize(application_name:, env:)
-      @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+      @application_name = application_name
 
       @environments = DEFAULT_ENVIRONMENTS.clone
       @env = env
@@ -48,46 +48,29 @@ module Hanami
       self.root = Dir.pwd
       self.settings_store = Application::Settings::DotenvStore.new.with_dotenv_loaded
 
-      config.logger = Configuration::Logger.new(env: env, application_name: method(:application_name))
+      config.logger = Configuration::Logger.new(env: env, application_name: application_name)
 
-      @assets = begin
-        require_path = "hanami/assets/application_configuration"
-        require require_path
+      @assets = load_dependent_config("hanami/assets/application_configuration") {
         Hanami::Assets::ApplicationConfiguration.new
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      }
 
-      # Config for actions (same for views, below) may not be available if the gem isn't
-      # loaded; fall back to a null config object if it's missing
-      @actions = begin
-        require_path = "hanami/action/application_configuration"
-        require require_path
-        Hanami::Action::ApplicationConfiguration.new(assets_server_url: assets.server_url)
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      @actions = load_dependent_config("hanami/action") {
+        require_relative "configuration/actions"
+        Actions.new
+      }
 
       @middleware = Middleware.new
 
       @router = Router.new(self)
 
-      @views = begin
-        require_path = "hanami/view/application_configuration"
-        require require_path
-        Hanami::View::ApplicationConfiguration.new
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      @views = load_dependent_config("hanami/view") {
+        require_relative "configuration/views"
+        Views.new
+      }
 
       yield self if block_given?
     end
+    # rubocop:enable Metrics/AbcSize
 
     def environment(env_name, &block)
       environments[env_name] << block
@@ -109,14 +92,6 @@ module Hanami
       super
     end
 
-    def namespace
-      inflector.constantize(@namespace)
-    end
-
-    def application_name
-      inflector.underscore(@namespace).to_sym
-    end
-
     setting :root, constructor: -> path { Pathname(path) }
 
     setting :inflector, default: Dry::Inflector.new
@@ -162,6 +137,16 @@ module Hanami
       end
     end
 
+    def load_dependent_config(require_path, &block)
+      require require_path
+      yield
+    rescue LoadError => e
+      raise e unless e.path == require_path
+
+      require_relative "configuration/null_configuration"
+      NullConfiguration.new
+    end
+
     def method_missing(name, *args, &block)
       if config.respond_to?(name)
         config.public_send(name, *args, &block)

data/lib/hanami/constants.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
 module Hanami
+  CONTAINER_KEY_DELIMITER = "."
+  private_constant :CONTAINER_KEY_DELIMITER
+
   # @api private
   MODULE_DELIMITER = "::"
   private_constant :MODULE_DELIMITER
 
+  PATH_DELIMITER = "/"
+  private_constant :PATH_DELIMITER
+
   # @api private
   CONFIG_DIR = "config"
   private_constant :CONFIG_DIR

data/lib/hanami/errors.rb

@@ -9,4 +9,7 @@ module Hanami
 
   # @since 2.0.0
   SliceLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  ComponentLoadError = Class.new(Error)
 end

data/lib/hanami/slice.rb

@@ -4,20 +4,21 @@ 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
-    def self.inherited(klass)
+    def self.inherited(subclass)
       super
 
-      klass.extend(ClassMethods)
+      subclass.extend(ClassMethods)
 
       # Eagerly initialize any variables that may be accessed inside the subclass body
-      klass.instance_variable_set(:@application, Hanami.application)
-      klass.instance_variable_set(:@container, Class.new(Dry::System::Container))
+      subclass.instance_variable_set(:@application, Hanami.application)
+      subclass.instance_variable_set(:@container, Class.new(Dry::System::Container))
     end
 
     # rubocop:disable Metrics/ModuleLength
@@ -25,15 +26,11 @@ module Hanami
       attr_reader :application, :container
 
       def slice_name
-        inflector.underscore(name.split(MODULE_DELIMITER)[-2]).to_sym
+        @slice_name ||= SliceName.new(self, inflector: method(:inflector))
       end
 
       def namespace
-        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
-      end
-
-      def namespace_path
-        inflector.underscore(namespace)
+        slice_name.namespace
       end
 
       def root
@@ -175,7 +172,7 @@ module Hanami
       end
 
       def prepare_container_base_config
-        container.config.name = slice_name
+        container.config.name = slice_name.to_sym
         container.config.root = root
         container.config.provider_dirs = [File.join("config", "providers")]
 
@@ -199,7 +196,7 @@ module Hanami
             # 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)
+            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.
@@ -207,7 +204,7 @@ 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)
@@ -224,7 +221,7 @@ module Hanami
         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))

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