Add support of running script files with no extension using shebang subcommand

Author: MaciejG604

modules/build/src/main/scala/scala/build/input/Inputs.scala

@@ -13,6 +13,7 @@ import scala.build.internal.Constants
 import scala.build.internal.zip.WrappedZipInputStream
 import scala.build.options.Scope
 import scala.build.preprocessing.ScopePath
+import scala.build.preprocessing.SheBang.isShebangScript
 import scala.util.Properties
 import scala.util.matching.Regex
 
@@ -261,7 +262,8 @@ object Inputs {
     download: String => Either[String, Array[Byte]],
     stdinOpt: => Option[Array[Byte]],
     acceptFds: Boolean,
-    enableMarkdown: Boolean
+    enableMarkdown: Boolean,
+    isRunWithShebang: Boolean
   ): Seq[Either[String, Seq[Element]]] = args.zipWithIndex.map {
     case (arg, idx) =>
       lazy val path      = os.Path(arg, cwd)
@@ -297,10 +299,21 @@ object Inputs {
       else if os.isDir(path) then Right(Seq(Directory(path)))
       else if acceptFds && arg.startsWith("/dev/fd/") then
         Right(Seq(VirtualScript(content, arg, os.sub / s"input-${idx + 1}.sc")))
+      else if isRunWithShebang && os.exists(path) then
+        if isShebangScript(String(content)) then Right(Seq(Script(dir, subPath)))
+        else
+          Left(s"""$arg does not contain shebang header
+                  |possible fixes:
+                  |  Add '#!/usr/bin/env scala-cli shebang' to the top of the file
+                  |  Add extension to the file's name e.q. '.sc'
+                  |""".stripMargin)
       else {
         val msg =
-          if (os.exists(path))
-            s"$arg: unrecognized source type (expected .scala or .sc extension, or a directory)"
+          if os.exists(path) then
+            if isShebangScript(String(content)) then
+              s"$arg scripts with no file extension should be run with 'scala-cli shebang'"
+            else
+              s"$arg: unrecognized source type (expected .scala or .sc extension, or a directory)"
           else s"$arg: not found"
         Left(msg)
       }
@@ -320,10 +333,11 @@ object Inputs {
     forcedWorkspace: Option[os.Path],
     enableMarkdown: Boolean,
     allowRestrictedFeatures: Boolean,
-    extraClasspathWasPassed: Boolean
+    extraClasspathWasPassed: Boolean,
+    isRunWithShebang: Boolean
   ): Either[BuildException, Inputs] = {
     val validatedArgs: Seq[Either[String, Seq[Element]]] =
-      validateArgs(args, cwd, download, stdinOpt, acceptFds, enableMarkdown)
+      validateArgs(args, cwd, download, stdinOpt, acceptFds, enableMarkdown, isRunWithShebang)
     val validatedSnippets: Seq[Either[String, Seq[Element]]] =
       validateSnippets(scriptSnippetList, scalaSnippetList, javaSnippetList, markdownSnippetList)
     val validatedArgsAndSnippets = validatedArgs ++ validatedSnippets
@@ -364,7 +378,8 @@ object Inputs {
     forcedWorkspace: Option[os.Path] = None,
     enableMarkdown: Boolean = false,
     allowRestrictedFeatures: Boolean,
-    extraClasspathWasPassed: Boolean
+    extraClasspathWasPassed: Boolean,
+    isRunWithShebang: Boolean
   ): Either[BuildException, Inputs] =
     if (
       args.isEmpty && scriptSnippetList.isEmpty && scalaSnippetList.isEmpty && javaSnippetList.isEmpty &&
@@ -388,7 +403,8 @@ object Inputs {
         forcedWorkspace,
         enableMarkdown,
         allowRestrictedFeatures,
-        extraClasspathWasPassed
+        extraClasspathWasPassed,
+        isRunWithShebang
       )
 
   def default(): Option[Inputs] = None

modules/build/src/main/scala/scala/build/preprocessing/SheBang.scala

@@ -5,6 +5,8 @@ import scala.util.matching.Regex
 object SheBang {
   private val sheBangRegex: Regex = s"""(^(#!.*(\\r\\n?|\\n)?)+(\\s*!#.*)?)""".r
 
+  def isShebangScript(content: String): Boolean = sheBangRegex.unanchored.matches(content)
+
   def ignoreSheBangLines(content: String): (String, Boolean) =
     if (content.startsWith("#!")) {
       val regexMatch = sheBangRegex.findFirstMatchIn(content)

modules/build/src/test/scala/scala/build/tests/TestInputs.scala

@@ -44,7 +44,8 @@ final case class TestInputs(
         tmpDir,
         forcedWorkspace = forcedWorkspaceOpt.map(_.resolveFrom(tmpDir)),
         allowRestrictedFeatures = true,
-        extraClasspathWasPassed = false
+        extraClasspathWasPassed = false,
+        isRunWithShebang = false
       )
       res match {
         case Left(err)     => throw new Exception(err)

modules/cli/src/main/scala/scala/cli/commands/clean/Clean.scala

@@ -21,7 +21,8 @@ object Clean extends ScalaCommand[CleanOptions] {
       defaultInputs = () => Inputs.default(),
       forcedWorkspace = options.workspace.forcedWorkspaceOpt,
       allowRestrictedFeatures = ScalaCli.allowRestrictedFeatures,
-      extraClasspathWasPassed = false
+      extraClasspathWasPassed = false,
+      isRunWithShebang = false
     ) match {
       case Left(message) =>
         System.err.println(message)

modules/cli/src/main/scala/scala/cli/commands/run/Run.scala

@@ -106,11 +106,16 @@ object Run extends ScalaCommand[RunOptions] with BuildCommandHelpers {
     inputArgs: Seq[String],
     programArgs: Seq[String],
     defaultInputs: () => Option[Inputs],
-    logger: Logger
+    logger: Logger,
+    isRunWithShebang: Boolean = false
   ): Unit = {
     val initialBuildOptions = buildOptionsOrExit(options)
 
-    val inputs = options.shared.inputs(inputArgs, defaultInputs = defaultInputs).orExit(logger)
+    val inputs = options.shared.inputs(
+      inputArgs,
+      defaultInputs = defaultInputs,
+      isRunWithShebang
+    ).orExit(logger)
     CurrentParams.workspaceOpt = Some(inputs.workspace)
     val threads = BuildThreads.create()
 

modules/cli/src/main/scala/scala/cli/commands/shared/SharedOptions.scala

@@ -177,7 +177,7 @@ final case class SharedOptions(
   @Recurse
     input: SharedInputOptions = SharedInputOptions(),
   @Recurse
-  helpGroups: HelpGroupOptions = HelpGroupOptions(),
+    helpGroups: HelpGroupOptions = HelpGroupOptions(),
 
   @Hidden
     strictBloopJsonCheck: Option[Boolean] = None,
@@ -512,7 +512,8 @@ final case class SharedOptions(
 
   def inputs(
     args: Seq[String],
-    defaultInputs: () => Option[Inputs] = () => Inputs.default()
+    defaultInputs: () => Option[Inputs] = () => Inputs.default(),
+    isRunWithShebang: Boolean = false
   ): Either[BuildException, Inputs] =
     SharedOptions.inputs(
       args,
@@ -529,7 +530,8 @@ final case class SharedOptions(
       javaSnippetList = allJavaSnippets,
       markdownSnippetList = allMarkdownSnippets,
       enableMarkdown = markdown.enableMarkdown,
-      extraClasspathWasPassed = extraJarsAndClassPath.nonEmpty
+      extraClasspathWasPassed = extraJarsAndClassPath.nonEmpty,
+      isRunWithShebang = isRunWithShebang
     )
 
   def allScriptSnippets: List[String]   = snippet.scriptSnippet ++ snippet.executeScript
@@ -544,7 +546,8 @@ final case class SharedOptions(
       SharedOptions.downloadInputs(coursierCache),
       SharedOptions.readStdin(logger = logger),
       !Properties.isWin,
-      enableMarkdown = true
+      enableMarkdown = true,
+      isRunWithShebang = false
     )
 
   def strictBloopJsonCheckOrDefault: Boolean =
@@ -582,7 +585,8 @@ object SharedOptions {
     javaSnippetList: List[String],
     markdownSnippetList: List[String],
     enableMarkdown: Boolean = false,
-    extraClasspathWasPassed: Boolean = false
+    extraClasspathWasPassed: Boolean = false,
+    isRunWithShebang: Boolean = false
   ): Either[BuildException, Inputs] = {
     val resourceInputs = resourceDirs
       .map(os.Path(_, Os.pwd))
@@ -606,7 +610,8 @@ object SharedOptions {
       forcedWorkspace = forcedWorkspaceOpt,
       enableMarkdown = enableMarkdown,
       allowRestrictedFeatures = ScalaCli.allowRestrictedFeatures,
-      extraClasspathWasPassed = extraClasspathWasPassed
+      extraClasspathWasPassed = extraClasspathWasPassed,
+      isRunWithShebang
     )
     maybeInputs.map { inputs =>
       val forbiddenDirs =

modules/cli/src/main/scala/scala/cli/commands/shebang/Shebang.scala

@@ -23,6 +23,7 @@ object Shebang extends ScalaCommand[ShebangOptions] {
       args.remaining.headOption.toSeq,
       args.remaining.drop(1),
       () => None,
-      logger
+      logger,
+      isRunWithShebang = true
     )
 }

modules/integration/src/test/scala/scala/cli/integration/RunScriptTestDefinitions.scala

@@ -326,4 +326,44 @@ trait RunScriptTestDefinitions { _: RunTestDefinitions =>
         expect(p.out.trim() == "List(1, 2, 3, -v)")
       }
     }
+
+  test("script file with shebang header and no extension run with scala-cli shebang") {
+    val inputs = TestInputs(
+      os.rel / "script-with-shebang" ->
+        s"""|#!/usr/bin/env -S ${TestUtil.cli.mkString(" ")} shebang -S 2.13
+            |//> using scala "$actualScalaVersion"
+            |println(args.toList)""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val output = if (!Properties.isWin) {
+        os.perms.set(root / "script-with-shebang", os.PermSet.fromString("rwx------"))
+        os.proc("./script-with-shebang", "1", "2", "3", "-v").call(cwd = root).out.trim()
+      }
+      else
+        os.proc(TestUtil.cli, "shebang", "script-with-shebang", "1", "2", "3", "-v")
+          .call(cwd = root).out.trim()
+      expect(output == "List(1, 2, 3, -v)")
+    }
+  }
+
+  test("script file with NO shebang header and no extension run with scala-cli shebang") {
+    val inputs = TestInputs(
+      os.rel / "script-no-shebang" ->
+        s"""//> using scala "$actualScalaVersion"
+           |println(args.toList)""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val output = if (!Properties.isWin) {
+        os.perms.set(root / "script-no-shebang", os.PermSet.fromString("rwx------"))
+        os.proc(TestUtil.cli, "shebang", "script-no-shebang", "1", "2", "3", "-v")
+          .call(cwd = root, check = false, stderr = os.Pipe).err.trim()
+      }
+      else
+        os.proc(TestUtil.cli, "shebang", "script-no-shebang", "1", "2", "3", "-v")
+          .call(cwd = root, check = false, stderr = os.Pipe).err.trim()
+      expect(output.contains(
+        "does not contain shebang header"
+      ))
+    }
+  }
 }