platform_build_blueprint/ninja_writer.go

// Copyright 2014 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 blueprint

import (
	"io"
	"strings"
	"unicode"
)

const (
	indentWidth    = 4
	maxIndentDepth = 2
	lineWidth      = 80
)

var indentString = strings.Repeat(" ", indentWidth*maxIndentDepth)

type StringWriterWriter interface {
	io.StringWriter
	io.Writer
}

type ninjaWriter struct {
	writer StringWriterWriter

	justDidBlankLine bool // true if the last operation was a BlankLine
}

func newNinjaWriter(writer StringWriterWriter) *ninjaWriter {
	return &ninjaWriter{
		writer: writer,
	}
}

func (n *ninjaWriter) Comment(comment string) error {
	n.justDidBlankLine = false

	const lineHeaderLen = len("# ")
	const maxLineLen = lineWidth - lineHeaderLen

	var lineStart, lastSplitPoint int
	for i, r := range comment {
		if unicode.IsSpace(r) {
			// We know we can safely split the line here.
			lastSplitPoint = i + 1
		}

		var line string
		var writeLine bool
		switch {
		case r == '\n':
			// Output the line without trimming the left so as to allow comments
			// to contain their own indentation.
			line = strings.TrimRightFunc(comment[lineStart:i], unicode.IsSpace)
			writeLine = true

		case (i-lineStart > maxLineLen) && (lastSplitPoint > lineStart):
			// The line has grown too long and is splittable.  Split it at the
			// last split point.
			line = strings.TrimSpace(comment[lineStart:lastSplitPoint])
			writeLine = true
		}

		if writeLine {
			line = strings.TrimSpace("# "+line) + "\n"
			_, err := n.writer.WriteString(line)
			if err != nil {
				return err
			}
			lineStart = lastSplitPoint
		}
	}

	if lineStart != len(comment) {
		line := strings.TrimSpace(comment[lineStart:])
		_, err := n.writer.WriteString("# ")
		if err != nil {
			return err
		}
		_, err = n.writer.WriteString(line)
		if err != nil {
			return err
		}
		_, err = n.writer.WriteString("\n")
		if err != nil {
			return err
		}
	}

	return nil
}

func (n *ninjaWriter) Pool(name string) error {
	n.justDidBlankLine = false
	return n.writeStatement("pool", name)
}

func (n *ninjaWriter) Rule(name string) error {
	n.justDidBlankLine = false
	return n.writeStatement("rule", name)
}

func (n *ninjaWriter) Build(comment string, rule string, outputs, implicitOuts,
	explicitDeps, implicitDeps, orderOnlyDeps, validations []*ninjaString,
	outputStrings, implicitOutStrings, explicitDepStrings,
	implicitDepStrings, orderOnlyDepStrings, validationStrings []string,
	nameTracker *nameTracker) error {

	n.justDidBlankLine = false

	const lineWrapLen = len(" $")
	const maxLineLen = lineWidth - lineWrapLen

	wrapper := &ninjaWriterWithWrap{
		ninjaWriter: n,
		maxLineLen:  maxLineLen,
	}

	if comment != "" {
		err := wrapper.Comment(comment)
		if err != nil {
			return err
		}
	}

	wrapper.WriteString("build")

	for _, output := range outputStrings {
		wrapper.Space()
		outputEscaper.WriteString(wrapper, output)
	}
	for _, output := range outputs {
		wrapper.Space()
		output.ValueWithEscaper(wrapper, nameTracker, outputEscaper)
	}

	if len(implicitOuts) > 0 || len(implicitOutStrings) > 0 {
		wrapper.WriteStringWithSpace("|")

		for _, out := range implicitOutStrings {
			wrapper.Space()
			outputEscaper.WriteString(wrapper, out)
		}
		for _, out := range implicitOuts {
			wrapper.Space()
			out.ValueWithEscaper(wrapper, nameTracker, outputEscaper)
		}
	}

	wrapper.WriteString(":")

	wrapper.WriteStringWithSpace(rule)

	for _, dep := range explicitDepStrings {
		wrapper.Space()
		inputEscaper.WriteString(wrapper, dep)
	}
	for _, dep := range explicitDeps {
		wrapper.Space()
		dep.ValueWithEscaper(wrapper, nameTracker, inputEscaper)
	}

	if len(implicitDeps) > 0 || len(implicitDepStrings) > 0 {
		wrapper.WriteStringWithSpace("|")

		for _, dep := range implicitDepStrings {
			wrapper.Space()
			inputEscaper.WriteString(wrapper, dep)
		}
		for _, dep := range implicitDeps {
			wrapper.Space()
			dep.ValueWithEscaper(wrapper, nameTracker, inputEscaper)
		}
	}

	if len(orderOnlyDeps) > 0 || len(orderOnlyDepStrings) > 0 {
		wrapper.WriteStringWithSpace("||")

		for _, dep := range orderOnlyDepStrings {
			wrapper.Space()
			inputEscaper.WriteString(wrapper, dep)
		}
		for _, dep := range orderOnlyDeps {
			wrapper.Space()
			dep.ValueWithEscaper(wrapper, nameTracker, inputEscaper)
		}
	}

	if len(validations) > 0 || len(validationStrings) > 0 {
		wrapper.WriteStringWithSpace("|@")

		for _, dep := range validationStrings {
			wrapper.Space()
			inputEscaper.WriteString(wrapper, dep)
		}
		for _, dep := range validations {
			wrapper.Space()
			dep.ValueWithEscaper(wrapper, nameTracker, inputEscaper)
		}
	}

	return wrapper.Flush()
}

func (n *ninjaWriter) Assign(name, value string) error {
	n.justDidBlankLine = false
	_, err := n.writer.WriteString(name)
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(" = ")
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(value)
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString("\n")
	if err != nil {
		return err
	}
	return nil
}

func (n *ninjaWriter) ScopedAssign(name, value string) error {
	n.justDidBlankLine = false
	_, err := n.writer.WriteString(indentString[:indentWidth])
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(name)
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(" = ")
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(value)
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString("\n")
	if err != nil {
		return err
	}
	return nil
}

func (n *ninjaWriter) Default(nameTracker *nameTracker, targets []*ninjaString, targetStrings []string) error {
	n.justDidBlankLine = false

	const lineWrapLen = len(" $")
	const maxLineLen = lineWidth - lineWrapLen

	wrapper := &ninjaWriterWithWrap{
		ninjaWriter: n,
		maxLineLen:  maxLineLen,
	}

	wrapper.WriteString("default")

	for _, target := range targetStrings {
		wrapper.Space()
		outputEscaper.WriteString(wrapper, target)
	}
	for _, target := range targets {
		wrapper.Space()
		target.ValueWithEscaper(wrapper, nameTracker, outputEscaper)
	}

	return wrapper.Flush()
}

func (n *ninjaWriter) Subninja(file string) error {
	n.justDidBlankLine = false
	return n.writeStatement("subninja", file)
}

func (n *ninjaWriter) BlankLine() (err error) {
	// We don't output multiple blank lines in a row.
	if !n.justDidBlankLine {
		n.justDidBlankLine = true
		_, err = n.writer.WriteString("\n")
	}
	return err
}

func (n *ninjaWriter) writeStatement(directive, name string) error {
	_, err := n.writer.WriteString(directive + " ")
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString(name)
	if err != nil {
		return err
	}
	_, err = n.writer.WriteString("\n")
	if err != nil {
		return err
	}
	return nil
}

// ninjaWriterWithWrap is an io.StringWriter that writes through to a ninjaWriter, but supports
// user-readable line wrapping on boundaries when ninjaWriterWithWrap.Space is called.
// It collects incoming calls to WriteString until either the line length is exceeded, in which case
// it inserts a wrap before the pending strings and then writes them, or the next call to Space, in
// which case it writes out the pending strings.
//
// WriteString never returns an error, all errors are held until Flush is called.  Once an error has
// occurred all writes become noops.
type ninjaWriterWithWrap struct {
	*ninjaWriter
	// pending lists the strings that have been written since the last call to Space.
	pending []string

	// pendingLen accumulates the lengths of the strings in pending.
	pendingLen int

	// lineLen accumulates the number of bytes on the current line.
	lineLen int

	// maxLineLen is the length of the line before wrapping.
	maxLineLen int

	// space is true if the strings in pending should be preceded by a space.
	space bool

	// err holds any error that has occurred to return in Flush.
	err error
}

// WriteString writes the string to buffer, wrapping on a previous Space call if necessary.
// It never returns an error, all errors are held until Flush is called.
func (n *ninjaWriterWithWrap) WriteString(s string) (written int, noError error) {
	// Always return the full length of the string and a nil error.
	// ninjaWriterWithWrap doesn't return errors to the caller, it saves them until Flush()
	written = len(s)

	if n.err != nil {
		return
	}

	const spaceLen = 1
	if !n.space {
		// No space is pending, so a line wrap can't be inserted before this, so just write
		// the string.
		n.lineLen += len(s)
		_, n.err = n.writer.WriteString(s)
	} else if n.lineLen+len(s)+spaceLen > n.maxLineLen {
		// A space is pending, and the pending strings plus the current string would exceed the
		// maximum line length.  Wrap and indent before the pending space and strings, then write
		// the pending and current strings.
		_, n.err = n.writer.WriteString(" $\n")
		if n.err != nil {
			return
		}
		_, n.err = n.writer.WriteString(indentString[:indentWidth*2])
		if n.err != nil {
			return
		}
		n.lineLen = indentWidth*2 + n.pendingLen
		s = strings.TrimLeftFunc(s, unicode.IsSpace)
		n.pending = append(n.pending, s)
		n.lineLen += len(s)
		n.writePending()

		n.space = false
	} else {
		// A space is pending but the current string would not reach the maximum line length,
		// add it to the pending list.
		n.pending = append(n.pending, s)
		n.pendingLen += len(s)
		n.lineLen += len(s)
	}

	return
}

func (n *ninjaWriterWithWrap) Write(p []byte) (written int, noError error) {
	// Write is rarely used, implement it via WriteString.
	return n.WriteString(string(p))
}

// Space inserts a space that is also a possible wrapping point into the string.
func (n *ninjaWriterWithWrap) Space() {
	if n.err != nil {
		return
	}
	if n.space {
		// A space was already pending, and the space plus any strings written after the space did
		// not reach the maxmimum line length, so write out the old space and pending strings.
		_, n.err = n.writer.WriteString(" ")
		n.lineLen++
		n.writePending()
	}
	n.space = true
}

// writePending writes out all the strings stored in pending and resets it.
func (n *ninjaWriterWithWrap) writePending() {
	if n.err != nil {
		return
	}
	for _, pending := range n.pending {
		_, n.err = n.writer.WriteString(pending)
		if n.err != nil {
			return
		}
	}
	// Reset the length of pending back to 0 without reducing its capacity to avoid reallocating
	// the backing array.
	n.pending = n.pending[:0]
	n.pendingLen = 0
}

// WriteStringWithSpace is a helper that calls Space and WriteString.
func (n *ninjaWriterWithWrap) WriteStringWithSpace(s string) {
	n.Space()
	_, _ = n.WriteString(s)
}

// Flush writes out any pending space or strings and then a newline.  It also returns any errors
// that have previously occurred.
func (n *ninjaWriterWithWrap) Flush() error {
	if n.space {
		_, n.err = n.writer.WriteString(" ")
	}
	n.writePending()
	if n.err != nil {
		return n.err
	}
	_, err := n.writer.WriteString("\n")
	return err
}