hanami 2.0.0.alpha6 → 2.0.0.alpha8

data/lib/hanami/configuration/actions.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+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
+
+      setting :cookies, default: {}, constructor: -> options { Cookies.new(options) }
+      setting :sessions, constructor: proc { |storage, *options| Sessions.new(storage, *options) }
+      setting :csrf_protection
+
+      setting :name_inference_base, default: "actions"
+      setting :view_context_identifier, default: "view.context"
+      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 = 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}"
+            csp[:style_src] += " #{assets_server_url}"
+          end
+        end
+
+        configure_defaults
+      end
+
+      def finalize!
+        # A nil value for `csrf_protection` means it has not been explicitly configured
+        # (neither true nor false), so we can default it to whether sessions are enabled
+        self.csrf_protection = sessions.enabled? if csrf_protection.nil?
+
+        if content_security_policy
+          default_headers["Content-Security-Policy"] = content_security_policy.to_str
+        end
+      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
+
+      # Apply defaults for base configuration settings
+      def configure_defaults
+        self.default_request_format = :html
+        self.default_response_format = :html
+
+        self.default_headers = {
+          "X-Frame-Options" => "DENY",
+          "X-Content-Type-Options" => "nosniff",
+          "X-XSS-Protection" => "1; mode=block"
+        }
+      end
+
+      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
+
+      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/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

@@ -13,21 +13,20 @@ require_relative "configuration/middleware"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
 require_relative "configuration/source_dirs"
+require_relative "constants"
 
 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
 
-    MODULE_DELIMITER = "::"
-    private_constant :MODULE_DELIMITER
+    attr_reader :application_name
+    attr_reader :env
 
     attr_reader :actions
     attr_reader :middleware
@@ -37,57 +36,41 @@ 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
-      config.env = env
+      @env = env
 
       # Some default setting values must be assigned at initialize-time to ensure they
       # have appropriate values for the current application
       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,21 +92,6 @@ module Hanami
       super
     end
 
-    def namespace
-      inflector.constantize(@namespace)
-    end
-
-    def application_name
-      inflector.underscore(@namespace).to_sym
-    end
-
-    setting :env
-
-    def env=(new_env)
-      config.env = env
-      apply_env_config(new_env)
-    end
-
     setting :root, constructor: -> path { Pathname(path) }
 
     setting :inflector, default: Dry::Inflector.new
@@ -148,20 +116,8 @@ module Hanami
 
     setting :settings_store, default: Application::Settings::DotenvStore
 
-    setting :slices_dir, default: "slices"
-
-    setting :slices_namespace, default: Object
-
-    # TODO: convert into a dedicated object with explicit behaviour around blocks per
-    # slice, etc.
-    setting :slices, default: {}, constructor: :dup.to_proc
-
     setting :source_dirs, default: Configuration::SourceDirs.new, cloneable: true
 
-    def slice(slice_name, &block)
-      slices[slice_name] = block
-    end
-
     setting :base_url, default: "http://0.0.0.0:2300", constructor: -> url { URI(url) }
 
     def for_each_middleware(&blk)
@@ -181,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

@@ -0,0 +1,29 @@
+# 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
+
+  # @api private
+  SLICES_DIR = "slices"
+  private_constant :SLICES_DIR
+
+  # @api private
+  LIB_DIR = "lib"
+  private_constant :LIB_DIR
+
+  # @api private
+  RB_EXT = ".rb"
+  private_constant :RB_EXT
+end

data/lib/hanami/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @since 2.0.0
+  Error = Class.new(StandardError)
+
+  # @since 2.0.0
+  ApplicationLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  SliceLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  ComponentLoadError = Class.new(Error)
+end