platform_build_blueprint/parser/modify.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 parser

import (
	"fmt"
	"io"
	"math"
	"sort"
)

func AddStringToList(list *List, s string) (modified bool) {
	for _, v := range list.Values {
		if v.Type() != StringType {
			panic(fmt.Errorf("expected string in list, got %s", v.Type()))
		}

		if sv, ok := v.(*String); ok && sv.Value == s {
			// string already exists
			return false
		}
	}

	list.Values = append(list.Values, &String{
		LiteralPos: list.RBracePos,
		Value:      s,
	})

	return true
}

func RemoveStringFromList(list *List, s string) (modified bool) {
	for i, v := range list.Values {
		if v.Type() != StringType {
			panic(fmt.Errorf("expected string in list, got %s", v.Type()))
		}

		if sv, ok := v.(*String); ok && sv.Value == s {
			list.Values = append(list.Values[:i], list.Values[i+1:]...)
			return true
		}
	}

	return false
}

func ReplaceStringsInList(list *List, replacements map[string]string) (replaced bool) {
	modified := false
	for i, v := range list.Values {
		if v.Type() != StringType {
			panic(fmt.Errorf("expected string in list, got %s", v.Type()))
		}
		if sv, ok := v.(*String); ok && replacements[sv.Value] != "" {
			pos := list.Values[i].Pos()
			list.Values[i] = &String{
				LiteralPos: pos,
				Value:      replacements[sv.Value],
			}
			modified = true
		}
	}
	return modified
}

// A Patch represents a region of a text buffer to be replaced [Start, End) and its Replacement
type Patch struct {
	Start, End  int
	Replacement string
}

// A PatchList is a list of sorted, non-overlapping Patch objects
type PatchList []Patch

type PatchOverlapError error

// Add adds a Patch to a PatchList.  It returns a PatchOverlapError if the patch cannot be added.
func (list *PatchList) Add(start, end int, replacement string) error {
	patch := Patch{start, end, replacement}
	if patch.Start > patch.End {
		return fmt.Errorf("invalid patch, start %d is after end %d", patch.Start, patch.End)
	}
	for _, p := range *list {
		if (patch.Start >= p.Start && patch.Start < p.End) ||
			(patch.End >= p.Start && patch.End < p.End) ||
			(p.Start >= patch.Start && p.Start < patch.End) ||
			(p.Start == patch.Start && p.End == patch.End) {
			return PatchOverlapError(fmt.Errorf("new patch %d-%d overlaps with existing patch %d-%d",
				patch.Start, patch.End, p.Start, p.End))
		}
	}
	*list = append(*list, patch)
	list.sort()
	return nil
}

func (list *PatchList) sort() {
	sort.SliceStable(*list,
		func(i, j int) bool {
			return (*list)[i].Start < (*list)[j].Start
		})
}

// Apply applies all the Patch objects in PatchList to the data from an input ReaderAt to an output Writer.
func (list *PatchList) Apply(in io.ReaderAt, out io.Writer) error {
	var offset int64
	for _, patch := range *list {
		toWrite := int64(patch.Start) - offset
		written, err := io.Copy(out, io.NewSectionReader(in, offset, toWrite))
		if err != nil {
			return err
		}
		offset += toWrite
		if written != toWrite {
			return fmt.Errorf("unexpected EOF at %d", offset)
		}

		_, err = io.WriteString(out, patch.Replacement)
		if err != nil {
			return err
		}

		offset += int64(patch.End - patch.Start)
	}
	_, err := io.Copy(out, io.NewSectionReader(in, offset, math.MaxInt64-offset))
	return err
}