Merge pull request #3 from elbachir-one/main

 Made some fixes and added version flag

Author: ashish0kumar

.goreleaser.yaml

@@ -21,6 +21,8 @@ builds:
     goarch:
       - amd64
       - arm64
+    ldflags:
+      - -s -w -X github.com/ashish0kumar/typtea/cmd.version={{.Version}}
 
 archives:
   - id: default
@@ -50,4 +52,4 @@ changelog:
 
 release:
   draft: false
-  prerelease: auto
+  prerelease: auto

cmd/root.go

@@ -7,15 +7,33 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var (
+	version     = "dev" // fallback to dev
+	showVersion bool
+)
+
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
 	Use:   "typtea",
 	Short: "A minimal typing speed test in your terminal",
 	Long: `A terminal-based typing speed test application.
-Supports multiple programming languages like Python, JavaScript, Go, and more.`,
+	Supports multiple programming languages like Python, JavaScript, Go, and more.`,
 	Example: `  typtea start --lang python
-  typtea start --duration 30 --lang javascript
-  typtea start --list-langs`,
+	typtea start --duration 30 --lang javascript
+	typtea start --list-langs`,
+	Run: func(cmd *cobra.Command, args []string) {
+		// Show help if no subcommands or flags are provided
+		cmd.Help()
+	},
+}
+
+// versionCmd prints the current version of typtea
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show the version of typtea",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Println("typtea version", version)
+	},
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately
@@ -26,8 +44,22 @@ func Execute() {
 	}
 }
 
-// init function initializes the root command and adds subcommands
+// init function initializes the root command and adds subcommands and flags
 func init() {
 	rootCmd.CompletionOptions.DisableDefaultCmd = true // Disable default completion command
+
+	// Add --version flag with shorthand -v
+	rootCmd.PersistentFlags().BoolVarP(&showVersion, "version", "v", false, "Show the version and exit")
+
+	// Add your subcommands
 	rootCmd.AddCommand(startCmd)
+	rootCmd.AddCommand(versionCmd)
+
+	// Check for version flag early and exit if set
+	cobra.OnInitialize(func() {
+		if showVersion {
+			fmt.Println("typtea version", version)
+			os.Exit(0)
+		}
+	})
 }

cmd/start.go

@@ -2,8 +2,6 @@ package cmd
 
 import (
 	"fmt"
-	"log"
-	"os"
 	"strings"
 
 	"github.com/ashish0kumar/typtea/internal/game"
@@ -31,24 +29,22 @@ var startCmd = &cobra.Command{
 	RunE: runTypingTest,
 }
 
-// init function initializes the start command and its flags
 func init() {
-	startCmd.Flags().IntVarP(&duration, "duration", "d", 30, "Test duration in seconds")
+	startCmd.Flags().IntVarP(&duration, "duration", "d", 30, "Test duration in seconds (10-300)")
 	startCmd.Flags().StringVarP(&language, "lang", "l", "en", "Language for typing test")
 	startCmd.Flags().BoolVar(&listLangs, "list-langs", false, "List all available languages")
 }
 
-// runTypingTest is the main function that runs the typing test
+// runTypingTest runs the typing test or lists languages if requested
 func runTypingTest(cmd *cobra.Command, args []string) error {
-
 	// Initialize the language manager
 	langManager := game.NewLanguageManager()
 
-	// If --list-langs is set, print available languages and exit
+	// If --list-langs flag is set, print available languages and exit
 	if listLangs {
-		fmt.Println("Available languages:")
+		cmd.Println("Available languages:")
 		for _, lang := range langManager.GetAvailableLanguages() {
-			fmt.Printf("  %s\n", lang)
+			cmd.Printf("  %s\n", lang)
 		}
 		return nil
 	}
@@ -58,25 +54,24 @@ func runTypingTest(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("duration must be between 10 and 300 seconds (e.g., --duration 60)")
 	}
 
-	// Validate language
+	// Validate language availability
 	if !langManager.IsLanguageAvailable(language) {
 		available := langManager.GetAvailableLanguages()
-		fmt.Fprintf(os.Stderr, "Error: Language '%s' not available.\n", language)
-		fmt.Fprintf(os.Stderr, "Available languages: %s\n", strings.Join(available, ", "))
+		cmd.PrintErrf("Error: Language '%s' not available.\n", language)
+		cmd.PrintErrf("Available languages: %s\n", strings.Join(available, ", "))
 		return fmt.Errorf("invalid language: %s", language)
 	}
 
 	// Create a new typing test model
 	model, err := tui.NewModel(duration, language)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error creating typing test: %v\n", err)
-		os.Exit(1)
+		return fmt.Errorf("error creating typing test: %w", err)
 	}
 
-	// Start the TUI program
+	// Start the TUI program with alternate screen
 	p := tea.NewProgram(model, tea.WithAltScreen())
 	if _, err := p.Run(); err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("error running TUI program: %w", err)
 	}
 
 	return nil

internal/game/languages.go

@@ -29,15 +29,17 @@ func NewLanguageManager() *LanguageManager {
 	lm := &LanguageManager{
 		loadedLanguages: make(map[string][]string),
 	}
-	lm.scanAvailableLanguages()
+	if err := lm.scanAvailableLanguages(); err != nil {
+		fmt.Printf("Warning: failed to scan available languages: %v\n", err)
+	}
 	return lm
 }
 
 // scanAvailableLanguages scans the embedded filesystem for available language files
-func (lm *LanguageManager) scanAvailableLanguages() {
+func (lm *LanguageManager) scanAvailableLanguages() error {
 	entries, err := fs.ReadDir(embeddedLanguages, "data")
 	if err != nil {
-		return
+		return err
 	}
 
 	for _, entry := range entries {
@@ -46,10 +48,13 @@ func (lm *LanguageManager) scanAvailableLanguages() {
 			lm.availableLanguages = append(lm.availableLanguages, lang)
 		}
 	}
+	return nil
 }
 
 // LoadLanguage loads the specified language from embedded files and caches it
 func (lm *LanguageManager) LoadLanguage(langCode string) ([]string, error) {
+	langCode = strings.ToLower(langCode)
+
 	// Check if already loaded
 	if words, exists := lm.loadedLanguages[langCode]; exists {
 		return words, nil
@@ -78,13 +83,16 @@ func (lm *LanguageManager) LoadLanguage(langCode string) ([]string, error) {
 	return langData.Words, nil
 }
 
-// GetAvailableLanguages returns a list of all available language codes
+// GetAvailableLanguages returns a copy of all available language codes
 func (lm *LanguageManager) GetAvailableLanguages() []string {
-	return lm.availableLanguages
+	cpy := make([]string, len(lm.availableLanguages))
+	copy(cpy, lm.availableLanguages)
+	return cpy
 }
 
 // IsLanguageAvailable checks if a language is available in the manager
 func (lm *LanguageManager) IsLanguageAvailable(langCode string) bool {
+	langCode = strings.ToLower(langCode)
 	for _, lang := range lm.availableLanguages {
 		if lang == langCode {
 			return true

internal/game/typing.go

@@ -44,11 +44,15 @@ func NewTypingGame(duration int) *TypingGame {
 		LinesPerView: 3,
 		CharsPerLine: 50,
 	}
-
 	game.generateDisplayLines()
 	return game
 }
 
+// Reset reinitializes the game to a fresh state
+func (g *TypingGame) Reset() {
+	*g = *NewTypingGame(g.Duration)
+}
+
 // generateDisplayLines creates the initial display lines based on the words available
 func (g *TypingGame) generateDisplayLines() {
 	lines := make([]string, 0, g.LinesPerView)
@@ -109,32 +113,36 @@ func (g *TypingGame) Start() {
 	}
 }
 
-// Reset resets the game state to allow for a new session
+// AddCharacter handles user input and updates game state
 func (g *TypingGame) AddCharacter(char rune) {
 	if !g.IsStarted {
 		g.Start()
 	}
 
 	if g.IsFinished || g.IsTimeUp() {
+		g.IsFinished = true
 		return
 	}
 
 	g.UserInput += string(char)
-	displayText := strings.Join(g.DisplayLines, " ")
+	displayText := []rune(strings.Join(g.DisplayLines, " "))
 
 	// Check if the character is within bounds
 	if g.CurrentPos < len(displayText) && g.CurrentPos >= 0 {
-		if rune(displayText[g.CurrentPos]) != char {
+		if displayText[g.CurrentPos] != char {
 			g.Errors[g.GlobalPos] = true
 			g.TotalErrorsMade++
 		}
 		g.CurrentPos++
 		g.GlobalPos++
 
 		// Check if the first line is completed
-		if g.CurrentPos >= len(g.DisplayLines[0])+1 { // +1 for space
+		if g.CurrentPos >= len([]rune(g.DisplayLines[0])) {
 			g.shiftLines()
 		}
+	} else {
+		// End of available text
+		g.IsFinished = true
 	}
 }
 
@@ -161,6 +169,7 @@ func (g *TypingGame) RemoveCharacter() {
 		g.CurrentPos--
 		g.GlobalPos--
 
+		// Remove error mark if previously added
 		delete(g.Errors, g.GlobalPos)
 	}
 }
@@ -189,19 +198,16 @@ func (g *TypingGame) GetStats() TypingStats {
 	uncorrectedErrors := len(g.Errors)
 
 	// Calculate Net WPM (Gross WPM - uncorrected errors per minute)
-	netWPM := grossWPM
-	if minutes > 0 {
-		errorRate := float64(uncorrectedErrors) / minutes
-		netWPM = grossWPM - errorRate
-	}
+	errorRate := float64(uncorrectedErrors) / minutes
+	netWPM := grossWPM - errorRate
 
 	// Ensure Net WPM doesn't go below 0
 	if netWPM < 0 {
 		netWPM = 0
 	}
 
 	// Calculate accuracy (correct characters / total characters typed * 100)
-	correctChars := g.GlobalPos - g.TotalErrorsMade // You need to add this field
+	correctChars := g.GlobalPos - g.TotalErrorsMade
 	accuracy := 0.0
 	if g.GlobalPos > 0 {
 		accuracy = float64(correctChars) / float64(g.GlobalPos) * 100
@@ -217,7 +223,7 @@ func (g *TypingGame) GetStats() TypingStats {
 		Accuracy:          accuracy,
 		CharactersTyped:   g.GlobalPos,
 		CorrectChars:      correctChars,
-		TotalChars:        len(g.GetDisplayText()),
+		TotalChars:        len([]rune(g.GetDisplayText())),
 		TimeElapsed:       elapsed,
 		IsComplete:        g.IsFinished,
 		UncorrectedErrors: uncorrectedErrors,

internal/game/words.go

@@ -2,6 +2,7 @@ package game
 
 import (
 	"math/rand"
+	"sort"
 	"strings"
 	"time"
 )
@@ -12,9 +13,13 @@ var weights []int
 var cumulativeWeights []int
 var currentLanguageCode string
 
-// init initializes the language manager and sets the default language to en
+// init initializes the language manager and sets the default language to "en"
 func init() {
 	languageManager = NewLanguageManager()
+	err := SetLanguage("en")
+	if err != nil {
+		panic("failed to initialize default language: " + err.Error())
+	}
 }
 
 // SetLanguage sets the current language for the game and loads the corresponding words
@@ -50,7 +55,7 @@ func calculateWeights() {
 		weights[i] = len(currentLanguageWords) - i
 	}
 
-	// Calculate cumulative weights
+	// Calculate cumulative weights for binary search
 	cumulativeWeights = make([]int, len(weights))
 	cumSum := 0
 	for i, w := range weights {
@@ -65,25 +70,18 @@ func findWordIndex(r int) int {
 		return 0
 	}
 
-	left, right := 0, len(cumulativeWeights)-1
-
-	for left < right {
-		mid := (left + right) / 2
-		if cumulativeWeights[mid] < r {
-			left = mid + 1
-		} else {
-			right = mid
-		}
-	}
-
-	return left
+	return sort.Search(len(cumulativeWeights), func(i int) bool {
+		return cumulativeWeights[i] >= r
+	})
 }
 
 // GenerateWords generates a slice of words based on the current language and the specified count
 func GenerateWords(count int) []string {
 	if len(currentLanguageWords) == 0 {
 		// Fallback to English
-		SetLanguage("en")
+		if err := SetLanguage("en"); err != nil {
+			panic("failed to load fallback language: " + err.Error())
+		}
 	}
 
 	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
@@ -93,16 +91,16 @@ func GenerateWords(count int) []string {
 	if currentLanguageCode == "en" && len(cumulativeWeights) > 0 {
 		maxWeight := cumulativeWeights[len(cumulativeWeights)-1]
 
-		for i := 0; i < count; i++ {
-			r := rand.Intn(maxWeight) + 1
+		for i := range words {
+			r := rng.Intn(maxWeight) + 1 // random in range [1, maxWeight]
 			idx := findWordIndex(r)
 			words[i] = currentLanguageWords[idx]
 		}
 		return words
 	}
 
 	// For all other languages, use simple random selection
-	for i := 0; i < count; i++ {
+	for i := range words {
 		words[i] = currentLanguageWords[rng.Intn(len(currentLanguageWords))]
 	}