Merge pull request #1534 from alexarchambault/missing-org-name

Check for missing org and version at the same time in publish

Author: alexarchambault

modules/cli/src/main/scala/scala/cli/commands/publish/Publish.scala

@@ -407,35 +407,29 @@ object Publish extends ScalaCommand[PublishOptions] with BuildCommandHelpers {
     }
   }
 
-  private def buildFileSet(
-    build: Build.Successful,
-    docBuildOpt: Option[Build.Successful],
-    workingDir: os.Path,
-    now: Instant,
-    isIvy2LocalLike: Boolean,
-    isCi: Boolean,
-    logger: Logger
-  ): Either[BuildException, (FileSet, (coursier.core.Module, String))] = either {
-
-    logger.debug(s"Preparing project ${build.project.projectName}")
-
-    val publishOptions = build.options.notForBloopOptions.publishOptions
+  private def orgNameVersion(
+    publishOptions: scala.build.options.PublishOptions,
+    workspace: os.Path,
+    logger: Logger,
+    scalaArtifactsOpt: Option[ScalaArtifacts],
+    isCi: Boolean
+  ): Either[BuildException, (String, String, String)] = {
 
-    lazy val orgNameOpt = GitRepo.maybeGhRepoOrgName(build.inputs.workspace, logger)
+    lazy val orgNameOpt = GitRepo.maybeGhRepoOrgName(workspace, logger)
 
-    val org = publishOptions.organization match {
-      case Some(org0) => org0.value
-      case None       => value(defaultOrganization(orgNameOpt.map(_._1), logger))
+    val maybeOrg = publishOptions.organization match {
+      case Some(org0) => Right(org0.value)
+      case None       => defaultOrganization(orgNameOpt.map(_._1), logger)
     }
 
     val moduleName = publishOptions.moduleName match {
       case Some(name0) => name0.value
       case None =>
         val name = publishOptions.name match {
           case Some(name0) => name0.value
-          case None        => defaultName(build.inputs.workspace, logger)
+          case None        => defaultName(workspace, logger)
         }
-        build.artifacts.scalaOpt.map(_.params) match {
+        scalaArtifactsOpt.map(_.params) match {
           case Some(scalaParams) =>
             val pf = publishOptions.scalaPlatformSuffix.getOrElse {
               scalaParams.platform.fold("")("_" + _)
@@ -450,26 +444,57 @@ object Publish extends ScalaCommand[PublishOptions] with BuildCommandHelpers {
         }
     }
 
-    val ver = publishOptions.version match {
-      case Some(ver0) => ver0.value
+    val maybeVer = publishOptions.version match {
+      case Some(ver0) => Right(ver0.value)
       case None =>
         val computeVer = publishOptions.contextual(isCi).computeVersion.orElse {
-          def isGitRepo = GitRepo.gitRepoOpt(build.inputs.workspace).isDefined
+          def isGitRepo = GitRepo.gitRepoOpt(workspace).isDefined
           val default   = defaultComputeVersion(!isCi && isGitRepo)
           if (default.isDefined)
             logger.message(
               s"Using directive ${defaultVersionError.directiveName} not set, assuming git:tag as publish.computeVersion"
             )
           default
         }
-        value {
-          computeVer match {
-            case Some(cv) => cv.get(build.inputs.workspace)
-            case None     => defaultVersion
-          }
+        computeVer match {
+          case Some(cv) => cv.get(workspace)
+          case None     => defaultVersion
         }
     }
 
+    (maybeOrg, maybeVer)
+      .traverseN
+      .left.map(CompositeBuildException(_))
+      .map {
+        case (org, ver) =>
+          (org, moduleName, ver)
+      }
+  }
+
+  private def buildFileSet(
+    build: Build.Successful,
+    docBuildOpt: Option[Build.Successful],
+    workingDir: os.Path,
+    now: Instant,
+    isIvy2LocalLike: Boolean,
+    isCi: Boolean,
+    logger: Logger
+  ): Either[BuildException, (FileSet, (coursier.core.Module, String))] = either {
+
+    logger.debug(s"Preparing project ${build.project.projectName}")
+
+    val publishOptions = build.options.notForBloopOptions.publishOptions
+
+    val (org, moduleName, ver) = value {
+      orgNameVersion(
+        publishOptions,
+        build.inputs.workspace,
+        logger,
+        build.artifacts.scalaOpt,
+        isCi
+      )
+    }
+
     logger.message(s"Publishing $org:$moduleName:$ver")
 
     val mainJar = {

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

@@ -177,4 +177,29 @@ class PublishTestsDefault extends PublishTestDefinitions(scalaVersionOpt = None)
       expect(output == "Hello from Python")
     }
   }
+
+  test("missing org and version") {
+    // Missing org and missing version should be reported at the same time,
+    // rather than one at a time.
+    val inputs = TestInputs(
+      os.rel / "Messages.scala" ->
+        """package messages
+          |
+          |object Messages {
+          |  def hello = "Hello"
+          |}
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val tmpDir = os.temp.dir(prefix = "scala-cli-publish-test")
+      for (f <- os.list(root))
+        os.copy.into(f, tmpDir)
+      val publishRepo = root / "the-repo"
+      val res = os.proc(TestUtil.cli, "publish", "--publish-repo", publishRepo, tmpDir)
+        .call(cwd = root, check = false, mergeErrIntoOut = true)
+      val output = res.out.text()
+      expect(output.contains("Missing organization"))
+      expect(output.contains("Missing version"))
+    }
+  }
 }