hanami 1.3.5 → 2.0.0.alpha4

data/lib/hanami/cli/application/cli.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require_relative "commands"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI
+      class CLI < Hanami::CLI
+        attr_reader :application
+
+        def initialize(application: nil, commands: Commands)
+          super(commands)
+          @application = application
+        end
+
+        private
+
+        # TODO: we should make a prepare_command method upstream
+        def parse(result, out)
+          command, arguments = super
+
+          if command.respond_to?(:with_application)
+            # Set HANAMI_ENV before the application inits to ensure all aspects
+            # of the boot process respect the provided env
+            ENV["HANAMI_ENV"] = arguments[:env] if arguments[:env]
+
+            require "hanami/init"
+            application = Hanami.application
+
+            [command.with_application(application), arguments]
+          else
+            [command, arguments]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../base_command"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI command (intended to run inside application directory)
+      class Command < BaseCommand
+        def self.inherited(klass)
+          super
+
+          klass.option :env, aliases: ["-e"], default: nil, desc: "Application environment"
+        end
+
+        attr_reader :application
+
+        def initialize(application: nil, **opts)
+          super(**opts)
+          @application = application
+        end
+
+        def with_application(application)
+          self.class.new(
+            command_name: @command_name,
+            application: application,
+            out: out,
+            inflector: application.inflector,
+            files: files,
+          )
+        end
+
+        private
+
+        def run_command(klass, *args)
+          klass.new(
+            command_name: klass.name,
+            application: application,
+            out: out,
+            inflector: application.inflector,
+            files: files,
+          ).call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/application/commands/console.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "hanami/cli/application/command"
+require "hanami/console/context"
+
+module Hanami
+  class CLI
+    module Application
+      module Commands # rubocop:disable Style/Documentation
+        # Hanami application `console` CLI command
+        class Console < Command
+          REPL =
+            begin
+              require "pry"
+              Pry
+            rescue LoadError
+              require "irb"
+              IRB
+            end
+
+          desc "Open interactive console"
+
+          def call(**)
+            measure "#{prompt_prefix} booted in" do
+              out.puts "=> starting #{prompt_prefix} console"
+              application.init
+            end
+
+            start_repl
+          end
+
+          private
+
+          def start_repl
+            context = Hanami::Console::Context.new(application)
+
+            case REPL.name.to_sym
+            when :Pry
+              start_pry(context)
+            when :IRB
+              start_irb(context)
+            end
+          end
+
+          def start_pry(context)
+            # https://github.com/pry/pry/pull/1877
+            if Gem.loaded_specs["pry"].version >= Gem::Version.new("0.13.0")
+              Pry.prompt = Pry::Prompt.new(:hanami, "Hanami Console prompt.", prompt_procs)
+              Pry.start(context)
+            else
+              Pry.start(context, prompt_procs)
+            end
+          end
+
+          def start_irb(context)
+            IRB.start(context, prompt_procs)
+          end
+
+          def prompt_procs
+            [proc { default_prompt }, proc { indented_prompt }]
+          end
+
+          def default_prompt
+            "#{prompt_prefix}> "
+          end
+
+          def indented_prompt
+            "#{prompt_prefix}* "
+          end
+
+          def prompt_prefix
+            "#{inflector.underscore(application.application_name)}[#{application.config.env}]"
+          end
+        end
+
+        register "console", Console
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "hanami/cli/registry"
+
+module Hanami
+  class CLI
+    module Application
+      # Hanami application CLI commands registry
+      module Commands
+        extend Hanami::CLI::Registry
+
+        require_relative "commands/console"
+      end
+    end
+  end
+end

data/lib/hanami/cli/base_command.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "hanami/cli/command"
+require "hanami/utils/files"
+
+module Hanami
+  class CLI
+    # Base class for Hanami application CLI commands
+    class BaseCommand < Hanami::CLI::Command
+      attr_reader :out
+      attr_reader :inflector
+      attr_reader :files
+
+      def initialize(
+        command_name:,
+        out: $stdout,
+        inflector: Dry::Inflector.new,
+        files: Hanami::Utils::Files
+      )
+        super(command_name: command_name)
+
+        @out = out
+        @inflector = inflector
+        @files = files
+      end
+
+      private
+
+      def run_command(klass, *args)
+        klass.new(
+          command_name: klass.name,
+          application: application,
+          out: out,
+          files: files,
+        ).call(*args)
+      end
+
+      def measure(desc)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        out.puts "=> #{desc} in #{(stop - start).round(1)}s"
+      end
+    end
+  end
+end

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

@@ -1,12 +1,10 @@
-require 'hanami'
-require 'hanami/environment'
-require 'hanami/components'
-require 'dry/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
@@ -72,30 +70,22 @@ 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
-
-            super(**options)
-          rescue StandardError => e
-            warn e.message
-            warn e.backtrace.join("\n\t")
+            # FIXME: merge ENV vars (like HANAMI_ENV) into **options
+            super(options)
+          rescue StandardError => exception
+            warn exception.message
+            warn exception.backtrace.join("\n\t")
             exit(1)
           end
         end
 
         # @since 1.1.0
         # @api private
-        def initialize(out: $stdout, files: Utils::Files)
-          @out       = out
-          @files     = files
-          @templates = Templates.new(self.class)
+        def initialize(command_name:, out: $stdout, files: Utils::Files)
+          super(command_name: command_name)
+
+          @out   = out
+          @files = files
         end
 
         private
@@ -107,7 +97,7 @@ module Hanami
         class Renderer
           # @since 1.1.0
           # @api private
-          TRIM_MODE = "-".freeze
+          TRIM_MODE = "-"
 
           # @since 1.1.0
           # @api private
@@ -124,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
@@ -165,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/cli/commands.rb

@@ -1,5 +1,7 @@
-require 'dry/cli'
-require 'ostruct'
+# frozen_string_literal: true
+
+require "dry/cli"
+require "ostruct"
 
 module Hanami
   # Hanami CLI
@@ -23,7 +25,7 @@ module Hanami
     #       module CLI
     #         module Commands
     #           class Generate < Hanami::CLI::Command
-    #             desc "Generate Webpack config"
+    #             desc "Generate Webpack configuration"
     #
     #             def call(*)
     #               # ...
@@ -56,46 +58,8 @@ module Hanami
     module Commands
       extend Dry::CLI::Registry
 
-      # CLI command context
-      #
-      # @since 1.1.0
-      # @api private
-      class Context < OpenStruct
-        # @since 1.1.0
-        # @api private
-        def initialize(data)
-          data = data.each_with_object({}) do |(k, v), result|
-            v = Utils::String.new(v) if v.is_a?(::String)
-            result[k] = v
-          end
-
-          super(data)
-          freeze
-        end
-
-        # @since 1.1.0
-        # @api private
-        def with(data)
-          self.class.new(to_h.merge(data))
-        end
-
-        # @since 1.1.0
-        # @api private
-        def binding
-          super
-        end
-      end
-
       require "hanami/cli/commands/command"
-      require "hanami/cli/commands/assets"
-      require "hanami/cli/commands/console"
-      require "hanami/cli/commands/db"
-      require "hanami/cli/commands/destroy"
-      require "hanami/cli/commands/generate"
-      require "hanami/cli/commands/new"
-      require "hanami/cli/commands/routes"
       require "hanami/cli/commands/server"
-      require "hanami/cli/commands/version"
     end
   end
 end

data/lib/hanami/configuration/logger.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/logger"
+
+module Hanami
+  class Configuration
+    # Hanami logger configuration
+    #
+    # @since 2.0.0
+    class Logger
+      include Dry::Configurable
+
+      protected :config
+
+      setting :logger_class, default: Hanami::Logger
+
+      setting :options, default: {level: :debug}
+
+      # Currently used for logging of Rack requests only.
+      #
+      # TODO: incorporate this into the standard logging some way or another
+      setting :filter_params, default: %w[_csrf password password_confirmation].freeze
+
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration/middleware.rb

@@ -1,39 +1,19 @@
-require "concurrent"
+# frozen_string_literal: true
 
 module Hanami
-  # @api private
   class Configuration
-    # Middleware configuration
-    # @since 1.2.0
+    # Hanami application configured Rack middleware
+    #
+    # @since 2.0.0
     class Middleware
-      # @api private
-      # @since 1.2.0
-      def initialize
-        @middleware = Concurrent::Array.new
-      end
+      attr_reader :stack
 
-      # Use a Rack middleware
-      #
-      # @param middleware [#call] a Rack middleware
-      # @param args [Array<Object>] an optional set of options
-      # @param blk [Proc] an optional block to pass to the middleware
-      #
-      # @since 1.2.0
-      #
-      # @example
-      #   # config/environment.rb
-      #   # ...
-      #   Hanami.configure do
-      #     middleware.use MyRackMiddleware
-      #   end
-      def use(middleware, *args, &blk)
-        @middleware.push([middleware, args, blk])
+      def initialize
+        @stack = []
       end
 
-      # @api private
-      # @since 1.2.0
-      def each(&blk)
-        @middleware.each(&blk)
+      def use(middleware, *args, &block)
+        stack.push([middleware, *args, block].compact)
       end
     end
   end

data/lib/hanami/configuration/null_configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  class Configuration
+    # NullConfiguration can serve as a fallback configuration object when out-of-gem
+    # configuration objects are not available (specifically, when the hanami-controller or
+    # hanami-view gems are not loaded)
+    class NullConfiguration
+      include Dry::Configurable
+    end
+  end
+end

data/lib/hanami/configuration/router.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require_relative "../application/routing/resolver"
+
+module Hanami
+  class Configuration
+    # Hanami router configuration
+    #
+    # @since 2.0.0
+    # @api private
+    class Router
+      include Dry::Configurable
+
+      # Base configuration is provided so router config can include the `base_url`
+      attr_reader :base_configuration
+      private :base_configuration
+
+      # @api private
+      # @since 2.0.0
+      def initialize(base_configuration)
+        @base_configuration = base_configuration
+      end
+
+      setting :routes_path, default: File.join("config", "routes")
+
+      setting :routes_class_name, default: "Routes"
+
+      setting :resolver, default: Application::Routing::Resolver
+
+      # @api private
+      # @since 2.0.0
+      def options
+        {base_url: base_configuration.base_url}
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _include_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end