github.com/westcoastroms/westcoastroms-build@v0.0.0-20190928114312-2350e5a73030/build/blueprint/parser/modify.go (about)

     1  // Copyright 2014 Google Inc. All rights reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package parser
    16  
    17  import (
    18  	"fmt"
    19  	"io"
    20  	"math"
    21  	"sort"
    22  )
    23  
    24  func AddStringToList(list *List, s string) (modified bool) {
    25  	for _, v := range list.Values {
    26  		if v.Type() != StringType {
    27  			panic(fmt.Errorf("expected string in list, got %s", v.Type()))
    28  		}
    29  
    30  		if sv, ok := v.(*String); ok && sv.Value == s {
    31  			// string already exists
    32  			return false
    33  		}
    34  	}
    35  
    36  	list.Values = append(list.Values, &String{
    37  		LiteralPos: list.RBracePos,
    38  		Value:      s,
    39  	})
    40  
    41  	return true
    42  }
    43  
    44  func RemoveStringFromList(list *List, s string) (modified bool) {
    45  	for i, v := range list.Values {
    46  		if v.Type() != StringType {
    47  			panic(fmt.Errorf("expected string in list, got %s", v.Type()))
    48  		}
    49  
    50  		if sv, ok := v.(*String); ok && sv.Value == s {
    51  			list.Values = append(list.Values[:i], list.Values[i+1:]...)
    52  			return true
    53  		}
    54  	}
    55  
    56  	return false
    57  }
    58  
    59  // A Patch represents a region of a text buffer to be replaced [Start, End) and its Replacement
    60  type Patch struct {
    61  	Start, End  int
    62  	Replacement string
    63  }
    64  
    65  // A PatchList is a list of sorted, non-overlapping Patch objects
    66  type PatchList []Patch
    67  
    68  type PatchOverlapError error
    69  
    70  // Add adds a Patch to a PatchList.  It returns a PatchOverlapError if the patch cannot be added.
    71  func (list *PatchList) Add(start, end int, replacement string) error {
    72  	patch := Patch{start, end, replacement}
    73  	if patch.Start > patch.End {
    74  		return fmt.Errorf("invalid patch, start %d is after end %d", patch.Start, patch.End)
    75  	}
    76  	for _, p := range *list {
    77  		if (patch.Start >= p.Start && patch.Start < p.End) ||
    78  			(patch.End >= p.Start && patch.End < p.End) ||
    79  			(p.Start >= patch.Start && p.Start < patch.End) ||
    80  			(p.Start == patch.Start && p.End == patch.End) {
    81  			return PatchOverlapError(fmt.Errorf("new patch %d-%d overlaps with existing patch %d-%d",
    82  				patch.Start, patch.End, p.Start, p.End))
    83  		}
    84  	}
    85  	*list = append(*list, patch)
    86  	list.sort()
    87  	return nil
    88  }
    89  
    90  func (list *PatchList) sort() {
    91  	sort.SliceStable(*list,
    92  		func(i, j int) bool {
    93  			return (*list)[i].Start < (*list)[j].Start
    94  		})
    95  }
    96  
    97  // Apply applies all the Patch objects in PatchList to the data from an input ReaderAt to an output Writer.
    98  func (list *PatchList) Apply(in io.ReaderAt, out io.Writer) error {
    99  	var offset int64
   100  	for _, patch := range *list {
   101  		toWrite := int64(patch.Start) - offset
   102  		written, err := io.Copy(out, io.NewSectionReader(in, offset, toWrite))
   103  		if err != nil {
   104  			return err
   105  		}
   106  		offset += toWrite
   107  		if written != toWrite {
   108  			return fmt.Errorf("unexpected EOF at %d", offset)
   109  		}
   110  
   111  		_, err = io.WriteString(out, patch.Replacement)
   112  		if err != nil {
   113  			return err
   114  		}
   115  
   116  		offset += int64(patch.End - patch.Start)
   117  	}
   118  	_, err := io.Copy(out, io.NewSectionReader(in, offset, math.MaxInt64-offset))
   119  	return err
   120  }