hanami 0.8.0 → 0.9.0

data/lib/hanami/components.rb

@@ -0,0 +1,107 @@
+require 'concurrent'
+
+module Hanami
+  # Components API
+  #
+  # Components are an internal Hanami that provides precise loading mechanism
+  # for a project. It is responsible to load frameworks, configurations, code, etc..
+  #
+  # The implementation is thread-safe
+  #
+  # @since 0.9.0
+  # @api private
+  module Components
+    # Available components
+    #
+    # @since 0.9.0
+    # @api private
+    @_components = Concurrent::Hash.new
+
+    # Resolved components
+    #
+    # @since 0.9.0
+    # @api private
+    @_resolved   = Concurrent::Map.new
+
+    # Register a component
+    #
+    # @param name [String] the unique component name
+    # @param blk [Proc] the logic of the component
+    #
+    # @since 0.9.0
+    # @api private
+    #
+    # @see Hanami::Components::Component
+    def self.register(name, &blk)
+      @_components[name] = Component.new(name, &blk)
+    end
+
+    # Return a registered component
+    #
+    # @param name [String] the name of the component
+    #
+    # @raise [ArgumentError] if the component is unknown
+    #
+    # @since 0.9.0
+    # @api private
+    def self.component(name)
+      @_components.fetch(name) do
+        raise ArgumentError.new("Component not found: `#{name}'.\nAvailable components are: #{@_components.keys.join(', ')}")
+      end
+    end
+
+    # Mark a component as resolved by providing a value or a block.
+    # In the latter case, the returning value of the block is associated with
+    # the component.
+    #
+    # @param name [String] the name of the component to mark as resolved
+    # @param value [Object] the optional value of the component
+    # @param blk [Proc] the optional block which returning value is associated with the component.
+    #
+    # @since 0.9.0
+    # @api private
+    def self.resolved(name, value = nil, &blk)
+      if block_given?
+        @_resolved.fetch_or_store(name, &blk)
+      else
+        @_resolved.compute_if_absent(name) { value }
+      end
+    end
+
+    # Ask to resolve a component.
+    #
+    # This is used as dependency mechanism.
+    # For instance `model` component depends on `model.configuration`. Before to
+    # resolve `model`, `Components` uses this method to resolve that dependency first.
+    #
+    # @param names [String,Array<String>] one or more components to be resolved
+    #
+    # @since 0.9.0
+    # @api private
+    def self.resolve(*names)
+      Array(names).flatten.each do |name|
+        @_resolved.fetch_or_store(name) do
+          component = @_components.fetch(name)
+          component.call(Hanami.configuration)
+        end
+      end
+    end
+
+    # Return the value of an already resolved component.
+    #
+    # @param name [String] the component name
+    #
+    # @raise [ArgumentError] if the component is unknown or not resolved yet.
+    #
+    # @since 0.9.0
+    # @api private
+    def self.[](name)
+      @_resolved.fetch(name) do
+        raise ArgumentError.new("Component not resolved: `#{name}'.\nResolved components are: #{@_resolved.keys.join(', ')}")
+      end
+    end
+
+    require 'hanami/components/component'
+    require 'hanami/components/components'
+  end
+end

data/lib/hanami/components/app/assets.rb

@@ -0,0 +1,55 @@
+module Hanami
+  module Components
+    module App
+      # hanami-assets configuration for a sigle Hanami application in the project.
+      #
+      # @since 0.9.0
+      # @api private
+      class Assets
+        # Configure hanami-assets for a single Hanami application in the project.
+        #
+        # @param app [Hanami::Configuration::App] a Hanami application
+        #
+        # @since 0.9.0
+        # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def self.resolve(app)
+          config    = app.configuration
+          namespace = app.namespace
+
+          unless namespace.const_defined?('Assets', false)
+            assets = Hanami::Assets.duplicate(namespace) do
+              root             config.root
+
+              scheme           config.scheme
+              host             config.host
+              port             config.port
+
+              public_directory Hanami.public_directory
+              prefix           Utils::PathPrefix.new('/assets').join(config.path_prefix)
+
+              manifest         Hanami.public_directory.join('assets.json')
+              compile          true
+
+              config.assets.__apply(self)
+            end
+
+            assets.configure do
+              cdn host != config.host
+            end
+
+            namespace.const_set('Assets', assets)
+          end
+
+          name = "#{app.app_name}.assets"
+          Components.resolved(name, namespace.const_get('Assets').configuration)
+          Components[name]
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/hanami/components/app/controller.rb

@@ -0,0 +1,69 @@
+require 'hanami/action/session'
+require 'hanami/action/routing_helpers'
+
+module Hanami
+  module Components
+    module App
+      # hanami-controller configuration for a sigle Hanami application in the project.
+      #
+      # @since 0.9.0
+      # @api private
+      class Controller
+        STRICT_TRANSPORT_SECURITY_HEADER = 'Strict-Transport-Security'.freeze
+        STRICT_TRANSPORT_SECURITY_DEFAULT_VALUE = 'max-age=31536000'.freeze
+
+        # Configure hanami-controller for a single Hanami application in the project.
+        #
+        # @param app [Hanami::Configuration::App] a Hanami application
+        #
+        # @since 0.9.0
+        # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def self.resolve(app)
+          config    = app.configuration
+          namespace = app.namespace
+
+          unless namespace.const_defined?('Controller', false)
+            controller = Hanami::Controller.duplicate(namespace) do
+              handle_exceptions config.handle_exceptions
+              default_request_format config.default_request_format
+              default_response_format config.default_response_format
+              default_headers(
+                Hanami::Config::Security::X_FRAME_OPTIONS_HEADER         => config.security.x_frame_options,
+                Hanami::Config::Security::X_CONTENT_TYPE_OPTIONS_HEADER  => config.security.x_content_type_options,
+                Hanami::Config::Security::X_XSS_PROTECTION_HEADER        => config.security.x_xss_protection,
+                Hanami::Config::Security::CONTENT_SECURITY_POLICY_HEADER => config.security.content_security_policy
+              )
+              default_headers[STRICT_TRANSPORT_SECURITY_HEADER] = STRICT_TRANSPORT_SECURITY_DEFAULT_VALUE if config.force_ssl
+
+              if config.cookies.enabled?
+                require 'hanami/action/cookies'
+                prepare { include Hanami::Action::Cookies }
+                cookies config.cookies.default_options
+              end
+
+              if config.sessions.enabled?
+                prepare do
+                  include Hanami::Action::Session
+                  include Hanami::Action::CSRFProtection
+                end
+              end
+
+              prepare { include Hanami::Action::RoutingHelpers }
+
+              config.controller.__apply(self)
+            end
+
+            namespace.const_set('Controller', controller)
+          end
+
+          Components.resolved "#{app.app_name}.controller", namespace.const_get('Controller').configuration
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/hanami/components/app/logger.rb

@@ -0,0 +1,30 @@
+require 'hanami/logger'
+
+module Hanami
+  module Components
+    module App
+      # hanami/logger configuration for a sigle Hanami application in the project.
+      #
+      # @since 0.9.0
+      # @api private
+      class Logger
+        # Configure hanami/logger for a single Hanami application in the project.
+        #
+        # @param app [Hanami::Configuration::App] a Hanami application
+        #
+        # @since 0.9.0
+        # @api private
+        def self.resolve(app)
+          namespace = app.namespace
+          return unless namespace.logger.nil?
+
+          config = app.configuration
+
+          # TODO: review this logic
+          config.logger.app_name(namespace.to_s)
+          namespace.logger = config.logger.build
+        end
+      end
+    end
+  end
+end

data/lib/hanami/components/app/routes.rb

@@ -0,0 +1,51 @@
+require 'hanami/routes'
+require 'hanami/routing/default'
+
+module Hanami
+  module Components
+    module App
+      # hanami-router configuration for a sigle Hanami application in the project.
+      #
+      # @since 0.9.0
+      # @api private
+      class Routes
+        # Configure hanami-router for a single Hanami application in the project.
+        #
+        # @param app [Hanami::Configuration::App] a Hanami application
+        #
+        # @since 0.9.0
+        # @api private
+        def self.resolve(app)
+          namespace = app.namespace
+          routes    = application_routes(app)
+
+          if namespace.routes.nil? # rubocop:disable Style/IfUnlessModifier
+            namespace.routes = Hanami::Routes.new(routes)
+          end
+
+          Components.resolved("#{app.app_name}.routes", routes)
+        end
+
+        def self.application_routes(app) # rubocop:disable Metrics/MethodLength
+          config      = app.configuration
+          namespace   = app.namespace
+
+          resolver    = Hanami::Routing::EndpointResolver.new(pattern: config.controller_pattern, namespace: namespace)
+          default_app = Hanami::Routing::Default.new
+
+          Hanami::Router.new(
+            resolver:    resolver,
+            default_app: default_app,
+            parsers:     config.body_parsers,
+            scheme:      config.scheme,
+            host:        config.host,
+            port:        config.port,
+            prefix:      config.path_prefix,
+            force_ssl:   config.force_ssl,
+            &config.routes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/components/app/view.rb

@@ -0,0 +1,40 @@
+module Hanami
+  module Components
+    module App
+      # hanami-view configuration for a sigle Hanami application in the project.
+      #
+      # @since 0.9.0
+      # @api private
+      class View
+        # Configure hanami-view for a single Hanami application in the project.
+        #
+        # @param app [Hanami::Configuration::App] a Hanami application
+        #
+        # @since 0.9.0
+        # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def self.resolve(app)
+          config    = app.configuration
+          namespace = app.namespace
+
+          unless namespace.const_defined?('View', false)
+            view = Hanami::View.duplicate(namespace) do
+              root   config.templates
+              layout config.layout
+
+              config.view.__apply(self)
+            end
+
+            namespace.const_set('View', view)
+          end
+
+          Components.resolved "#{app.app_name}.view", namespace.const_get('View').configuration
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/hanami/components/component.rb

@@ -0,0 +1,166 @@
+module Hanami
+  module Components
+    # Base component
+    #
+    # @since 0.9.0
+    # @api private
+    #
+    # @see Hanami::Components
+    class Component
+      # Instantiate a new component
+      #
+      # @param name [String] the component name
+      # @param blk [Proc] the logic of the component
+      #
+      # @return [Hanami::Components::Component]
+      #
+      # @since 0.9.0
+      # @api private
+      def initialize(name, &blk)
+        @name         = name
+        @requirements = []
+        @_prepare     = ->(*) {}
+        @_resolve     = -> {}
+        instance_eval(&blk)
+      end
+
+      # Run or resolve the component
+      #
+      # @param configuration [Hanami::Configuration] the Hanami configuration for the project
+      #
+      # @since 0.9.0
+      # @api private
+      def call(configuration)
+        resolve_requirements
+        _prepare.call(configuration)
+
+        unless _run.nil?
+          _run.call(configuration)
+          return
+        end
+
+        resolved(name, _resolve.call(configuration))
+      end
+
+      private
+
+      # Component name
+      #
+      # @return [String]
+      #
+      # @since 0.9.0
+      # @api private
+      attr_reader :name
+
+      # Component requirements
+      #
+      # @return [Array<String>]
+      #
+      # @since 0.9.0
+      # @api private
+      attr_reader :requirements
+
+      # Prepare logic
+      #
+      # @since 0.9.0
+      # @api private
+      attr_accessor :_prepare
+
+      # Resolve logic
+      #
+      # @since 0.9.0
+      # @api private
+      attr_accessor :_resolve
+
+      # Run logic
+      #
+      # @since 0.9.0
+      # @api private
+      attr_accessor :_run
+
+      # Declare component requirement(s)
+      #
+      # @param components [Array<String>] the name of the other components to
+      #   depend on
+      def requires(*components)
+        self.requirements = Array(components).flatten
+      end
+
+      # Declare prepare logic
+      #
+      # @param blk [Proc] prepare logic
+      #
+      # @since 0.9.0
+      # @api private
+      def prepare(&blk)
+        self._prepare = blk
+      end
+
+      # Declare resolve logic
+      #
+      # @param blk [Proc] resolve logic
+      #
+      # @since 0.9.0
+      # @api private
+      def resolve(&blk)
+        self._resolve = blk
+      end
+
+      # Declare run logic
+      #
+      # @param blk [Proc] run logic
+      #
+      # @since 0.9.0
+      # @api private
+      def run(&blk)
+        self._run = blk
+      end
+
+      # Set requirements
+      #
+      # @param names [Array<String>] the requirements
+      #
+      # @since 0.9.0
+      # @api private
+      def requirements=(names)
+        @requirements = Array(names).flatten
+      end
+
+      # Resolve the requirements before to execute the logic of this component
+      #
+      # @since 0.9.0
+      # @api private
+      #
+      # @see Hanami::Components.resolve
+      def resolve_requirements
+        Components.resolve(requirements)
+      end
+
+      # Get a registered component by name
+      #
+      # @param name [String] the component name
+      #
+      # @since 0.9.0
+      # @api private
+      #
+      # @see Hanami::Components.component
+      def component(name)
+        Components.component(name)
+      end
+
+      # Mark a component as resolved by providing a value or a block.
+      #
+      # @param name [String] the name of the component to mark as resolved
+      # @param value [Object] the optional value of the component
+      # @param blk [Proc] the optional block which returning value is associated with the component.
+      #
+      # @since 0.9.0
+      # @api private
+      #
+      # @see Hanami::Components.resolved
+      def resolved(name, value = nil, &blk)
+        Components.resolved(name, value, &blk)
+      end
+    end
+  end
+end