hanami-cli 2.0.0.alpha8.1 → 2.0.0.beta1

data/lib/hanami/cli/commands/{monolith → app}/generate/slice.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "hanami/cli/command"
-require "hanami/cli/generators/monolith/slice"
+require "hanami/cli/generators/app/slice"
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
@@ -10,14 +10,14 @@ require "hanami/cli/url"
 module Hanami
   module CLI
     module Commands
-      module Monolith
+      module App
         module Generate
           class Slice < Command
             argument :name, required: true, desc: "The slice name"
             option :url_prefix, required: false, type: :string, desc: "The slice URL prefix"
 
             def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
-                           generator: Generators::Monolith::Slice.new(fs: fs, inflector: inflector), **)
+                           generator: Generators::App::Slice.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)
             end
@@ -25,7 +25,7 @@ module Hanami
             def call(name:, url_prefix: nil, **)
               require "hanami/setup"
 
-              app = inflector.underscore(Hanami.application.namespace)
+              app = inflector.underscore(Hanami.app.namespace)
               name = inflector.underscore(Shellwords.shellescape(name))
               url_prefix = sanitize_url_prefix(name, url_prefix)
 

data/lib/hanami/cli/commands/{monolith → app}/generate.rb

@@ -3,7 +3,7 @@
 module Hanami
   module CLI
     module Commands
-      module Monolith
+      module App
         module Generate
           require_relative "./generate/slice"
           require_relative "./generate/action"

data/lib/hanami/cli/commands/{monolith → app}/install.rb

@@ -5,7 +5,7 @@ require "hanami/cli/command"
 module Hanami
   module CLI
     module Commands
-      module Monolith
+      module App
         class Install < Command
           def call(*)
           end

data/lib/hanami/cli/commands/app/routes.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "hanami"
+require "hanami/router/inspector"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        # Inspect the application routes
+        #
+        # All the formatters available from `hanami-router` are available:
+        #
+        # ```
+        # $ hanami routes --format=csv
+        # ```
+        #
+        # Experimental: You can also use a custom formatter registered in the
+        # application container. You can identify it by its key:
+        #
+        # ```
+        # $ hanami routes --format=custom_routes_formatter
+        # ```
+        class Routes < Hanami::CLI::Command
+          DEFAULT_FORMAT = "human_friendly"
+          private_constant :DEFAULT_FORMAT
+
+          VALID_FORMATS = [
+            DEFAULT_FORMAT,
+            "csv"
+          ].freeze
+          private_constant :VALID_FORMATS
+
+          desc "Inspect application"
+
+          option :format,
+                 default: DEFAULT_FORMAT,
+                 required: false,
+                 desc: "Output format"
+
+          # @api private
+          def call(format: DEFAULT_FORMAT, **)
+            require "hanami/prepare"
+            inspector = Hanami::Router::Inspector.new(formatter: resolve_formatter(format))
+            app.router(inspector: inspector)
+            out.puts inspector.call
+          end
+
+          private
+
+          def resolve_formatter(format)
+            if VALID_FORMATS.include?(format)
+              resolve_formatter_from_hanami_router(format)
+            else
+              resolve_formatter_from_app(format)
+            end
+          end
+
+          def resolve_formatter_from_hanami_router(format)
+            case format
+            when "human_friendly"
+              require "hanami/router/formatter/human_friendly"
+              Hanami::Router::Formatter::HumanFriendly.new
+            when "csv"
+              require "hanami/router/formatter/csv"
+              Hanami::Router::Formatter::CSV.new
+            end
+          end
+
+          # Experimental
+          def resolve_formatter_from_app(format)
+            app[format]
+          end
+
+          def app
+            Hanami.app
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/app/server.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "rack"
+require_relative "../app"
+require_relative "../../server"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        # Launch Hanami web server.
+        #
+        # It's intended to be used only on development. For production, you
+        # should use the rack handler command directly (i.e. `bundle exec puma
+        # -C config/puma.rb`).
+        #
+        # The server is just a thin wrapper on top of Rack::Server. The options that it
+        # accepts fall into two different categories:
+        #
+        # - When not explicitly set, port and host are not passed to the rack
+        # server instance. This way, they can be configured through the
+        # configured rack handler (e.g., the puma configuration file).
+        #
+        # - All others are always given by the Hanami command.
+        #
+        # Run `bundle exec hanami server -h` to see all the supported options.
+        class Server < Command
+          DEFAULT_PORT = 2300
+          private_constant :DEFAULT_PORT
+
+          desc "Start Hanami server"
+
+          option :host, default: nil, required: false,
+                        desc: "The host address to bind to (falls back to the rack handler)"
+          option :port, default: DEFAULT_PORT, required: false,
+                        desc: "The port to run the server on (falls back to the rack handler)"
+          option :config, default: "config.ru", required: false, desc: "Rack configuration file"
+          option :debug, default: false, required: false, desc: "Turn on/off debug output", type: :boolean
+          option :warn, default: false, required: false, desc: "Turn on/off warnings", type: :boolean
+
+          def initialize(server: Hanami::CLI::Server.new)
+            super()
+            @server = server
+          end
+
+          # @api private
+          def call(port: DEFAULT_PORT, **kwargs)
+            server.call(port: port, **kwargs)
+          end
+
+          private
+
+          attr_reader :server
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/{monolith → app}/version.rb

@@ -5,7 +5,7 @@ require "hanami/cli/command"
 module Hanami
   module CLI
     module Commands
-      module Monolith
+      module App
         class Version < Command
           def call(*)
             require "hanami/version"

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        require_relative "app/version"
+        require_relative "app/install"
+        require_relative "app/console"
+        require_relative "app/server"
+        require_relative "app/routes"
+        # require_relative "app/generate"
+        # require_relative "app/db/create"
+        # require_relative "app/db/create_migration"
+        # require_relative "app/db/drop"
+        # require_relative "app/db/migrate"
+        # require_relative "app/db/setup"
+        # require_relative "app/db/reset"
+        # require_relative "app/db/rollback"
+        # require_relative "app/db/sample_data"
+        # require_relative "app/db/seed"
+        # require_relative "app/db/structure/dump"
+        # require_relative "app/db/version"
+
+        def self.extended(base)
+          base.module_eval do
+            register "version", Commands::App::Version, aliases: ["v", "-v", "--version"]
+            register "install", Commands::App::Install
+            register "console", Commands::App::Console, aliases: ["c"]
+            register "server",  Commands::App::Server,  aliases: ["s"]
+            register "routes",  Commands::App::Routes
+
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "install", Install
+
+            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
+            # register "generate", aliases: ["g"] do |prefix|
+            #   prefix.register "slice", Generate::Slice
+            #   prefix.register "action", Generate::Action
+            # end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/commands/db/utils/database.rb

@@ -8,7 +8,7 @@ module Hanami
       module DB
         module Utils
           class Database
-            attr_reader :application, :config
+            attr_reader :app, :config
 
             SCHEME_MAP = {
               "sqlite" => -> {
@@ -29,8 +29,8 @@ module Hanami
               }
             }.freeze
 
-            def self.[](application)
-              config = DatabaseConfig.new(application.settings.database_url)
+            def self.[](app)
+              config = DatabaseConfig.new(app.settings.database_url)
 
               resolver = SCHEME_MAP.fetch(config.db_type) do
                 raise "#{config.db_type} is not a supported db scheme"
@@ -38,11 +38,11 @@ module Hanami
 
               klass = resolver.()
 
-              klass.new(application: application, config: config)
+              klass.new(app: app, config: config)
             end
 
-            def initialize(application:, config:)
-              @application = application
+            def initialize(app:, config:)
+              @app = app
               @config = config
             end
 
@@ -63,14 +63,14 @@ module Hanami
             end
 
             def root_path
-              application.root
+              app.root
             end
 
             def rom_config
               @rom_config ||=
                 begin
-                  application.prepare(:persistence)
-                  application.container["persistence.config"]
+                  app.prepare(:persistence)
+                  app.container["persistence.config"]
                 end
             end
 
@@ -109,7 +109,7 @@ module Hanami
 
             def sequel_migrator
               @sequel_migrator ||= begin
-                require 'sequel'
+                require "sequel"
                 Sequel.extension :migration
                 Sequel::TimestampMigrator.new(migrator.connection, migrations_path, {})
               end

data/lib/hanami/cli/commands/gem/new.rb

@@ -3,51 +3,49 @@
 require "hanami/cli/command"
 require "hanami/cli/bundler"
 require "hanami/cli/command_line"
-require "hanami/cli/generators/gem/application"
+require "hanami/cli/generators/gem/app"
 require "dry/files"
+require "dry/inflector"
 
 module Hanami
   module CLI
     module Commands
       module Gem
         class New < Command
-          ARCHITECTURES = %w[monolith micro].freeze
-          private_constant :ARCHITECTURES
-
-          DEFAULT_ARCHITECTURE = ARCHITECTURES.first
-          private_constant :DEFAULT_ARCHITECTURE
-
-          DEFAULT_SLICE_NAME = "main"
-          private_constant :DEFAULT_SLICE_NAME
-
-          DEFAULT_SLICE_URL_PREFIX = "/"
-          private_constant :DEFAULT_SLICE_URL_PREFIX
-
-          argument :app, required: true, desc: "The application name"
-
-          option :architecture, alias: "arch", default: DEFAULT_ARCHITECTURE,
-                                values: ARCHITECTURES, desc: "The architecture"
-
-          option :slice, default: DEFAULT_SLICE_NAME, desc: %(The initial slice name, only for "monolith" architecture)
-          option :slice_url_prefix, default: DEFAULT_SLICE_URL_PREFIX,
-                                    desc: %(The initial slice URL prefix, only for "monolith" architecture)
-
-          def initialize(fs: Dry::Files.new, bundler: CLI::Bundler.new(fs: fs),
-                         command_line: CLI::CommandLine.new(bundler: bundler), **other)
+          SKIP_BUNDLE_DEFAULT = false
+          private_constant :SKIP_BUNDLE_DEFAULT
+
+          argument :app, required: true, desc: "App name"
+
+          option :skip_bundle, type: :boolean, required: false,
+                               default: SKIP_BUNDLE_DEFAULT, desc: "Skip bundle install"
+
+          # rubocop:disable Metrics/ParameterLists
+          def initialize(
+            fs: Dry::Files.new,
+            inflector: Dry::Inflector.new,
+            bundler: CLI::Bundler.new(fs: fs),
+            command_line: CLI::CommandLine.new(bundler: bundler),
+            generator: Generators::Gem::App.new(fs: fs, inflector: inflector, command_line: command_line),
+            **other
+          )
             @bundler = bundler
             @command_line = command_line
-            super(fs: fs, **other)
+            @generator = generator
+            super(fs: fs, inflector: inflector, **other)
           end
+          # rubocop:enable Metrics/ParameterLists
 
-          def call(app:, architecture: DEFAULT_ARCHITECTURE, slice: DEFAULT_SLICE_NAME,
-                   slice_url_prefix: DEFAULT_SLICE_URL_PREFIX, **)
+          def call(app:, skip_bundle: SKIP_BUNDLE_DEFAULT, **)
             app = inflector.underscore(app)
 
             fs.mkdir(app)
             fs.chdir(app) do
-              generator(architecture).call(app, slice, slice_url_prefix) do
-                bundler.install!
-                run_install_commmand!
+              generator.call(app) do
+                unless skip_bundle
+                  bundler.install!
+                  run_install_commmand!
+                end
               end
             end
           end
@@ -56,14 +54,7 @@ module Hanami
 
           attr_reader :bundler
           attr_reader :command_line
-
-          def generator(architecture)
-            unless ARCHITECTURES.include?(architecture)
-              raise ArgumentError.new("unknown architecture `#{architecture}'")
-            end
-
-            Generators::Gem::Application[architecture, fs, inflector, command_line]
-          end
+          attr_reader :generator
 
           def run_install_commmand!
             command_line.call("hanami install").tap do |result|

data/lib/hanami/cli/commands/gem/version.rb

@@ -8,8 +8,28 @@ module Hanami
       module Gem
         class Version < Command
           def call(*)
+            version = detect_version
+            out.puts "v#{version}"
+          end
+
+          private
+
+          def detect_version
+            hanami_version ||
+              hanami_cli_version
+          end
+
+          def hanami_version
             require "hanami/version"
-            out.puts "v#{Hanami::VERSION}"
+
+            Hanami::VERSION
+          rescue LoadError # rubocop:disable Lint/SuppressedException
+          end
+
+          def hanami_cli_version
+            require "hanami/cli/version"
+
+            Hanami::CLI::VERSION
           end
         end
       end

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

@@ -5,14 +5,12 @@ module Hanami
     module Commands
       module Gem
         require_relative "gem/version"
-        # FIXME: temporary disabled for Hanami v2.0.0.alpha2
-        # require_relative "gem/new"
+        require_relative "gem/new"
 
         def self.extended(base)
           base.module_eval do
             register "version", Version, aliases: ["v", "-v", "--version"]
-            # FIXME: temporary disabled for Hanami v2.0.0.alpha2
-            # register "new", New
+            register "new", New
           end
         end
       end

data/lib/hanami/cli/commands.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
 module Hanami
-  # TODO: move elsewhere
-  def self.architecture
-    return :monolith if File.exist?("config/application.rb")
-  end
-
   module CLI
+    def self.within_hanami_app?
+      File.exist?("config/app.rb") ||
+        File.exist?("app.rb")
+    end
+
     module Commands
     end
 
-    def self.register_commands!(architecture = Hanami.architecture)
-      commands = case architecture
-                 when :monolith
-                   require_relative "commands/monolith"
-                   Commands::Monolith
+    def self.register_commands!(within_hanami_app = Hanami::CLI.within_hanami_app?)
+      commands = if within_hanami_app
+                   require_relative "commands/app"
+                   Commands::App
                  else
                    require_relative "commands/gem"
                    Commands::Gem

data/lib/hanami/cli/generators/{monolith → app}/action.rb

@@ -2,13 +2,13 @@
 
 require "erb"
 require "dry/files"
-require "hanami/cli/generators/monolith/action_context"
+require "hanami/cli/generators/app/action_context"
 require "hanami/cli/url"
 
 module Hanami
   module CLI
     module Generators
-      module Monolith
+      module App
         class Action
           def initialize(fs:, inflector:)
             @fs = fs

data/lib/hanami/cli/generators/{monolith → app}/action_context.rb

@@ -6,7 +6,7 @@ require "dry/files/path"
 module Hanami
   module CLI
     module Generators
-      module Monolith
+      module App
         class ActionContext < SliceContext
           def initialize(inflector, slice, controller, action)
             @controller = controller

data/lib/hanami/cli/generators/{monolith → app}/slice.rb

@@ -2,12 +2,12 @@
 
 require "erb"
 require "dry/files"
-require "hanami/cli/generators/monolith/slice_context"
+require "hanami/cli/generators/app/slice_context"
 
 module Hanami
   module CLI
     module Generators
-      module Monolith
+      module App
         class Slice
           def initialize(fs:, inflector:)
             @fs = fs

data/lib/hanami/cli/generators/{monolith → app}/slice_context.rb

@@ -5,7 +5,7 @@ require_relative "../context"
 module Hanami
   module CLI
     module Generators
-      module Monolith
+      module App
         class SliceContext < Generators::Context
           def initialize(inflector, app, slice, slice_url_prefix)
             @slice = slice

data/lib/hanami/cli/generators/context.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "hanami/version"
+require_relative "./version"
 
 module Hanami
   module CLI
@@ -16,7 +16,7 @@ module Hanami
         end
 
         def hanami_version
-          Hanami::Version.gem_requirement
+          Version.gem_requirement
         end
 
         def classified_app_name

data/lib/hanami/cli/generators/gem/{application/monolith/entities.erb → app/action.erb}

@@ -1,9 +1,9 @@
 # auto_register: false
 # frozen_string_literal: true
 
+require "hanami/action"
+
 module <%= classified_app_name %>
-  module Entities
+  class Action < Hanami::Action
   end
 end
-
-Dir[File.join(__dir__, "entities", "*.rb")].each(&method(:require))

data/lib/hanami/cli/generators/gem/{application/monolith/application.erb → app/app.erb}

@@ -3,6 +3,6 @@
 require "hanami"
 
 module <%= classified_app_name %>
-  class Application < Hanami::Application
+  class App < Hanami::App
   end
 end

data/lib/hanami/cli/generators/gem/app/gemfile.erb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "rake"
+
+gem "hanami-router", "<%= hanami_version %>"
+gem "hanami-controller", "<%= hanami_version %>"
+gem "hanami", "<%= hanami_version %>"
+
+gem "puma"
+
+group :cli, :development, :test do
+  gem "hanami-rspec"
+end

data/lib/hanami/cli/generators/gem/app/operation.erb

@@ -0,0 +1,9 @@
+# auto_register: false
+# frozen_string_literal: true
+
+require "hanami/operation"
+
+module <%= classified_app_name %>
+  class Operation < Hanami::Operation
+  end
+end

data/lib/hanami/cli/generators/gem/app/rakefile.erb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hanami/rake_tasks"

data/lib/hanami/cli/generators/gem/app/relation.erb

@@ -0,0 +1,7 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= classified_app_name %>
+  class Relation < Hanami::Relation
+  end
+end