spell tidy

Author: fcharlie

cmd/zeta-serve/global.go

@@ -34,6 +34,6 @@ func (v VersionFlag) BeforeApply(app *kong.Kong, vars kong.Vars) error {
 	return nil
 }
 
-type Debuger interface {
+type Debugger interface {
 	DbgPrint(format string, args ...any)
 }

docs/sparse-checkout.md

@@ -50,6 +50,6 @@ func NewSparseTreeMatcher(dirs []string) Matcher {
 
 对于稀疏检出，我们的策略是将路径转为 noder.Matcher，然后从 root tree 开始匹配，对于非 tree 对象则检出，tree 对象如果未匹配上，则跳过，匹配到则使用其子 Matcher，如果子 Matcher 为 nil 或长度为 0，则直接跳过匹配，认为所有的子条目均能匹配上，这样一样就建立了稀疏树。
 
-我们对 TreeNode/Index Node/Filesyem Node 均采用相同的机制过滤，就能够实现稀疏树之外的目录不可见，状态不会跟踪。但存在一个问题，HugeSCM 借鉴了 Git，使用 index 机制创建提交，代码基本源自 go-git，而 go-git 的实现不太完美，不够好，无法支持全功能的稀疏检出，实现也有诸多错误，我们的改造量也比较大，因此，在 HugeSCM 中，我们引入了不可变对象的概念，将稀疏树的排除目录作为不可变条目，在写入 tree 时合并这些条目。就可以达到相应的目的。
+我们对 TreeNode/Index Node/Filesystem Node 均采用相同的机制过滤，就能够实现稀疏树之外的目录不可见，状态不会跟踪。但存在一个问题，HugeSCM 借鉴了 Git，使用 index 机制创建提交，代码基本源自 go-git，而 go-git 的实现不太完美，不够好，无法支持全功能的稀疏检出，实现也有诸多错误，我们的改造量也比较大，因此，在 HugeSCM 中，我们引入了不可变对象的概念，将稀疏树的排除目录作为不可变条目，在写入 tree 时合并这些条目。就可以达到相应的目的。
 
 在 Windows/macOS 的系统上，由于其文件系统忽略路径大小写，如果存储库中有忽略大小写后同名的文件/目录，则可能会导致工作区异常，在 git 中，这个问题一直存在，也基本无法得到解决，而 HugeSCM 利用稀疏检出的机制，将冲突的路径视为不可变，不可见对象，在 Windows/macOS 上对其保持不检出，不能被修改的原则，避免了同名文件的数据丢失。

modules/diferenco/color/color.go

@@ -42,7 +42,7 @@ const (
 	BgBlue       = "\033[44m"
 	BgMagenta    = "\033[45m"
 	BgCyan       = "\033[46m"
-	BgWhilte     = "\033[47m"
+	BgWhite      = "\033[47m"
 	BgDefault    = "\033[49m"
 	Faint        = "\033[2m"
 	FaintItalic  = "\033[2;3m"

modules/diferenco/diferenco.go

@@ -71,7 +71,7 @@ func AlgorithmFromName(s string) (Algorithm, error) {
 	if a, ok := algorithmValueMap[strings.ToLower(s)]; ok {
 		return a, nil
 	}
-	return Unspecified, fmt.Errorf("unsupport algoritm '%s' %w", s, ErrUnsupportedAlgorithm)
+	return Unspecified, fmt.Errorf("unsupported algorithm '%s' %w", s, ErrUnsupportedAlgorithm)
 }
 
 // commonPrefixLength returns the length of the common prefix of two T slices.

modules/diferenco/histogram.go

@@ -9,21 +9,21 @@ import "context"
 const MaxChainLen = 63
 
 type histogram[E comparable] struct {
-	tokenOccurances map[E][]int
+	tokenOccurrences map[E][]int
 }
 
 func (h *histogram[E]) populate(a []E) {
 	for i, e := range a {
-		if p, ok := h.tokenOccurances[e]; ok {
-			h.tokenOccurances[e] = append(p, i)
+		if p, ok := h.tokenOccurrences[e]; ok {
+			h.tokenOccurrences[e] = append(p, i)
 			continue
 		}
-		h.tokenOccurances[e] = []int{i}
+		h.tokenOccurrences[e] = []int{i}
 	}
 }
 
-func (h *histogram[E]) numTokenOccurances(e E) int {
-	if p, ok := h.tokenOccurances[e]; ok {
+func (h *histogram[E]) numTokenOccurrences(e E) int {
+	if p, ok := h.tokenOccurrences[e]; ok {
 		return len(p)
 	}
 	return 0
@@ -32,7 +32,7 @@ func (h *histogram[E]) numTokenOccurances(e E) int {
 func (h *histogram[E]) clear() {
 	// runtime: clear() is slow for maps with big capacity and small number of items
 	// https://github.com/golang/go/issues/70617
-	h.tokenOccurances = make(map[E][]int)
+	h.tokenOccurrences = make(map[E][]int)
 }
 
 type Lcs struct {
@@ -51,7 +51,7 @@ func (s *LcsSearch[E]) run(before, after []E, h *histogram[E]) {
 	pos := 0
 	for pos < len(after) {
 		e := after[pos]
-		if num := h.numTokenOccurances(e); num != 0 {
+		if num := h.numTokenOccurrences(e); num != 0 {
 			s.foundCS = true
 			if num <= s.minOccurrences {
 				pos = s.updateLcs(before, after, pos, e, h)
@@ -65,12 +65,12 @@ func (s *LcsSearch[E]) run(before, after []E, h *histogram[E]) {
 
 func (s *LcsSearch[E]) updateLcs(before, after []E, afterPos int, token E, h *histogram[E]) int {
 	nextTokenIndex2 := afterPos + 1
-	tokenOccurances := h.tokenOccurances[token]
-	tokenIndex1 := tokenOccurances[0]
+	tokenOccurrences := h.tokenOccurrences[token]
+	tokenIndex1 := tokenOccurrences[0]
 	pos := 1
-occurancesIter:
+occurrencesIter:
 	for {
-		occurances := h.numTokenOccurances(token)
+		occurrences := h.numTokenOccurrences(token)
 		s1, s2 := tokenIndex1, afterPos
 		for {
 			if s1 == 0 || s2 == 0 {
@@ -82,8 +82,8 @@ occurancesIter:
 			}
 			s1--
 			s2--
-			newOcurances := h.numTokenOccurances(t1)
-			occurances = min(newOcurances, occurances)
+			newOccurrences := h.numTokenOccurrences(t1)
+			occurrences = min(newOccurrences, occurrences)
 		}
 		e1, e2 := tokenIndex1+1, afterPos+1
 		for {
@@ -94,28 +94,28 @@ occurancesIter:
 			if t1 != t2 {
 				break
 			}
-			newOccuraces := h.numTokenOccurances(t1)
-			occurances = min(occurances, newOccuraces)
+			newOccurrences := h.numTokenOccurrences(t1)
+			occurrences = min(occurrences, newOccurrences)
 			e1++
 			e2++
 		}
 		if nextTokenIndex2 < e2 {
 			nextTokenIndex2 = e2
 		}
 		length := e2 - s2
-		if s.lcs.length < length || s.minOccurrences > occurances {
-			s.minOccurrences = occurances
+		if s.lcs.length < length || s.minOccurrences > occurrences {
+			s.minOccurrences = occurrences
 			s.lcs = Lcs{
 				beforeStart: s1,
 				afterStart:  s2,
 				length:      length,
 			}
 		}
 		for {
-			if pos >= len(tokenOccurances) {
-				break occurancesIter
+			if pos >= len(tokenOccurrences) {
+				break occurrencesIter
 			}
-			nextTokenIndex := tokenOccurances[pos]
+			nextTokenIndex := tokenOccurrences[pos]
 			pos++
 			if nextTokenIndex > e2 {
 				tokenIndex1 = nextTokenIndex
@@ -145,42 +145,42 @@ type changesOut struct {
 	changes []Change
 }
 
-func (h *histogram[E]) run(ctx context.Context, beforce []E, beforePos int, after []E, afterPos int, o *changesOut) error {
+func (h *histogram[E]) run(ctx context.Context, before []E, beforePos int, after []E, afterPos int, o *changesOut) error {
 	for {
 		select {
 		case <-ctx.Done():
 			return ctx.Err()
 		default:
 		}
-		if len(beforce) == 0 {
+		if len(before) == 0 {
 			if len(after) != 0 {
 				o.changes = append(o.changes, Change{P1: beforePos, P2: afterPos, Ins: len(after)})
 			}
 			return nil
 		}
 		if len(after) == 0 {
-			o.changes = append(o.changes, Change{P1: beforePos, P2: afterPos, Del: len(beforce)})
+			o.changes = append(o.changes, Change{P1: beforePos, P2: afterPos, Del: len(before)})
 			return nil
 		}
-		h.populate(beforce)
-		lcs := findLcs(beforce, after, h)
+		h.populate(before)
+		lcs := findLcs(before, after, h)
 		if lcs == nil {
-			changes, err := onpCompute(ctx, beforce, beforePos, after, afterPos)
+			changes, err := onpCompute(ctx, before, beforePos, after, afterPos)
 			if err != nil {
 				return err
 			}
 			o.changes = append(o.changes, changes...)
 			return nil
 		}
 		if lcs.length == 0 {
-			o.changes = append(o.changes, Change{P1: beforePos, P2: afterPos, Del: len(beforce), Ins: len(after)})
+			o.changes = append(o.changes, Change{P1: beforePos, P2: afterPos, Del: len(before), Ins: len(after)})
 			return nil
 		}
-		if err := h.run(ctx, beforce[:lcs.beforeStart], beforePos, after[:lcs.afterStart], afterPos, o); err != nil {
+		if err := h.run(ctx, before[:lcs.beforeStart], beforePos, after[:lcs.afterStart], afterPos, o); err != nil {
 			return err
 		}
 		e1 := lcs.beforeStart + lcs.length
-		beforce = beforce[e1:]
+		before = before[e1:]
 		beforePos += e1
 		e2 := lcs.afterStart + lcs.length
 		after = after[e2:]
@@ -197,7 +197,7 @@ func HistogramDiff[E comparable](ctx context.Context, L1, L2 []E) ([]Change, err
 	L1 = L1[:len(L1)-suffix]
 	L2 = L2[:len(L2)-suffix]
 	h := &histogram[E]{
-		tokenOccurances: make(map[E][]int, len(L1)),
+		tokenOccurrences: make(map[E][]int, len(L1)),
 	}
 	o := &changesOut{changes: make([]Change, 0, 100)}
 	if err := h.run(ctx, L1, prefix, L2, prefix, o); err != nil {

modules/diferenco/merge.go

@@ -236,7 +236,7 @@ func Diff3Merge[E comparable](ctx context.Context, o, a, b []E, algo Algorithm,
 		return false
 	}
 
-	for i := 0; i < len(indices); i++ {
+	for i := range indices {
 		var x = indices[i]
 		var side = x[0]
 		if side == -1 {

modules/env/env.go

@@ -28,7 +28,7 @@ var allowedEnv = []string{
 	// Environment variables to tell git to use custom SSH executable or command
 	"GIT_SSH",
 	"GIT_SSH_COMMAND",
-	// Environment variables neesmd for ssh-agent based authentication
+	// Environment variables need for ssh-agent based authentication
 	"SSH_AUTH_SOCK",
 	"SSH_AGENT_PID",
 

modules/oss/list.go

@@ -24,7 +24,7 @@ type ListObjectsResult struct {
 	CommonPrefixes []string           `xml:"CommonPrefixes>Prefix"` // You can think of commonprefixes as "folders" whose names end with the delimiter
 }
 
-// ObjectProperties defines Objecct properties
+// ObjectProperties defines Object properties
 type ObjectProperties struct {
 	XMLName      xml.Name  `xml:"Contents"`
 	Key          string    `xml:"Key"`                   // Object key

modules/term/fmt_test.go

@@ -31,7 +31,7 @@ func TestSanitized(t *testing.T) {
 
 func TestTable(t *testing.T) {
 	table := make([]int, 0, 256)
-	for i := 0; i < 256; i++ {
+	for i := range 256 {
 		// iscntrl: i < 0x20 || i == 0x7f
 		if i < 0x20 || i == 0x7f {
 			table = append(table, CHAR_CONTROL)

modules/trace/trace.go

@@ -9,15 +9,15 @@ import (
 	"github.com/antgroup/hugescm/modules/term"
 )
 
-type Debuger interface {
+type Debugger interface {
 	DbgPrint(format string, args ...any)
 }
 
-func NewDebuger(verbose bool) Debuger {
-	return &debuger{verbose: verbose}
+func NewDebugger(verbose bool) Debugger {
+	return &debugger{verbose: verbose}
 }
 
-type debuger struct {
+type debugger struct {
 	verbose bool
 }
 
@@ -46,13 +46,13 @@ func DbgPrint(format string, args ...any) {
 	_, _ = os.Stderr.Write(buffer.Bytes())
 }
 
-func (d debuger) DbgPrint(format string, args ...any) {
+func (d debugger) DbgPrint(format string, args ...any) {
 	if !d.verbose {
 		return
 	}
 	DbgPrint(format, args...)
 }
 
 var (
-	_ Debuger = &debuger{}
+	_ Debugger = &debugger{}
 )