hanami 2.0.0.beta3 → 2.0.0.rc1

data/lib/hanami/slice_configurable.rb

@@ -56,7 +56,7 @@ module Hanami
       def slice_for(klass)
         return unless klass.name
 
-        slices = Hanami.app.slices.to_a + [Hanami.app]
+        slices = Hanami.app.slices.with_nested + [Hanami.app]
 
         slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
       end

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) }
 
@@ -75,6 +75,14 @@ module Hanami
       slices.values
     end
 
+    def with_nested
+      to_a.flat_map { |slice|
+        # 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
+
     private
 
     def root
@@ -85,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.beta3"
+    # @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,47 +93,138 @@ 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
         gem(gem_name)
-        true
       rescue Gem::LoadError
         false
       end
     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/prepare_container_spec.rb

@@ -23,6 +23,8 @@ RSpec.describe "Container / prepare_container", :app_integration do
 
     # The prepare_container block is called when the slice is prepared
     slice.prepare
+
+    autoloaders_teardown!
   end
 
   describe "in app", :in_prepare_container do

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "stringio"
+
+RSpec.describe "Hanami web app", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  around do |example|
+    with_tmp_directory(Dir.mktmpdir, &example)
+  end
+
+  specify "Setting middlewares in the config" do
+    write "config/app.rb", <<~RUBY
+      require "hanami"
+
+      module TestApp
+        class App < Hanami::App
+          config.middleware.use :body_parser, :json
+          config.logger.stream = StringIO.new
+        end
+      end
+    RUBY
+
+    write "config/routes.rb", <<~RUBY
+      module TestApp
+        class Routes < Hanami::Routes
+          post "/users", to: "users.create"
+        end
+      end
+    RUBY
+
+    write "app/actions/users/create.rb", <<~RUBY
+      module TestApp
+        module Actions
+          module Users
+            class Create < Hanami::Action
+              accept :json
+
+              def handle(req, res)
+                res.body = req.params[:users].join("-")
+              end
+            end
+          end
+        end
+      end
+    RUBY
+
+    require "hanami/boot"
+
+    post(
+      "/users",
+      JSON.dump("users" => %w[jane john jade joe]),
+      "CONTENT_TYPE" => "application/json"
+    )
+
+    expect(last_response).to be_successful
+    expect(last_response.body).to eql("jane-john-jade-joe")
+  end
+
+  specify "Configuring custom mime-types and body parser" do
+    write "config/app.rb", <<~RUBY
+      require "hanami"
+
+      module TestApp
+        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
+
+    write "config/routes.rb", <<~RUBY
+      module TestApp
+        class Routes < Hanami::Routes
+          post "/users", to: "users.create"
+        end
+      end
+    RUBY
+
+    write "app/actions/users/create.rb", <<~RUBY
+      module TestApp
+        module Actions
+          module Users
+            class Create < Hanami::Action
+              accept :json
+
+              def handle(req, res)
+                res.body = req.params[:users].join("-")
+              end
+            end
+          end
+        end
+      end
+    RUBY
+
+    require "hanami/boot"
+
+    post(
+      "/users",
+      JSON.dump("users" => %w[jane john jade joe]),
+      "CONTENT_TYPE" => "application/json+scim"
+    )
+
+    expect(last_response).to be_successful
+    expect(last_response.body).to eql("jane-john-jade-joe")
+  end
+end