blob: f00fc1ee240a943d40fa623a2864a1195d6d77d1 [file] [log] [blame]
// 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 main
import (
"bufio"
"bytes"
"encoding/json"
"io"
"os"
"regexp"
"strings"
"unicode"
)
type jsonWhitelist struct {
Paths []string
IgnoreMatchingLines []string
}
type whitelist struct {
path string
ignoreMatchingLines []string
}
func parseWhitelists(whitelists []string, whitelistFiles []string) ([]whitelist, error) {
var ret []whitelist
add := func(path string, ignoreMatchingLines []string) {
for _, x := range ret {
if x.path == path {
x.ignoreMatchingLines = append(x.ignoreMatchingLines, ignoreMatchingLines...)
return
}
}
ret = append(ret, whitelist{
path: path,
ignoreMatchingLines: ignoreMatchingLines,
})
}
for _, file := range whitelistFiles {
newWhitelists, err := parseWhitelistFile(file)
if err != nil {
return nil, err
}
for _, w := range newWhitelists {
add(w.path, w.ignoreMatchingLines)
}
}
for _, s := range whitelists {
colon := strings.IndexRune(s, ':')
var ignoreMatchingLines []string
if colon >= 0 {
ignoreMatchingLines = []string{s[colon+1:]}
}
add(s, ignoreMatchingLines)
}
return ret, nil
}
func parseWhitelistFile(file string) ([]whitelist, error) {
r, err := os.Open(file)
if err != nil {
return nil, err
}
defer r.Close()
d := json.NewDecoder(newJSONCommentStripper(r))
var jsonWhitelists []jsonWhitelist
err = d.Decode(&jsonWhitelists)
var whitelists []whitelist
for _, w := range jsonWhitelists {
for _, p := range w.Paths {
whitelists = append(whitelists, whitelist{
path: p,
ignoreMatchingLines: w.IgnoreMatchingLines,
})
}
}
return whitelists, err
}
func filterModifiedPaths(l [][2]*ZipArtifactFile, whitelists []whitelist) ([][2]*ZipArtifactFile, error) {
outer:
for i := 0; i < len(l); i++ {
for _, w := range whitelists {
if match, err := Match(w.path, l[i][0].Name); err != nil {
return l, err
} else if match {
if match, err := diffIgnoringMatchingLines(l[i][0], l[i][1], w.ignoreMatchingLines); err != nil {
return l, err
} else if match || len(w.ignoreMatchingLines) == 0 {
l = append(l[:i], l[i+1:]...)
i--
}
continue outer
}
}
}
if len(l) == 0 {
l = nil
}
return l, nil
}
func filterNewPaths(l []*ZipArtifactFile, whitelists []whitelist) ([]*ZipArtifactFile, error) {
outer:
for i := 0; i < len(l); i++ {
for _, w := range whitelists {
if match, err := Match(w.path, l[i].Name); err != nil {
return l, err
} else if match && len(w.ignoreMatchingLines) == 0 {
l = append(l[:i], l[i+1:]...)
i--
}
continue outer
}
}
if len(l) == 0 {
l = nil
}
return l, nil
}
func diffIgnoringMatchingLines(a *ZipArtifactFile, b *ZipArtifactFile, ignoreMatchingLines []string) (match bool, err error) {
lineMatchesIgnores := func(b []byte) (bool, error) {
for _, m := range ignoreMatchingLines {
if match, err := regexp.Match(m, b); err != nil {
return false, err
} else if match {
return match, nil
}
}
return false, nil
}
filter := func(z *ZipArtifactFile) ([]byte, error) {
var ret []byte
r, err := z.Open()
if err != nil {
return nil, err
}
s := bufio.NewScanner(r)
for s.Scan() {
if match, err := lineMatchesIgnores(s.Bytes()); err != nil {
return nil, err
} else if !match {
ret = append(ret, "\n"...)
ret = append(ret, s.Bytes()...)
}
}
return ret, nil
}
bufA, err := filter(a)
if err != nil {
return false, err
}
bufB, err := filter(b)
if err != nil {
return false, err
}
return bytes.Compare(bufA, bufB) == 0, nil
}
func applyWhitelists(diff zipDiff, whitelists []whitelist) (zipDiff, error) {
var err error
diff.modified, err = filterModifiedPaths(diff.modified, whitelists)
if err != nil {
return diff, err
}
diff.onlyInA, err = filterNewPaths(diff.onlyInA, whitelists)
if err != nil {
return diff, err
}
diff.onlyInB, err = filterNewPaths(diff.onlyInB, whitelists)
if err != nil {
return diff, err
}
return diff, nil
}
func newJSONCommentStripper(r io.Reader) *jsonCommentStripper {
return &jsonCommentStripper{
r: bufio.NewReader(r),
}
}
type jsonCommentStripper struct {
r *bufio.Reader
b []byte
err error
}
func (j *jsonCommentStripper) Read(buf []byte) (int, error) {
for len(j.b) == 0 {
if j.err != nil {
return 0, j.err
}
j.b, j.err = j.r.ReadBytes('\n')
if isComment(j.b) {
j.b = nil
}
}
n := copy(buf, j.b)
j.b = j.b[n:]
return n, nil
}
var commentPrefix = []byte("//")
func isComment(b []byte) bool {
for len(b) > 0 && unicode.IsSpace(rune(b[0])) {
b = b[1:]
}
return bytes.HasPrefix(b, commentPrefix)
}