lunny/git-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lfs: make strings translatable

Browse Source
This commit is contained in:
brian m. carlson 2021-12-14 16:05:11 +00:00
parent 1367468ec8
commit 17d756b780
No known key found for this signature in database
GPG Key ID: 2D0C9BC12F82B3A1
12 changed files with 61 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lfs/attribute.go
View File

@ -5,6 +5,7 @@ import (
"strings"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/tr"
)
// Attribute wraps the structure and some operations of Git's conception of an
@ -158,7 +159,7 @@ func (a *Attribute) set(gitConfig *git.Configuration, key, value string, upgrade
}
return err
} else if currentValue != value {
return fmt.Errorf("the %q attribute should be %q but is %q",
return fmt.Errorf(fmt.Sprintf(tr.Tr.Get("the %%q attribute should be %%q but is %%q")),
key, value, currentValue)
}

7
lfs/diff_index_scanner.go
View File

@ -8,6 +8,7 @@ import (
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/tr"
)
// Status represents the status of a file that appears in the output of `git
@ -69,7 +70,7 @@ func (s DiffIndexStatus) Format(state fmt.State, c rune) {
state.Write([]byte{byte(rune(s))})
}
default:
panic(fmt.Sprintf("cannot format %v for DiffIndexStatus", c))
panic(fmt.Sprintf(tr.Tr.Get("cannot format %v for DiffIndexStatus", c)))
}
}
@ -180,12 +181,12 @@ func (s *DiffIndexScanner) scan(line string) (*DiffIndexEntry, error) {
parts := strings.Split(line, "\t")
if len(parts) < 2 {
return nil, errors.Errorf("invalid line: %s", line)
return nil, errors.Errorf(tr.Tr.Get("invalid line: %s", line))
}
desc := strings.Fields(parts[0])
if len(desc) < 5 {
return nil, errors.Errorf("invalid description: %s", parts[0])
return nil, errors.Errorf(tr.Tr.Get("invalid description: %s", parts[0]))
}
entry := &DiffIndexEntry{

4
lfs/extension.go
View File

@ -11,7 +11,9 @@ import (
"strings"
"github.com/git-lfs/git-lfs/v3/config"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/subprocess"
"github.com/git-lfs/git-lfs/v3/tr"
)
type pipeRequest struct {
@ -142,7 +144,7 @@ func pipeExtensions(cfg *config.Configuration, request *pipeRequest) (response p
if err = ec.cmd.Wait(); err != nil {
if ec.err != nil {
errStr := ec.err.String()
err = fmt.Errorf("extension '%s' failed with: %s", ec.result.name, errStr)
err = errors.New(tr.Tr.Get("extension '%s' failed with: %s", ec.result.name, errStr))
}
return
}

27
lfs/gitfilter_smudge.go
View File

@ -11,6 +11,7 @@ import (
"github.com/git-lfs/git-lfs/v3/tools"
"github.com/git-lfs/git-lfs/v3/tools/humanize"
"github.com/git-lfs/git-lfs/v3/tq"
"github.com/git-lfs/git-lfs/v3/tr"
"github.com/rubyist/tracerx"
)
@ -20,7 +21,7 @@ func (f *GitFilter) SmudgeToFile(filename string, ptr *Pointer, download bool, m
if stat, _ := os.Stat(filename); stat != nil && stat.Mode()&0200 == 0 {
if err := os.Chmod(filename, stat.Mode()|0200); err != nil {
return errors.Wrap(err,
"Could not restore write permission")
tr.Tr.Get("Could not restore write permission"))
}
// When we're done, return the file back to its normal
@ -30,12 +31,12 @@ func (f *GitFilter) SmudgeToFile(filename string, ptr *Pointer, download bool, m
abs, err := filepath.Abs(filename)
if err != nil {
return fmt.Errorf("could not produce absolute path for %q", filename)
return errors.New(tr.Tr.Get("could not produce absolute path for %q", filename))
}
file, err := os.Create(abs)
if err != nil {
return fmt.Errorf("could not create working directory file: %v", err)
return errors.New(tr.Tr.Get("could not create working directory file: %v", err))
}
defer file.Close()
if _, err := f.Smudge(file, ptr, filename, download, manifest, cb); err != nil {
@ -45,7 +46,7 @@ func (f *GitFilter) SmudgeToFile(filename string, ptr *Pointer, download bool, m
ptr.Encode(file)
return err
} else {
return fmt.Errorf("could not write working directory file: %v", err)
return errors.New(tr.Tr.Get("could not write working directory file: %v", err))
}
}
return nil
@ -91,7 +92,7 @@ func (f *GitFilter) Smudge(writer io.Writer, ptr *Pointer, workingfile string, d
}
func (f *GitFilter) downloadFile(writer io.Writer, ptr *Pointer, workingfile, mediafile string, manifest *tq.Manifest, cb tools.CopyCallback) (int64, error) {
fmt.Fprintf(os.Stderr, "Downloading %s (%s)\n", workingfile, humanize.FormatBytes(uint64(ptr.Size)))
fmt.Fprintf(os.Stderr, tr.Tr.Get("Downloading %s (%s)\n", workingfile, humanize.FormatBytes(uint64(ptr.Size))))
// NOTE: if given, "cb" is a tools.CopyCallback which writes updates
// to the logpath specified by GIT_LFS_PROGRESS.
@ -116,7 +117,7 @@ func (f *GitFilter) downloadFile(writer io.Writer, ptr *Pointer, workingfile, me
}
}
return 0, errors.Wrapf(multiErr, "Error downloading %s (%s)", workingfile, ptr.Oid)
return 0, errors.Wrapf(multiErr, tr.Tr.Get("Error downloading %s (%s)", workingfile, ptr.Oid))
}
return f.readLocalFile(writer, ptr, mediafile, workingfile, nil)
@ -125,7 +126,7 @@ func (f *GitFilter) downloadFile(writer io.Writer, ptr *Pointer, workingfile, me
func (f *GitFilter) readLocalFile(writer io.Writer, ptr *Pointer, mediafile string, workingfile string, cb tools.CopyCallback) (int64, error) {
reader, err := tools.RobustOpen(mediafile)
if err != nil {
return 0, errors.Wrapf(err, "error opening media file")
return 0, errors.Wrapf(err, tr.Tr.Get("error opening media file"))
}
defer reader.Close()
@ -141,7 +142,7 @@ func (f *GitFilter) readLocalFile(writer io.Writer, ptr *Pointer, mediafile stri
for _, ptrExt := range ptr.Extensions {
ext, ok := registeredExts[ptrExt.Name]
if !ok {
err := fmt.Errorf("extension '%s' is not configured", ptrExt.Name)
err := errors.New(tr.Tr.Get("extension '%s' is not configured", ptrExt.Name))
return 0, errors.Wrap(err, "smudge")
}
ext.Priority = ptrExt.Priority
@ -174,18 +175,18 @@ func (f *GitFilter) readLocalFile(writer io.Writer, ptr *Pointer, mediafile stri
// verify name, order, and oids
oid := response.results[0].oidIn
if ptr.Oid != oid {
err = fmt.Errorf("actual oid %s during smudge does not match expected %s", oid, ptr.Oid)
err = errors.New(tr.Tr.Get("actual oid %s during smudge does not match expected %s", oid, ptr.Oid))
return 0, errors.Wrap(err, "smudge")
}
for _, expected := range ptr.Extensions {
actual := actualExts[expected.Name]
if actual.name != expected.Name {
err = fmt.Errorf("actual extension name '%s' does not match expected '%s'", actual.name, expected.Name)
err = errors.New(tr.Tr.Get("actual extension name '%s' does not match expected '%s'", actual.name, expected.Name))
return 0, errors.Wrap(err, "smudge")
}
if actual.oidOut != expected.Oid {
err = fmt.Errorf("actual oid %s for extension '%s' does not match expected %s", actual.oidOut, expected.Name, expected.Oid)
err = errors.New(tr.Tr.Get("actual oid %s for extension '%s' does not match expected %s", actual.oidOut, expected.Name, expected.Oid))
return 0, errors.Wrap(err, "smudge")
}
}
@ -193,14 +194,14 @@ func (f *GitFilter) readLocalFile(writer io.Writer, ptr *Pointer, mediafile stri
// setup reader
reader, err = os.Open(response.file.Name())
if err != nil {
return 0, errors.Wrapf(err, "Error opening smudged file: %s", err)
return 0, errors.Wrapf(err, tr.Tr.Get("Error opening smudged file: %s", err))
}
defer reader.Close()
}
n, err := tools.CopyWithCallback(writer, reader, ptr.Size, cb)
if err != nil {
return n, errors.Wrapf(err, "Error reading from media file: %s", err)
return n, errors.Wrapf(err, tr.Tr.Get("Error reading from media file: %s", err))
}
return n, nil

8
lfs/gitscanner.go
View File

@ -2,12 +2,12 @@ package lfs
import (
"errors"
"fmt"
"sync"
"time"
"github.com/git-lfs/git-lfs/v3/config"
"github.com/git-lfs/git-lfs/v3/filepathfilter"
"github.com/git-lfs/git-lfs/v3/tr"
"github.com/rubyist/tracerx"
)
@ -68,7 +68,7 @@ func (s *GitScanner) RemoteForPush(r string) error {
defer s.mu.Unlock()
if len(s.remote) > 0 && s.remote != r {
return fmt.Errorf("trying to set remote to %q, already set to %q", r, s.remote)
return errors.New(tr.Tr.Get("trying to set remote to %q, already set to %q", r, s.remote))
}
s.remote = r
@ -88,7 +88,7 @@ func (s *GitScanner) ScanRangeToRemote(left, right string, cb GitScannerFoundPoi
s.mu.Lock()
if len(s.remote) == 0 {
s.mu.Unlock()
return fmt.Errorf("unable to scan starting at %q: no remote set", left)
return errors.New(tr.Tr.Get("unable to scan starting at %q: no remote set", left))
}
s.mu.Unlock()
@ -107,7 +107,7 @@ func (s *GitScanner) ScanMultiRangeToRemote(left string, rights []string, cb Git
s.mu.Lock()
if len(s.remote) == 0 {
s.mu.Unlock()
return fmt.Errorf("unable to scan starting at %q: no remote set", left)
return errors.New(tr.Tr.Get("unable to scan starting at %q: no remote set", left))
}
s.mu.Unlock()

4
lfs/gitscanner_catfilebatch.go
View File

@ -7,7 +7,9 @@ import (
"io"
"github.com/git-lfs/git-lfs/v3/config"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/tr"
)
// runCatFileBatch uses 'git cat-file --batch' to get the object contents of a
@ -144,7 +146,7 @@ func (s *PointerScanner) next(blob string) (string, string, *WrappedPointer, err
}
if int64(size) != read {
return blobSha, "", nil, fmt.Errorf("expected %d bytes, read %d bytes", size, read)
return blobSha, "", nil, errors.New(tr.Tr.Get("expected %d bytes, read %d bytes", size, read))
}
var pointer *WrappedPointer

5
lfs/gitscanner_catfilebatchcheck.go
View File

@ -2,12 +2,13 @@ package lfs
import (
"bufio"
"fmt"
"io/ioutil"
"strconv"
"strings"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/tr"
)
// runCatFileBatchCheck uses 'git cat-file --batch-check' to get the type and
@ -49,7 +50,7 @@ func runCatFileBatchCheck(smallRevCh chan string, lockableCh chan string, lockab
stderr, _ := ioutil.ReadAll(cmd.Stderr)
err := cmd.Wait()
if err != nil {
errCh <- fmt.Errorf("error in git cat-file --batch-check: %v %v", err, string(stderr))
errCh <- errors.New(tr.Tr.Get("error in git cat-file --batch-check: %v %v", err, string(stderr)))
}
close(smallRevCh)
close(errCh)

8
lfs/gitscanner_log.go
View File

@ -10,9 +10,11 @@ import (
"strings"
"time"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/filepathfilter"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/subprocess"
"github.com/git-lfs/git-lfs/v3/tr"
"github.com/rubyist/tracerx"
)
@ -100,7 +102,7 @@ func scanStashed(cb GitScannerFoundPointer, s *GitScanner) error {
stashMergeShas = append(stashMergeShas, fmt.Sprintf("%v^..%v", stashMergeSha, stashMergeSha))
}
if err := scanner.Err(); err != nil {
fmt.Errorf("error while scanning git log for stashed refs: %v", err)
errors.New(tr.Tr.Get("error while scanning git log for stashed refs: %v", err))
}
err = cmd.Wait()
if err != nil {
@ -143,12 +145,12 @@ func parseScannerLogOutput(cb GitScannerFoundPointer, direction LogDiffDirection
}
if err := scanner.Err(); err != nil {
ioutil.ReadAll(cmd.Stdout)
ch <- gitscannerResult{Err: fmt.Errorf("error while scanning git log: %v", err)}
ch <- gitscannerResult{Err: errors.New(tr.Tr.Get("error while scanning git log: %v", err))}
}
stderr, _ := ioutil.ReadAll(cmd.Stderr)
err := cmd.Wait()
if err != nil {
ch <- gitscannerResult{Err: fmt.Errorf("error in git log: %v %v", err, string(stderr))}
ch <- gitscannerResult{Err: errors.New(tr.Tr.Get("error in git log: %v %v", err, string(stderr)))}
}
close(ch)
}()

4
lfs/gitscanner_tree.go
View File

@ -1,7 +1,6 @@
package lfs
import (
"fmt"
"io/ioutil"
"path"
"path/filepath"
@ -11,6 +10,7 @@ import (
"github.com/git-lfs/git-lfs/v3/filepathfilter"
"github.com/git-lfs/git-lfs/v3/git"
"github.com/git-lfs/git-lfs/v3/git/gitattr"
"github.com/git-lfs/git-lfs/v3/tr"
)
func runScanTree(cb GitScannerFoundPointer, ref string, filter *filepathfilter.Filter, gitEnv, osEnv config.Environment) error {
@ -116,7 +116,7 @@ func lsTreeBlobs(ref string, predicate func(*git.TreeBlob) bool) (*TreeBlobChann
stderr, _ := ioutil.ReadAll(cmd.Stderr)
err := cmd.Wait()
if err != nil {
errchan <- fmt.Errorf("error in git ls-tree: %v %v", err, string(stderr))
errchan <- errors.New(tr.Tr.Get("error in git ls-tree: %v %v", err, string(stderr)))
}
close(blobs)
close(errchan)

4
lfs/hook.go
View File

@ -9,7 +9,9 @@ import (
"strings"
"github.com/git-lfs/git-lfs/v3/config"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/tools"
"github.com/git-lfs/git-lfs/v3/tr"
"github.com/rubyist/tracerx"
)
@ -157,5 +159,5 @@ func (h *Hook) matchesCurrent() (bool, error) {
}
}
return false, fmt.Errorf("Hook already exists: %s\n\n%s\n", string(h.Type), tools.Indent(contents))
return false, errors.New(tr.Tr.Get("Hook already exists: %s\n\n%s\n", string(h.Type), tools.Indent(contents)))
}

29
lfs/pointer.go
View File

@ -13,6 +13,7 @@ import (
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/fs"
"github.com/git-lfs/git-lfs/v3/tr"
"github.com/git-lfs/gitobj/v2"
)
@ -103,7 +104,7 @@ func DecodePointerFromFile(file string) (*Pointer, error) {
return nil, err
}
if stat.Size() >= blobSizeCutoff {
return nil, errors.NewNotAPointerError(errors.New("file size exceeds lfs pointer size cutoff"))
return nil, errors.NewNotAPointerError(errors.New(tr.Tr.Get("file size exceeds lfs pointer size cutoff")))
}
f, err := os.OpenFile(file, os.O_RDONLY, 0644)
if err != nil {
@ -150,7 +151,7 @@ func DecodeFrom(reader io.Reader) (*Pointer, io.Reader, error) {
func verifyVersion(version string) error {
if len(version) == 0 {
return errors.NewNotAPointerError(errors.New("Missing version"))
return errors.NewNotAPointerError(errors.New(tr.Tr.Get("Missing version")))
}
for _, v := range v1Aliases {
@ -159,7 +160,7 @@ func verifyVersion(version string) error {
}
}
return errors.New("Invalid version: " + version)
return errors.New(tr.Tr.Get("Invalid version: %s", version))
}
func decodeKV(data []byte) (*Pointer, error) {
@ -177,7 +178,7 @@ func decodeKV(data []byte) (*Pointer, error) {
value, ok := kvps["oid"]
if !ok {
return nil, errors.New("Invalid Oid")
return nil, errors.New(tr.Tr.Get("Invalid OID"))
}
oid, err := parseOid(value)
@ -188,7 +189,7 @@ func decodeKV(data []byte) (*Pointer, error) {
value, ok = kvps["size"]
size, err := strconv.ParseInt(value, 10, 64)
if err != nil || size < 0 {
return nil, fmt.Errorf("invalid size: %q", value)
return nil, errors.New(tr.Tr.Get("invalid size: %q", value))
}
var extensions []*PointerExtension
@ -212,14 +213,14 @@ func decodeKV(data []byte) (*Pointer, error) {
func parseOid(value string) (string, error) {
parts := strings.SplitN(value, ":", 2)
if len(parts) != 2 {
return "", errors.New("Invalid Oid value: " + value)
return "", errors.New(tr.Tr.Get("Invalid OID value: %s", value))
}
if parts[0] != oidType {
return "", errors.New("Invalid Oid type: " + parts[0])
return "", errors.New(tr.Tr.Get("Invalid OID type: %s", parts[0]))
}
oid := parts[1]
if !oidRE.Match([]byte(oid)) {
return "", errors.New("Invalid Oid: " + oid)
return "", errors.New(tr.Tr.Get("Invalid OID: %s", oid))
}
return oid, nil
}
@ -227,12 +228,12 @@ func parseOid(value string) (string, error) {
func parsePointerExtension(key string, value string) (*PointerExtension, error) {
keyParts := strings.SplitN(key, "-", 3)
if len(keyParts) != 3 || keyParts[0] != "ext" {
return nil, errors.New("Invalid extension value: " + value)
return nil, errors.New(tr.Tr.Get("Invalid extension value: %s", value))
}
p, err := strconv.Atoi(keyParts[1])
if err != nil || p < 0 {
return nil, errors.New("Invalid priority: " + keyParts[1])
return nil, errors.New(tr.Tr.Get("Invalid priority: %s", keyParts[1]))
}
name := keyParts[2]
@ -249,7 +250,7 @@ func validatePointerExtensions(exts []*PointerExtension) error {
m := make(map[int]struct{})
for _, ext := range exts {
if _, exist := m[ext.Priority]; exist {
return fmt.Errorf("duplicate priority found: %d", ext.Priority)
return errors.New(tr.Tr.Get("duplicate priority found: %d", ext.Priority))
}
m[ext.Priority] = struct{}{}
}
@ -260,7 +261,7 @@ func decodeKVData(data []byte) (kvps map[string]string, exts map[string]string,
kvps = make(map[string]string)
if !matcherRE.Match(data) {
err = errors.NewNotAPointerError(errors.New("invalid header"))
err = errors.NewNotAPointerError(errors.New(tr.Tr.Get("invalid header")))
return
}
@ -275,7 +276,7 @@ func decodeKVData(data []byte) (kvps map[string]string, exts map[string]string,
parts := strings.SplitN(text, " ", 2)
if len(parts) < 2 {
err = errors.NewNotAPointerError(fmt.Errorf("error reading line %d: %s", line, text))
err = errors.NewNotAPointerError(errors.New(tr.Tr.Get("error reading line %d: %s", line, text)))
return
}
@ -283,7 +284,7 @@ func decodeKVData(data []byte) (kvps map[string]string, exts map[string]string,
value := parts[1]
if numKeys <= line {
err = errors.NewNotAPointerError(fmt.Errorf("extra line: %s", text))
err = errors.NewNotAPointerError(errors.New(tr.Tr.Get("extra line: %s", text)))
return
}

4
lfs/util.go
View File

@ -9,7 +9,9 @@ import (
"strings"
"github.com/git-lfs/git-lfs/v3/config"
"github.com/git-lfs/git-lfs/v3/errors"
"github.com/git-lfs/git-lfs/v3/tools"
"github.com/git-lfs/git-lfs/v3/tr"
)
type Platform int
@ -209,7 +211,7 @@ func (p *currentToRepoPatternConverter) Convert(filename string) string {
func pathConverterArgs(cfg *config.Configuration) (string, string, bool, error) {
currDir, err := os.Getwd()
if err != nil {
return "", "", false, fmt.Errorf("unable to get working dir: %v", err)
return "", "", false, errors.New(tr.Tr.Get("unable to get working dir: %v", err))
}
currDir = tools.ResolveSymlinks(currDir)
return cfg.LocalWorkingDir(), currDir, cfg.LocalWorkingDir() == currDir, nil