| // Copyright © 2014 Steve Francia <spf@spf13.com>. |
| // Copyright 2009 The Go Authors. 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 afero |
| |
| import ( |
| "path/filepath" |
| "sort" |
| "strings" |
| ) |
| |
| // Glob returns the names of all files matching pattern or nil |
| // if there is no matching file. The syntax of patterns is the same |
| // as in Match. The pattern may describe hierarchical names such as |
| // /usr/*/bin/ed (assuming the Separator is '/'). |
| // |
| // Glob ignores file system errors such as I/O errors reading directories. |
| // The only possible returned error is ErrBadPattern, when pattern |
| // is malformed. |
| // |
| // This was adapted from (http://golang.org/pkg/path/filepath) and uses several |
| // built-ins from that package. |
| func Glob(fs Fs, pattern string) (matches []string, err error) { |
| if !hasMeta(pattern) { |
| // afero does not support Lstat directly. |
| if _, err = lstatIfOs(fs, pattern); err != nil { |
| return nil, nil |
| } |
| return []string{pattern}, nil |
| } |
| |
| dir, file := filepath.Split(pattern) |
| switch dir { |
| case "": |
| dir = "." |
| case string(filepath.Separator): |
| // nothing |
| default: |
| dir = dir[0 : len(dir)-1] // chop off trailing separator |
| } |
| |
| if !hasMeta(dir) { |
| return glob(fs, dir, file, nil) |
| } |
| |
| var m []string |
| m, err = Glob(fs, dir) |
| if err != nil { |
| return |
| } |
| for _, d := range m { |
| matches, err = glob(fs, d, file, matches) |
| if err != nil { |
| return |
| } |
| } |
| return |
| } |
| |
| // glob searches for files matching pattern in the directory dir |
| // and appends them to matches. If the directory cannot be |
| // opened, it returns the existing matches. New matches are |
| // added in lexicographical order. |
| func glob(fs Fs, dir, pattern string, matches []string) (m []string, e error) { |
| m = matches |
| fi, err := fs.Stat(dir) |
| if err != nil { |
| return |
| } |
| if !fi.IsDir() { |
| return |
| } |
| d, err := fs.Open(dir) |
| if err != nil { |
| return |
| } |
| defer d.Close() |
| |
| names, _ := d.Readdirnames(-1) |
| sort.Strings(names) |
| |
| for _, n := range names { |
| matched, err := filepath.Match(pattern, n) |
| if err != nil { |
| return m, err |
| } |
| if matched { |
| m = append(m, filepath.Join(dir, n)) |
| } |
| } |
| return |
| } |
| |
| // hasMeta reports whether path contains any of the magic characters |
| // recognized by Match. |
| func hasMeta(path string) bool { |
| // TODO(niemeyer): Should other magic characters be added here? |
| return strings.IndexAny(path, "*?[") >= 0 |
| } |