What's the right way to make a Command with parameters from other targets?

[dwalend]

What's the right way to make a Command with parameters from other targets?

I'm refactoring some cut/paste code in a build.sc file, and would like to get rid of the duplicate code. The code uploads one file or another via scp.

def scpAssembly():Command[CommandResult] = T.command { { val localPath = assembly().path.toString() // scp command here... }

I'd like to consolidate the complexity into a general command that take parameters - along the lines of

def scpUp(localPath:Path,remotePath:String): Command[CommandResult] = T.command { // scp command here... }
and then use it with

scpUp(assembly().path,s"${artifactName()}.jar")

but I get Target#apply() can only be used with a T{...} block , and haven't been able to solve the type puzzle for the parameters.

Thanks,

David

[lefou]

The issue is, that you can't call another task in the parameter list of the command.

The solution is, to move the task execution (actually, it's only a dependency and a reference to the outcome) into the shared task.

def scpUp(localPathTask: Task[Path], remotePath: String): Task[CommandResult] = T.task { 
  val localPath: Path = localPathTask()
  // scp command here... 
}

scpUp(T.task{ assembly().path }, s"${artifactName()}.jar")()

[dwalend]

(How do you define a type in a way that it can't be used in a parameter? I didn't know that was possible.)

My own (less satisfying) fix was to define the method outside of Mill's abstractions:

def scpUp(localPath:Path,remotePath:String):(Int,Seq[Either[geny.Bytes, geny.Bytes]]) = { ... }

and then call it with some ugly type monkeying:

  def scpAssembly():Command[CommandResult] = T.command {
    ( CommandResult.apply _ ).tupled(scpUp(assembly().path,s"${artifactName()}.jar"))
  }

What I'd really like to have to show the kids is an uncluttered:

def scpAssembly():Command[CommandResult] = T.command { scpUp(assembly().path,s"${artifactName()}.jar") }

It seems like I could get there by adding a conversion from Task[A] to A, and a defined type to paper over (Int,Seq[Either[geny.Bytes, geny.Bytes]]) .

Are there any parts for that already around?

Is there a good reason not to pursue the cleanup?

Thanks,

David

[lefou]

(How do you define a type in a way that it can't be used in a parameter? I didn't know that was possible.)

It isn't a restriction of the type, but in the runtime. Mill first builds a task graph and then executes it. So you can't "inject" new tasks after the graph evaluation has started. So, you either factor shared code into a task (T.task) or use a classic def (without any special mill semantic).

Mills command / command parameter handling is probably unnecessarily restrictive. There are other issues, e.g. when calling a command from another command (for examples, use the search). We're open for any improvements.

[lefou]

Are there any parts for that already around?

Have a look at the methods defined in Target, e.g. traverse, sequence.

[dwalend]

Thanks!

[lefou]

FTR, Commands (T.command) now support parameters of type Task (T.task), which should make command more reusable. See #1825