hanami 2.0.0.alpha1 → 2.0.0.alpha5

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

@@ -15,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,9 +72,9 @@ module Hanami
           def call(**options)
             # 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

data/lib/hanami/cli/commands.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "hanami/cli"
+require "dry/cli"
+require "ostruct"
 
 module Hanami
   # Hanami CLI
@@ -55,7 +56,7 @@ module Hanami
     # @since 1.1.0
     # @api private
     module Commands
-      extend Hanami::CLI::Registry
+      extend Dry::CLI::Registry
 
       require "hanami/cli/commands/command"
       require "hanami/cli/commands/server"

data/lib/hanami/configuration/logger.rb

@@ -0,0 +1,84 @@
+# 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 :application_name
+
+      setting :level
+
+      setting :stream
+
+      setting :formatter
+
+      setting :colors
+
+      setting :filters, default: %w[_csrf password password_confirmation].freeze
+
+      setting :options, default: [], constructor: ->(value) { Array(value).flatten }, cloneable: true
+
+      setting :logger_class, default: Hanami::Logger
+
+      def initialize(env:, application_name:)
+        @env = env
+        @application_name = application_name
+
+        config.level = case env
+                       when :production
+                         :info
+                       else
+                         :debug
+                       end
+
+        config.stream = case env
+                        when :test
+                          File.join("log", "#{env}.log")
+                        else
+                          $stdout
+                        end
+
+        config.formatter = case env
+                           when :production
+                             :json
+                           end
+
+        config.colors = case env
+                        when :production, :test
+                          false
+                        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)
+      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, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration/middleware.rb

@@ -6,15 +6,15 @@ module Hanami
     #
     # @since 2.0.0
     class Middleware
+      attr_reader :stack
+
       def initialize
         @stack = []
       end
 
-      def use(middleware, *args)
-        stack.push([middleware, *args])
+      def use(middleware, *args, &block)
+        stack.push([middleware, *args, block].compact)
       end
-
-      attr_reader :stack
     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

data/lib/hanami/configuration/sessions.rb

@@ -9,8 +9,11 @@ module Hanami
     #
     # @since 2.0.0
     class Sessions
+      NULL_SESSION_OPTION = :null
+      private_constant :NULL_SESSION_OPTION
+
       def self.null
-        NULL_STORAGE
+        self.class.new(NULL_SESSION_OPTION)
       end
 
       attr_reader :storage, :options
@@ -23,7 +26,7 @@ module Hanami
       end
 
       def enabled?
-        storage != NULL_STORAGE
+        storage != NULL_SESSION_OPTION
       end
 
       def middleware
@@ -32,9 +35,6 @@ module Hanami
 
       private
 
-      NULL_STORAGE = :null
-      private_constant :NULL_STORAGE
-
       def storage_middleware
         require_storage
 

data/lib/hanami/configuration/source_dirs.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/system/config/component_dirs"
+
+module Hanami
+  class Configuration
+    # Configuration for slice source dirs
+    #
+    # @since 2.0.0
+    class SourceDirs
+      DEFAULT_COMPONENT_DIR_PATHS = %w[lib actions repositories views].freeze
+      private_constant :DEFAULT_COMPONENT_DIR_PATHS
+
+      include Dry::Configurable
+
+      setting :component_dirs,
+        default: Dry::System::Config::ComponentDirs.new.tap { |dirs|
+          DEFAULT_COMPONENT_DIR_PATHS.each do |path|
+            dirs.add path
+          end
+        },
+        cloneable: true
+
+      setting :autoload_paths, default: %w[entities]
+
+      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