temp for tree extraction
This commit is contained in:
286
internal/git/rerere.go
Normal file
286
internal/git/rerere.go
Normal file
@ -0,0 +1,286 @@
|
||||
package git
|
||||
|
||||
import (
|
||||
"crypto/sha1"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
gogit "github.com/go-git/go-git/v5"
|
||||
)
|
||||
|
||||
// RerereManager manages git rerere (reuse recorded resolution) functionality
|
||||
type RerereManager struct {
|
||||
repo *gogit.Repository
|
||||
cachePath string
|
||||
enabled bool
|
||||
repoPath string
|
||||
conflictResolver *ConflictResolver
|
||||
}
|
||||
|
||||
// NewRerereManager creates a new RerereManager instance
|
||||
func NewRerereManager(repo *gogit.Repository, onyxPath, repoPath string) *RerereManager {
|
||||
cachePath := filepath.Join(onyxPath, "rerere_cache")
|
||||
|
||||
return &RerereManager{
|
||||
repo: repo,
|
||||
cachePath: cachePath,
|
||||
enabled: true,
|
||||
repoPath: repoPath,
|
||||
conflictResolver: NewConflictResolver(repo, repoPath),
|
||||
}
|
||||
}
|
||||
|
||||
// Enable enables rerere functionality
|
||||
func (rm *RerereManager) Enable() {
|
||||
rm.enabled = true
|
||||
}
|
||||
|
||||
// Disable disables rerere functionality
|
||||
func (rm *RerereManager) Disable() {
|
||||
rm.enabled = false
|
||||
}
|
||||
|
||||
// IsEnabled returns whether rerere is enabled
|
||||
func (rm *RerereManager) IsEnabled() bool {
|
||||
return rm.enabled
|
||||
}
|
||||
|
||||
// RecordConflicts records current conflicts for future resolution
|
||||
func (rm *RerereManager) RecordConflicts() error {
|
||||
if !rm.enabled {
|
||||
return nil
|
||||
}
|
||||
|
||||
conflicts, err := rm.conflictResolver.DetectConflicts()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to detect conflicts: %w", err)
|
||||
}
|
||||
|
||||
if len(conflicts) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
// For each conflict, create a cache entry
|
||||
for _, conflict := range conflicts {
|
||||
if err := rm.recordConflict(conflict); err != nil {
|
||||
// Log error but continue with other conflicts
|
||||
fmt.Fprintf(os.Stderr, "Warning: failed to record conflict for %s: %v\n", conflict.FilePath, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// recordConflict records a single conflict
|
||||
func (rm *RerereManager) recordConflict(conflict ConflictInfo) error {
|
||||
// Read the conflicted file
|
||||
fullPath := filepath.Join(rm.repoPath, conflict.FilePath)
|
||||
content, err := os.ReadFile(fullPath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read conflicted file: %w", err)
|
||||
}
|
||||
|
||||
// Generate a unique ID for this conflict pattern
|
||||
conflictID := rm.generateConflictID(content)
|
||||
|
||||
// Create cache directory for this conflict
|
||||
conflictDir := filepath.Join(rm.cachePath, conflictID)
|
||||
if err := os.MkdirAll(conflictDir, 0755); err != nil {
|
||||
return fmt.Errorf("failed to create conflict cache directory: %w", err)
|
||||
}
|
||||
|
||||
// Save the preimage (conflict state)
|
||||
preimagePath := filepath.Join(conflictDir, "preimage")
|
||||
if err := os.WriteFile(preimagePath, content, 0644); err != nil {
|
||||
return fmt.Errorf("failed to write preimage: %w", err)
|
||||
}
|
||||
|
||||
// Save metadata
|
||||
metadataPath := filepath.Join(conflictDir, "metadata")
|
||||
metadata := fmt.Sprintf("file=%s\nbase=%s\nours=%s\ntheirs=%s\n",
|
||||
conflict.FilePath, conflict.BaseHash, conflict.OursHash, conflict.TheirsHash)
|
||||
if err := os.WriteFile(metadataPath, []byte(metadata), 0644); err != nil {
|
||||
return fmt.Errorf("failed to write metadata: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RecordResolution records the resolution for previously recorded conflicts
|
||||
func (rm *RerereManager) RecordResolution() error {
|
||||
if !rm.enabled {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Find all recorded conflicts
|
||||
entries, err := os.ReadDir(rm.cachePath)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("failed to read rerere cache: %w", err)
|
||||
}
|
||||
|
||||
for _, entry := range entries {
|
||||
if !entry.IsDir() {
|
||||
continue
|
||||
}
|
||||
|
||||
conflictID := entry.Name()
|
||||
if err := rm.recordResolutionForConflict(conflictID); err != nil {
|
||||
// Log error but continue
|
||||
fmt.Fprintf(os.Stderr, "Warning: failed to record resolution for %s: %v\n", conflictID, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// recordResolutionForConflict records the resolution for a specific conflict
|
||||
func (rm *RerereManager) recordResolutionForConflict(conflictID string) error {
|
||||
conflictDir := filepath.Join(rm.cachePath, conflictID)
|
||||
|
||||
// Read metadata to get file path
|
||||
metadataPath := filepath.Join(conflictDir, "metadata")
|
||||
metadataContent, err := os.ReadFile(metadataPath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read metadata: %w", err)
|
||||
}
|
||||
|
||||
// Parse file path from metadata
|
||||
filePath := ""
|
||||
for _, line := range strings.Split(string(metadataContent), "\n") {
|
||||
if strings.HasPrefix(line, "file=") {
|
||||
filePath = strings.TrimPrefix(line, "file=")
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if filePath == "" {
|
||||
return fmt.Errorf("file path not found in metadata")
|
||||
}
|
||||
|
||||
// Check if file still has conflicts
|
||||
fullPath := filepath.Join(rm.repoPath, filePath)
|
||||
if _, err := os.Stat(fullPath); os.IsNotExist(err) {
|
||||
// File was deleted or doesn't exist, skip
|
||||
return nil
|
||||
}
|
||||
|
||||
hasConflicts, err := rm.conflictResolver.IsFileConflicted(filePath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to check if file is conflicted: %w", err)
|
||||
}
|
||||
|
||||
if hasConflicts {
|
||||
// Still has conflicts, not resolved yet
|
||||
return nil
|
||||
}
|
||||
|
||||
// Read the resolved content
|
||||
resolvedContent, err := os.ReadFile(fullPath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read resolved file: %w", err)
|
||||
}
|
||||
|
||||
// Save the postimage (resolved state)
|
||||
postimagePath := filepath.Join(conflictDir, "postimage")
|
||||
if err := os.WriteFile(postimagePath, resolvedContent, 0644); err != nil {
|
||||
return fmt.Errorf("failed to write postimage: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// ApplyResolutions applies previously recorded resolutions to current conflicts
|
||||
func (rm *RerereManager) ApplyResolutions() (int, error) {
|
||||
if !rm.enabled {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
conflicts, err := rm.conflictResolver.DetectConflicts()
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("failed to detect conflicts: %w", err)
|
||||
}
|
||||
|
||||
appliedCount := 0
|
||||
|
||||
for _, conflict := range conflicts {
|
||||
// Read the conflicted file
|
||||
fullPath := filepath.Join(rm.repoPath, conflict.FilePath)
|
||||
content, err := os.ReadFile(fullPath)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
// Generate conflict ID
|
||||
conflictID := rm.generateConflictID(content)
|
||||
|
||||
// Check if we have a resolution for this conflict
|
||||
postimagePath := filepath.Join(rm.cachePath, conflictID, "postimage")
|
||||
if _, err := os.Stat(postimagePath); os.IsNotExist(err) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Apply the resolution
|
||||
resolvedContent, err := os.ReadFile(postimagePath)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
if err := os.WriteFile(fullPath, resolvedContent, 0644); err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
appliedCount++
|
||||
}
|
||||
|
||||
return appliedCount, nil
|
||||
}
|
||||
|
||||
// generateConflictID generates a unique ID for a conflict pattern
|
||||
func (rm *RerereManager) generateConflictID(content []byte) string {
|
||||
// Normalize conflict content by removing variable parts
|
||||
normalized := rm.normalizeConflict(content)
|
||||
|
||||
// Generate SHA1 hash
|
||||
hash := sha1.New()
|
||||
io.WriteString(hash, normalized)
|
||||
return hex.EncodeToString(hash.Sum(nil))
|
||||
}
|
||||
|
||||
// normalizeConflict normalizes conflict content for matching
|
||||
func (rm *RerereManager) normalizeConflict(content []byte) string {
|
||||
// Convert to string
|
||||
str := string(content)
|
||||
|
||||
// Remove commit hashes from conflict markers (they vary)
|
||||
lines := strings.Split(str, "\n")
|
||||
var normalized []string
|
||||
|
||||
for _, line := range lines {
|
||||
if strings.HasPrefix(line, "<<<<<<<") {
|
||||
normalized = append(normalized, "<<<<<<<")
|
||||
} else if strings.HasPrefix(line, ">>>>>>>") {
|
||||
normalized = append(normalized, ">>>>>>>")
|
||||
} else {
|
||||
normalized = append(normalized, line)
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(normalized, "\n")
|
||||
}
|
||||
|
||||
// ClearCache clears the rerere cache
|
||||
func (rm *RerereManager) ClearCache() error {
|
||||
return os.RemoveAll(rm.cachePath)
|
||||
}
|
||||
|
||||
// GetCachePath returns the path to the rerere cache
|
||||
func (rm *RerereManager) GetCachePath() string {
|
||||
return rm.cachePath
|
||||
}
|
||||
Reference in New Issue
Block a user