hanami 2.0.0.beta4 → 2.0.0.rc1

data/lib/hanami/slice_registrar.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "constants"
-require_relative "slice"
 
 module Hanami
   # @api private
   class SliceRegistrar
+    VALID_SLICE_NAME_RE = /^[a-z][a-z0-9_]+$/
     SLICE_DELIMITER = CONTAINER_KEY_DELIMITER
 
     attr_reader :parent, :slices
@@ -17,14 +17,16 @@ module Hanami
     end
 
     def register(name, slice_class = nil, &block)
+      unless name.to_s =~ VALID_SLICE_NAME_RE
+        raise ArgumentError, "slice name #{name.inspect} must be lowercase alphanumeric text and underscores only"
+      end
+
       return unless filter_slice_names([name]).any?
 
       if slices.key?(name.to_sym)
         raise SliceLoadError, "Slice '#{name}' is already registered"
       end
 
-      # TODO: raise error unless name meets format (i.e. single level depth only)
-
       slice = slice_class || build_slice(name, &block)
 
       configure_slice(name, slice)
@@ -44,8 +46,6 @@ module Hanami
     end
 
     def load_slices
-      return self unless root
-
       slice_configs = Dir[root.join(CONFIG_DIR, SLICES_DIR, "*#{RB_EXT}")]
         .map { |file| File.basename(file, RB_EXT) }
 
@@ -77,7 +77,9 @@ module Hanami
 
     def with_nested
       to_a.flat_map { |slice|
-        [slice] + slice.slices.with_nested
+        # Return nested slices first so that their more specific namespaces may be picked up first
+        # by SliceConfigurable#slice_for
+        slice.slices.with_nested + [slice]
       }
     end
 
@@ -91,36 +93,39 @@ module Hanami
       parent.inflector
     end
 
-    # Runs when a slice file has been found at `config/slices/[slice_name].rb`, or a slice
-    # directory at `slices/[slice_name]`. Attempts to require the slice class, if defined,
-    # or generates a new slice class for the given slice name.
+    def parent_slice_namespace
+      parent.eql?(parent.app) ? Object : parent.namespace
+    end
+
+    # Runs when a slice file has been found at `config/slices/[slice_name].rb`, or a slice directory
+    # at `slices/[slice_name]`. Attempts to require the slice class, if defined, before registering
+    # the slice. If a slice class is not found, registering the slice will generate the slice class.
     def load_slice(slice_name)
-      slice_const_name = inflector.camelize(slice_name)
       slice_require_path = root.join(CONFIG_DIR, SLICES_DIR, slice_name).to_s
-
       begin
         require(slice_require_path)
       rescue LoadError => e
         raise e unless e.path == slice_require_path
       end
 
+      slice_module_name = inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
       slice_class =
         begin
-          inflector.constantize("#{slice_const_name}::Slice")
+          inflector.constantize("#{slice_module_name}#{MODULE_DELIMITER}Slice")
         rescue NameError => e
-          raise e unless e.name.to_s == slice_const_name || e.name.to_s == :Slice
+          raise e unless e.name.to_s == inflector.camelize(slice_name) || e.name.to_s == :Slice
         end
 
       register(slice_name, slice_class)
     end
 
     def build_slice(slice_name, &block)
+      slice_module_name = inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
       slice_module =
         begin
-          slice_module_name = inflector.camelize(slice_name.to_s)
           inflector.constantize(slice_module_name)
         rescue NameError
-          Object.const_set(inflector.camelize(slice_module_name), Module.new)
+          parent_slice_namespace.const_set(inflector.camelize(slice_name), Module.new)
         end
 
       slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))

data/lib/hanami/version.rb

@@ -6,9 +6,8 @@ module Hanami
   # @since 0.9.0
   # @api private
   module Version
-    # @since 0.9.0
-    # @api private
-    VERSION = "2.0.0.beta4"
+    # @api public
+    VERSION = "2.0.0.rc1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module Hanami
+  # @api private
   module Web
     # Rack logger for Hanami apps
+    #
+    # @api private
+    # @since 2.0.0
     class RackLogger
       REQUEST_METHOD = "REQUEST_METHOD"
       private_constant :REQUEST_METHOD
@@ -25,10 +29,14 @@ module Hanami
       CONTENT_LENGTH = "Content-Length"
       private_constant :CONTENT_LENGTH
 
+      # @api private
+      # @since 2.0.0
       def initialize(logger)
         @logger = logger
       end
 
+      # @api private
+      # @since 2.0.0
       def attach(rack_monitor)
         rack_monitor.on :stop do |event|
           log_request event[:env], event[:status], event[:time]
@@ -39,6 +47,8 @@ module Hanami
         end
       end
 
+      # @api private
+      # @since 2.0.0
       def log_request(env, status, elapsed)
         data = {
           verb: env[REQUEST_METHOD],
@@ -47,16 +57,16 @@ module Hanami
           ip: env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR],
           path: env[SCRIPT_NAME] + env[PATH_INFO].to_s,
           length: extract_content_length(env),
-          params: env[ROUTER_PARAMS],
-          time: Time.now,
+          params: env[ROUTER_PARAMS]
         }
 
         logger.info(data)
       end
 
+      # @api private
+      # @since 2.0.0
       def log_exception(exception)
-        logger.error exception.message
-        logger.error exception.backtrace.join("\n")
+        logger.error(exception)
       end
 
       private

data/lib/hanami.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "zeitwerk"
+require_relative "hanami/constants"
+
 # A complete web framework for Ruby
 #
 # @since 0.1.0
@@ -9,11 +12,21 @@ module Hanami
   @_mutex = Mutex.new
   @_bundled = {}
 
+  # @api private
+  # @since 2.0.0
+  def self.loader
+    @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+      loader.ignore(
+        "#{loader.dirs.first}/hanami/{constants,boot,errors,prepare,rake_tasks,setup}.rb"
+      )
+    end
+  end
+
   # Finds and loads the Hanami app file (`config/app.rb`).
   #
   # Raises an exception if the app file cannot be found.
   #
-  # @return [Hanami::App] the loaded app class
+  # @return [app] the loaded app class
   #
   # @api public
   # @since 2.0.0
@@ -34,32 +47,18 @@ module Hanami
     end
   end
 
-  # Finds and returns the absolute path for the Hanami app file (`config/app.rb`).
+  # Returns the Hamami app class.
   #
-  # Searches within the given directory, then searches upwards through parent directories until the
-  # app file can be found.
+  # To ensure your Hanami app is loaded, run {.setup} (or `require "hanami/setup"`) first.
   #
-  # @param dir [String] The directory from which to start searching. Defaults to the current
-  #   directory.
+  # @return [Hanami::App] the app class
   #
-  # @return [String, nil] the app file path, or nil if not found.
+  # @raise [AppLoadError] if the app has not been loaded
+  #
+  # @see .setup
   #
   # @api public
   # @since 2.0.0
-  def self.app_path(dir = Dir.pwd)
-    dir = Pathname(dir).expand_path
-    path = dir.join(APP_PATH)
-
-    if path.file?
-      path.to_s
-    elsif !dir.root?
-      app_path(dir.parent)
-    end
-  end
-
-  APP_PATH = "config/app.rb"
-  private_constant :APP_PATH
-
   def self.app
     @_mutex.synchronize do
       unless defined?(@_app)
@@ -72,10 +71,18 @@ module Hanami
     end
   end
 
+  # Returns true if the Hanami app class has been loaded.
+  #
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 2.0.0
   def self.app?
     instance_variable_defined?(:@_app)
   end
 
+  # @api private
+  # @since 2.0.0
   def self.app=(klass)
     @_mutex.synchronize do
       if instance_variable_defined?(:@_app)
@@ -86,30 +93,117 @@ module Hanami
     end
   end
 
+  # Finds and returns the absolute path for the Hanami app file (`config/app.rb`).
+  #
+  # Searches within the given directory, then searches upwards through parent directories until the
+  # app file can be found.
+  #
+  # @param dir [String] The directory from which to start searching. Defaults to the current
+  #   directory.
+  #
+  # @return [String, nil] the app file path, or nil if not found.
+  #
+  # @api public
+  # @since 2.0.0
+  def self.app_path(dir = Dir.pwd)
+    dir = Pathname(dir).expand_path
+    path = dir.join(APP_PATH)
+
+    if path.file?
+      path.to_s
+    elsif !dir.root?
+      app_path(dir.parent)
+    end
+  end
+
+  # Returns the Hanami app environment as loaded from the `HANAMI_ENV` environment variable.
+  #
+  # @example
+  #   Hanami.env # => :development
+  #
+  # @return [Symbol] the environment name
+  #
+  # @api public
+  # @since 2.0.0
   def self.env
     ENV.fetch("HANAMI_ENV") { ENV.fetch("RACK_ENV", "development") }.to_sym
   end
 
+  # Returns true if {.env} matches any of the given names
+  #
+  # @example
+  #   Hanami.env # => :development
+  #   Hanami.env?(:development, :test) # => true
+  #
+  # @param names [Array<Symbol>] the environment names to check
+  #
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 2.0.0
   def self.env?(*names)
     names.map(&:to_sym).include?(env)
   end
 
+  # Returns the app's logger.
+  #
+  # Direct global access to the logger via this method is not recommended. Instead, consider
+  # accessing the logger via the app or slice container, in most cases as an dependency using the
+  # `Deps` mixin.
+  #
+  # @example
+  #   # app/my_component.rb
+  #
+  #   module MyApp
+  #     class MyComponent
+  #       include Deps["logger"]
+  #
+  #       def some_method
+  #         logger.info("hello")
+  #       end
+  #     end
+  #   end
+  #
+  # @return [Dry::Logger::Dispatcher]
+  #
+  # @api public
+  # @since 1.0.0
   def self.logger
     app[:logger]
   end
 
+  # Prepares the Hanami app.
+  #
+  # @see App::ClassMethods#prepare
+  #
+  # @api public
+  # @since 2.0.0
   def self.prepare
     app.prepare
   end
 
+  # Boots the Hanami app.
+  #
+  # @see App::ClassMethods#boot
+  #
+  # @api public
+  # @since 2.0.0
   def self.boot
     app.boot
   end
 
+  # Shuts down the Hanami app.
+  #
+  # @see App::ClassMethods#shutdown
+  #
+  # @api public
+  # @since 2.0.0
   def self.shutdown
     app.shutdown
   end
 
+  # @api private
+  # @since 2.0.0
   def self.bundled?(gem_name)
     @_mutex.synchronize do
       @_bundled[gem_name] ||= begin
@@ -120,12 +214,17 @@ module Hanami
     end
   end
 
+  # Returns an array of bundler group names to be eagerly loaded by hanami-cli and other CLI
+  # extensions.
+  #
+  # @api private
+  # @since 2.0.0
   def self.bundler_groups
     [:plugins]
   end
 
-  require_relative "hanami/version"
+  loader.setup
+
   require_relative "hanami/errors"
   require_relative "hanami/extensions"
-  require_relative "hanami/app"
 end

data/spec/integration/action/csrf_protection_spec.rb

@@ -35,7 +35,7 @@ RSpec.describe "App action / CSRF protection", :app_integration do
     context "CSRF protection explicitly disabled" do
       let(:app_hook) {
         proc do
-          config.sessions = :cookie, {secret: "abc123"}
+          config.actions.sessions = :cookie, {secret: "abc123"}
           config.actions.csrf_protection = false
         end
       }

data/spec/integration/container/application_routes_helper_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 RSpec.describe "App routes helper", :app_integration do
   specify "Routing to actions based on their container identifiers" do
     with_tmp_directory(Dir.mktmpdir) do
@@ -8,7 +10,7 @@ RSpec.describe "App routes helper", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY

data/spec/integration/container/provider_lifecycle_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe "Container / Provider lifecycle", :app_integration do
+  let!(:slice) {
+    module TestApp
+      class App < Hanami::App
+        register_provider :connection do
+          prepare do
+            module ::TestApp
+              class Connection
+                def initialize
+                  @connected = true
+                end
+
+                def disconnect
+                  @connected = false
+                end
+
+                def connected?
+                  @connected
+                end
+              end
+            end
+          end
+
+          start do
+            register("connection", TestApp::Connection.new)
+          end
+
+          stop do
+            container["connection"].disconnect
+          end
+        end
+      end
+    end
+
+    TestApp::App
+  }
+
+  before do
+    require "hanami/setup"
+  end
+
+  specify "individual providers can be prepared, started and stopped" do
+    expect { TestApp::Connection }.to raise_error NameError
+
+    slice.prepare :connection
+
+    expect(TestApp::Connection).to be
+    expect(slice.container.registered?("connection")).to be false
+
+    slice.start :connection
+
+    expect(slice.container.registered?("connection")).to be true
+    expect(slice["connection"]).to be_connected
+
+    slice.stop :connection
+
+    expect(slice["connection"]).not_to be_connected
+  end
+end

data/spec/integration/container/standard_providers/rack_provider_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe "Container / Standard providers / Rack", :app_integration do
+  specify "Rack provider is loaded when rack is bundled" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "slices/main/.keep", ""
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
+      expect(Main::Slice["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
+    end
+  end
+
+  specify "Rack provider is not loaded when rack is not bundled" do
+    allow(Hanami).to receive(:bundled?).and_call_original
+    allow(Hanami).to receive(:bundled?).with("rack").and_return false
+
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "slices/main/.keep", ""
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.key?("rack.monitor")).to be false
+      expect(Main::Slice.key?("rack.monitor")).to be false
+    end
+  end
+end

data/spec/integration/container/{standard_bootable_components_spec.rb → standard_providers_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe "Container / Standard bootable components", :app_integration do
+RSpec.describe "Container / Standard providers", :app_integration do
   specify "Standard components are available on booted container" do
     with_tmp_directory(Dir.mktmpdir) do
       write "config/app.rb", <<~RUBY
@@ -15,7 +15,7 @@ RSpec.describe "Container / Standard bootable components", :app_integration do
 
       expect(Hanami.app.key?(:settings)).to be false
       expect(Hanami.app["inflector"]).to eql Hanami.app.inflector
-      expect(Hanami.app["logger"]).to be_a_kind_of(Hanami::Logger)
+      expect(Hanami.app["logger"]).to be_a_kind_of(Dry::Logger::Dispatcher)
       expect(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
     end
   end
@@ -36,7 +36,7 @@ RSpec.describe "Container / Standard bootable components", :app_integration do
 
       expect(Hanami.app.key?(:settings)).to be false
       expect(Hanami.app["inflector"]).to eql Hanami.app.inflector
-      expect(Hanami.app["logger"]).to be_a_kind_of(Hanami::Logger)
+      expect(Hanami.app["logger"]).to be_a_kind_of(Dry::Logger::Dispatcher)
       expect(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
     end
   end

data/spec/integration/rack_app/body_parser_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Hanami web app", :app_integration do
   include Rack::Test::Methods
@@ -18,6 +19,7 @@ RSpec.describe "Hanami web app", :app_integration do
       module TestApp
         class App < Hanami::App
           config.middleware.use :body_parser, :json
+          config.logger.stream = StringIO.new
         end
       end
     RUBY
@@ -66,6 +68,7 @@ RSpec.describe "Hanami web app", :app_integration do
         class App < Hanami::App
           config.actions.formats["application/json+scim"] = :json
           config.middleware.use :body_parser, [json: "application/json+scim"]
+          config.logger.stream = StringIO.new
         end
       end
     RUBY