hanami 1.3.1 → 2.0.0.alpha2

data/lib/hanami/cli/commands/command.rb

@@ -1,12 +1,10 @@
-require 'hanami'
-require 'hanami/environment'
-require 'hanami/components'
-require 'hanami/cli/command'
-require 'hanami/cli/commands/project'
-require 'hanami/cli/commands/templates'
-require 'concurrent'
-require 'hanami/utils/files'
-require 'erb'
+# frozen_string_literal: true
+
+require "hanami"
+require "hanami/cli/command"
+require "concurrent"
+require "hanami/utils/files"
+require "erb"
 
 module Hanami
   # Hanami CLI
@@ -17,7 +15,7 @@ module Hanami
       # Abstract command
       #
       # @since 1.1.0
-      class Command < Hanami::CLI::Command
+      class Command < Dry::CLI::Command
         # @since 1.1.0
         # @api private
         def self.inherited(component)
@@ -72,20 +70,11 @@ module Hanami
           # @since 1.1.0
           # @api private
           def call(**options)
-            if self.class.requirements.any?
-              environment = Hanami::Environment.new(options)
-              environment.require_project_environment
-
-              requirements.resolved('environment', environment)
-              requirements.resolve(self.class.requirements)
-
-              options = environment.to_options.merge(options)
-            end
-
+            # FIXME: merge ENV vars (like HANAMI_ENV) into **options
             super(options)
-          rescue StandardError => e
-            warn e.message
-            warn e.backtrace.join("\n\t")
+          rescue StandardError => exception
+            warn exception.message
+            warn exception.backtrace.join("\n\t")
             exit(1)
           end
         end
@@ -95,9 +84,8 @@ module Hanami
         def initialize(command_name:, out: $stdout, files: Utils::Files)
           super(command_name: command_name)
 
-          @out       = out
-          @files     = files
-          @templates = Templates.new(self.class)
+          @out   = out
+          @files = files
         end
 
         private
@@ -109,7 +97,7 @@ module Hanami
         class Renderer
           # @since 1.1.0
           # @api private
-          TRIM_MODE = "-".freeze
+          TRIM_MODE = "-"
 
           # @since 1.1.0
           # @api private
@@ -126,7 +114,7 @@ module Hanami
 
         # @since 1.1.0
         # @api private
-        SAY_FORMATTER = "%<operation>12s  %<path>s\n".freeze
+        SAY_FORMATTER = "%<operation>12s  %<path>s\n"
 
         # @since 1.1.0
         # @api private
@@ -167,13 +155,15 @@ module Hanami
         # @since 1.1.0
         # @api private
         def project
-          Project
+          # FIXME: is this still useful?
+          raise "it used to be implemented as Project"
         end
 
         # @since 1.1.0
         # @api private
         def requirements
-          Hanami::Components
+          # FIXME: require components via the new Hanami::Container
+          raise "it used to be implemented as Hanami::Components"
         end
       end
     end

data/lib/hanami/cli/commands/server.rb

@@ -1,35 +1,84 @@
+# frozen_string_literal: true
+
 module Hanami
+  # Hanami CLI
+  #
+  # @since 1.1.0
   class CLI
     module Commands
       # @since 1.1.0
       # @api private
       class Server < Command
-        requires 'code_reloading'
-
         desc "Start Hanami server (only for development)"
 
-        option :server,         desc: "Force a server engine (eg, webrick, puma, thin, etc..)"
-        option :host,           desc: "The host address to bind to"
-        option :port,           desc: "The port to run the server on", aliases: ["-p"]
-        option :debug,          desc: "Turn on debug output"
-        option :warn,           desc: "Turn on warnings"
-        option :daemonize,      desc: "Daemonize the server"
-        option :pid,            desc: "Path to write a pid file after daemonize"
-        option :code_reloading, desc: "Code reloading", type: :boolean, default: true
+        option :server,    desc: "Force a server engine (eg, webrick, puma, thin, etc..)"
+        option :host,      desc: "The host address to bind to"
+        option :port,      desc: "The port to run the server on", aliases: ["-p"]
+        option :debug,     desc: "Turn on debug output", type: :boolean
+        option :warn,      desc: "Turn on warnings", type: :boolean
+        option :daemonize, desc: "Daemonize the server", type: :boolean
+        option :pid,       desc: "Path to write a pid file after daemonize"
 
         example [
           "                    # Basic usage (it uses the bundled server engine)",
           "--server=webrick    # Force `webrick` server engine",
           "--host=0.0.0.0      # Bind to a host",
-          "--port=2306         # Bind to a port",
-          "--no-code-reloading # Disable code reloading"
+          "--port=2306         # Bind to a port"
         ]
 
         # @since 1.1.0
         # @api private
-        def call(*)
+        def call(**args)
+          require "hanami"
+          require "hanami/container"
           require "hanami/server"
-          Hanami::Server.new.start
+
+          options = parse_arguments(args)
+          Hanami::Server.new(options).start
+        end
+
+        private
+
+        DEFAULT_CONFIG = "config.ru"
+        private_constant :DEFAULT_CONFIG
+
+        DEFAULT_HOST = "0.0.0.0"
+        private_constant :DEFAULT_HOST
+
+        DEFAULT_PORT = "2300"
+        private_constant :DEFAULT_PORT
+
+        OPTIONAL_SETTINGS = %i[
+          server
+          debug
+          warn
+          daemonize
+          pid
+        ].freeze
+
+        def parse_arguments(args)
+          Hanami::Container.start(:env)
+
+          {
+            config: DEFAULT_CONFIG,
+            Host: host(args),
+            Port: port(args),
+            AccessLog: []
+          }.merge(
+            args.slice(*OPTIONAL_SETTINGS)
+          )
+        end
+
+        def host(args)
+          args.fetch(:host) do
+            ENV.fetch("HANAMI_HOST", DEFAULT_HOST)
+          end
+        end
+
+        def port(args)
+          args.fetch(:port) do
+            ENV.fetch("HANAMI_PORT", DEFAULT_PORT)
+          end
         end
       end
     end

data/lib/hanami/configuration.rb

@@ -1,212 +1,270 @@
-require 'concurrent'
-require 'hanami/application'
-require 'hanami/utils/class'
-require 'hanami/utils/string'
+# frozen_string_literal: true
+
+require "uri"
+require "concurrent/hash"
+require "concurrent/array"
+require "dry/inflector"
+require "pathname"
+require "zeitwerk"
 
 module Hanami
-  # @api private
+  # Hanami application configuration
+  #
+  # @since 2.0.0
+  #
+  # rubocop:disable Metrics/ClassLength
   class Configuration
-    require "hanami/configuration/app"
-    require "hanami/configuration/middleware"
-
-    # @api private
-    def initialize(&blk)
-      @settings = Concurrent::Map.new
-      instance_eval(&blk)
-    end
-
-    # Mount a Hanami::Application or a Rack app
-    #
-    # @param app [#call] an application compatible with Rack SPEC
-    # @param options [Hash] a set of options
-    # @option :at [String] options the mount point
-    #
-    # @since 0.9.0
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     mount Web::Application, at: '/'
-    #
-    #     # ...
-    #   end
-    def mount(app, options)
-      mounted[app] = App.new(app, options.fetch(:at))
-    end
-
-    # Configure database
-    #
-    # @param blk [Proc] the database configuration
-    #
-    # @see Hanami::Model.configure
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     model do
-    #       adapter :sql, ENV['DATABASE_URL']
-    #
-    #       migrations 'db/migrations'
-    #       schema     'db/schema.sql'
-    #     end
-    #
-    #     # ...
-    #   end
-    def model(&blk)
-      if block_given?
-        settings.put_if_absent(:model, blk)
-      else
-        settings.fetch(:model)
+    require_relative "configuration/middleware"
+    require_relative "configuration/router"
+    require_relative "configuration/sessions"
+
+    attr_reader :actions
+    attr_reader :views
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def initialize(env:)
+      @settings = Concurrent::Hash.new
+
+      self.autoloader = Zeitwerk::Loader.new
+
+      self.env = env
+      self.environments = DEFAULT_ENVIRONMENTS.clone
+
+      self.root = Dir.pwd
+      self.slices_dir = DEFAULT_SLICES_DIR
+      settings[:slices] = {}
+
+      self.settings_path = DEFAULT_SETTINGS_PATH
+      self.settings_loader_options = {}
+
+      self.base_url = DEFAULT_BASE_URL
+
+      self.logger   = DEFAULT_LOGGER.clone
+      self.rack_logger_filter_params = DEFAULT_RACK_LOGGER_FILTER_PARAMS.clone
+      self.sessions = DEFAULT_SESSIONS
+
+      self.router     = Router.new(base_url)
+      self.middleware = Middleware.new
+
+      self.inflections = Dry::Inflector.new
+
+      @actions = begin
+        require_path = "hanami/action/application_configuration"
+        require require_path
+        Hanami::Action::ApplicationConfiguration.new
+      rescue LoadError => e
+        raise e unless e.path == require_path
+        Object.new
       end
-    end
 
-    # Configure mailer
-    #
-    # @param blk [Proc] the mailer configuration
-    #
-    # @see Hanami::Mailer.configure
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     mailer do
-    #       root 'lib/bookshelf/mailers'
-    #
-    #       # See http://hanamirb.org/guides/mailers/delivery
-    #       delivery :test
-    #     end
-    #
-    #     # ...
-    #   end
-    def mailer(&blk)
-      mailer_settings.push(blk) if block_given?
-    end
-
-    # @since next
-    # @api private
-    def mailer_settings
-      settings.fetch_or_store(:mailers, [])
-    end
-
-    # @since 0.9.0
-    # @api private
-    def mounted
-      settings.fetch_or_store(:mounted, {})
-    end
-
-    # @since 1.2.0
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     middleware.use MyRackMiddleware
-    #   end
-    def middleware
-      settings.fetch_or_store(:middleware, Configuration::Middleware.new)
-    end
-
-    # Setup Early Hints feature
-    #
-    # @since 1.2.0
-    #
-    # @example Enable for all the environments
-    #   # config/environment.rb
-    #   Hanami.configure do
-    #     early_hints true
-    #   end
-    #
-    # @example Enable only for production
-    #   # config/environment.rb
-    #   Hanami.configure do
-    #     environment :production do
-    #       early_hints true
-    #     end
-    #   end
-    def early_hints(value = nil)
-      if value.nil?
-        settings.fetch(:early_hints, false)
-      else
-        settings[:early_hints] = value
+      @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
+        Object.new
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    # @since 0.9.0
-    # @api private
-    def apps
-      mounted.each_pair do |klass, app|
-        yield(app) if klass <= Hanami::Application
+    def finalize
+      environment_for(env).each do |blk|
+        instance_eval(&blk)
       end
+
+      # Finalize nested configuration
+      #
+      # TODO: would be good to just create empty configurations for actions/views
+      #       instead of plain objects
+      actions.finalize! if actions.respond_to?(:finalize!)
+      views.finalize! if views.respond_to?(:finalize!)
+
+      self
+    end
+
+    def environment(name, &blk)
+      environment_for(name).push(blk)
+    end
+
+    def autoloader=(loader)
+      settings[:autoloader] = loader || nil
     end
 
-    # Configure logger
-    #
-    # @since 1.0.0
-    #
-    # @param options [Array] a set of options
-    #
-    # @see Hanami.logger
-    # @see Hanami::Logger
-    #
-    # @see http://hanamirb.org/guides/projects/logging/
-    #
-    # @example Basic Usage
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger level: :debug
-    #     end
-    #   end
-    #
-    # @example Daily Rotation
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger 'daily', level: :debug
-    #     end
-    #   end
-    def logger(*options)
-      if options.empty?
-        settings.fetch(:logger, nil)
+    def autoloader
+      settings.fetch(:autoloader)
+    end
+
+    def env=(value)
+      settings[:env] = value
+    end
+
+    def env
+      settings.fetch(:env)
+    end
+
+    def root=(root)
+      settings[:root] = Pathname(root)
+    end
+
+    def root
+      settings.fetch(:root)
+    end
+
+    def slices_dir=(dir)
+      settings[:slices_dir] = dir
+    end
+
+    def slices_dir
+      settings.fetch(:slices_dir)
+    end
+
+    def slices_namespace=(namespace)
+      settings[:slices_namespace] = namespace
+    end
+
+    def slices_namespace
+      settings.fetch(:slices_namespace) { Object }
+    end
+
+    def slice(slice_name, &block)
+      settings[:slices][slice_name] = block
+    end
+
+    def slices
+      settings[:slices]
+    end
+
+    def settings_path=(value)
+      settings[:settings_path] = value
+    end
+
+    def settings_path
+      settings.fetch(:settings_path)
+    end
+
+    def settings_loader=(loader)
+      settings[:settings_loader] = loader
+    end
+
+    def settings_loader
+      settings.fetch(:settings_loader) {
+        require "hanami/application/settings/loader"
+        settings[:settings_loader] = Application::Settings::Loader
+      }
+    end
+
+    def settings_loader_options=(options)
+      settings[:settings_loader_options] = options
+    end
+
+    def settings_loader_options
+      settings[:settings_loader_options]
+    end
+
+    def base_url=(value)
+      settings[:base_url] = URI.parse(value)
+    end
+
+    def base_url
+      settings.fetch(:base_url)
+    end
+
+    def logger=(options)
+      settings[:logger] = options
+    end
+
+    def logger
+      settings.fetch(:logger)
+    end
+
+    def rack_logger_filter_params=(params)
+      settings[:rack_logger_filter_params] = params
+    end
+
+    def rack_logger_filter_params
+      settings[:rack_logger_filter_params]
+    end
+
+    def router=(value)
+      settings[:router] = value
+    end
+
+    def router
+      settings.fetch(:router)
+    end
+
+    def sessions=(*args)
+      settings[:sessions] = Sessions.new(args)
+    end
+
+    def sessions
+      settings.fetch(:sessions)
+    end
+
+    def middleware
+      settings.fetch(:middleware)
+    end
+
+    def inflections(&blk)
+      if blk.nil?
+        settings.fetch(:inflections)
       else
-        settings[:logger] = options
+        settings[:inflections] = Dry::Inflector.new(&blk)
       end
     end
 
-    # Configure settings for the current environment
-    # @since 1.0.0
-    #
-    # @param name [Symbol] the name of the Hanami environment
-    #
-    # @see Hanami.env
-    #
-    # @example Configure Logging for Different Environments
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger level: :debug
-    #     end
-    #
-    #     environment :production do
-    #       logger level: :info, formatter: :json
-    #     end
-    #   end
-    def environment(name)
-      yield if ENV['HANAMI_ENV'] == name.to_s
+    alias inflector inflections
+
+    def for_each_middleware(&blk)
+      stack = middleware.stack.dup
+      stack += sessions.middleware if sessions.enabled?
+
+      stack.each(&blk)
+    end
+
+    protected
+
+    def environment_for(name)
+      settings[:environments][name]
+    end
+
+    def environments=(values)
+      settings[:environments] = values
+    end
+
+    def middleware=(value)
+      settings[:middleware] = value
+    end
+
+    def inflections=(value)
+      settings[:inflections] = value
     end
 
     private
 
-    # @api private
+    DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
+    private_constant :DEFAULT_ENVIRONMENTS
+
+    DEFAULT_SLICES_DIR = "slices"
+    private_constant :DEFAULT_SLICES_DIR
+
+    DEFAULT_BASE_URL = "http://0.0.0.0:2300"
+    private_constant :DEFAULT_BASE_URL
+
+    DEFAULT_LOGGER = { level: :debug }.freeze
+    private_constant :DEFAULT_LOGGER
+
+    DEFAULT_RACK_LOGGER_FILTER_PARAMS = %w[_csrf password password_confirmation].freeze
+    private_constant :DEFAULT_RACK_LOGGER_FILTER_PARAMS
+
+    DEFAULT_SETTINGS_PATH = File.join("config", "settings")
+    private_constant :DEFAULT_SETTINGS_PATH
+
+    DEFAULT_SESSIONS = Sessions.null
+    private_constant :DEFAULT_SESSIONS
+
     attr_reader :settings
   end
+  # rubocop:enable Metrics/ClassLength
 end