hanami-cli 2.0.0.beta2 → 2.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 511daafabba67025eb83dd27f06c62a9809ab89c8901445e5c00f15bbf8fd8ca
-  data.tar.gz: 7d303b0c72fb47c2cf0ba107af0e6899d83b14b580565f4b30c43f4bc87ab4f9
+  metadata.gz: 9e5786ce0557b00c863e145560473293d2d172f96c4bcdd10e7dcc32484a32a3
+  data.tar.gz: 036fb11ad8f805173889beb755daa50d8de1da678d74e853f9f8ddf65fa3dde1
 SHA512:
-  metadata.gz: 716e634d4c572a09cd9954484d9dafc6affaafc13d03ec1e79703436b3efd305d1823dc4d35e92207b5388ebc33aef9f9ba603089cf73b3aec904957fe760bd6
-  data.tar.gz: e7d545d1cd6bfabcc5b4305b755c319c06a4e688e74a4639765c8f0026aac6b039d3459d670014a096ebd726b4a3192f694e273285341698b52a02b0762ae4a4
+  metadata.gz: 3bde684529fa1ae28f86bee5aa8b9fb42297a7e112ff272751c0a234f5cb22cb13ea6a3bf46d580a56d9804225fd2d0834e131eb53fd60184cb0d6096f8f2a08
+  data.tar.gz: de2d099cfe069f4fd6c85aa23c5ce60f0133e9a6c1858c9f237f9c104ee5f2e56ab11965a7b979de754d6cdcefc8cbb9b5abfc9b0acc58cda2e2402cb570c546

data/.rubocop.yml

@@ -22,6 +22,8 @@ Style/BlockDelimiters:
   Enabled: false
 Style/CommentedKeyword:
   Enabled: false
+Style/EmptyHeredoc:
+  Enabled: false
 Style/LambdaCall:
   Enabled: false
 Style/TrailingCommaInArguments:

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 Hanami Command Line Interface
 
+## v2.0.0.beta4 - 2022-10-24
+
+### Changed
+
+- [Sean Collins] Show output when generating files (e.g. in `hanami new`) (#49)
+- [Luca Guidi] Advertise Bundler and Hanami install steps when running `hanami new` (#54)
+
+## v2.0.0.beta3 - 2022-09-21
+
+### Added
+
+- [Luca Guidi] New applications to support Puma server out of the box. Add the `puma` gem to `Gemfile` and generate `config/puma.rb`.
+- [Luca Guidi] New applications to support code reloading for `hanami server` via `hanami-reloader`. This gem is added to app's `Gemfile`.
+- [Marc Busqué] Introduce code reloading for `hanami console` via `#reload` method to be invoked within the console context.
+
+### Fixed
+
+- [Luca Guidi] Respect plural when generating code via `hanami new` and `hanami generate`. Example: `hanami new code_insights` => `CodeInsights` instead of `CodeInsight`
+- [Luca Guidi] Ensure `hanami generate action` to not crash when invoked with non-RESTful action names. Example: `hanami generate action talent.apply`
+
+### Changed
+
+- [Piotr Solnica] `hanami generate action` to add routes to `config/routes.rb` without the `define` block context. See https://github.com/hanami/hanami/pull/1208
+
 ## v2.0.0.beta2 - 2022-08-16
 
 ### Added

data/Gemfile

@@ -8,7 +8,6 @@ unless ENV["CI"]
   gem "yard",   require: false
 end
 
-gem "dry-files", require: false, github: "dry-rb/dry-files", branch: :main
 gem "hanami", require: false, github: "hanami/hanami", branch: :main
 gem "hanami-router", github: "hanami/router", branch: :main
 

data/hanami-cli.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bundler", "~> 2.1"
   spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "dry-cli", "~> 0.7"
-  spec.add_dependency "dry-files", "~> 0.2", ">= 0.2.0"
+  spec.add_dependency "dry-files", "~> 0.3", ">= 0.3.0"
   spec.add_dependency "dry-inflector", "~> 0.2"
 
   spec.add_development_dependency "rspec", "~> 3.9"

data/lib/hanami/cli/command.rb

@@ -7,9 +7,10 @@ require "dry/inflector"
 module Hanami
   module CLI
     class Command < Dry::CLI::Command
-      def initialize(out: $stdout, fs: Dry::Files.new, inflector: Dry::Inflector.new)
+      def initialize(out: $stdout, err: $stderr, fs: Dry::Files.new, inflector: Dry::Inflector.new)
         super()
         @out = out
+        @err = err
         @fs = fs
         @inflector = inflector
       end
@@ -18,6 +19,8 @@ module Hanami
 
       attr_reader :out
 
+      attr_reader :err
+
       attr_reader :fs
 
       attr_reader :inflector

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

@@ -8,15 +8,17 @@ module Hanami
     module Commands
       module App
         class Command < Hanami::CLI::Command
+          ACTION_SEPARATOR = "."
+
           module Environment
-            def call(**opts)
+            def call(*args, **opts)
               env = opts[:env]
 
               hanami_env = env ? env.to_s : ENV.fetch("HANAMI_ENV", "development")
 
               ENV["HANAMI_ENV"] = hanami_env
 
-              super(**opts)
+              super(*args, **opts)
             end
           end
 

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

@@ -10,37 +10,47 @@ module Hanami
       module App
         # @api public
         class Console < App::Command
-          REPLS = {
+          ENGINES = {
             "pry" => -> (*args) {
               begin
                 require "hanami/cli/repl/pry"
                 Repl::Pry.new(*args)
-              rescue LoadError; end # rubocop:disable Lint/SuppressedException
+              rescue LoadError # rubocop:disable Lint/SuppressedException
+              end
             },
             "irb" => -> (*args) {
               require "hanami/cli/repl/irb"
               Repl::Irb.new(*args)
             },
           }.freeze
+          private_constant :ENGINES
 
-          desc "App REPL"
+          DEFAULT_ENGINE = "irb"
+          private_constant :DEFAULT_ENGINE
 
-          option :env, required: false, desc: "Application environment"
-          option :repl, required: false, desc: "REPL gem that should be used ('pry' or 'irb')"
+          desc "Start app console (REPL)"
+
+          option :engine, required: false, desc: "Console engine", values: ENGINES.keys
 
           # @api private
-          def call(repl: nil, **opts)
-            engine = resolve_engine(repl, opts)
-            engine.start
+          def call(engine: nil, **opts)
+            console_engine = resolve_engine(engine, opts)
+
+            if console_engine.nil?
+              err.puts "`#{engine}' is not bundled. Please run `bundle add #{engine}' and retry."
+              exit(1)
+            end
+
+            console_engine.start
           end
 
           private
 
-          def resolve_engine(repl, opts)
-            if repl
-              REPLS.fetch(repl).(app, opts)
+          def resolve_engine(engine, opts)
+            if engine
+              ENGINES.fetch(engine).(app, opts)
             else
-              REPLS.map { |(_, loader)| loader.(app, opts) }.compact.first
+              ENGINES.map { |(_, loader)| loader.(app, opts) }.compact.first
             end
           end
         end

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

@@ -15,6 +15,7 @@ module Hanami
                 out.puts "=> database #{database.name} created"
               else
                 out.puts "=> failed to create database #{database.name}"
+                exit $?.exitstatus
               end
             end
           end

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

@@ -28,7 +28,23 @@ module Hanami
             #                    desc: "Skip view and template generation"
             option :slice, required: false, desc: "Slice name"
 
-            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+            # rubocop:disable Layout/LineLength
+            example [
+              %(books.index               # GET    /books          to: "books.index"    (MyApp::Actions::Books::Index)),
+              %(books.new                 # GET    /books/new      to: "books.new"      (MyApp::Actions::Books::New)),
+              %(books.create              # POST   /books          to: "books.create"   (MyApp::Actions::Books::Create)),
+              %(books.edit                # GET    /books/:id/edit to: "books.edit"     (MyApp::Actions::Books::Edit)),
+              %(books.update              # PATCH  /books/:id      to: "books.update"   (MyApp::Actions::Books::Update)),
+              %(books.show                # GET    /books/:id      to: "books.show"     (MyApp::Actions::Books::Show)),
+              %(books.destroy             # DELETE /books/:id      to: "books.destroy"  (MyApp::Actions::Books::Destroy)),
+              %(books.sale                # GET    /books/sale     to: "books.sale"     (MyApp::Actions::Books::Sale)),
+              %(sessions.new --url=/login # GET    /login          to: "sessions.new"   (MyApp::Actions::Sessions::New)),
+              %(authors.update --http=put # PUT    /authors/:id    to: "authors.update" (MyApp::Actions::Authors::Update)),
+              %(users.index --slice=admin # GET    /admin/users    to: "users.index"    (Admin::Actions::Users::Update))
+            ]
+            # rubocop:enable Layout/LineLength
+
+            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Action.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)
@@ -50,9 +66,6 @@ module Hanami
 
             private
 
-            ACTION_SEPARATOR = "."
-            private_constant :ACTION_SEPARATOR
-
             attr_reader :generator
           end
         end

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

@@ -5,6 +5,7 @@ require "hanami/cli/generators/app/slice"
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+require "hanami/cli/files"
 require "hanami/cli/url"
 
 module Hanami
@@ -14,22 +15,27 @@ module Hanami
         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"
+            option :url, required: false, type: :string, desc: "The slice URL prefix"
 
-            def initialize(fs: Dry::Files.new, inflector: Dry::Inflector.new,
+            example [
+              "admin          # Admin slice (/admin URL prefix)",
+              "users --url=/u # Users slice (/u URL prefix)",
+            ]
+
+            def initialize(fs: Hanami::CLI::Files.new, inflector: Dry::Inflector.new,
                            generator: Generators::App::Slice.new(fs: fs, inflector: inflector), **)
               @generator = generator
               super(fs: fs)
             end
 
-            def call(name:, url_prefix: nil, **)
+            def call(name:, url: nil, **)
               require "hanami/setup"
 
               app = inflector.underscore(Hanami.app.namespace)
               name = inflector.underscore(Shellwords.shellescape(name))
-              url_prefix = sanitize_url_prefix(name, url_prefix)
+              url = sanitize_url_prefix(name, url)
 
-              generator.call(app, name, url_prefix)
+              generator.call(app, name, url)
             end
 
             private
@@ -39,14 +45,14 @@ module Hanami
 
             attr_reader :generator
 
-            def sanitize_url_prefix(name, url_prefix)
-              result = url_prefix
+            def sanitize_url_prefix(name, url)
+              result = url
               result = inflector.underscore(Shellwords.shellescape(result)) unless result.nil?
 
               result ||= DEFAULT_URL_PREFIX + name
               CLI::URL.call(result)
             rescue ArgumentError
-              raise ArgumentError.new("invalid URL prefix: `#{url_prefix}'")
+              raise ArgumentError.new("invalid URL prefix: `#{url}'")
             end
 
             def valid_url?(url)

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

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module App
         class Install < Command
+          desc "Install Hanami third-party plugins"
+
           def call(*)
           end
         end

data/lib/hanami/cli/commands/app/{middlewares.rb → middleware.rb}

@@ -7,30 +7,35 @@ module Hanami
   module CLI
     module Commands
       module App
-        # List registered middlewares in the app router
+        # List registered middleware in the app router
         #
-        # It outputs middlewares registered along with the paths where they
+        # It outputs middleware registered along with the paths where they
         # apply:
         #
         # ```
-        # $ hanami middlewares
+        # $ bundle exec hanami middleware
         # /    Rack::Session::Cookie
         # ```
         #
         # Given arguments can be inspected:
         #
         # ```
-        # $ hanami middlewares --with-arguments
+        # $ bundle exec hanami middleware --with-arguments
         # /    Rack::Session::Cookie args: [{:secret=>"foo"}]
         # ```
-        class Middlewares < Hanami::CLI::Command
-          desc "List all the registered middlewares"
+        class Middleware < Hanami::CLI::Command
+          desc "Print app Rack middleware stack"
 
           DEFAULT_WITH_ARGUMENTS = false
 
           option :with_arguments, default: DEFAULT_WITH_ARGUMENTS, required: false,
                                   desc: "Include inspected arguments", type: :boolean
 
+          example [
+            "middleware                  # Print app Rack middleware stack",
+            "middleware --with-arguments # Print app Rack middleware stack, including initialize arguments",
+          ]
+
           # @api private
           def call(with_arguments: DEFAULT_WITH_ARGUMENTS)
             require "hanami/prepare"

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "hanami"
-require "hanami/router/inspector"
 
 module Hanami
   module CLI
@@ -12,14 +11,14 @@ module Hanami
         # All the formatters available from `hanami-router` are available:
         #
         # ```
-        # $ hanami routes --format=csv
+        # $ bundle exec 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
+        # $ bundle exec hanami routes --format=custom_routes_formatter
         # ```
         class Routes < Hanami::CLI::Command
           DEFAULT_FORMAT = "human_friendly"
@@ -31,15 +30,21 @@ module Hanami
           ].freeze
           private_constant :VALID_FORMATS
 
-          desc "Inspect application"
+          desc "Print app routes"
 
           option :format,
                  default: DEFAULT_FORMAT,
                  required: false,
                  desc: "Output format"
 
+          example [
+            "routes              # Print app routes",
+            "routes --format=csv # Print app routes, using CSV format",
+          ]
+
           # @api private
           def call(format: DEFAULT_FORMAT, **)
+            require "hanami/router/inspector"
             require "hanami/prepare"
             inspector = Hanami::Router::Inspector.new(formatter: resolve_formatter(format))
             app.router(inspector: inspector)

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

@@ -28,13 +28,16 @@ module Hanami
           DEFAULT_PORT = 2300
           private_constant :DEFAULT_PORT
 
-          desc "Start Hanami server"
+          DEFAULT_CONFIG_PATH = "config.ru"
+          private_constant :DEFAULT_CONFIG_PATH
+
+          desc "Start Hanami app 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 :config, default: DEFAULT_CONFIG_PATH, 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
 

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

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module App
         class Version < Command
+          desc "Print Hanami app version"
+
           def call(*)
             require "hanami/version"
             out.puts "v#{Hanami::VERSION}"

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

@@ -10,7 +10,7 @@ module Hanami
         require_relative "app/server"
         require_relative "app/routes"
         require_relative "app/generate"
-        require_relative "app/middlewares"
+        require_relative "app/middleware"
         # require_relative "app/db/create"
         # require_relative "app/db/create_migration"
         # require_relative "app/db/drop"
@@ -30,7 +30,7 @@ module Hanami
             register "console", Commands::App::Console, aliases: ["c"]
             register "server", Commands::App::Server, aliases: ["s"]
             register "routes", Commands::App::Routes
-            register "middlewares", Commands::App::Middlewares
+            register "middleware", Commands::App::Middleware
 
             register "generate", aliases: ["g"] do |prefix|
               prefix.register "slice", Generate::Slice

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

@@ -30,7 +30,14 @@ module Hanami
             }.freeze
 
             def self.[](app)
-              config = DatabaseConfig.new(app.settings.database_url)
+              database_url =
+                if app.key?(:settings) && app[:settings].respond_to?(:database_url)
+                  app[:settings].database_url
+                else
+                  ENV.fetch("DATABASE_URL")
+                end
+
+              config = DatabaseConfig.new(database_url)
 
               resolver = SCHEME_MAP.fetch(config.db_type) do
                 raise "#{config.db_type} is not a supported db scheme"

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "shellwords"
+require "open3"
 require_relative "database"
 
 module Hanami
@@ -10,6 +11,10 @@ module Hanami
         module Utils
           class Postgres < Database
             def create_command
+              existing_stdout, status = Open3.capture2(cli_env_vars, "psql -t -c '\\l #{escaped_name}'")
+
+              return true if status.success? && existing_stdout.include?(escaped_name)
+
               system(cli_env_vars, "createdb #{escaped_name}")
             end
 

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

@@ -4,7 +4,7 @@ require "hanami/cli/command"
 require "hanami/cli/bundler"
 require "hanami/cli/command_line"
 require "hanami/cli/generators/gem/app"
-require "dry/files"
+require "hanami/cli/files"
 require "dry/inflector"
 
 module Hanami
@@ -12,17 +12,25 @@ module Hanami
     module Commands
       module Gem
         class New < Command
-          SKIP_BUNDLE_DEFAULT = false
-          private_constant :SKIP_BUNDLE_DEFAULT
+          SKIP_INSTALL_DEFAULT = false
+          private_constant :SKIP_INSTALL_DEFAULT
+
+          desc "Generate a new Hanami app"
 
           argument :app, required: true, desc: "App name"
 
-          option :skip_bundle, type: :boolean, required: false,
-                               default: SKIP_BUNDLE_DEFAULT, desc: "Skip bundle install"
+          option :skip_install, type: :boolean, required: false,
+                                default: SKIP_INSTALL_DEFAULT,
+                                desc: "Skip app installation (Bundler, third-party Hanami plugins)"
+
+          example [
+            "bookshelf                # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace", # rubocop:disable Layout/LineLength
+            "bookshelf --skip-install # Generate a new Hanami app, but it skips Hanami installation"
+          ]
 
           # rubocop:disable Metrics/ParameterLists
           def initialize(
-            fs: Dry::Files.new,
+            fs: Hanami::CLI::Files.new,
             inflector: Dry::Inflector.new,
             bundler: CLI::Bundler.new(fs: fs),
             command_line: CLI::CommandLine.new(bundler: bundler),
@@ -36,14 +44,18 @@ module Hanami
           end
           # rubocop:enable Metrics/ParameterLists
 
-          def call(app:, skip_bundle: SKIP_BUNDLE_DEFAULT, **)
+          def call(app:, skip_install: SKIP_INSTALL_DEFAULT, **)
             app = inflector.underscore(app)
 
             fs.mkdir(app)
             fs.chdir(app) do
               generator.call(app) do
-                unless skip_bundle
+                if skip_install
+                  out.puts "Skipping installation, please enter `#{app}' directory and run `bundle exec hanami install'"
+                else
+                  out.puts "Running Bundler install..."
                   bundler.install!
+                  out.puts "Running Hanami install..."
                   run_install_commmand!
                 end
               end

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

@@ -7,6 +7,8 @@ module Hanami
     module Commands
       module Gem
         class Version < Command
+          desc "Hanami version"
+
           def call(*)
             version = detect_version
             out.puts "v#{version}"

data/lib/hanami/cli/commands.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami"
-
 module Hanami
   module CLI
     # Returns true if the CLI is being called from inside an Hanami app.
@@ -12,7 +10,8 @@ module Hanami
     # @api public
     # @since 2.0.0
     def self.within_hanami_app?
-      !!Hanami.app_path
+      File.exist?("config/app.rb") ||
+        File.exist?("app.rb")
     end
 
     module Commands

data/lib/hanami/cli/files.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  module CLI
+    class Files < Dry::Files
+      def initialize(out: $stdout, **args)
+        super(**args)
+        @out = out
+      end
+
+      def write(path, *content)
+        already_exists = exist?(path)
+        super
+        if already_exists
+          updated(path)
+        else
+          created(path)
+        end
+      end
+
+      def mkdir(path)
+        unless exist?(path)
+          super
+          created("#{path}/")
+        end
+      end
+
+      def chdir(path, &blk)
+        within_folder(path)
+        super
+      end
+
+      private
+
+      attr_reader :out
+
+      def updated(path)
+        out.puts "Updated #{path}"
+      end
+
+      def created(path)
+        out.puts "Created #{path}"
+      end
+
+      def within_folder(path)
+        out.puts "-> Within #{path}/"
+      end
+    end
+  end
+end

data/lib/hanami/cli/generators/app/action/action.erb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   module Actions
 <%= module_controller_declaration %>
-<%= module_controller_offset %>class <%= classified_action_name %> < <%= classified_app_name %>::Action
+<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_app_name %>::Action
 <%= module_controller_offset %>  def handle(*, response)
 <%= module_controller_offset %>    response.body = self.class.name
 <%= module_controller_offset %>  end

data/lib/hanami/cli/generators/app/action/slice_action.erb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module <%= classified_slice_name %>
+module <%= camelized_slice_name %>
   module Actions
 <%= module_controller_declaration %>
-<%= module_controller_offset %>class <%= classified_action_name %> < <%= classified_slice_name %>::Action
+<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_slice_name %>::Action
 <%= module_controller_offset %>  def handle(*, response)
 <%= module_controller_offset %>    response.body = self.class.name
 <%= module_controller_offset %>  end

data/lib/hanami/cli/generators/app/action/template.html.erb

@@ -1,2 +1,2 @@
-<h1><%= classified_slice_name %>::Views::<%= classified_controller_name %>::<%= classified_action_name %></h1>
+<h1><%= camelized_slice_name %>::Views::<%= camelized_controller_name %>::<%= camelized_action_name %></h1>
 <h2><%= template_path %></h2>

data/lib/hanami/cli/generators/app/action/view.erb

@@ -3,10 +3,10 @@
 
 require "<%= underscored_slice_name %>/view"
 
-module <%= classified_slice_name %>
+module <%= camelized_slice_name %>
   module Views
 <%= module_controller_declaration %>
-<%= module_controller_offset %>class <%= classified_action_name %> < <%= classified_slice_name %>::View
+<%= module_controller_offset %>class <%= camelized_action_name %> < <%= camelized_slice_name %>::View
 <%= module_controller_offset %>end
 <%= module_controller_end %>
   end

data/lib/hanami/cli/generators/app/action.rb

@@ -2,6 +2,7 @@
 
 require "erb"
 require "dry/files"
+require "hanami/cli/files"
 require "hanami/cli/generators/app/action_context"
 require "hanami/cli/url"
 
@@ -42,16 +43,19 @@ module Hanami
           private_constant :ROUTE_RESTFUL_HTTP_METHODS
 
           ROUTE_RESTFUL_URL_SUFFIXES = {
-            "index" => "",
-            "new" => "/new",
-            "create" => "",
-            "edit" => "/:id/edit",
-            "update" => "/:id",
-            "show" => "/:id",
-            "destroy" => "/:id"
+            "index" => [],
+            "new" => ["new"],
+            "create" => [],
+            "edit" => [":id", "edit"],
+            "update" => [":id"],
+            "show" => [":id"],
+            "destroy" => [":id"]
           }.freeze
           private_constant :ROUTE_RESTFUL_URL_SUFFIXES
 
+          PATH_SEPARATOR = "/"
+          private_constant :PATH_SEPARATOR
+
           attr_reader :fs
 
           attr_reader :inflector
@@ -66,24 +70,22 @@ module Hanami
               route(controller, action, url, http)
             )
 
-            fs.chdir(slice_directory) do
-              fs.mkdir(directory = fs.join("actions", controller))
-              fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
-
-              # unless skip_view
-              #   fs.mkdir(directory = fs.join("views", controller))
-              #   fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
-              #
-              #   fs.mkdir(directory = fs.join("templates", controller))
-              #   fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
-              # end
-            end
+            fs.mkdir(directory = fs.join(slice_directory, "actions", controller))
+            fs.write(fs.join(directory, "#{action}.rb"), t("slice_action.erb", context))
+
+            # unless skip_view
+            #   fs.mkdir(directory = fs.join(slice_directory, "views", controller))
+            #   fs.write(fs.join(directory, "#{action}.rb"), t("view.erb", context))
+            #
+            #   fs.mkdir(directory = fs.join(slice_directory, "templates", controller))
+            #   fs.write(fs.join(directory, "#{action}.#{format}.erb"), t(template_format(format), context))
+            # end
           end
 
           def generate_for_app(controller, action, url, http, _format, _skip_view, context)
-            fs.inject_line_at_block_bottom(
+            fs.inject_line_at_class_bottom(
               fs.join("config", "routes.rb"),
-              /define/,
+              "class Routes",
               route(controller, action, url, http)
             )
 
@@ -120,7 +122,10 @@ module Hanami
           alias_method :t, :template
 
           def route_url(controller, action, url)
-            CLI::URL.call(url || ("/#{controller.join('/')}" + ROUTE_RESTFUL_URL_SUFFIXES.fetch(action)))
+            action = ROUTE_RESTFUL_URL_SUFFIXES.fetch(action) { [action] }
+            url ||= "#{PATH_SEPARATOR}#{(controller + action).join(PATH_SEPARATOR)}"
+
+            CLI::URL.call(url)
           end
 
           def route_http(action, http)

data/lib/hanami/cli/generators/app/action_context.rb

@@ -14,14 +14,14 @@ module Hanami
             super(inflector, app, slice, nil)
           end
 
-          def classified_controller_name
+          def camelized_controller_name
             controller.map do |token|
               inflector.camelize(token)
             end.join(NAMESPACE_SEPARATOR)
           end
 
-          def classified_action_name
-            inflector.classify(action)
+          def camelized_action_name
+            inflector.camelize(action)
           end
 
           def underscored_controller_name

data/lib/hanami/cli/generators/app/slice/action.erb

@@ -1,7 +1,7 @@
 # auto_register: false
 # frozen_string_literal: true
 
-module <%= classified_slice_name %>
-  class Action < <%= classified_app_name %>::Action
+module <%= camelized_slice_name %>
+  class Action < <%= camelized_app_name %>::Action
   end
 end

data/lib/hanami/cli/generators/app/slice/entities.erb

@@ -1,7 +1,7 @@
 # auto_register: false
 # frozen_string_literal: true
 
-module <%= classified_slice_name %>
+module <%= camelized_slice_name %>
   module Entities
   end
 end

data/lib/hanami/cli/generators/app/slice/repository.erb

@@ -3,8 +3,8 @@
 require "<%= underscored_app_name %>/repository"
 require_relative "entities"
 
-module <%= classified_slice_name %>
-  class Repository < <%= classified_app_name %>::Repository
+module <%= camelized_slice_name %>
+  class Repository < <%= camelized_app_name %>::Repository
     struct_namespace Entities
   end
 end

data/lib/hanami/cli/generators/app/slice/routes.erb

@@ -1,3 +1,3 @@
 
-slice :<%= underscored_slice_name %>, at: "<%= slice_url_prefix %>" do
+slice :<%= underscored_slice_name %>, at: "<%= url %>" do
 end

data/lib/hanami/cli/generators/app/slice/slice.erb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module <%= classified_slice_name %>
+module <%= camelized_slice_name %>
   class Slice < Hanami::Slice
   end
 end

data/lib/hanami/cli/generators/app/slice/view.erb

@@ -3,7 +3,7 @@
 
 require "<%= underscored_app_name %>/view"
 
-module <%= classified_slice_name %>
-  class View < <%= classified_app_name %>::View
+module <%= camelized_slice_name %>
+  class View < <%= camelized_app_name %>::View
   end
 end

data/lib/hanami/cli/generators/app/slice.rb

@@ -14,25 +14,25 @@ module Hanami
             @inflector = inflector
           end
 
-          def call(app, slice, slice_url_prefix, context: SliceContext.new(inflector, app, slice, slice_url_prefix))
-            fs.inject_line_at_block_bottom(fs.join("config", "routes.rb"), /define/, t("routes.erb", context).chomp)
+          def call(app, slice, url, context: SliceContext.new(inflector, app, slice, url))
+            fs.inject_line_at_class_bottom(
+              fs.join("config", "routes.rb"), "class Routes", t("routes.erb", context).chomp
+            )
 
             fs.mkdir(directory = "slices/#{slice}")
 
-            fs.chdir(directory) do
-              # fs.write("config/slice.rb", t("slice.erb", context))
-              fs.write("action.rb", t("action.erb", context))
-              # fs.write("view.rb", t("view.erb", context))
-              # fs.write("entities.rb", t("entities.erb", context))
-              # fs.write("repository.rb", t("repository.erb", context))
-
-              fs.write("actions/.keep", t("keep.erb", context))
-              # fs.write("views/.keep", t("keep.erb", context))
-              # fs.write("templates/.keep", t("keep.erb", context))
-              # fs.write("templates/layouts/.keep", t("keep.erb", context))
-              # fs.write("entities/.keep", t("keep.erb", context))
-              # fs.write("repositories/.keep", t("keep.erb", context))
-            end
+            # fs.write("#{directory}/config/slice.rb", t("slice.erb", context))
+            fs.write(fs.join(directory, "action.rb"), t("action.erb", context))
+            # fs.write(fs.join(directory, "/view.rb"), t("view.erb", context))
+            # fs.write(fs.join(directory, "/entities.rb"), t("entities.erb", context))
+            # fs.write(fs.join(directory, "/repository.rb"), t("repository.erb", context))
+
+            fs.write(fs.join(directory, "actions/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, views/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, templates/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, templates/layouts/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, entities/.keep"), t("keep.erb", context))
+            # fs.write(fs.join(directory, repositories/.keep"), t("keep.erb", context))
           end
 
           private

data/lib/hanami/cli/generators/app/slice_context.rb

@@ -7,14 +7,14 @@ module Hanami
     module Generators
       module App
         class SliceContext < Generators::Context
-          def initialize(inflector, app, slice, slice_url_prefix)
+          def initialize(inflector, app, slice, url)
             @slice = slice
-            @slice_url_prefix = slice_url_prefix
+            @url = url
             super(inflector, app)
           end
 
-          def classified_slice_name
-            inflector.classify(slice)
+          def camelized_slice_name
+            inflector.camelize(slice)
           end
 
           def underscored_slice_name
@@ -25,7 +25,7 @@ module Hanami
 
           attr_reader :slice
 
-          attr_reader :slice_url_prefix
+          attr_reader :url
         end
       end
     end

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

@@ -19,8 +19,8 @@ module Hanami
           Version.gem_requirement
         end
 
-        def classified_app_name
-          inflector.classify(app)
+        def camelized_app_name
+          inflector.camelize(app)
         end
 
         def underscored_app_name

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

@@ -3,7 +3,7 @@
 
 require "hanami/action"
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   class Action < Hanami::Action
   end
 end

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

@@ -2,7 +2,7 @@
 
 require "hanami"
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   class App < Hanami::App
   end
 end

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

@@ -7,7 +7,7 @@ gem "hanami-router", "<%= hanami_version %>"
 gem "hanami-controller", "<%= hanami_version %>"
 gem "hanami-validations", "<%= hanami_version %>"
 
-gem "dry-types"
+gem "dry-types", "~> 1.0", ">= 1.6.1"
 gem "puma"
 gem "rake"
 
@@ -15,6 +15,10 @@ group :development, :test do
   gem "dotenv"
 end
 
+group :cli, :development do
+  gem "hanami-reloader"
+end
+
 group :cli, :development, :test do
   gem "hanami-rspec"
 end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+max_threads_count = ENV.fetch("HANAMI_MAX_THREADS", 5)
+min_threads_count = ENV.fetch("HANAMI_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+port        ENV.fetch("HANAMI_PORT", 2300)
+environment ENV.fetch("HANAMI_ENV", "development")
+workers     ENV.fetch("HANAMI_WEB_CONCURRENCY", 2)
+
+on_worker_boot do
+  Hanami.shutdown
+end
+
+preload_app!

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

@@ -1 +1 @@
-# <%= classified_app_name %>
+# <%= camelized_app_name %>

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

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   class Routes < Hanami::Routes
-    define do
-      root { "Hello from Hanami" }
-    end
+    root { "Hello from Hanami" }
   end
 end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "<%= underscored_app_name %>/types"
-
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   class Settings < Hanami::Settings
     # Define your app settings here, for example:
     #

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

@@ -2,7 +2,7 @@
 
 require "dry/types"
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   Types = Dry.Types
 
   module Types

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

@@ -4,7 +4,7 @@
 require "dry/validation"
 require "dry/schema/messages/i18n"
 
-module <%= classified_app_name %>
+module <%= camelized_app_name %>
   module Validator < Dry::Validation::Contract
     config.messages.backend = :i18n
     config.messages.top_namespace = "validation"

data/lib/hanami/cli/generators/gem/app.rb

@@ -40,6 +40,7 @@ module Hanami
             fs.write("config/app.rb", t("app.erb", context))
             fs.write("config/settings.rb", t("settings.erb", context))
             fs.write("config/routes.rb", t("routes.erb", context))
+            fs.write("config/puma.rb", t("puma.erb", context))
 
             fs.write("lib/tasks/.keep", t("keep.erb", context))
             fs.write("lib/#{app}/types.rb", t("types.erb", context))

data/lib/hanami/cli/middleware_stack_inspector.rb

@@ -11,9 +11,9 @@ module Hanami
       def inspect(include_arguments: false)
         max_path_length = @stack.map { |(path)| path.length }.max
 
-        @stack.map { |path, middlewares|
-          middlewares.map { |(middleware, arguments)|
-            "#{path.ljust(max_path_length + 3)} #{format_middleware(middleware)}".tap { |line|
+        @stack.map { |path, middleware|
+          middleware.map { |(mware, arguments)|
+            "#{path.ljust(max_path_length + 3)} #{format_middleware(mware)}".tap { |line|
               line << " #{format_arguments(arguments)}" if include_arguments
             }
           }

data/lib/hanami/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Hanami
   module CLI
-    VERSION = "2.0.0.beta2"
+    VERSION = "2.0.0.beta4"
   end
 end

data/lib/hanami/console/context.rb

@@ -34,8 +34,9 @@ module Hanami
           hanami_app
         end
 
-        define_method(:app) do
-          hanami_app
+        define_method(:reload) do
+          puts "Reloading..."
+          Kernel.exec("#{$PROGRAM_NAME} console")
         end
 
         define_method(:method_missing) do |name, *args, &block|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-cli
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.beta4
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-16 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,20 +58,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: dry-inflector
   requirement: !ruby/object:Gem::Requirement
@@ -175,7 +175,7 @@ files:
 - lib/hanami/cli/commands/app/generate/action.rb
 - lib/hanami/cli/commands/app/generate/slice.rb
 - lib/hanami/cli/commands/app/install.rb
-- lib/hanami/cli/commands/app/middlewares.rb
+- lib/hanami/cli/commands/app/middleware.rb
 - lib/hanami/cli/commands/app/routes.rb
 - lib/hanami/cli/commands/app/server.rb
 - lib/hanami/cli/commands/app/version.rb
@@ -188,6 +188,7 @@ files:
 - lib/hanami/cli/commands/gem/new.rb
 - lib/hanami/cli/commands/gem/version.rb
 - lib/hanami/cli/error.rb
+- lib/hanami/cli/files.rb
 - lib/hanami/cli/generators/app/action.rb
 - lib/hanami/cli/generators/app/action/action.erb
 - lib/hanami/cli/generators/app/action/slice_action.erb
@@ -212,6 +213,7 @@ files:
 - lib/hanami/cli/generators/gem/app/env.erb
 - lib/hanami/cli/generators/gem/app/gemfile.erb
 - lib/hanami/cli/generators/gem/app/keep.erb
+- lib/hanami/cli/generators/gem/app/puma.erb
 - lib/hanami/cli/generators/gem/app/rakefile.erb
 - lib/hanami/cli/generators/gem/app/readme.erb
 - lib/hanami/cli/generators/gem/app/routes.erb