Core application

hanami.gemspec

@@ -26,7 +26,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "hanami-router",     "~> 2.0.alpha"
   spec.add_dependency "hanami-controller", "~> 2.0.alpha"
   spec.add_dependency "hanami-cli",        "~> 1.0.alpha"
-  spec.add_dependency "bundler",           "~> 1.16"
+  spec.add_dependency "dry-system",        "~> 0.10"
+  spec.add_dependency "dry-inflector",     "~> 0.1", ">= 0.1.2"
+  spec.add_dependency "bundler",           ">= 1.16", "< 3"
 
   spec.add_development_dependency "rspec",     "~>  3.8"
   spec.add_development_dependency "rack-test", "~> 1.1"

lib/hanami.rb

@@ -8,4 +8,64 @@
 module Hanami
   require "hanami/version"
   require "hanami/frameworks"
+  require "hanami/container"
+  require "hanami/application"
+
+  @_mutex = Mutex.new
+
+  def self.application
+    @_mutex.synchronize do
+      raise "Hanami application not configured" unless defined?(@_application)
+
+      @_application
+    end
+  end
+
+  def self.application=(app)
+    @_mutex.synchronize do
+      raise "Hanami application already configured" if defined?(@_application)
+
+      @_application = app unless app.name.nil?
+    end
+  end
+
+  def self.app
+    @_mutex.synchronize do
+      raise "Hanami.app not configured" unless defined?(@_app)
+
+      @_app
+    end
+  end
+
+  def self.app=(app)
+    @_mutex.synchronize do
+      raise "Hanami.app already configured" if defined?(@_app)
+
+      @_app = app
+    end
+  end
+
+  def self.root
+    Container.root
+  end
+
+  def self.env
+    # TODO: make this to work
+    :development
+  end
+
+  def self.logger
+    Container[:logger]
+  end
+
+  def self.boot
+    @_mutex.synchronize do
+      raise "Hanami application already booted" if defined?(@_booted)
+
+      @_booted = true
+    end
+
+    Container.finalize!
+    self.app = application.new
+  end
 end

lib/hanami/application.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "hanami/configuration"
+require "hanami/routes"
+require "hanami/router"
+
+module Hanami
+  # Hanami application
+  #
+  # @since 2.0.0
+  class Application
+    @_mutex = Mutex.new
+
+    def self.inherited(app)
+      @_mutex.synchronize do
+        app.class_eval do
+          @_mutex         = Mutex.new
+          @_configuration = Hanami::Configuration.new(env: Hanami.env)
+
+          extend ClassMethods
+          include InstanceMethods
+        end
+
+        Hanami.application = app
+      end
+    end
+
+    # Class method interface
+    #
+    # @since 2.0.0
+    module ClassMethods
+      def configuration
+        @_configuration
+      end
+
+      alias config configuration
+
+      def routes(&blk)
+        @_mutex.synchronize do
+          if blk.nil?
+            raise "Hanami.application.routes not configured" unless defined?(@_routes)
+
+            @_routes
+          else
+            @_routes = Routes.new(&blk)
+          end
+        end
+      end
+    end
+
+    # Instance method interface
+    #
+    # @since 2.0.0
+    module InstanceMethods
+      def initialize(configuration: self.class.configuration, routes: self.class.routes)
+        @app = Rack::Builder.new do
+          configuration.for_each_middleware do |m, *args|
+            use m, *args
+          end
+
+          run Hanami::Router.new(**configuration.router_settings, &routes)
+        end
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

lib/hanami/boot.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami"
+
+Hanami.boot

lib/hanami/cli/commands.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+
+module Hanami
+  # Hanami CLI
+  #
+  # @since 1.1.0
+  class CLI
+    # Register a command to expand Hanami CLI
+    #
+    # @param name [String] the command name
+    # @param command [NilClass,Hanami::CLI::Command,Hanami::CLI::Commands::Command]
+    #   the optional command
+    # @param aliases [Array<String>] an optional list of aliases
+    #
+    # @since 1.1.0
+    #
+    # @example Third party gem
+    #   require "hanami/cli/commands"
+    #
+    #   module Hanami
+    #     module Webpack
+    #       module CLI
+    #         module Commands
+    #           class Generate < Hanami::CLI::Command
+    #             desc "Generate Webpack configuration"
+    #
+    #             def call(*)
+    #               # ...
+    #             end
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   Hanami::CLI.register "generate webpack", Hanami::Webpack::CLI::Commands::Generate
+    #
+    #   # $ bundle exec hanami generate
+    #   # Commands:
+    #   #   hanami generate action APP ACTION                    # Generate an action for app
+    #   #   hanami generate app APP                              # Generate an app
+    #   #   hanami generate mailer MAILER                        # Generate a mailer
+    #   #   hanami generate migration MIGRATION                  # Generate a migration
+    #   #   hanami generate model MODEL                          # Generate a model
+    #   #   hanami generate secret [APP]                         # Generate session secret
+    #   #   hanami generate webpack                              # Generate Webpack configuration
+    def self.register(name, command = nil, aliases: [], &blk)
+      Commands.register(name, command, aliases: aliases, &blk)
+    end
+
+    # CLI commands registry
+    #
+    # @since 1.1.0
+    # @api private
+    module Commands
+      extend Hanami::CLI::Registry
+
+      require "hanami/cli/commands/server"
+    end
+  end
+end

lib/hanami/cli/commands/server.rb

@@ -0,0 +1,88 @@
+# 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
+        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", 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"
+        ]
+
+        # @since 1.1.0
+        # @api private
+        def call(**args)
+          require "hanami"
+          require "hanami/container"
+          require "hanami/server"
+
+          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
+
+    register "server", Commands::Server, aliases: ["s"]
+  end
+end