Move dexpreopt.Script to android.RuleBuilder
Move dexpreopt.Script to android.RuleBuilder so that the builder
style can be used in more places. Also add tests for it.
Test: rule_builder_test.go
Change-Id: I92a963bd112bf033b08899e930094b908acfcdfd
diff --git a/android/rule_builder.go b/android/rule_builder.go
new file mode 100644
index 0000000..b7e8432
--- /dev/null
+++ b/android/rule_builder.go
@@ -0,0 +1,230 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package android
+
+import (
+ "fmt"
+ "path/filepath"
+ "sort"
+ "strings"
+
+ "github.com/google/blueprint"
+ "github.com/google/blueprint/proptools"
+)
+
+type RuleBuilderInstall struct {
+ From, To string
+}
+
+type RuleBuilder struct {
+ commands []*RuleBuilderCommand
+ installs []RuleBuilderInstall
+ restat bool
+}
+
+func (r *RuleBuilder) Restat() *RuleBuilder {
+ r.restat = true
+ return r
+}
+
+func (r *RuleBuilder) Install(from, to string) {
+ r.installs = append(r.installs, RuleBuilderInstall{from, to})
+}
+
+func (r *RuleBuilder) Command() *RuleBuilderCommand {
+ command := &RuleBuilderCommand{}
+ r.commands = append(r.commands, command)
+ return command
+}
+
+func (r *RuleBuilder) Inputs() []string {
+ outputs := r.outputSet()
+
+ inputs := make(map[string]bool)
+ for _, c := range r.commands {
+ for _, input := range c.inputs {
+ if !outputs[input] {
+ inputs[input] = true
+ }
+ }
+ }
+
+ var inputList []string
+ for input := range inputs {
+ inputList = append(inputList, input)
+ }
+ sort.Strings(inputList)
+
+ return inputList
+}
+
+func (r *RuleBuilder) outputSet() map[string]bool {
+ outputs := make(map[string]bool)
+ for _, c := range r.commands {
+ for _, output := range c.outputs {
+ outputs[output] = true
+ }
+ }
+ return outputs
+}
+
+func (r *RuleBuilder) Outputs() []string {
+ outputs := r.outputSet()
+
+ var outputList []string
+ for output := range outputs {
+ outputList = append(outputList, output)
+ }
+ sort.Strings(outputList)
+ return outputList
+}
+
+func (r *RuleBuilder) Installs() []RuleBuilderInstall {
+ return append([]RuleBuilderInstall(nil), r.installs...)
+}
+
+func (r *RuleBuilder) Tools() []string {
+ var tools []string
+ for _, c := range r.commands {
+ tools = append(tools, c.tools...)
+ }
+ return tools
+}
+
+func (r *RuleBuilder) Commands() []string {
+ var commands []string
+ for _, c := range r.commands {
+ commands = append(commands, string(c.buf))
+ }
+ return commands
+}
+
+func (r *RuleBuilder) Build(pctx PackageContext, ctx ModuleContext, name string, desc string) {
+ var inputs Paths
+ for _, input := range r.Inputs() {
+ rel, isRel := MaybeRel(ctx, PathForModuleOut(ctx).String(), input)
+ if isRel {
+ inputs = append(inputs, PathForModuleOut(ctx, rel))
+ } else {
+ // TODO: use PathForOutput once boot image is moved to where PathForOutput can find it.
+ inputs = append(inputs, &unknownRulePath{input})
+ }
+ }
+
+ var outputs WritablePaths
+ for _, output := range r.Outputs() {
+ rel := Rel(ctx, PathForModuleOut(ctx).String(), output)
+ outputs = append(outputs, PathForModuleOut(ctx, rel))
+ }
+
+ if len(r.Commands()) > 0 {
+ ctx.Build(pctx, BuildParams{
+ Rule: ctx.Rule(pctx, name, blueprint.RuleParams{
+ Command: strings.Join(proptools.NinjaEscape(r.Commands()), " && "),
+ CommandDeps: r.Tools(),
+ }),
+ Implicits: inputs,
+ Outputs: outputs,
+ Description: desc,
+ })
+ }
+}
+
+type RuleBuilderCommand struct {
+ buf []byte
+ inputs []string
+ outputs []string
+ tools []string
+}
+
+func (c *RuleBuilderCommand) Text(text string) *RuleBuilderCommand {
+ if len(c.buf) > 0 {
+ c.buf = append(c.buf, ' ')
+ }
+ c.buf = append(c.buf, text...)
+ return c
+}
+
+func (c *RuleBuilderCommand) Textf(format string, a ...interface{}) *RuleBuilderCommand {
+ return c.Text(fmt.Sprintf(format, a...))
+}
+
+func (c *RuleBuilderCommand) Flag(flag string) *RuleBuilderCommand {
+ return c.Text(flag)
+}
+
+func (c *RuleBuilderCommand) FlagWithArg(flag, arg string) *RuleBuilderCommand {
+ return c.Text(flag + arg)
+}
+
+func (c *RuleBuilderCommand) FlagWithList(flag string, list []string, sep string) *RuleBuilderCommand {
+ return c.Text(flag + strings.Join(list, sep))
+}
+
+func (c *RuleBuilderCommand) Tool(path string) *RuleBuilderCommand {
+ c.tools = append(c.tools, path)
+ return c.Text(path)
+}
+
+func (c *RuleBuilderCommand) Input(path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c.Text(path)
+}
+
+func (c *RuleBuilderCommand) Implicit(path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c
+}
+
+func (c *RuleBuilderCommand) Implicits(paths []string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, paths...)
+ return c
+}
+
+func (c *RuleBuilderCommand) Output(path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c.Text(path)
+}
+
+func (c *RuleBuilderCommand) ImplicitOutput(path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c
+}
+
+func (c *RuleBuilderCommand) FlagWithInput(flag, path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c.Text(flag + path)
+}
+
+func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths []string, sep string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, paths...)
+ return c.FlagWithList(flag, paths, sep)
+}
+
+func (c *RuleBuilderCommand) FlagWithOutput(flag, path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c.Text(flag + path)
+}
+
+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
new file mode 100644
index 0000000..b4c9e0e
--- /dev/null
+++ b/android/rule_builder_test.go
@@ -0,0 +1,148 @@
+// Copyright 2019 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package android
+
+import (
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+)
+
+func TestRuleBuilder(t *testing.T) {
+ rule := RuleBuilder{}
+
+ cmd := rule.Command().
+ Flag("Flag").
+ FlagWithArg("FlagWithArg=", "arg").
+ FlagWithInput("FlagWithInput=", "input").
+ FlagWithOutput("FlagWithOutput=", "output").
+ Implicit("Implicit").
+ ImplicitOutput("ImplicitOutput").
+ Input("Input").
+ Output("Output").
+ Text("Text").
+ Tool("Tool")
+
+ rule.Command().
+ Text("command2").
+ Input("input2").
+ Output("output2").
+ Tool("tool2")
+
+ // Test updates to the first command after the second command has been started
+ cmd.Text("after command2")
+ // Test updating a command when the previous update did not replace the cmd variable
+ cmd.Text("old cmd")
+
+ // Test a command that uses the output of a previous command as an input
+ rule.Command().
+ Text("command3").
+ Input("input3").
+ Input("output2").
+ Output("output3")
+
+ wantCommands := []string{
+ "Flag FlagWithArg=arg FlagWithInput=input FlagWithOutput=output Input Output Text Tool after command2 old cmd",
+ "command2 input2 output2 tool2",
+ "command3 input3 output2 output3",
+ }
+ 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())
+ }
+ if !reflect.DeepEqual(rule.Inputs(), wantInputs) {
+ t.Errorf("\nwant rule.Inputs() = %#v\n got %#v", wantInputs, rule.Inputs())
+ }
+ if !reflect.DeepEqual(rule.Outputs(), wantOutputs) {
+ t.Errorf("\nwant rule.Outputs() = %#v\n got %#v", wantOutputs, rule.Outputs())
+ }
+ if !reflect.DeepEqual(rule.Tools(), wantTools) {
+ t.Errorf("\nwant rule.Tools() = %#v\n got %#v", wantTools, rule.Tools())
+ }
+}
+
+func testRuleBuilderFactory() Module {
+ module := &testRuleBuilderModule{}
+ module.AddProperties(&module.properties)
+ InitAndroidModule(module)
+ return module
+}
+
+type testRuleBuilderModule struct {
+ ModuleBase
+ properties struct {
+ Src string
+ }
+}
+
+func (t *testRuleBuilderModule) GenerateAndroidBuildActions(ctx ModuleContext) {
+ rule := RuleBuilder{}
+
+ in := PathForSource(ctx, t.properties.Src)
+ out := PathForModuleOut(ctx, ctx.ModuleName())
+
+ rule.Command().Tool("cp").Input(in.String()).Output(out.String())
+
+ rule.Build(pctx, ctx, "rule", "desc")
+}
+
+func TestRuleBuilder_Build(t *testing.T) {
+ buildDir, err := ioutil.TempDir("", "soong_test_rule_builder")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(buildDir)
+
+ bp := `
+ rule_builder_test {
+ name: "foo",
+ src: "bar",
+ }
+ `
+
+ config := TestConfig(buildDir, nil)
+ ctx := NewTestContext()
+ ctx.MockFileSystem(map[string][]byte{
+ "Android.bp": []byte(bp),
+ "bar": nil,
+ "cp": nil,
+ })
+ ctx.RegisterModuleType("rule_builder_test", ModuleFactoryAdaptor(testRuleBuilderFactory))
+ ctx.Register()
+
+ _, errs := ctx.ParseFileList(".", []string{"Android.bp"})
+ FailIfErrored(t, errs)
+ _, errs = ctx.PrepareBuildActions(config)
+ FailIfErrored(t, errs)
+
+ foo := ctx.ModuleForTests("foo", "").Rule("rule")
+
+ // TODO: make RuleParams accessible to tests and verify rule.Command().Tools() ends up in CommandDeps
+
+ if len(foo.Implicits) != 1 || foo.Implicits[0].String() != "bar" {
+ t.Errorf("want foo.Implicits = [%q], got %q", "bar", foo.Implicits.Strings())
+ }
+
+ wantOutput := filepath.Join(buildDir, ".intermediates", "foo", "foo")
+ if len(foo.Outputs) != 1 || foo.Outputs[0].String() != wantOutput {
+ t.Errorf("want foo.Outputs = [%q], got %q", wantOutput, foo.Outputs.Strings())
+ }
+
+}