Revert "Make RuleBuilder methods take Paths"
This reverts commit acdd6940719125104dfd2f692990c99682f95f05.
Reason for revert: broke ndk build
Change-Id: I5655e48c15eb8f5f0267afdd853fbc25765b8623
diff --git a/android/rule_builder.go b/android/rule_builder.go
index 5edd7b6..3b86947 100644
--- a/android/rule_builder.go
+++ b/android/rule_builder.go
@@ -16,6 +16,7 @@
import (
"fmt"
+ "path/filepath"
"sort"
"strings"
@@ -28,7 +29,7 @@
type RuleBuilder struct {
commands []*RuleBuilderCommand
installs RuleBuilderInstalls
- temporariesSet map[WritablePath]bool
+ temporariesSet map[string]bool
restat bool
missingDeps []string
}
@@ -36,14 +37,13 @@
// NewRuleBuilder returns a newly created RuleBuilder.
func NewRuleBuilder() *RuleBuilder {
return &RuleBuilder{
- temporariesSet: make(map[WritablePath]bool),
+ temporariesSet: make(map[string]bool),
}
}
// RuleBuilderInstall is a tuple of install from and to locations.
type RuleBuilderInstall struct {
- From Path
- To string
+ From, To string
}
type RuleBuilderInstalls []RuleBuilderInstall
@@ -56,7 +56,7 @@
if i != 0 {
sb.WriteRune(' ')
}
- sb.WriteString(install.From.String())
+ sb.WriteString(install.From)
sb.WriteRune(':')
sb.WriteString(install.To)
}
@@ -80,7 +80,7 @@
// Install associates an output of the rule with an install location, which can be retrieved later using
// RuleBuilder.Installs.
-func (r *RuleBuilder) Install(from Path, to string) {
+func (r *RuleBuilder) Install(from, to string) {
r.installs = append(r.installs, RuleBuilderInstall{from, to})
}
@@ -95,22 +95,19 @@
// Temporary marks an output of a command as an intermediate file that will be used as an input to another command
// in the same rule, and should not be listed in Outputs.
-func (r *RuleBuilder) Temporary(path WritablePath) {
+func (r *RuleBuilder) Temporary(path string) {
r.temporariesSet[path] = true
}
// DeleteTemporaryFiles adds a command to the rule that deletes any outputs that have been marked using Temporary
// when the rule runs. DeleteTemporaryFiles should be called after all calls to Temporary.
func (r *RuleBuilder) DeleteTemporaryFiles() {
- var temporariesList WritablePaths
+ var temporariesList []string
for intermediate := range r.temporariesSet {
temporariesList = append(temporariesList, intermediate)
}
-
- sort.Slice(temporariesList, func(i, j int) bool {
- return temporariesList[i].String() < temporariesList[j].String()
- })
+ sort.Strings(temporariesList)
r.Command().Text("rm").Flag("-f").Outputs(temporariesList)
}
@@ -118,35 +115,32 @@
// Inputs returns the list of paths that were passed to the RuleBuilderCommand methods that take input paths, such
// as RuleBuilderCommand.Input, RuleBuilderComand.Implicit, or RuleBuilderCommand.FlagWithInput. Inputs to a command
// that are also outputs of another command in the same RuleBuilder are filtered out.
-func (r *RuleBuilder) Inputs() Paths {
+func (r *RuleBuilder) Inputs() []string {
outputs := r.outputSet()
- inputs := make(map[string]Path)
+ inputs := make(map[string]bool)
for _, c := range r.commands {
for _, input := range c.inputs {
- if _, isOutput := outputs[input.String()]; !isOutput {
- inputs[input.String()] = input
+ if !outputs[input] {
+ inputs[input] = true
}
}
}
- var inputList Paths
- for _, input := range inputs {
+ var inputList []string
+ for input := range inputs {
inputList = append(inputList, input)
}
-
- sort.Slice(inputList, func(i, j int) bool {
- return inputList[i].String() < inputList[j].String()
- })
+ sort.Strings(inputList)
return inputList
}
-func (r *RuleBuilder) outputSet() map[string]WritablePath {
- outputs := make(map[string]WritablePath)
+func (r *RuleBuilder) outputSet() map[string]bool {
+ outputs := make(map[string]bool)
for _, c := range r.commands {
for _, output := range c.outputs {
- outputs[output.String()] = output
+ outputs[output] = true
}
}
return outputs
@@ -154,20 +148,16 @@
// Outputs returns the list of paths that were passed to the RuleBuilderCommand methods that take output paths, such
// as RuleBuilderCommand.Output, RuleBuilderCommand.ImplicitOutput, or RuleBuilderCommand.FlagWithInput.
-func (r *RuleBuilder) Outputs() WritablePaths {
+func (r *RuleBuilder) Outputs() []string {
outputs := r.outputSet()
- var outputList WritablePaths
- for _, output := range outputs {
+ var outputList []string
+ for output := range outputs {
if !r.temporariesSet[output] {
outputList = append(outputList, output)
}
}
-
- sort.Slice(outputList, func(i, j int) bool {
- return outputList[i].String() < outputList[j].String()
- })
-
+ sort.Strings(outputList)
return outputList
}
@@ -176,11 +166,11 @@
return append(RuleBuilderInstalls(nil), r.installs...)
}
-func (r *RuleBuilder) toolsSet() map[string]Path {
- tools := make(map[string]Path)
+func (r *RuleBuilder) toolsSet() map[string]bool {
+ tools := make(map[string]bool)
for _, c := range r.commands {
for _, tool := range c.tools {
- tools[tool.String()] = tool
+ tools[tool] = true
}
}
@@ -188,18 +178,14 @@
}
// Tools returns the list of paths that were passed to the RuleBuilderCommand.Tool method.
-func (r *RuleBuilder) Tools() Paths {
+func (r *RuleBuilder) Tools() []string {
toolsSet := r.toolsSet()
- var toolsList Paths
- for _, tool := range toolsSet {
+ var toolsList []string
+ for tool := range toolsSet {
toolsList = append(toolsList, tool)
}
-
- sort.Slice(toolsList, func(i, j int) bool {
- return toolsList[i].String() < toolsList[j].String()
- })
-
+ sort.Strings(toolsList)
return toolsList
}
@@ -225,10 +211,45 @@
// Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
// Outputs.
func (r *RuleBuilder) Build(pctx PackageContext, ctx BuilderContext, name string, desc string) {
+ // TODO: convert RuleBuilder arguments and storage to Paths
+ mctx, _ := ctx.(ModuleContext)
+ var inputs Paths
+ for _, input := range r.Inputs() {
+ // Module output paths
+ if mctx != nil {
+ rel, isRel := MaybeRel(ctx, PathForModuleOut(mctx).String(), input)
+ if isRel {
+ inputs = append(inputs, PathForModuleOut(mctx, rel))
+ continue
+ }
+ }
+
+ // Other output paths
+ rel, isRel := MaybeRel(ctx, PathForOutput(ctx).String(), input)
+ if isRel {
+ inputs = append(inputs, PathForOutput(ctx, rel))
+ continue
+ }
+
+ // TODO: remove this once boot image is moved to where PathForOutput can find it.
+ inputs = append(inputs, &unknownRulePath{input})
+ }
+
+ var outputs WritablePaths
+ for _, output := range r.Outputs() {
+ if mctx != nil {
+ rel := Rel(ctx, PathForModuleOut(mctx).String(), output)
+ outputs = append(outputs, PathForModuleOut(mctx, rel))
+ } else {
+ rel := Rel(ctx, PathForOutput(ctx).String(), output)
+ outputs = append(outputs, PathForOutput(ctx, rel))
+ }
+ }
+
if len(r.missingDeps) > 0 {
ctx.Build(pctx, BuildParams{
Rule: ErrorRule,
- Outputs: r.Outputs(),
+ Outputs: outputs,
Description: desc,
Args: map[string]string{
"error": "missing dependencies: " + strings.Join(r.missingDeps, ", "),
@@ -241,10 +262,10 @@
ctx.Build(pctx, BuildParams{
Rule: ctx.Rule(pctx, name, blueprint.RuleParams{
Command: strings.Join(proptools.NinjaEscape(r.Commands()), " && "),
- CommandDeps: r.Tools().Strings(),
+ CommandDeps: r.Tools(),
}),
- Implicits: r.Inputs(),
- Outputs: r.Outputs(),
+ Implicits: inputs,
+ Outputs: outputs,
Description: desc,
})
}
@@ -256,9 +277,9 @@
// space as a separator from the previous method.
type RuleBuilderCommand struct {
buf []byte
- inputs Paths
- outputs WritablePaths
- tools Paths
+ inputs []string
+ outputs []string
+ tools []string
}
// Text adds the specified raw text to the command line. The text should not contain input or output paths or the
@@ -308,21 +329,21 @@
// Tool adds the specified tool path to the command line. The path will be also added to the dependencies returned by
// RuleBuilder.Tools.
-func (c *RuleBuilderCommand) Tool(path Path) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Tool(path string) *RuleBuilderCommand {
c.tools = append(c.tools, path)
- return c.Text(path.String())
+ return c.Text(path)
}
// Input adds the specified input path to the command line. The path will also be added to the dependencies returned by
// RuleBuilder.Inputs.
-func (c *RuleBuilderCommand) Input(path Path) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Input(path string) *RuleBuilderCommand {
c.inputs = append(c.inputs, path)
- return c.Text(path.String())
+ return c.Text(path)
}
// Inputs adds the specified input paths to the command line, separated by spaces. The paths will also be added to the
// dependencies returned by RuleBuilder.Inputs.
-func (c *RuleBuilderCommand) Inputs(paths Paths) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Inputs(paths []string) *RuleBuilderCommand {
for _, path := range paths {
c.Input(path)
}
@@ -331,28 +352,28 @@
// Implicit adds the specified input path to the dependencies returned by RuleBuilder.Inputs without modifying the
// command line.
-func (c *RuleBuilderCommand) Implicit(path Path) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Implicit(path string) *RuleBuilderCommand {
c.inputs = append(c.inputs, path)
return c
}
// Implicits adds the specified input paths to the dependencies returned by RuleBuilder.Inputs without modifying the
// command line.
-func (c *RuleBuilderCommand) Implicits(paths Paths) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Implicits(paths []string) *RuleBuilderCommand {
c.inputs = append(c.inputs, paths...)
return c
}
// Output adds the specified output path to the command line. The path will also be added to the outputs returned by
// RuleBuilder.Outputs.
-func (c *RuleBuilderCommand) Output(path WritablePath) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Output(path string) *RuleBuilderCommand {
c.outputs = append(c.outputs, path)
- return c.Text(path.String())
+ return c.Text(path)
}
// Outputs adds the specified output paths to the command line, separated by spaces. The paths will also be added to
// the outputs returned by RuleBuilder.Outputs.
-func (c *RuleBuilderCommand) Outputs(paths WritablePaths) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) Outputs(paths []string) *RuleBuilderCommand {
for _, path := range paths {
c.Output(path)
}
@@ -361,37 +382,37 @@
// ImplicitOutput adds the specified output path to the dependencies returned by RuleBuilder.Outputs without modifying
// the command line.
-func (c *RuleBuilderCommand) ImplicitOutput(path WritablePath) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) ImplicitOutput(path string) *RuleBuilderCommand {
c.outputs = append(c.outputs, path)
return c
}
// ImplicitOutputs adds the specified output paths to the dependencies returned by RuleBuilder.Outputs without modifying
// the command line.
-func (c *RuleBuilderCommand) ImplicitOutputs(paths WritablePaths) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) ImplicitOutputs(paths []string) *RuleBuilderCommand {
c.outputs = append(c.outputs, paths...)
return c
}
// FlagWithInput adds the specified flag and input path to the command line, with no separator between them. The path
// will also be added to the dependencies returned by RuleBuilder.Inputs.
-func (c *RuleBuilderCommand) FlagWithInput(flag string, path Path) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) FlagWithInput(flag, path string) *RuleBuilderCommand {
c.inputs = append(c.inputs, path)
- return c.Text(flag + path.String())
+ return c.Text(flag + path)
}
// FlagWithInputList adds the specified flag and input paths to the command line, with the inputs joined by sep
// and no separator between the flag and inputs. The input paths will also be added to the dependencies returned by
// RuleBuilder.Inputs.
-func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths Paths, sep string) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths []string, sep string) *RuleBuilderCommand {
c.inputs = append(c.inputs, paths...)
- return c.FlagWithList(flag, paths.Strings(), sep)
+ return c.FlagWithList(flag, paths, sep)
}
// FlagForEachInput adds the specified flag joined with each input path to the command line. The input paths will also
// be added to the dependencies returned by RuleBuilder.Inputs. The result is identical to calling FlagWithInput for
// each input path.
-func (c *RuleBuilderCommand) FlagForEachInput(flag string, paths Paths) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) FlagForEachInput(flag string, paths []string) *RuleBuilderCommand {
for _, path := range paths {
c.FlagWithInput(flag, path)
}
@@ -400,12 +421,23 @@
// FlagWithOutput adds the specified flag and output path to the command line, with no separator between them. The path
// will also be added to the outputs returned by RuleBuilder.Outputs.
-func (c *RuleBuilderCommand) FlagWithOutput(flag string, path WritablePath) *RuleBuilderCommand {
+func (c *RuleBuilderCommand) FlagWithOutput(flag, path string) *RuleBuilderCommand {
c.outputs = append(c.outputs, path)
- return c.Text(flag + path.String())
+ return c.Text(flag + path)
}
// String returns the command line.
func (c *RuleBuilderCommand) String() string {
return string(c.buf)
}
+
+type unknownRulePath struct {
+ path string
+}
+
+var _ Path = (*unknownRulePath)(nil)
+
+func (p *unknownRulePath) String() string { return p.path }
+func (p *unknownRulePath) Ext() string { return filepath.Ext(p.path) }
+func (p *unknownRulePath) Base() string { return filepath.Base(p.path) }
+func (p *unknownRulePath) Rel() string { return p.path }
diff --git a/android/rule_builder_test.go b/android/rule_builder_test.go
index f738faf..f947348 100644
--- a/android/rule_builder_test.go
+++ b/android/rule_builder_test.go
@@ -24,30 +24,10 @@
"testing"
)
-func pathContext() PathContext {
- return PathContextForTesting(TestConfig("out", nil),
- map[string][]byte{
- "ld": nil,
- "a.o": nil,
- "b.o": nil,
- "cp": nil,
- "a": nil,
- "b": nil,
- "ls": nil,
- "turbine": nil,
- "java": nil,
- })
-}
-
func ExampleRuleBuilder() {
rule := NewRuleBuilder()
- ctx := pathContext()
-
- rule.Command().
- Tool(PathForSource(ctx, "ld")).
- Inputs(PathsForTesting("a.o", "b.o")).
- FlagWithOutput("-o ", PathForOutput(ctx, "linked"))
+ rule.Command().Tool("ld").Inputs([]string{"a.o", "b.o"}).FlagWithOutput("-o ", "linked")
rule.Command().Text("echo success")
// To add the command to the build graph:
@@ -59,26 +39,18 @@
fmt.Printf("outputs: %q\n", rule.Outputs())
// Output:
- // commands: "ld a.o b.o -o out/linked && echo success"
+ // commands: "ld a.o b.o -o linked && echo success"
// tools: ["ld"]
// inputs: ["a.o" "b.o"]
- // outputs: ["out/linked"]
+ // outputs: ["linked"]
}
func ExampleRuleBuilder_Temporary() {
rule := NewRuleBuilder()
- ctx := pathContext()
-
- rule.Command().
- Tool(PathForSource(ctx, "cp")).
- Input(PathForSource(ctx, "a")).
- Output(PathForOutput(ctx, "b"))
- rule.Command().
- Tool(PathForSource(ctx, "cp")).
- Input(PathForOutput(ctx, "b")).
- Output(PathForOutput(ctx, "c"))
- rule.Temporary(PathForOutput(ctx, "b"))
+ rule.Command().Tool("cp").Input("a").Output("b")
+ rule.Command().Tool("cp").Input("b").Output("c")
+ rule.Temporary("b")
fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && "))
fmt.Printf("tools: %q\n", rule.Tools())
@@ -86,26 +58,18 @@
fmt.Printf("outputs: %q\n", rule.Outputs())
// Output:
- // commands: "cp a out/b && cp out/b out/c"
+ // commands: "cp a b && cp b c"
// tools: ["cp"]
// inputs: ["a"]
- // outputs: ["out/c"]
+ // outputs: ["c"]
}
func ExampleRuleBuilder_DeleteTemporaryFiles() {
rule := NewRuleBuilder()
- ctx := pathContext()
-
- rule.Command().
- Tool(PathForSource(ctx, "cp")).
- Input(PathForSource(ctx, "a")).
- Output(PathForOutput(ctx, "b"))
- rule.Command().
- Tool(PathForSource(ctx, "cp")).
- Input(PathForOutput(ctx, "b")).
- Output(PathForOutput(ctx, "c"))
- rule.Temporary(PathForOutput(ctx, "b"))
+ rule.Command().Tool("cp").Input("a").Output("b")
+ rule.Command().Tool("cp").Input("b").Output("c")
+ rule.Temporary("b")
rule.DeleteTemporaryFiles()
fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && "))
@@ -114,112 +78,93 @@
fmt.Printf("outputs: %q\n", rule.Outputs())
// Output:
- // commands: "cp a out/b && cp out/b out/c && rm -f out/b"
+ // commands: "cp a b && cp b c && rm -f b"
// tools: ["cp"]
// inputs: ["a"]
- // outputs: ["out/c"]
+ // outputs: ["c"]
}
func ExampleRuleBuilder_Installs() {
rule := NewRuleBuilder()
- ctx := pathContext()
-
- out := PathForOutput(ctx, "linked")
-
- rule.Command().
- Tool(PathForSource(ctx, "ld")).
- Inputs(PathsForTesting("a.o", "b.o")).
- FlagWithOutput("-o ", out)
- rule.Install(out, "/bin/linked")
- rule.Install(out, "/sbin/linked")
+ rule.Command().Tool("ld").Inputs([]string{"a.o", "b.o"}).FlagWithOutput("-o ", "linked")
+ rule.Install("linked", "/bin/linked")
+ rule.Install("linked", "/sbin/linked")
fmt.Printf("rule.Installs().String() = %q\n", rule.Installs().String())
// Output:
- // rule.Installs().String() = "out/linked:/bin/linked out/linked:/sbin/linked"
+ // rule.Installs().String() = "linked:/bin/linked linked:/sbin/linked"
}
func ExampleRuleBuilderCommand() {
rule := NewRuleBuilder()
- ctx := pathContext()
-
// chained
- rule.Command().
- Tool(PathForSource(ctx, "ld")).
- Inputs(PathsForTesting("a.o", "b.o")).
- FlagWithOutput("-o ", PathForOutput(ctx, "linked"))
+ rule.Command().Tool("ld").Inputs([]string{"a.o", "b.o"}).FlagWithOutput("-o ", "linked")
// unchained
cmd := rule.Command()
- cmd.Tool(PathForSource(ctx, "ld"))
- cmd.Inputs(PathsForTesting("a.o", "b.o"))
- cmd.FlagWithOutput("-o ", PathForOutput(ctx, "linked"))
+ cmd.Tool("ld")
+ cmd.Inputs([]string{"a.o", "b.o"})
+ cmd.FlagWithOutput("-o ", "linked")
// mixed:
- cmd = rule.Command().Tool(PathForSource(ctx, "ld"))
- cmd.Inputs(PathsForTesting("a.o", "b.o"))
- cmd.FlagWithOutput("-o ", PathForOutput(ctx, "linked"))
+ cmd = rule.Command().Tool("ld")
+ cmd.Inputs([]string{"a.o", "b.o"})
+ cmd.FlagWithOutput("-o ", "linked")
}
func ExampleRuleBuilderCommand_Flag() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "ls")).Flag("-l"))
+ Tool("ls").Flag("-l"))
// Output:
// ls -l
}
func ExampleRuleBuilderCommand_FlagWithArg() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "ls")).
+ Tool("ls").
FlagWithArg("--sort=", "time"))
// Output:
// ls --sort=time
}
func ExampleRuleBuilderCommand_FlagForEachArg() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "ls")).
+ Tool("ls").
FlagForEachArg("--sort=", []string{"time", "size"}))
// Output:
// ls --sort=time --sort=size
}
func ExampleRuleBuilderCommand_FlagForEachInput() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "turbine")).
- FlagForEachInput("--classpath ", PathsForTesting("a.jar", "b.jar")))
+ Tool("turbine").
+ FlagForEachInput("--classpath ", []string{"a.jar", "b.jar"}))
// Output:
// turbine --classpath a.jar --classpath b.jar
}
func ExampleRuleBuilderCommand_FlagWithInputList() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "java")).
- FlagWithInputList("-classpath=", PathsForTesting("a.jar", "b.jar"), ":"))
+ Tool("java").
+ FlagWithInputList("-classpath=", []string{"a.jar", "b.jar"}, ":"))
// Output:
// java -classpath=a.jar:b.jar
}
func ExampleRuleBuilderCommand_FlagWithInput() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "java")).
- FlagWithInput("-classpath=", PathForSource(ctx, "a")))
+ Tool("java").
+ FlagWithInput("-classpath=", "a"))
// Output:
// java -classpath=a
}
func ExampleRuleBuilderCommand_FlagWithList() {
- ctx := pathContext()
fmt.Println(NewRuleBuilder().Command().
- Tool(PathForSource(ctx, "ls")).
+ Tool("ls").
FlagWithList("--sort=", []string{"time", "size"}, ","))
// Output:
// ls --sort=time,size
@@ -228,35 +173,23 @@
func TestRuleBuilder(t *testing.T) {
rule := NewRuleBuilder()
- fs := map[string][]byte{
- "input": nil,
- "Implicit": nil,
- "Input": nil,
- "Tool": nil,
- "input2": nil,
- "tool2": nil,
- "input3": nil,
- }
-
- ctx := PathContextForTesting(TestConfig("out", nil), fs)
-
cmd := rule.Command().
Flag("Flag").
FlagWithArg("FlagWithArg=", "arg").
- FlagWithInput("FlagWithInput=", PathForSource(ctx, "input")).
- FlagWithOutput("FlagWithOutput=", PathForOutput(ctx, "output")).
- Implicit(PathForSource(ctx, "Implicit")).
- ImplicitOutput(PathForOutput(ctx, "ImplicitOutput")).
- Input(PathForSource(ctx, "Input")).
- Output(PathForOutput(ctx, "Output")).
+ FlagWithInput("FlagWithInput=", "input").
+ FlagWithOutput("FlagWithOutput=", "output").
+ Implicit("Implicit").
+ ImplicitOutput("ImplicitOutput").
+ Input("Input").
+ Output("Output").
Text("Text").
- Tool(PathForSource(ctx, "Tool"))
+ Tool("Tool")
rule.Command().
Text("command2").
- Input(PathForSource(ctx, "input2")).
- Output(PathForOutput(ctx, "output2")).
- Tool(PathForSource(ctx, "tool2"))
+ Input("input2").
+ Output("output2").
+ Tool("tool2")
// Test updates to the first command after the second command has been started
cmd.Text("after command2")
@@ -266,18 +199,18 @@
// Test a command that uses the output of a previous command as an input
rule.Command().
Text("command3").
- Input(PathForSource(ctx, "input3")).
- Input(PathForOutput(ctx, "output2")).
- Output(PathForOutput(ctx, "output3"))
+ Input("input3").
+ Input("output2").
+ Output("output3")
wantCommands := []string{
- "Flag FlagWithArg=arg FlagWithInput=input FlagWithOutput=out/output Input out/Output Text Tool after command2 old cmd",
- "command2 input2 out/output2 tool2",
- "command3 input3 out/output2 out/output3",
+ "Flag FlagWithArg=arg FlagWithInput=input FlagWithOutput=output Input Output Text Tool after command2 old cmd",
+ "command2 input2 output2 tool2",
+ "command3 input3 output2 output3",
}
- wantInputs := PathsForSource(ctx, []string{"Implicit", "Input", "input", "input2", "input3"})
- wantOutputs := PathsForOutput(ctx, []string{"ImplicitOutput", "Output", "output", "output2", "output3"})
- wantTools := PathsForSource(ctx, []string{"Tool", "tool2"})
+ wantInputs := []string{"Implicit", "Input", "input", "input2", "input3"}
+ wantOutputs := []string{"ImplicitOutput", "Output", "output", "output2", "output3"}
+ wantTools := []string{"Tool", "tool2"}
if !reflect.DeepEqual(rule.Commands(), wantCommands) {
t.Errorf("\nwant rule.Commands() = %#v\n got %#v", wantCommands, rule.Commands())
@@ -329,7 +262,7 @@
func testRuleBuilder_Build(ctx BuilderContext, in Path, out WritablePath) {
rule := NewRuleBuilder()
- rule.Command().Tool(PathForSource(ctx, "cp")).Input(in).Output(out)
+ rule.Command().Tool("cp").Input(in.String()).Output(out.String())
rule.Build(pctx, ctx, "rule", "desc")
}