| // Copyright 2018 The Bazel 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 res | |
| import ( | |
| "errors" | |
| "fmt" | |
| "path" | |
| "strings" | |
| ) | |
| // ErrNotResPath the provided path does not seem to point to a resource file | |
| var ErrNotResPath = errors.New("Not a resource path") | |
| // ErrSkipResPath the provided path does needs to be skipped. | |
| var ErrSkipResPath = errors.New("resource path that does needs to be skipped") | |
| // PathInfo contains all information about a resource that can be derived from its location on the filesystem. | |
| type PathInfo struct { | |
| Path string | |
| ResDir string | |
| TypeDir string | |
| Type Type | |
| Qualifier string | |
| Density Density | |
| } | |
| // ParsePath converts a path string into a PathInfo object if the string points to a resource file. | |
| func ParsePath(p string) (PathInfo, error) { | |
| parent := path.Dir(p) | |
| resDir := path.Dir(parent) | |
| typeDir := path.Base(parent) | |
| if strings.HasPrefix(path.Base(p), ".") { | |
| return PathInfo{}, ErrSkipResPath | |
| } | |
| resType, err := ParseValueOrType(strings.Split(typeDir, "-")[0]) | |
| qualifier := extractQualifier(typeDir) | |
| if err != nil { | |
| return PathInfo{}, ErrNotResPath | |
| } | |
| var density Density | |
| for _, q := range strings.Split(qualifier, "-") { | |
| var err error | |
| density, err = ParseDensity(q) | |
| if err != nil { | |
| return PathInfo{}, err | |
| } | |
| if density != UnspecifiedDensity { | |
| break | |
| } | |
| } | |
| return PathInfo{ | |
| Path: p, | |
| ResDir: resDir, | |
| TypeDir: typeDir, | |
| Type: resType, | |
| Qualifier: qualifier, | |
| Density: density, | |
| }, nil | |
| } | |
| // MakePathInfo converts a path string into a PathInfo object. | |
| func MakePathInfo(p string) (*PathInfo, error) { | |
| pi, err := ParsePath(p) | |
| if err != nil { | |
| return nil, fmt.Errorf("ParsePath failed to parse %q: %v", p, err) | |
| } | |
| return &pi, nil | |
| } | |
| // MakePathInfos converts a list of path strings into a list of PathInfo objects. | |
| func MakePathInfos(paths []string) ([]*PathInfo, error) { | |
| pis := make([]*PathInfo, 0, len(paths)) | |
| for _, p := range paths { | |
| if strings.HasPrefix(path.Base(p), ".") { | |
| continue | |
| } | |
| pi, err := MakePathInfo(p) | |
| if err != nil { | |
| return nil, err | |
| } | |
| pis = append(pis, pi) | |
| } | |
| return pis, nil | |
| } | |
| func extractQualifier(s string) string { | |
| base := path.Base(s) | |
| parts := strings.SplitN(base, "-", 2) | |
| if len(parts) > 1 { | |
| return parts[1] | |
| } | |
| return "" | |
| } |