feat: add warning messages for empty files

- Add warning output to stderr when empty files are detected
- Implement path display mode support in FileCounter
- Add getDisplayPath method for flexible path formatting
- Include comprehensive tests for empty file handling
- Warning messages use appropriate path format based on display mode

Empty files now show: 'Warning: Empty file detected: <path>'

Author: 100gle

file.go

@@ -1,16 +1,20 @@
 package wordcounter
 
 import (
+	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 )
 
 // FileCounter provides character counting functionality for individual files.
 // It implements the Counter interface and combines file I/O operations
 // with text analysis capabilities.
 type FileCounter struct {
-	tc       *Counter // Internal text counter for character analysis (private)
-	FileName string   // Absolute path to the file being analyzed
+	tc              *Counter // Internal text counter for character analysis (private)
+	FileName        string   // Absolute path to the file being analyzed
+	originalPath    string   // Original path as provided by user
+	pathDisplayMode string   // Path display mode: absolute or relative
 }
 
 // NewFileCounter creates a new FileCounter instance for the specified file.
@@ -23,12 +27,19 @@ type FileCounter struct {
 //
 // Returns a configured FileCounter ready for counting operations.
 func NewFileCounter(filename string) *FileCounter {
+	return NewFileCounterWithPathMode(filename, PathDisplayAbsolute)
+}
+
+// NewFileCounterWithPathMode creates a new FileCounter with specified path display mode.
+func NewFileCounterWithPathMode(filename string, pathDisplayMode string) *FileCounter {
 	tc := NewCounter()
 	absPath := ToAbsolutePath(filename)
 
 	fc := &FileCounter{
-		FileName: absPath,
-		tc:       tc,
+		FileName:        absPath,
+		originalPath:    filename,
+		pathDisplayMode: pathDisplayMode,
+		tc:              tc,
 	}
 
 	return fc
@@ -62,6 +73,12 @@ func (fc *FileCounter) Count() error {
 		return NewFileReadError(fc.FileName, err)
 	}
 
+	// Check for empty file and issue warning
+	if len(data) == 0 {
+		displayPath := fc.getDisplayPath()
+		fmt.Fprintf(os.Stderr, "Warning: Empty file detected: %s\n", displayPath)
+	}
+
 	if err := fc.tc.CountBytes(data); err != nil {
 		return NewFileReadError(fc.FileName, err)
 	}
@@ -77,10 +94,23 @@ func (fc *FileCounter) GetStats() *Stats {
 }
 
 func (fc *FileCounter) GetRow() Row {
-	row := append(Row{fc.FileName}, fc.tc.S.ToRow()...)
+	displayPath := fc.getDisplayPath()
+	row := append(Row{displayPath}, fc.tc.S.ToRow()...)
 	return row
 }
 
+// getDisplayPath returns the path to display based on the path display mode
+func (fc *FileCounter) getDisplayPath() string {
+	if fc.pathDisplayMode == PathDisplayRelative {
+		if fc.originalPath != "" {
+			return fc.originalPath
+		}
+		// Fallback to basename if original path is not available
+		return filepath.Base(fc.FileName)
+	}
+	return fc.FileName
+}
+
 func (fc *FileCounter) GetHeader() Row {
 	headers := append(Row{"File"}, fc.tc.S.Header()...)
 	return headers

file_test.go

@@ -81,6 +81,19 @@ func TestFileCounter_Count(t *testing.T) {
 		t.Error("FileCounter.Count() failed, expected error for non-existent file")
 	}
 
+	// Test counting the words in an empty file
+	emptyFilename := "testdata/empty.md"
+	fc = wcg.NewFileCounter(emptyFilename)
+	err = fc.Count()
+	if err != nil {
+		t.Errorf("FileCounter.Count() failed for empty file, unexpected error: %v", err)
+	}
+	expectedEmptyRow := wcg.Row{filepath.Join(wd, emptyFilename), 0, 0, 0, 0}
+	emptyRow := fc.GetRow()
+	if !reflect.DeepEqual(emptyRow, expectedEmptyRow) {
+		t.Errorf("FileCounter.GetRow() failed for empty file, expected row: %v, got: %v", expectedEmptyRow, emptyRow)
+	}
+
 	// Test counting the words in a file that should be ignored based on the ignore patterns
 	fc = wcg.NewFileCounter(filename)
 	err = fc.Count()
@@ -247,3 +260,53 @@ func TestFileCounter_GetStats(t *testing.T) {
 		t.Errorf("FileCounter.GetStats() returned incorrect stats: %+v", stats)
 	}
 }
+
+func TestFileCounter_EmptyFileHandling(t *testing.T) {
+	// Create a temporary empty file for testing
+	tempFile, err := os.CreateTemp("", "empty_test_*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+	defer os.Remove(tempFile.Name())
+	tempFile.Close()
+
+	// Test that empty file doesn't cause errors
+	fc := wcg.NewFileCounter(tempFile.Name())
+	err = fc.Count()
+	if err != nil {
+		t.Errorf("FileCounter.Count() failed for empty file: %v", err)
+	}
+
+	// Verify statistics are all zero
+	stats := fc.GetStats()
+	if stats.Lines != 0 || stats.ChineseChars != 0 || stats.NonChineseChars != 0 || stats.TotalChars != 0 {
+		t.Errorf("Empty file should have zero statistics, got: Lines=%d, ChineseChars=%d, NonChineseChars=%d, TotalChars=%d",
+			stats.Lines, stats.ChineseChars, stats.NonChineseChars, stats.TotalChars)
+	}
+
+	// Test row output
+	row := fc.GetRow()
+	expectedRow := wcg.Row{tempFile.Name(), 0, 0, 0, 0}
+	if !reflect.DeepEqual(row, expectedRow) {
+		t.Errorf("Empty file row output incorrect, expected: %v, got: %v", expectedRow, row)
+	}
+}
+
+func TestFileCounter_PathDisplayMode(t *testing.T) {
+	filename := "testdata/test.md"
+
+	// Test absolute path mode (default)
+	fc := wcg.NewFileCounter(filename)
+	row := fc.GetRow()
+	expectedAbsPath := filepath.Join(wd, filename)
+	if row[0] != expectedAbsPath {
+		t.Errorf("Absolute path mode failed, expected: %s, got: %s", expectedAbsPath, row[0])
+	}
+
+	// Test relative path mode
+	fc = wcg.NewFileCounterWithPathMode(filename, wcg.PathDisplayRelative)
+	row = fc.GetRow()
+	if row[0] != filename {
+		t.Errorf("Relative path mode failed, expected: %s, got: %s", filename, row[0])
+	}
+}