hanami-cli 2.2.1 → 2.3.0.beta2

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

@@ -21,36 +21,73 @@ module Hanami
 
             # @since 2.2.0
             # @api private
-            def initialize(
-              fs:,
-              inflector:,
-              **opts
-            )
+            def initialize(fs:, out:, **)
               super
-              @generator = generator_class.new(fs: fs, inflector: inflector, out: out)
+              @generator = generator_class.new(fs:, inflector:, out:)
             end
 
+            # @since 2.2.0
+            # @api private
             def generator_class
-              # Must be implemented by subclasses, with class that takes:
-              # fs:, inflector:, out:
+              # Must be implemented by subclasses, with initialize method that takes:
+              # fs:, out:
             end
 
             # @since 2.2.0
             # @api private
-            def call(name:, slice: nil, **)
-              if slice
-                generator.call(
-                  key: name,
-                  namespace: slice,
-                  base_path: fs.join("slices", inflector.underscore(slice))
-                )
-              else
+            def call(name:, slice: nil, **opts)
+              slice ||= detect_slice_from_cwd
+
+              if slice.nil?
                 generator.call(
                   key: name,
                   namespace: app.namespace,
-                  base_path: "app"
+                  base_path: "app",
+                  **opts,
                 )
+                return
               end
+
+              slice_root = slice.respond_to?(:root) ? slice.root : detect_slice_root(slice)
+              raise MissingSliceError.new(slice) unless fs.exist?(slice_root)
+
+              generator.call(
+                key: name,
+                namespace: slice,
+                base_path: slice_root,
+                **opts,
+              )
+            end
+
+            private
+
+            def detect_slice_from_cwd
+              slices_by_root = app.slices.with_nested.each.to_h { |slice| [slice.root.to_s, slice] }
+              slices_by_root[fs.pwd]
+            end
+
+            # Returns the root for the given slice name.
+            #
+            # This currently works with top-level slices only, and it simply appends the slice's
+            # name onto the "slices/" dir, returning e.g. "slices/main" when given "main".
+            #
+            # TODO: Make this work with nested slices when given slash-delimited slice names like
+            # "parent/child", which should look for "slices/parent/slices/child".
+            #
+            # This method makes two checks for the slice root (building off both `app.root` as well
+            # as `fs`). This is entirely to account for how we test commands, with most tests using
+            # an in-memory `fs` adapter, any files created via which will be invisible to the `app`,
+            # which doesn't know about the `fs`.
+            #
+            # FIXME: It would be better to find a way for this to make one check only. An ideal
+            # approach would be to use the slice_name to find actual slice registered within
+            # `app.slices`. To do this, we'd probably need to stop testing with an in-memory `fs`
+            # here.
+            def detect_slice_root(slice_name)
+              slice_root_in_fs = fs.join("slices", inflector.underscore(slice_name))
+              return slice_root_in_fs if fs.exist?(slice_root_in_fs)
+
+              app.root.join("slices", inflector.underscore(slice_name))
             end
           end
         end

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

@@ -3,6 +3,7 @@
 require "dry/inflector"
 require "dry/files"
 require "shellwords"
+
 module Hanami
   module CLI
     module Commands
@@ -10,9 +11,8 @@ module Hanami
         module Generate
           # @api private
           # @since 2.2.0
-          class Component < App::Command
+          class Component < Command
             argument :name, required: true, desc: "Component name"
-            option :slice, required: false, desc: "Slice name"
 
             example [
               %(isbn_decoder               (MyApp::IsbnDecoder)),
@@ -20,26 +20,11 @@ module Hanami
               %(isbn_decoder --slice=admin (Admin::IsbnDecoder)),
               %(Exporters::Complete::CSV   (MyApp::Exporters::Complete::CSV)),
             ]
-            attr_reader :generator
-            private :generator
 
-            # @api private
             # @since 2.2.0
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::Component.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              @generator = generator
-              super(fs: fs, inflector: inflector, **opts)
-            end
-
             # @api private
-            # @since 2.2.0
-            def call(name:, slice: nil, **)
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-
-              generator.call(app.namespace, name, slice)
+            def generator_class
+              Generators::App::Component
             end
           end
         end

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

@@ -11,12 +11,12 @@ module Hanami
         module Generate
           # @since 2.1.0
           # @api private
-          class Part < App::Command
+          class Part < Command
             DEFAULT_SKIP_TESTS = false
             private_constant :DEFAULT_SKIP_TESTS
 
             argument :name, required: true, desc: "Part name"
-            option :slice, required: false, desc: "Slice name"
+
             option \
               :skip_tests,
               required: false,
@@ -28,26 +28,9 @@ module Hanami
               %(book               (MyApp::Views::Parts::Book)),
               %(book --slice=admin (Admin::Views::Parts::Book)),
             ]
-            attr_reader :generator
-            private :generator
-
-            # @since 2.0.0
-            # @api private
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::Part.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              super(fs: fs, inflector: inflector, **opts)
-              @generator = generator
-            end
-
-            # @since 2.0.0
-            # @api private
-            def call(name:, slice: nil, skip_tests: DEFAULT_SKIP_TESTS, **) # rubocop:disable Lint/UnusedMethodArgument
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
 
-              generator.call(app.namespace, name, slice)
+            def generator_class
+              Generators::App::Part
             end
           end
         end

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

@@ -49,11 +49,11 @@ module Hanami
             # @since 2.0.0
             # @api private
             def initialize(
-              fs:, inflector:,
+              fs:,
               generator: Generators::App::Slice.new(fs: fs, inflector: inflector),
               **opts
             )
-              super(fs: fs, inflector: inflector, **opts)
+              super(fs: fs, **opts)
               @generator = generator
             end
 

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

@@ -13,40 +13,21 @@ module Hanami
         module Generate
           # @since 2.0.0
           # @api private
-          class View < App::Command
-            # TODO: make this configurable
-            DEFAULT_FORMAT = "html"
-            private_constant :DEFAULT_FORMAT
-
+          class View < Command
+            # TODO: make format configurable
             # TODO: make engine configurable
 
             argument :name, required: true, desc: "View name"
-            option :slice, required: false, desc: "Slice name"
 
             example [
               %(books.index               (MyApp::Actions::Books::Index)),
               %(books.index --slice=admin (Admin::Actions::Books::Index)),
             ]
-            attr_reader :generator
-            private :generator
 
-            # @since 2.0.0
+            # @since 2.2.0
             # @api private
-            def initialize(
-              fs:, inflector:,
-              generator: Generators::App::View.new(fs: fs, inflector: inflector),
-              **opts
-            )
-              super(fs: fs, inflector: inflector, **opts)
-              @generator = generator
-            end
-
-            # @since 2.0.0
-            # @api private
-            def call(name:, format: DEFAULT_FORMAT, slice: nil, **)
-              slice = inflector.underscore(Shellwords.shellescape(slice)) if slice
-
-              generator.call(app.namespace, name, format, slice)
+            def generator_class
+              Generators::App::View
             end
           end
         end

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/server.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "rack"
 require "hanami/port"
 require_relative "../app"
 require_relative "../../server"

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")
@@ -32,6 +33,7 @@ module Hanami
                 db.register "create", DB::Create
                 db.register "drop", DB::Drop
                 db.register "migrate", DB::Migrate
+                db.register "rollback", DB::Rollback
                 db.register "structure dump", DB::Structure::Dump
                 db.register "structure load", DB::Structure::Load
                 db.register "seed", DB::Seed

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

@@ -30,6 +30,11 @@ module Hanami
           SKIP_DB_DEFAULT = false
           private_constant :SKIP_DB_DEFAULT
 
+          # @since 2.2.0
+          # @api private
+          SKIP_VIEW_DEFAULT = false
+          private_constant :SKIP_VIEW_DEFAULT
+
           # @since 2.2.0
           # @api private
           DATABASE_SQLITE = "sqlite"
@@ -46,6 +51,9 @@ module Hanami
           # @api private
           SUPPORTED_DATABASES = [DATABASE_SQLITE, DATABASE_POSTGRES, DATABASE_MYSQL].freeze
 
+          # @api private
+          FORBIDDEN_APP_NAMES = %w[app slice].freeze
+
           desc "Generate a new Hanami app"
 
           # @since 2.0.0
@@ -76,6 +84,12 @@ module Hanami
                            default: SKIP_DB_DEFAULT,
                            desc: "Skip including hanami-db"
 
+          # @since 2.2.0
+          # @api private
+          option :skip_view, type: :flag, required: false,
+                             default: SKIP_VIEW_DEFAULT,
+                             desc: "Skip including hanami-view"
+
           # @since 2.2.0
           # @api private
           option :database, type: :string, required: false,
@@ -87,8 +101,9 @@ module Hanami
             "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 --skip-install                     # Generate a new Hanami app, but it skips Hanami installation",
-            "bookshelf --skip-assets                      # Generate a new Hanami app without hanmai-assets",
+            "bookshelf --skip-assets                      # Generate a new Hanami app without hanami-assets",
             "bookshelf --skip-db                          # Generate a new Hanami app without hanami-db",
+            "bookshelf --skip-view                        # Generate a new Hanami app without hanami-view",
             "bookshelf --database={sqlite|postgres|mysql} # Generate a new Hanami app with a specified database (default: sqlite)",
           ]
           # rubocop:enable Layout/LineLength
@@ -98,13 +113,13 @@ module Hanami
           # @since 2.0.0
           # @api private
           def initialize(
-            fs:, inflector:,
+            fs:,
             bundler: CLI::Bundler.new(fs: fs),
             generator: Generators::Gem::App.new(fs: fs, inflector: inflector),
             system_call: SystemCall.new,
             **opts
           )
-            super(fs: fs, inflector: inflector, **opts)
+            super(fs: fs, **opts)
             @bundler = bundler
             @generator = generator
             @system_call = system_call
@@ -120,12 +135,14 @@ module Hanami
             skip_install: SKIP_INSTALL_DEFAULT,
             skip_assets: SKIP_ASSETS_DEFAULT,
             skip_db: SKIP_DB_DEFAULT,
+            skip_view: SKIP_VIEW_DEFAULT,
             database: nil
           )
             # rubocop:enable Metrics/ParameterLists
             app = inflector.underscore(app)
 
             raise PathAlreadyExistsError.new(app) if fs.exist?(app)
+            raise ForbiddenAppNameError.new(app) if FORBIDDEN_APP_NAMES.include?(app)
 
             normalized_database ||= normalize_database(database)
 
@@ -137,6 +154,7 @@ module Hanami
                 head: head,
                 skip_assets: skip_assets,
                 skip_db: skip_db,
+                skip_view: skip_view,
                 database: normalized_database
               )
               generator.call(app, context: context) do
@@ -158,6 +176,9 @@ module Hanami
 
                   out.puts "Running hanami install..."
                   run_install_command!(head: head)
+
+                  out.puts "Initializing git repository..."
+                  init_git_repository
                 end
               end
             end
@@ -193,6 +214,16 @@ module Hanami
               end
             end
           end
+
+          # @api private
+          def init_git_repository
+            system_call.call("git", ["init"]).tap do |result|
+              unless result.successful?
+                out.puts "WARNING: Failed to initialize git repository"
+                out.puts(result.err.lines.map { |line| line.prepend("    ") })
+              end
+            end
+          end
         end
       end
     end

data/lib/hanami/cli/errors.rb

@@ -44,6 +44,24 @@ module Hanami
       end
     end
 
+    # @api public
+    class FileAlreadyExistsError < Error
+      ERROR_MESSAGE = <<~ERROR.chomp
+        The file `%<file_path>s` could not be generated because it already exists.
+      ERROR
+
+      def initialize(file_path)
+        super(ERROR_MESSAGE % {file_path:})
+      end
+    end
+
+    # @api public
+    class ForbiddenAppNameError < Error
+      def initialize(name)
+        super("Cannot create new Hanami app with the name: `#{name}'")
+      end
+    end
+
     # @since 2.0.0
     # @api public
     class MissingSliceError < Error
@@ -100,6 +118,14 @@ module Hanami
       end
     end
 
+    # @since 2.2.0
+    # @api public
+    class DatabaseExistenceCheckError < Error
+      def initialize(original_message)
+        super("Could not check if the database exists. Error message:\n#{original_message}")
+      end
+    end
+
     # @since 2.2.0
     # @api public
     class ConflictingOptionsError < Error

data/lib/hanami/cli/files.rb

@@ -14,6 +14,13 @@ module Hanami
         @out = out
       end
 
+      # @api private
+      def create(path, *content)
+        raise FileAlreadyExistsError.new(path) if exist?(path)
+
+        write(path, *content)
+      end
+
       # @since 2.0.0
       # @api private
       def write(path, *content)
@@ -33,10 +40,10 @@ module Hanami
       # @since 2.0.0
       # @api private
       def mkdir(path)
-        unless exist?(path)
-          super
-          created(_path(path))
-        end
+        return if exist?(path)
+
+        super
+        created(dir_path(path))
       end
 
       # @since 2.0.0
@@ -46,6 +53,13 @@ module Hanami
         super
       end
 
+      def touch(path)
+        return if exist?(path)
+
+        super
+        created(path)
+      end
+
       private
 
       attr_reader :out
@@ -77,10 +91,10 @@ module Hanami
       end
 
       def within_folder(path)
-        out.puts "-> Within #{_path(path)}"
+        out.puts "-> Within #{dir_path(path)}"
       end
 
-      def _path(path)
+      def dir_path(path)
         path + ::File::SEPARATOR
       end
     end