hanami-cli 2.3.0.beta1 → 2.3.0

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

@@ -41,7 +41,6 @@ module Hanami
               default: DEFAULT_SKIP_VIEW,
               desc: "Skip view and template generation"
 
-            # TODO: Implement this
             option \
               :skip_tests,
               required: false,
@@ -60,7 +59,6 @@ module Hanami
 
             # option :format, required: false, type: :string, default: DEFAULT_FORMAT, desc: "Template format"
 
-            # 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)),
@@ -74,15 +72,13 @@ module Hanami
               %(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 generator_class
               Generators::App::Action
             end
 
             # @since 2.0.0
             # @api private
-            # rubocop:disable Lint/ParameterLists
+            # rubocop:disable Metrics/ParameterLists
             def call(
               name:,
               slice: nil,
@@ -90,22 +86,23 @@ module Hanami
               http_method: nil,
               skip_view: DEFAULT_SKIP_VIEW,
               skip_route: DEFAULT_SKIP_ROUTE,
-              skip_tests: DEFAULT_SKIP_TESTS # rubocop:disable Lint/UnusedMethodArgument
+              skip_tests: DEFAULT_SKIP_TESTS
             )
               name = Naming.new(inflector:).action_name(name)
 
               raise InvalidActionNameError.new(name) unless name.include?(".")
 
               super(
-                name:,
-                slice:,
-                url_path:,
-                skip_route:,
-                http_method:,
+                name: name,
+                slice: slice,
+                url_path: url_path,
+                skip_route: skip_route,
+                http_method: http_method,
                 skip_view: skip_view || !Hanami.bundled?("hanami-view"),
+                skip_tests: skip_tests
               )
             end
-            # rubocop:enable Lint/ParameterLists
+            # rubocop:enable Metrics/ParameterLists
           end
         end
       end

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

@@ -29,17 +29,17 @@ module Hanami
             # @since 2.2.0
             # @api private
             option :skip_db,
-              type: :flag,
-              required: false,
-              default: SKIP_DB_DEFAULT,
-              desc: "Skip database"
+                   type: :flag,
+                   required: false,
+                   default: SKIP_DB_DEFAULT,
+                   desc: "Skip database"
             # @since 2.2.0
             # @api private
             option :skip_route,
-              type: :flag,
-              required: false,
-              default: DEFAULT_SKIP_ROUTE,
-              desc: "Skip route generation"
+                   type: :flag,
+                   required: false,
+                   default: DEFAULT_SKIP_ROUTE,
+                   desc: "Skip route generation"
 
             example [
               "admin          # Admin slice (/admin URL prefix)",

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "hanami"
+require_relative "../../errors"
+
+module Hanami
+  module CLI
+    module Commands
+      module App
+        # Run a given code or file in the context of the application
+        #
+        # This command is useful for running scripts that need to load the application environment.
+        # You can pass a Ruby file to be executed, or you can run an interactive Ruby shell (IRB)
+        # with the application environment loaded.
+        #
+        # Examples:
+        #
+        # $ bundle exec hanami run path/to/script.rb
+        # $ bundle exec hanami run 'puts Hanami.app["repos.user_repo"].all.count'
+        #
+        # @since 2.0.0
+        # @api private
+        class Run < Hanami::CLI::Command
+          RunError = Class.new(StandardError)
+
+          desc "Run code in the context of the application"
+
+          example [
+            "path/to/script.rb                     # Run a Ruby script in the context of the application",
+            "'puts Hanami.app[\"repos.user_repo\"].all.count' # Run inline Ruby code in the context of the application",
+          ]
+
+          argument :code_or_path, required: true, desc: "Path to a Ruby file or inline Ruby code to be executed"
+
+          def initialize(command_exit: method(:exit), **opts)
+            super(**opts)
+            @command_exit = command_exit
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def call(code_or_path:, **)
+            require "hanami/prepare"
+
+            if File.exist?(code_or_path)
+              validate_file_path!(code_or_path)
+              Kernel.load code_or_path
+            else
+              validate_inline_code!(code_or_path)
+              begin
+                eval(code_or_path, binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+              rescue SyntaxError => e
+                err.puts "Syntax error in code: #{e.message}"
+                raise RunError, "Syntax error in code: #{e.message}"
+              rescue NameError => e
+                err.puts "Name error in code: #{e.message}"
+                raise RunError, "Name error in code: #{e.message}"
+              rescue StandardError => e
+                err.puts "Error executing code: #{e.class}: #{e.message}"
+                raise RunError, "Error executing code: #{e.class}: #{e.message}"
+              end
+            end
+          rescue RunError
+            @command_exit.call(1)
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          private
+
+          def validate_file_path!(file_path)
+            errors = []
+
+            # Ensure the file is a Ruby file
+            unless file_path.end_with?(".rb")
+              errors << "Error: Only Ruby files (.rb) are allowed"
+            end
+
+            # Resolve the absolute path and ensure it's within the app directory
+            resolved_path = File.expand_path(file_path)
+            app_root = File.expand_path(Dir.pwd)
+
+            unless resolved_path.start_with?(app_root)
+              errors << "Error: File must be within the application directory"
+            end
+
+            # Check file size (prevent loading extremely large files)
+            file_size = File.size(file_path)
+            if file_size > 10 * 1024 * 1024 # 10MB limit
+              errors << "Error: File too large (maximum 10MB allowed)"
+            end
+
+            unless errors.empty?
+              errors.each { |error| err.puts error }
+              raise RunError, errors.join("\n")
+            end
+          end
+
+          def validate_inline_code!(code)
+            # Basic validation for inline code
+            if code.length > 10_000 # 10KB limit for inline code
+              err.puts "Error: Inline code too long (maximum 10,000 characters allowed)"
+              raise RunError, "Error: Inline code too long (maximum 10,000 characters allowed)"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,7 @@ module Hanami
             register "console", Commands::App::Console, aliases: ["c"]
             register "server", Commands::App::Server, aliases: ["s"]
             register "routes", Commands::App::Routes
+            register "run", Commands::App::Run
             register "middleware", Commands::App::Middleware
 
             if Hanami.bundled?("hanami-assets")

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

@@ -10,16 +10,21 @@ module Hanami
         # @since 2.0.0
         # @api private
         class New < Command
-          # @since 2.0.0
-          # @api private
-          SKIP_INSTALL_DEFAULT = false
-          private_constant :SKIP_INSTALL_DEFAULT
-
           # @since 2.1.0
           # @api private
           HEAD_DEFAULT = false
           private_constant :HEAD_DEFAULT
 
+          # @since 2.3.0
+          # @api private
+          GEM_SOURCE_DEFAULT = "rubygems.org"
+          private_constant :GEM_SOURCE_DEFAULT
+
+          # @since 2.0.0
+          # @api private
+          SKIP_INSTALL_DEFAULT = false
+          private_constant :SKIP_INSTALL_DEFAULT
+
           # @since 2.1.0
           # @api private
           SKIP_ASSETS_DEFAULT = false
@@ -60,18 +65,24 @@ module Hanami
           # @api private
           argument :app, required: true, desc: "App name"
 
-          # @since 2.0.0
-          # @api private
-          option :skip_install, type: :flag, required: false,
-                                default: SKIP_INSTALL_DEFAULT,
-                                desc: "Skip app installation (Bundler, third-party Hanami plugins)"
-
           # @since 2.1.0
           # @api private
           option :head, type: :flag, required: false,
                         default: HEAD_DEFAULT,
                         desc: "Use Hanami HEAD version (from GitHub `main` branches)"
 
+          # @since 2.3.0
+          # @api private
+          option :gem_source, required: true,
+                              default: GEM_SOURCE_DEFAULT,
+                              desc: "Where to source Ruby gems from"
+
+          # @since 2.0.0
+          # @api private
+          option :skip_install, type: :flag, required: false,
+                                default: SKIP_INSTALL_DEFAULT,
+                                desc: "Skip app installation (Bundler, third-party Hanami plugins)"
+
           # @since 2.1.0
           # @api private
           option :skip_assets, type: :flag, required: false,
@@ -100,6 +111,7 @@ module Hanami
           example [
             "bookshelf                                    # Generate a new Hanami app in `bookshelf/' directory, using `Bookshelf' namespace",
             "bookshelf --head                             # Generate a new Hanami app, using Hanami HEAD version from GitHub `main' branches",
+            "bookshelf --gem-source=gem.coop              # Generate a new Hanami app, using https://gem.coop as Ruby gem source",
             "bookshelf --skip-install                     # Generate a new Hanami app, but it skips Hanami installation",
             "bookshelf --skip-assets                      # Generate a new Hanami app without hanami-assets",
             "bookshelf --skip-db                          # Generate a new Hanami app without hanami-db",
@@ -132,6 +144,7 @@ module Hanami
           def call(
             app:,
             head: HEAD_DEFAULT,
+            gem_source: GEM_SOURCE_DEFAULT,
             skip_install: SKIP_INSTALL_DEFAULT,
             skip_assets: SKIP_ASSETS_DEFAULT,
             skip_db: SKIP_DB_DEFAULT,
@@ -152,6 +165,7 @@ module Hanami
                 inflector,
                 app,
                 head: head,
+                gem_source: gem_source,
                 skip_assets: skip_assets,
                 skip_db: skip_db,
                 skip_view: skip_view,
@@ -177,6 +191,9 @@ module Hanami
                   out.puts "Running hanami install..."
                   run_install_command!(head: head)
 
+                  out.puts "Running bundle binstubs hanami-cli rake..."
+                  install_binstubs!
+
                   out.puts "Initializing git repository..."
                   init_git_repository
                 end
@@ -215,6 +232,11 @@ module Hanami
             end
           end
 
+          # @api private
+          def install_binstubs!
+            bundler.bundle("binstubs hanami-cli rake")
+          end
+
           # @api private
           def init_git_repository
             system_call.call("git", ["init"]).tap do |result|

data/lib/hanami/cli/errors.rb

@@ -110,6 +110,7 @@ module Hanami
       end
     end
 
+    # rubocop:disable Layout/LineLength
     # @since 2.2.0
     # @api public
     class DatabaseNotSupportedError < Error
@@ -117,6 +118,7 @@ module Hanami
         super("`#{invalid_database}' is not a supported database. Supported databases are: #{supported_databases.join(', ')}")
       end
     end
+    # rubocop:enable Layout/LineLength
 
     # @since 2.2.0
     # @api public

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

@@ -27,10 +27,10 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:)
+          def call(key:, namespace:, base_path:, url_path:, http_method:, skip_view:, skip_route:, skip_tests:)
             insert_route(key:, namespace:, url_path:, http_method:) unless skip_route
 
-            generate_action(key:, namespace:, base_path:, include_placeholder_body: skip_view)
+            generate_action(key: key, namespace: namespace, base_path: base_path, include_placeholder_body: skip_view)
 
             generate_view(key:, namespace:, base_path:) unless skip_view
           end
@@ -83,8 +83,14 @@ module Hanami
             if namespace == Hanami.app.namespace
               fs.inject_line_at_class_bottom(routes_location, "class Routes", route)
             else
-              slice_matcher = /slice[[:space:]]*:#{namespace}/
-              fs.inject_line_at_block_bottom(routes_location, slice_matcher, route)
+              slice_routes = fs.join("slices", namespace, "config", "routes.rb")
+
+              if fs.exist?(slice_routes)
+                fs.inject_line_at_class_bottom(slice_routes, "class Routes", route)
+              else
+                slice_matcher = /slice[[:space:]]*:#{namespace}/
+                fs.inject_line_at_block_bottom(routes_location, slice_matcher, route)
+              end
             end
           end
 
@@ -95,7 +101,7 @@ module Hanami
               fs: fs,
               inflector: inflector,
               namespace: namespace,
-              key: inflector.underscore(key),
+              key: key,
               base_path: base_path,
               parent_class_name: "#{inflector.camelize(namespace)}::Action",
               extra_namespace: "Actions",

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

@@ -24,7 +24,7 @@ module Hanami
             RubyClassFile.new(
               fs: fs,
               inflector: inflector,
-              key: inflector.underscore(key),
+              key: key,
               namespace: namespace,
               base_path: base_path,
             ).create

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

@@ -20,7 +20,7 @@ module Hanami
           # @since 2.2.0
           # @api private
           def call(key:, namespace:, base_path:, gateway:)
-            schema_name = key.split(KEY_SEPARATOR).last
+            schema_name = inflector.underscore(key.split(KEY_SEPARATOR).last)
             body_content = ["schema :#{schema_name}, infer: true"]
 
             body_content.prepend("gateway :#{gateway}") if gateway

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

@@ -17,11 +17,11 @@ module Hanami
             extra_namespace: nil,
             auto_register: nil,
             body: [],
-            **opts
+            **_opts
           )
             @fs = fs
             @inflector = inflector
-            @key = key
+            @key_segments = key.split(KEY_SEPARATOR).map { |segment| inflector.underscore(segment) }
             @namespace = namespace
             @base_path = base_path
             @extra_namespace = extra_namespace&.downcase
@@ -42,13 +42,13 @@ module Hanami
           # @api private
           def fully_qualified_name
             inflector.camelize(
-              [namespace, extra_namespace, *key_parts].join("/"),
+              [namespace, extra_namespace, *key_segments].join("/"),
             )
           end
 
           # @api private
           def path
-            fs.join(directory, "#{key_parts.last}.rb")
+            fs.join(directory, "#{key_segments.last}.rb")
           end
 
           private
@@ -57,7 +57,7 @@ module Hanami
           attr_reader(
             :fs,
             :inflector,
-            :key,
+            :key_segments,
             :base_path,
             :namespace,
             :extra_namespace,
@@ -79,7 +79,7 @@ module Hanami
 
           # @api private
           def local_namespaces
-            Array(extra_namespace) + key_parts[..-2]
+            Array(extra_namespace) + key_segments[..-2]
           end
 
           # @api private
@@ -100,7 +100,7 @@ module Hanami
 
           # @api private
           def constant_name
-            normalize(key_parts.last)
+            normalize(key_segments.last)
           end
 
           # @api private
@@ -116,11 +116,6 @@ module Hanami
           def normalize(name)
             inflector.camelize(name).gsub(/[^\p{Alnum}]/, "")
           end
-
-          # @api private
-          def key_parts
-            key.split(KEY_SEPARATOR)
-          end
         end
       end
     end

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

@@ -66,6 +66,17 @@ module Hanami
               body: ["# Add your view helpers here"]
             ).create
 
+            RubyClassFile.new(
+              fs: fs,
+              inflector: inflector,
+              namespace: slice,
+              key: "views.context",
+              base_path: directory,
+              parent_class_name: "#{Hanami.app.namespace}::View::Context",
+              auto_register: false,
+              body: ["# Define your view context here. See https://guides.hanamirb.org/views/context/ for details."]
+            ).create
+
             fs.create(
               fs.join(directory, "templates", "layouts", "app.html.erb"),
               app_layout_template(
@@ -93,11 +104,11 @@ module Hanami
               fs.create(
                 fs.join(directory, "assets", "css", "app.css"),
                 <<~CSS
-                    body {
-                      background-color: #fff;
-                      color: #000;
-                      font-family: sans-serif;
-                    }
+                  body {
+                    background-color: #fff;
+                    color: #000;
+                    font-family: sans-serif;
+                  }
                 CSS
               )
               fs.create(fs.join(directory, "assets", "images", "favicon.ico"), file("favicon.ico"))
@@ -161,9 +172,9 @@ module Hanami
                 <head>
                   <meta charset="UTF-8">
                   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                  <title>#{ page_title }</title>
-                  #{'<%= favicon_tag %>' if bundled_assets }
-                  #{'<%= stylesheet_tag "app" %>' if bundled_assets }
+                  <title>#{page_title}</title>
+                  #{'<%= favicon_tag %>' if bundled_assets}
+                  #{'<%= stylesheet_tag "app" %>' if bundled_assets}
                 </head>
                 <body>
                   <%= yield %>

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

@@ -44,7 +44,7 @@ module Hanami
               fs: fs,
               inflector: inflector,
               namespace: namespace,
-              key: inflector.underscore(key),
+              key: key,
               base_path: base_path,
               parent_class_name: "#{inflector.camelize(namespace)}::View",
               extra_namespace: "Views",

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

@@ -22,7 +22,7 @@ module Hanami
 
       # @since 2.2.0
       # @api private
-      KEY_SEPARATOR = %r{[.\/]}
+      KEY_SEPARATOR = %r{::|[.\/]}
       private_constant :KEY_SEPARATOR
 
       # @since 2.2.0

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

@@ -32,7 +32,9 @@ module Hanami
 
         # @since 2.0.0
         # @api private
-        def hanami_gem_version(gem_name)
+        def hanami_gem_version(name)
+          gem_name = name == "hanami" ? "hanami" : "hanami-#{name}"
+
           if hanami_head?
             %(github: "hanami/#{gem_name}", branch: "main")
           else
@@ -74,6 +76,15 @@ module Hanami
           options.fetch(:head)
         end
 
+        # @since 2.3.0
+        # @api private
+        def gem_source
+          value = options.fetch(:gem_source)
+          return value if value.match? %r{\A\w+://}
+
+          "https://#{value}"
+        end
+
         # @since 2.1.0
         # @api private
         def generate_assets?

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

@@ -0,0 +1,10 @@
+# auto_register: false
+# frozen_string_literal: true
+
+module <%= camelized_app_name %>
+  module Views
+    class Context < Hanami::View::Context
+      # Define your view context here. See https://guides.hanamirb.org/views/context/ for details.
+    end
+  end
+end

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source "<%= gem_source %>"
 
 <%= hanami_gem("hanami") %>
 <%- if hanami_head? -%>
 <%= hanami_gem("cli") %>
+<%= hanami_gem("utils") %>
 <%- end -%>
 <%- if generate_assets? -%>
 <%= hanami_gem("assets") %>
@@ -20,7 +21,7 @@ source "https://rubygems.org"
 <%- end -%>
 
 gem "dry-types", "~> 1.7"
-gem "dry-operation"
+gem "dry-operation", ">= 1.0.1"
 gem "puma"
 gem "rake"
 <%- if generate_sqlite? -%>

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

@@ -1,15 +1,15 @@
 # <%= camelized_app_name %>
 
-Welcome to your Hanami app!
+🌸 Welcome to your Hanami app!
 
-## Getting Started
+## Getting started
 
+- Set up the project up with `bin/setup`
 - Run the server with `bin/dev`
 - View the app at [http://localhost:2300](http://localhost:2300)
 - Run the tests with `bundle exec rake`
 
-## Useful Links
+## Useful links
 
-- [Hanami Home](http://hanamirb.org)
-- [Hanami Guides](https://guides.hanamirb.org/)
-- [Hanami API Doc](https://gemdocs.org/gems/hanami/latest)
+- [Hanami](http://hanamirb.org)
+- [Hanami guides](https://guides.hanamirb.org/)

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

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+# This script is a way to set up and keep your development environment updated
+# automatically. It is meant to be idempotent so that you can run it at any
+# time to get the same result. Add any new necessary setup steps to this file
+# as your application evolves.
+
+announce() {
+  local bold='\033[1m'
+  local reset='\033[0m'
+  printf "${bold}${1}${reset}\n"
+}
+
+announce "Running bundle install..."
+bundle check || bundle install
+
+announce "\nRunning npm install..."
+npm install
+
+<%- if generate_db? -%>
+announce "\nPreparing the database..."
+hanami db prepare
+
+<%- end -%>
+announce "\n🌸 Setup complete!"

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

@@ -3,7 +3,7 @@
 require "dry/types"
 
 module <%= camelized_app_name %>
-  Types = Dry.Types
+  Types = Dry.Types(default: :strict)
 
   module Types
     # Define your custom types here

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

@@ -46,6 +46,9 @@ module Hanami
             fs.create("bin/dev", file("dev"))
             fs.chmod("bin/dev", 0o755)
 
+            fs.create("bin/setup", t("setup.erb", context))
+            fs.chmod("bin/setup", 0o755)
+
             fs.create("config/app.rb", t("app.erb", context))
             fs.create("config/settings.rb", t("settings.erb", context))
             fs.create("config/routes.rb", t("routes.erb", context))
@@ -60,6 +63,7 @@ module Hanami
             if context.generate_view?
               fs.create("app/view.rb", t("view.erb", context))
               fs.create("app/views/helpers.rb", t("helpers.erb", context))
+              fs.create("app/views/context.rb", t("context.erb", context))
               fs.create("app/templates/layouts/app.html.erb", t("app_layout.erb", context))
 
               fs.create("public/404.html", file("404.html"))