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
This commit is contained in:
Colin Cross
230
android/rule_builder.go
Normal file
230
android/rule_builder.go
Normal file
@@ -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 }
|
||||
148
android/rule_builder_test.go
Normal file
148
android/rule_builder_test.go
Normal file
@@ -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())
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user