func listAllTags(store *storage.Storage, tx *storage.Tx, showCount, onePerLine bool) error {
log.Info(2, "retrieving all tags.")
if showCount {
count, err := store.TagCount(tx)
if err != nil {
return fmt.Errorf("could not retrieve tag count: %v", err)
}
fmt.Println(count)
} else {
tags, err := store.Tags(tx)
if err != nil {
return fmt.Errorf("could not retrieve tags: %v", err)
}
if onePerLine {
for _, tag := range tags {
fmt.Println(escape(tag.Name, '=', ' '))
}
} else {
tagNames := make([]string, len(tags))
for index, tag := range tags {
tagNames[index] = escape(tag.Name, '=', ' ')
}
terminal.PrintColumns(tagNames)
}
}
return nil
}
func listAllValues(store *storage.Storage, tx *storage.Tx, showCount, onePerLine bool) error {
log.Info(2, "retrieving all values.")
if showCount {
count, err := store.ValueCount(tx)
if err != nil {
return fmt.Errorf("could not retrieve value count: %v", err)
}
fmt.Println(count)
} else {
values, err := store.Values(tx)
if err != nil {
return fmt.Errorf("could not retrieve values: %v", err)
}
if onePerLine {
for _, value := range values {
fmt.Println(escape(value.Name))
}
} else {
valueNames := make([]string, len(values))
for index, value := range values {
valueNames[index] = escape(value.Name)
}
terminal.PrintColumns(valueNames)
}
}
return nil
}
func listValuesForTag(store *storage.Storage, tx *storage.Tx, tagName string, showCount, onePerLine bool) error {
tag, err := store.TagByName(tx, tagName)
if err != nil {
return fmt.Errorf("could not retrieve tag '%v': %v", tagName, err)
}
if tag == nil {
return fmt.Errorf("no such tag, '%v'", tagName)
}
log.Infof(2, "retrieving values for tag '%v'.", tagName)
values, err := store.ValuesByTag(tx, tag.Id)
if err != nil {
return fmt.Errorf("could not retrieve values for tag '%v': %v", tagName, err)
}
if showCount {
fmt.Println(len(values))
} else {
if onePerLine {
for _, value := range values {
fmt.Println(escape(value.Name, '=', ' '))
}
} else {
valueNames := make([]string, len(values))
for index, value := range values {
valueNames[index] = escape(value.Name, '=', ' ')
}
terminal.PrintColumns(valueNames)
}
}
return nil
}
func listTagsForPaths(store *storage.Storage, tx *storage.Tx, paths []string, showCount, onePerLine, explicitOnly, printPath, colour bool) (error, warnings) {
warnings := make(warnings, 0, 10)
printPath = printPath || len(paths) > 1 || !stdoutIsCharDevice()
for index, path := range paths {
absPath, err := filepath.Abs(path)
if err != nil {
return err, warnings
}
log.Infof(2, "%v: retrieving tags.", path)
file, err := store.FileByPath(tx, absPath)
if err != nil {
warnings = append(warnings, err.Error())
continue
}
var tagNames []string
if file != nil {
tagNames, err = tagNamesForFile(store, tx, file.Id, explicitOnly, colour)
if err != nil {
return err, warnings
}
} else {
_, err := os.Stat(absPath)
if err != nil {
switch {
case os.IsPermission(err):
warnings = append(warnings, fmt.Sprintf("%v: permission denied", path))
continue
case os.IsNotExist(err):
warnings = append(warnings, fmt.Sprintf("%v: no such file", path))
continue
default:
return fmt.Errorf("%v: could not stat file: %v", path, err), warnings
}
}
}
switch {
case showCount:
if printPath {
fmt.Print(path + ": ")
}
fmt.Println(strconv.Itoa(len(tagNames)))
case onePerLine:
if index > 0 {
fmt.Println()
}
if printPath {
fmt.Println(path + ":")
}
for _, tagName := range tagNames {
fmt.Println(tagName)
}
default:
if printPath {
fmt.Print(path + ":")
for _, tagName := range tagNames {
fmt.Print(" " + tagName)
}
fmt.Println()
} else {
terminal.PrintColumns(tagNames)
}
}
}
return nil, warnings
}