Merge branch 'main' of github.com:autobrr/mkbrr

Author: s0up4200

README.md

@@ -96,23 +96,21 @@ version: 1
 jobs:
   - output: ubuntu.torrent
     path: /path/to/ubuntu.iso
-    name: "Ubuntu 22.04 LTS"
     trackers:
-      - udp://tracker.opentrackr.org:1337/announce
+      - https://tracker.openbittorrent.com/announce
     webseeds:
       - https://releases.ubuntu.com/22.04/ubuntu-22.04.3-desktop-amd64.iso
-    piece_length: 20  # 1MB pieces (2^20)
     comment: "Ubuntu 22.04.3 LTS Desktop AMD64"
     private: false
 
   - output: release.torrent
     path: /path/to/release
-    name: "My Release"
     trackers:
-      - udp://tracker.example.com:1337/announce
-    piece_length: 18  # 256KB pieces (2^18)
+      - https://tracker.openbittorrent.com/announce
     private: true
     source: "GROUP"
+    comment: "My awesome release"
+    no_date: false
 ```
 
 Batch mode will process all jobs in parallel (up to 4 concurrent jobs) and provide a summary of results.

cmd/create.go

@@ -71,7 +71,6 @@ func init() {
 	}
 
 	createCmd.Flags().StringVarP(&outputPath, "output", "o", "", "set output path (default: <n>.torrent)")
-	createCmd.Flags().StringVarP(&torrentName, "name", "n", "", "set torrent name (default: basename of target)")
 	createCmd.Flags().StringVarP(&source, "source", "s", "", "add source string")
 	createCmd.Flags().BoolVarP(&noDate, "no-date", "d", false, "don't write creation date")
 	createCmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "be verbose")
@@ -95,7 +94,7 @@ func runCreate(cmd *cobra.Command, args []string) error {
 
 	start := time.Now()
 
-	// Batch mode
+	// batch mode
 	if batchFile != "" {
 		results, err := torrent.ProcessBatch(batchFile, verbose, version)
 		if err != nil {
@@ -107,7 +106,7 @@ func runCreate(cmd *cobra.Command, args []string) error {
 		return nil
 	}
 
-	// Single file mode
+	// single file mode
 	if _, err := os.Stat(args[0]); err != nil {
 		return fmt.Errorf("invalid path %q: %w", args[0], err)
 	}

examples/batch.yaml

@@ -2,28 +2,21 @@
 version: 1
 jobs:
   # Single file torrent
-  - output: ubuntu.torrent
-    path: /path/to/ubuntu.iso
-    name: "Ubuntu 22.04 LTS"
+  - output: random_movie.torrent
+    path: /Users/user/Downloads/Random.Movie.Title.2023.1080p.WEB-DL.mkv
     trackers:
-      - udp://tracker.opentrackr.org:1337/announce
-      - udp://tracker.openbittorrent.com:6969/announce
-    webseeds:
-      - https://releases.ubuntu.com/22.04/ubuntu-22.04.3-desktop-amd64.iso
-    piece_length: 20 # 1MB pieces (2^20)
-    comment: "Ubuntu 22.04.3 LTS Desktop AMD64"
+      - https://tracker.randomtracker.org/announce
+    #piece_length: 20
+    comment: "Random Movie Title - A thrilling adventure"
     private: false
 
   # Directory torrent
-  - output: release.torrent
-    path: /path/to/release
-    name: "My Release"
+  - output: random_release.torrent
+    path: '/Users/user/Downloads/Random Album - Best Hits (2025)'
     trackers:
-      - udp://tracker.example.com:1337/announce
-    webseeds:
-      - https://cdn.example.com/release/
-    piece_length: 18 # 256KB pieces (2^18)
+      - https://tracker.anothertracker.com/announce
+    #piece_length: 18
     private: true
-    source: "GROUP"
-    comment: "My awesome release"
+    source: "MUSIC"
+    comment: "Best Hits Compilation - 2025 Edition"
     no_date: false

internal/torrent/batch.go

@@ -19,7 +19,7 @@ type BatchConfig struct {
 type BatchJob struct {
 	Output      string   `yaml:"output"`
 	Path        string   `yaml:"path"`
-	Name        string   `yaml:"name"`
+	Name        string   `yaml:"-"`
 	Trackers    []string `yaml:"trackers"`
 	WebSeeds    []string `yaml:"webseeds"`
 	Private     bool     `yaml:"private"`
@@ -95,7 +95,7 @@ func ProcessBatch(configPath string, verbose bool, version string) ([]BatchResul
 		return nil, fmt.Errorf("no jobs defined in batch config")
 	}
 
-	// Validate all jobs before processing
+	// validate all jobs before processing
 	for _, job := range config.Jobs {
 		if err := validateJob(job); err != nil {
 			return nil, fmt.Errorf("invalid job configuration: %w", err)
@@ -105,11 +105,11 @@ func ProcessBatch(configPath string, verbose bool, version string) ([]BatchResul
 	results := make([]BatchResult, len(config.Jobs))
 	var wg sync.WaitGroup
 
-	// Process jobs in parallel with a worker pool
-	workers := minInt(len(config.Jobs), 4) // Limit concurrent jobs
+	// process jobs in parallel with a worker pool
+	workers := minInt(len(config.Jobs), 4) // limit concurrent jobs
 	jobs := make(chan int, len(config.Jobs))
 
-	// Start workers
+	// start workers
 	for i := 0; i < workers; i++ {
 		wg.Add(1)
 		go func() {
@@ -120,7 +120,7 @@ func ProcessBatch(configPath string, verbose bool, version string) ([]BatchResul
 		}()
 	}
 
-	// Send jobs to workers
+	// send jobs to workers
 	for i := range config.Jobs {
 		jobs <- i
 	}
@@ -156,23 +156,23 @@ func processJob(job BatchJob, verbose bool, version string) BatchResult {
 		Trackers: job.Trackers,
 	}
 
-	// Ensure output has .torrent extension
+	// ensure output has .torrent extension
 	output := job.Output
 	if filepath.Ext(output) != ".torrent" {
 		output += ".torrent"
 	}
 
-	// Convert job to CreateTorrentOptions
+	// convert job to CreateTorrentOptions
 	opts := job.ToCreateOptions(verbose, version)
 
-	// Create the torrent
+	// create the torrent
 	mi, err := CreateTorrent(opts)
 	if err != nil {
 		result.Error = fmt.Errorf("failed to create torrent: %w", err)
 		return result
 	}
 
-	// Write the torrent file
+	// write the torrent file
 	f, err := os.Create(output)
 	if err != nil {
 		result.Error = fmt.Errorf("failed to create output file: %w", err)
@@ -185,7 +185,7 @@ func processJob(job BatchJob, verbose bool, version string) BatchResult {
 		return result
 	}
 
-	// Collect torrent info
+	// collect torrent info
 	info := mi.GetInfo()
 	result.Success = true
 	result.Info = &TorrentInfo{

internal/torrent/batch_test.go

@@ -8,14 +8,14 @@ import (
 )
 
 func TestProcessBatch(t *testing.T) {
-	// Create a temporary directory for test files
+	// create a temporary directory for test files
 	tmpDir, err := os.MkdirTemp("", "mkbrr-batch-test")
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
 	defer os.RemoveAll(tmpDir)
 
-	// Create test files and directories
+	// create test files and directories
 	testFiles := []struct {
 		path    string
 		content string
@@ -44,7 +44,7 @@ func TestProcessBatch(t *testing.T) {
 		}
 	}
 
-	// Create batch config file
+	// create batch config file
 	configPath := filepath.Join(tmpDir, "batch.yaml")
 	configContent := []byte(fmt.Sprintf(`version: 1
 jobs:
@@ -73,13 +73,13 @@ jobs:
 		t.Fatalf("Failed to write config file: %v", err)
 	}
 
-	// Process batch
+	// process batch
 	results, err := ProcessBatch(configPath, true, "test-version")
 	if err != nil {
 		t.Fatalf("ProcessBatch failed: %v", err)
 	}
 
-	// Verify results
+	// verify results
 	if len(results) != 2 {
 		t.Errorf("Expected 2 results, got %d", len(results))
 	}
@@ -95,12 +95,12 @@ jobs:
 			continue
 		}
 
-		// Verify torrent files were created
+		// verify torrent files were created
 		if _, err := os.Stat(result.Info.Path); err != nil {
 			t.Errorf("Job %d torrent file not created: %v", i, err)
 		}
 
-		// Basic validation of torrent info
+		// basic validation of torrent info
 		if result.Info.InfoHash == "" {
 			t.Errorf("Job %d missing info hash", i)
 		}
@@ -109,7 +109,7 @@ jobs:
 			t.Errorf("Job %d has zero size", i)
 		}
 
-		// Check specific job details
+		// check specific job details
 		switch i {
 		case 0: // file1.txt
 			if result.Info.Files != 0 {

internal/torrent/create.go

@@ -147,14 +147,14 @@ func CreateTorrent(opts CreateTorrentOptions) (*Torrent, error) {
 	}
 
 	if len(files) == 1 {
-		// Check if the input path is a directory
+		// check if the input path is a directory
 		pathInfo, err := os.Stat(path)
 		if err != nil {
 			return nil, fmt.Errorf("error checking path: %w", err)
 		}
 
 		if pathInfo.IsDir() {
-			// If it's a directory, use the folder structure even for single files
+			// if it's a directory, use the folder structure even for single files
 			info.Files = make([]metainfo.FileInfo, 1)
 			relPath, _ := filepath.Rel(baseDir, files[0].path)
 			pathComponents := strings.Split(relPath, string(filepath.Separator))
@@ -163,7 +163,7 @@ func CreateTorrent(opts CreateTorrentOptions) (*Torrent, error) {
 				Length: files[0].length,
 			}
 		} else {
-			// If it's a single file directly, use the simple format
+			// if it's a single file directly, use the simple format
 			info.Length = files[0].length
 		}
 	} else {

internal/torrent/display.go

@@ -144,10 +144,17 @@ func (d *Display) ShowFileTree(info *metainfo.Info) {
 }
 
 func (d *Display) ShowOutputPathWithTime(path string, duration time.Duration) {
-	fmt.Printf("\n%s %s (%s)\n",
-		success("Wrote"),
-		white(path),
-		cyan("took "+d.formatter.FormatDuration(duration)))
+	if duration < time.Second {
+		fmt.Printf("\n%s %s (%s)\n",
+			success("Wrote"),
+			white(path),
+			cyan(fmt.Sprintf("elapsed %dms", duration.Milliseconds())))
+	} else {
+		fmt.Printf("\n%s %s (%s)\n",
+			success("Wrote"),
+			white(path),
+			cyan(fmt.Sprintf("elapsed %.2fs", duration.Seconds())))
+	}
 }
 
 func (d *Display) ShowBatchResults(results []BatchResult, duration time.Duration) {

internal/torrent/hasher.go

@@ -27,7 +27,7 @@ type pieceHasher struct {
 // - single vs multiple files
 // - average file size
 // - system CPU count
-// Returns readSize (buffer size for reading) and numWorkers (concurrent goroutines)
+// returns readSize (buffer size for reading) and numWorkers (concurrent goroutines)
 func (h *pieceHasher) optimizeForWorkload() (int, int) {
 	if len(h.files) == 0 {
 		return 0, 0
@@ -91,7 +91,7 @@ func (h *pieceHasher) hashPieces(numWorkers int) error {
 	h.readSize, numWorkers = h.optimizeForWorkload()
 
 	if numWorkers == 0 {
-		// No workers needed, possibly no pieces to hash
+		// no workers needed, possibly no pieces to hash
 		h.display.ShowProgress(0)
 		h.display.FinishProgress()
 		return nil

internal/torrent/hasher_large_test.go

@@ -51,7 +51,7 @@ func TestPieceHasher_LargeFiles(t *testing.T) {
 			files, expectedHashes := createTestFilesFast(t, tt.numFiles, tt.fileSize, tt.pieceLen)
 			hasher := NewPieceHasher(files, tt.pieceLen, tt.numPieces, &mockDisplay{})
 
-			// Test with different worker counts
+			// test with different worker counts
 			workerCounts := []int{1, 2, 4, 8}
 			for _, workers := range workerCounts {
 				t.Run(fmt.Sprintf("workers_%d", workers), func(t *testing.T) {