func grep(re *regexp.Regexp, path string, r io.Reader) error { in := bufio.NewReader(r) lineNo := 0 for { switch line, prefix, err := in.ReadLine(); { case prefix: return errors.New("Line is too long") case err == io.EOF: return nil case err != nil: return err default: lineNo++ match := re.Match(line) if (match && !*vFlag) || (!match && *vFlag) { if *nFlag && path != "" { os.Stdout.WriteString(path + ":") } if *nFlag { fmt.Print(lineNo, ":") } os.Stdout.WriteString(string(line) + "\n") } } } panic("Unreachable") }
func ReaderWaitFor(r io.Reader, re *regexp.Regexp, duration time.Duration) ([]byte, bool, error) { res := make(chan *readWaitResult, 1) quit := make(chan bool, 1) go func() { out := &bytes.Buffer{} var err error found := false var n int buf := make([]byte, 1024) for err == nil && !found { select { case <-quit: break default: n, err = r.Read(buf) if n > 0 { out.Write(buf[0:n]) } found = re.Match(out.Bytes()) } } res <- &readWaitResult{out.Bytes(), found, err} }() select { case result := <-res: return result.byts, result.found, result.err case <-time.After(duration): quit <- true return nil, false, ErrTimeout } }
func grep(rx *regexp.Regexp, r io.Reader) bool { matched := false s := bufio.NewScanner(r) for { if !s.Scan() { break } b := s.Bytes() m := rx.Match(b) if invert && !m { matched = true if _, err := os.Stdout.Write(b); err != nil { fmt.Println(err.Error()) os.Exit(1) } if _, err := fmt.Fprintln(os.Stdout); err != nil { fmt.Println(err.Error()) os.Exit(1) } } else if !invert && m { matched = true if _, err := os.Stdout.Write(b); err != nil { fmt.Println(err.Error()) os.Exit(1) } if _, err := fmt.Fprintln(os.Stdout); err != nil { fmt.Println(err.Error()) os.Exit(1) } } } return matched }
// 载入所有Page func LoadPages(root string, exclude string) (pages map[string]Mapper, err error) { pages = make(map[string]Mapper) err = nil var _exclude *regexp.Regexp if exclude != "" { _exclude, err = regexp.Compile(exclude) if err != nil { errMsg := fmt.Sprintf("BAD pages exclude regexp %q >> ", exclude, err.Error()) err = errors.New(errMsg) return } } err = filepath.Walk(filepath.Join(root, "pages/"), func(path string, info os.FileInfo, err error) error { if err != nil { return err } if info.IsDir() || strings.HasPrefix(filepath.Base(path), ".") { return nil } if _exclude != nil && _exclude.Match([]byte(path[len(root+"pages/"):])) { return nil } page, err := LoadPage(root, path) if err != nil { return err } pages[page.Id()] = page return nil }) return }
func read(name string, wg *sync.WaitGroup, reg *regexp.Regexp) { defer wg.Done() f, err := os.Open(name) if err != nil { errlog.Println(err) return } defer f.Close() var r io.Reader ext := filepath.Ext(name) switch ext { case ".gz": r, err = gzip.NewReader(f) if err != nil { log.Println(err) return } case ".bz": r = bzip2.NewReader(f) default: errlog.Println("Unknown extension:", ext) return } scanner := bufio.NewScanner(r) for scanner.Scan() { b := scanner.Bytes() if reg.Match(b) { log.Printf("%s: %s", name, b) } } if err := scanner.Err(); err != nil { errlog.Printf("Error while reading %s: %s", name, err) } }
// 载入所有的Post func LoadPosts(root string, exclude string) (posts map[string]Mapper, err error) { posts = make(map[string]Mapper) err = nil var _exclude *regexp.Regexp if exclude != "" { _exclude, err = regexp.Compile(exclude) if err != nil { err = errors.New("BAD pages exclude regexp : " + exclude + "\t" + err.Error()) return } } err = filepath.Walk(root+"posts/", func(path string, info os.FileInfo, err error) error { if err != nil { return err } if info.IsDir() || strings.HasPrefix(filepath.Base(path), ".") { return nil } if _exclude != nil && _exclude.Match([]byte(path[len(root+"posts/"):])) { return nil } post, err := LoadPost(root, path) if err != nil { return err } posts[post.Id()] = post return nil }) return }
func (collection *exampleCollection) applyRegExpFocus(focusFilter *regexp.Regexp) { for _, example := range collection.examples { if !focusFilter.Match([]byte(example.concatenatedString())) { example.skip() } } }
func ValidateCSVData(fn string, re *regexp.Regexp) (err error) { fin, err := os.Open(fn) if err != nil { // do not return the error, the file might be not needed return nil } defer fin.Close() r := bufio.NewReader(fin) line_number := 1 for { line, truncated, err := r.ReadLine() if err != nil { break } if truncated { return errors.New("line too long") } // skip the header line if line_number > 1 { if !re.Match(line) { return errors.New(fmt.Sprintf("%s: error on line %d: %s", fn, line_number, line)) } } line_number++ } return }
// find the directories and files which matches the regular expression func findRecursively(dir *os.File, reg *regexp.Regexp, currentwd string) (dirs, files []string) { dirs = make([]string, 0) files = make([]string, 0) fileInfos, err := dir.Readdir(0) if err != nil { return } for i := 0; i < len(fileInfos); i++ { name := fileInfos[i].Name() if reg.Match([]byte(name)) == true { if fileInfos[i].IsDir() == true { dirs = append(dirs, currentwd+"/"+name) } else { files = append(dirs, currentwd+"/"+name) } } if fileInfos[i].IsDir() == true { redir, err := os.Open(currentwd + "/" + name) if err != nil { continue } newDirs, newFiles := findRecursively(redir, reg, currentwd+"/"+name) dirs = append(dirs, newDirs...) files = append(files, newFiles...) redir.Close() } } return }
func (expect *ExpectSubprocess) ExpectRegex(re *regexp.Regexp) (buf []byte, err error) { join := make([][]byte, 0, 1024) chunk := make([]byte, 255) line := make([]byte, 0, 1024) var n int for { n, err = expect.f.Read(chunk) if err != nil { return } for i := 0; i < n; i++ { if chunk[i] != '\n' { line = append(line, chunk[i]) } success := re.Match(line) if success { buf = flatten(join) return } if chunk[i] == '\n' { line = append(line, chunk[i]) join = append(join, line) line = make([]byte, 0, 1024) } } } }
// Shell worker. func shell(check *Check, name *string, sleep *time.Duration) { // Execute with shell in N attemps. var out []byte var err error for i := 0; i < check.Tries; { out, err = exec.Command("sh", "-c", check.Shell).CombinedOutput() if err == nil { if check.Match != "" { // Match regexp. var regex *regexp.Regexp regex, err = regexp.Compile(check.Match) if err == nil && !regex.Match(out) { err = errors.New("Expected:\n" + check.Match + "\n\nGot:\n" + string(out)) } } break } i++ if i < check.Tries { time.Sleep(*sleep) } } // Process results. if err == nil { if check.Failed { ts := time.Now() mutex.Lock() check.Failed = false check.Since = ts.Format(time.RFC3339) modified = etag(ts) mutex.Unlock() subject := "Fixed: " + *name log(5, subject) if check.Notify != "" { notify(check, &subject, nil) } if check.Alert != "" { alert(check, name, nil, false) } } } else { if !check.Failed { ts := time.Now() mutex.Lock() check.Failed = true check.Since = ts.Format(time.RFC3339) modified = etag(ts) mutex.Unlock() msg := string(out) + err.Error() subject := "Failed: " + *name log(5, subject+"\n"+msg) if check.Notify != "" { notify(check, &subject, &msg) } if check.Alert != "" { alert(check, name, &msg, true) } } } }
func grepFailures(revs []*Revision, re *regexp.Regexp) []*failure { return processFailureLogs(revs, func(build *Build, data []byte) []*failure { if !re.Match(data) { return nil } return []*failure{new(failure)} }) }
// Find takes a compiled regexp and starting at the top of the file // returns the line number of all lines that match. func (traveler *FileTraveler) Find(rx *regexp.Regexp) (matches []int) { traveler.ForEach(func(pos int, line []byte) { if rx.Match(line) { matches = append(matches, pos) } }) return }
//ConstraintRegexp limits request item by regexp func ConstraintRegexp(item string, reg *regexp.Regexp) func(map[string]string) bool { return func(m map[string]string) bool { if value, ok := m[item]; ok { return reg.Match([]byte(value)) } return false } }
// ResponseMatchesGeneral is an abstraction of ResponseMatches and // ResponseMatchesInsecure that simply varies in the security of the connection func ResponseMatchesGeneral(urlstr string, re *regexp.Regexp, secure bool) (int, string, error) { body := chkutil.URLToBytes(urlstr, secure) if re.Match(body) { return errutil.Success() } msg := "Response didn't match regexp" return errutil.GenericError(msg, re.String(), []string{string(body)}) }
// filterParams filters sensitive information like passwords from being sent to // Rollbar. func filterParams(pattern *regexp.Regexp, values map[string][]string) map[string][]string { for key, _ := range values { if pattern.Match([]byte(key)) { values[key] = []string{FILTERED} } } return values }
func filterVariables(vars []api.Variable, filter *regexp.Regexp) []string { data := make([]string, 0, len(vars)) for _, v := range vars { if filter == nil || filter.Match([]byte(v.Name)) { data = append(data, fmt.Sprintf("%s = %s", v.Name, v.Value)) } } return data }
func list(context *config.Context, p string, hidden bool, ignore *regexp.Regexp) (fileChan chan *File, err error) { absPath := context.AbsPathOf(p) var f []os.FileInfo f, err = ioutil.ReadDir(absPath) fileChan = make(chan *File) if err != nil { close(fileChan) return } go func() { for _, file := range f { fileName := file.Name() if fileName == config.GDDirSuffix { continue } if ignore != nil && ignore.Match([]byte(fileName)) { continue } if isHidden(fileName, hidden) { continue } resPath := gopath.Join(absPath, fileName) // TODO: (@odeke-em) decide on how to deal with isFifo if namedPipe(file.Mode()) { fmt.Fprintf(os.Stderr, "%s (%s) is a named pipe, not reading from it\n", p, resPath) continue } if !symlink(file.Mode()) { fileChan <- NewLocalFile(resPath, file) } else { var symResolvPath string symResolvPath, err = filepath.EvalSymlinks(resPath) if err != nil { continue } var symInfo os.FileInfo symInfo, err = os.Stat(symResolvPath) if err != nil { continue } lf := NewLocalFile(symResolvPath, symInfo) // Retain the original name as appeared in // the manifest instead of the resolved one lf.Name = fileName fileChan <- lf } } close(fileChan) }() return }
func (db *DB) scan(dataType byte, key []byte, count int, inclusive bool, match string) ([][]byte, error) { var minKey, maxKey []byte var err error var r *regexp.Regexp if len(match) > 0 { if r, err = regexp.Compile(match); err != nil { return nil, err } } if len(key) > 0 { if err = checkKeySize(key); err != nil { return nil, err } if minKey, err = db.encodeMetaKey(dataType, key); err != nil { return nil, err } } else { if minKey, err = db.encodeMinKey(dataType); err != nil { return nil, err } } if maxKey, err = db.encodeMaxKey(dataType); err != nil { return nil, err } if count <= 0 { count = defaultScanCount } v := make([][]byte, 0, count) it := db.bucket.NewIterator() it.Seek(minKey) if !inclusive { if it.Valid() && bytes.Equal(it.RawKey(), minKey) { it.Next() } } for i := 0; it.Valid() && i < count && bytes.Compare(it.RawKey(), maxKey) < 0; it.Next() { if k, err := db.decodeMetaKey(dataType, it.Key()); err != nil { continue } else if r != nil && !r.Match(k) { continue } else { v = append(v, k) i++ } } it.Close() return v, nil }
func genPatternMatcher( regex *regexp.Regexp, sel func(last, current []byte) []byte, ) (matcher, error) { matcher := func(last, current []byte) bool { line := sel(last, current) return regex.Match(line) } return matcher, nil }
func scan(re *regexp.Regexp) { s := &ucd.Scanner{} for ; !s.Done(); s.Next() { rec := s.Record() r := rec.Rune() nam := rec.Name() if re.Match(nam) { fmt.Printf("U+%04X [%c] %s\n", r, r, nam) } } }
func anyMatch(pat *regexp.Regexp, args ...string) bool { if pat == nil { return false } for _, arg := range args { if pat.Match([]byte(arg)) { return true } } return false }
// 判断val是否能正确匹配exp中的正则表达式。 // val可以是[]byte, []rune, string类型。 func isMatch(exp *regexp.Regexp, val interface{}) bool { switch v := val.(type) { case []rune: return exp.MatchString(string(v)) case []byte: return exp.Match(v) case string: return exp.MatchString(v) default: return false } }
func (msg *LogMsg) hasPattern(arg interface{}) bool { var re *regexp.Regexp var err error if s, ok := arg.(string); ok { if re, err = regexp.Compile(s); err != nil { log.Fatal(err) } } else if re, ok = arg.(*regexp.Regexp); !ok { log.Fatalf("unexpected arg %T %v\n", arg, arg) } return re.Match([]byte(msg.msg)) }
func isMatched(v interface{}, with *regexp.Regexp) bool { switch v.(type) { case string: if with.MatchString(v.(string)) { return true } case []byte: if with.Match(v.([]byte)) { return true } } return false }
func matchesFilters(raw []byte, match *regexp.Regexp, exclude *regexp.Regexp) bool { matches := true if match != nil { matches = match.Match(raw) } if exclude != nil { matches = matches && !exclude.Match(raw) } return matches }
func addRegexpFilter() { var reg *regexp.Regexp if posix { reg = regexp.MustCompilePOSIX(pattern) } else { reg = regexp.MustCompile(pattern) } matchOK = func(s string) bool { b := slurpStripNullByte(s) return reg.Match(b) } }
func requestOutputInterpreter(result []byte, find *regexp.Regexp, ssl bool, sslwork bool) int { result_s := string(result) if strings.Contains(result_s, "HTTP/1.1 200") || strings.Contains(result_s, "HTTP/1.1 30") { if find.Match(result) { return 1 } else { if strings.Contains(result_s, "HTTP/1.1 200") { return 200 } else { return 300 } } } return -1 }
func (inp *Input) ValidateMatchRegexp(re *regexp.Regexp) { inp.Validators = append(inp.Validators, func(inp *Input, r *http.Request) bool { name := inp.Name value, ok := r.Form[name] ret := false if ok { if 0 != len(value) && re.Match([]byte(value[0])) { ret = true } } if !ret { inp.Errors = append(inp.Errors, fmt.Sprintf("%s is not valid", inp.Label)) } return ret }) }
// Test result from server against regexp func expectResult(t tLogger, c net.Conn, re *regexp.Regexp) []byte { // Wait for commands to be processed and results queued for read c.SetReadDeadline(time.Now().Add(1 * time.Second)) n, err := c.Read(expBuf) c.SetReadDeadline(time.Time{}) if n <= 0 && err != nil { stackFatalf(t, "Error reading from conn: %v\n", err) } buf := expBuf[:n] if !re.Match(buf) { stackFatalf(t, "Response did not match expected: \n\tReceived:'%q'\n\tExpected:'%s'\n", buf, re) } return buf }