command_catch.go

@@ -1,63 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"math/rand"
-	"net/http"
-)
-
-func commandCatch(p *PokedexConfig, a *string) error {
-	if *a == "" {
-		return fmt.Errorf("you need to specify a Pokemon to catch")
-	}
-	var pokemonName string
-	var baseUrl string
-	for _, encounter := range p.LocalPokemons.PokemonEncounters {
-		if encounter.PokemonSummary.Name == *a {
-			pokemonName = *a
-			baseUrl = encounter.PokemonSummary.DataUrl
-		}
-	}
-	if pokemonName == "" {
-		baseUrl = "https://pokeapi.co/api/v2/pokemon/" + *a
-	}
-	// if pokemonName != *a {
-	// 	fmt.Println("this pokemon is not present in the current area")
-	// 	return nil
-	// }
-
-	body, exists := p.Cache.Get(baseUrl)
-	if !exists {
-		client := http.Client{}
-
-		resp, err := client.Get(baseUrl)
-		if err != nil {
-			return fmt.Errorf("could not make request to Pokedex API! Err: %w", err)
-		}
-		body, err = io.ReadAll(resp.Body)
-		defer resp.Body.Close()
-		if resp.StatusCode > 299 {
-			return fmt.Errorf("request returned non-200 code! Code: %v Body: %v", resp.StatusCode, body)
-		}
-		if err != nil {
-			return fmt.Errorf("could not read request body! Err: %w", err)
-		}
-		p.Cache.Add(baseUrl, body)
-	}
-	var pokemon PokemonDetails
-	if err := json.Unmarshal(body, &pokemon); err != nil {
-		return fmt.Errorf("could not unmarshal Pokemon data! err: %w", err)
-	}
-	fmt.Printf("Throwing a Pokeball at %s...\n", *a)
-	catchSuccess := rand.Intn(pokemon.BaseExperience)
-	if 2*catchSuccess >= pokemon.BaseExperience {
-		fmt.Printf("%s was caught!\n", pokemon.Name)
-		p.CaughtPokemon = append(p.CaughtPokemon, pokemon)
-		return nil
-	}
-	fmt.Printf("%s escaped!\n", *a)
-
-	return nil
-}

command_exit.go

@@ -5,7 +5,7 @@ import (
 	"os"
 )
 
-func commandExit(p *PokedexConfig, a *string) error {
+func commandExit() error {
 	fmt.Println("Closing the Pokedex... Goodbye!")
 	os.Exit(0)
 	return nil

command_explore.go

@@ -1,43 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-)
-
-func commandExplore(p *PokedexConfig, a *string) error {
-	if *a == "" {
-		return fmt.Errorf("you need to specify an area to explore")
-	}
-	baseUrl := "https://pokeapi.co/api/v2/location-area/" + *a + "/"
-	body, exists := p.Cache.Get(baseUrl)
-	if !exists {
-		client := http.Client{}
-
-		resp, err := client.Get(baseUrl)
-		if err != nil {
-			return fmt.Errorf("could not make request to Pokedex API! Err: %w", err)
-		}
-
-		body, err = io.ReadAll(resp.Body)
-		defer resp.Body.Close()
-		if resp.StatusCode > 299 {
-			return fmt.Errorf("request returned non-200 code! Code: %v Body: %v", resp.StatusCode, body)
-		}
-		if err != nil {
-			return fmt.Errorf("could not read request body! Err: %w", err)
-		}
-		p.Cache.Add(baseUrl, body)
-	}
-	if err := json.Unmarshal(body, &p.LocalPokemons); err != nil {
-		return fmt.Errorf("could not unmarshal response! Err: %w", err)
-	}
-
-	for _, pokemon := range p.LocalPokemons.PokemonEncounters {
-		fmt.Println(pokemon.PokemonSummary.Name)
-	}
-
-	return nil
-}

command_help.go

@@ -4,10 +4,11 @@ import (
 	"fmt"
 )
 
-func commandHelp(p *PokedexConfig, a *string) error {
+
+func commandHelp() error {
 	fmt.Print("Pokedex CLI - available commands:\n\n")
 	for _, v := range getCommands() {
-		fmt.Printf("%s			%s\n", v.name, v.description)
+		fmt.Printf("%s		%s\n", v.name, v.description)
 	}
 	fmt.Println()
 	return nil

command_inspect.go

@@ -1,45 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"gopkg.in/yaml.v2"
-)
-
-type PokemonInspectOutput struct {
-	Name   string
-	Height int
-	Weight int
-	Stats  map[string]int
-	Types  []string
-}
-
-func commandInspect(p *PokedexConfig, a *string) error {
-	found := false
-	for _, pokemon := range p.CaughtPokemon {
-		if pokemon.Name == *a {
-			found = true
-			stats := map[string]int{}
-			types := []string{}
-			for _, pokeStat := range pokemon.PokeStats {
-				stats[pokeStat.PokeStat.Name] = pokeStat.BaseStat
-			}
-			for _, pokeType := range pokemon.PokeTypes {
-				types = append(types, pokeType.PokeType.Name)
-			}
-			pokemonInspectOutput := PokemonInspectOutput{
-				Name:   pokemon.Name,
-				Height: pokemon.Height,
-				Weight: pokemon.Weight,
-				Stats:  stats,
-				Types:  types,
-			}
-			data, _ := yaml.Marshal(pokemonInspectOutput)
-			fmt.Println(string(data))
-		}
-	}
-	if !found {
-		fmt.Println("you have not caught that pokemon")
-	}
-	return nil
-}

command_map.go

@@ -1,48 +1,5 @@
 package main
 
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-)
-
-func commandMap(p *PokedexConfig, a *string) error {
-	var baseUrl string
-	if p.LocationData.Next == nil {
-		baseUrl = "https://pokeapi.co/api/v2/location-area/"
-	} else {
-		baseUrl = *p.LocationData.Next
-	}
-
-	var body []byte
-	// Check if respones is available in cache
-	if resp, exists := p.Cache.Get(baseUrl); exists {
-		body = resp
-	} else {
-		client := &http.Client{}
-
-		resp, err := client.Get(baseUrl)
-		if err != nil {
-			return fmt.Errorf("could not make request to Pokedex API! Err: %w", err)
-		}
-
-		body, err = io.ReadAll(resp.Body)
-		defer resp.Body.Close()
-		if resp.StatusCode > 299 {
-			return fmt.Errorf("request returned non-200 code! Code: %v Body: %v", resp.StatusCode, body)
-		}
-		if err != nil {
-			return fmt.Errorf("could not read request body! Err: %w", err)
-		}
-		p.Cache.Add(baseUrl, body)
-	}
-
-	if err := json.Unmarshal(body, &p.LocationData); err != nil {
-		return fmt.Errorf("could not unmarshal response! Err: %w", err)
-	}
-	for _, location := range p.LocationData.Locations {
-		fmt.Println(location["name"])
-	}
+func commandMap() error {
 	return nil
 }

command_mapb.go

@@ -1,47 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-)
-
-func commandMapb(p *PokedexConfig, a *string) error {
-	var baseUrl string
-	if p.LocationData.Previous == nil {
-		fmt.Println("you're on the first page")
-		return nil
-	} else {
-		baseUrl = *p.LocationData.Previous
-	}
-	var body []byte
-	if resp, exists := p.Cache.Get(baseUrl); exists {
-		body = resp
-	} else {
-		client := &http.Client{}
-
-		resp, err := client.Get(baseUrl)
-		if err != nil {
-			return fmt.Errorf("could not make request to Pokedex API! Err: %w", err)
-		}
-
-		body, err = io.ReadAll(resp.Body)
-		defer resp.Body.Close()
-		if resp.StatusCode > 299 {
-			return fmt.Errorf("request returned non-200 code! Code: %v Body: %v", resp.StatusCode, body)
-		}
-		if err != nil {
-			return fmt.Errorf("could not read request body! Err: %w", err)
-		}
-
-		p.Cache.Add(baseUrl, body)
-	}
-	if err := json.Unmarshal(body, &p.LocationData); err != nil {
-		return fmt.Errorf("could not unmarshal response! Err: %w", err)
-	}
-	for _, location := range p.LocationData.Locations {
-		fmt.Println(location["name"])
-	}
-	return nil
-}

command_pokedex.go

@@ -1,16 +0,0 @@
-package main
-
-import "fmt"
-
-func commandPokedex(p *PokedexConfig, a *string) error {
-	if len(p.CaughtPokemon) == 0 {
-		fmt.Println("Your Pokedex is empty.")
-		return nil
-	}
-	fmt.Println("Your Pokedex:")
-	for _, pokemon := range p.CaughtPokemon {
-		fmt.Println(" - ", pokemon.Name)
-	}
-
-	return nil
-}

go.mod

@@ -1,5 +1,3 @@
 module k3gtpi.jumpingcrab.com/go-learning/pokedexcli
 
 go 1.24.5
-
-require gopkg.in/yaml.v2 v2.4.0

go.sum

@@ -1,4 +0,0 @@
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=

internal/pokecache/pokecache.go

@@ -1,63 +0,0 @@
-package pokecache
-
-import (
-	"sync"
-	"time"
-)
-
-type cacheEntry struct {
-	createdAt time.Time
-	val       []byte
-}
-
-type Cache struct {
-	PokeCache map[string]cacheEntry
-	Interval  time.Duration
-	Mu        sync.Mutex
-}
-
-func (c *Cache) Add(key string, val []byte) {
-	newEntry := cacheEntry{
-		createdAt: time.Now(),
-		val:       val,
-	}
-	c.Mu.Lock()
-	defer c.Mu.Unlock()
-	c.PokeCache[key] = newEntry
-}
-
-func (c *Cache) Get(key string) ([]byte, bool) {
-	c.Mu.Lock()
-
-	defer c.Mu.Unlock()
-	cache, exists := c.PokeCache[key]
-	if !exists {
-		return nil, false
-	}
-	return cache.val, true
-}
-
-func (c *Cache) reapLoop() {
-	ticker := time.NewTicker(c.Interval)
-	defer ticker.Stop()
-
-	for range ticker.C {
-		c.Mu.Lock()
-		for k, v := range c.PokeCache {
-			if time.Since(v.createdAt) > c.Interval {
-				delete(c.PokeCache, k)
-			}
-		}
-		c.Mu.Unlock()
-	}
-}
-
-func NewCache(interval time.Duration) *Cache {
-	newCache := Cache{
-		PokeCache: map[string]cacheEntry{},
-		Interval:  interval,
-		Mu:        sync.Mutex{},
-	}
-	go newCache.reapLoop()
-	return &newCache
-}

internal/pokecache/pokecache_test.go

@@ -1,70 +0,0 @@
-package pokecache
-
-import (
-	"fmt"
-	"testing"
-	"time"
-)
-
-func TestAddGet(t *testing.T) {
-	const interval = 5 * time.Second
-	cases := []struct {
-		key string
-		val []byte
-	}{
-		{
-			key: "https://example.com",
-			val: []byte("testdata"),
-		},
-		{
-			key: "https://example.com/path",
-			val: []byte("moretestdata"),
-		},
-	}
-
-	for i, c := range cases {
-		t.Run(fmt.Sprintf("Test case %v", i), func(t *testing.T) {
-			cache := NewCache(interval)
-			cache.Add(c.key, c.val)
-			val, ok := cache.Get(c.key)
-			if !ok {
-				t.Errorf("expected to find key")
-				return
-			}
-			if string(val) != string(c.val) {
-				t.Errorf("expected to find value")
-				return
-			}
-		})
-	}
-}
-
-func TestGetNonexistent(t *testing.T) {
-	const interval = 2 * time.Second
-	cache := NewCache(interval)
-	value, ok := cache.Get("http://does.not.exist/")
-	if ok || (value != nil) {
-		t.Errorf("expected cache miss")
-	}
-}
-
-func TestReapLoop(t *testing.T) {
-	const baseTime = 5 * time.Millisecond
-	const waitTime = baseTime + 5*time.Millisecond
-	cache := NewCache(baseTime)
-	cache.Add("https://example.com", []byte("testdata"))
-
-	_, ok := cache.Get("https://example.com")
-	if !ok {
-		t.Errorf("expected to find key")
-		return
-	}
-
-	time.Sleep(waitTime)
-
-	_, ok = cache.Get("https://example.com")
-	if ok {
-		t.Errorf("expected to not find key")
-		return
-	}
-}

repl.go

@@ -1,106 +1,42 @@
 package main
 
 import (
-	"bufio"
 	"fmt"
-	"os"
 	"strings"
-	"time"
-
-	"k3gtpi.jumpingcrab.com/go-learning/pokedexcli/internal/pokecache"
+	"bufio"
+	"os"
 )
 
 type cliCommand struct {
-	name        string
-	description string
-	callback    func(*PokedexConfig, *string) error
+	name		string
+	description	string
+	callback	func() error
 }
 
-type PokedexLocationData struct {
-	Next      *string             `json:"next"`
-	Previous  *string             `json:"previous"`
-	Locations []map[string]string `json:"results"`
-}
-
-type PokemonSummary struct {
-	Name    string `json:"name"`
-	DataUrl string `json:"url"`
-}
-
-type PokemonStat struct {
-	Name string `json:"name"`
-}
-
-type PokemonStats struct {
-	BaseStat int         `json:"base_stat"`
-	PokeStat PokemonStat `json:"stat"`
-}
-
-type PokemonTypeEntry struct {
-	Name string `json:"name"`
-}
-
-type PokemonTypes struct {
-	PokeType PokemonTypeEntry `json:"type"`
-}
-
-type PokemonDetails struct {
-	Name           string         `json:"name"`
-	BaseExperience int            `json:"base_experience"`
-	Weight         int            `json:"weight"`
-	Height         int            `json:"height"`
-	PokeStats      []PokemonStats `json:"stats"`
-	PokeTypes      []PokemonTypes `json:"types"`
-}
-
-type PokemonEncounterData struct {
-	PokemonSummary PokemonSummary `json:"pokemon"`
-}
-
-type PokedexLocalPokemons struct {
-	LocationName      string                 `json:"name"`
-	PokemonEncounters []PokemonEncounterData `json:"pokemon_encounters"`
-}
-
-type PokedexConfig struct {
-	Cache         *pokecache.Cache
-	LocationData  PokedexLocationData
-	LocalPokemons PokedexLocalPokemons
-	CaughtPokemon []PokemonDetails
-}
+var supportedCommands map[string]cliCommand
 
 func startRepl() {
 	reader := bufio.NewScanner(os.Stdin)
 	fmt.Println("Welcome to the Pokedex!")
-	pokedexConfig := PokedexConfig{}
-	pokedexConfig.Cache = pokecache.NewCache(5 * time.Second)
 	for {
+		// Print prompt
 		fmt.Printf("Pokedex > ")
 		reader.Scan()
 
 		words := cleanInput(reader.Text())
 		if len(words) == 0 {
 			continue
-		} else if len(words) > 2 {
-			fmt.Printf("Commands can only take one argument!")
-			continue
 		}
 
-		commandName := words[0]
+		commandName := words[0]	
 
 		command, valid := getCommands()[commandName]
 		if !valid {
 			fmt.Println("Unknown command.")
 			continue
 		}
-
-		arg := ""
-		if len(words) == 2 {
-			arg = words[1]
-		}
-
-		if err := command.callback(&pokedexConfig, &arg); err != nil {
-			fmt.Printf("Encountered error running command: %v\nErr: %v\n\n", command.name, err)
+		if err := command.callback(); err != nil {
+			fmt.Printf("Encountered error running command: %v\n", command.name)
 		}
 	}
 }
@@ -115,47 +51,22 @@ func cleanInput(text string) []string {
 	return words
 }
 
-func getCommands() map[string]cliCommand {
+func getCommands() map[string]cliCommand{
 	return map[string]cliCommand{
 		"help": {
-			name:        "help",
-			description: "Prints this help menu.",
-			callback:    commandHelp,
+			name:			"help",
+			description:	"Prints this help menu.",
+			callback:		commandHelp,
 		},
 		"exit": {
-			name:        "exit",
-			description: "Exits the Pokedex",
-			callback:    commandExit,
+			name:			"exit",
+			description:	"Exits the Pokedex",
+			callback:		commandExit,
 		},
 		"map": {
-			name:        "map",
-			description: "Print Pokemon world locations.",
-			callback:    commandMap,
-		},
-		"mapb": {
-			name:        "mapb",
-			description: "Print previous Pokemon locations.",
-			callback:    commandMapb,
-		},
-		"explore": {
-			name:        "explore",
-			description: "Print Pokemon found in specified area. Requires AREA_NAME argument.",
-			callback:    commandExplore,
-		},
-		"catch": {
-			name:        "catch",
-			description: "Attempt to catch a Pokemon present in current area. Requires POKEMON_NAME argument.",
-			callback:    commandCatch,
-		},
-		"inspect": {
-			name:        "inspect",
-			description: "Inspect a caught Pokemon. Requires POKEMON_NAME argument.",
-			callback:    commandInspect,
-		},
-		"pokedex": {
-			name:        "pokedex",
-			description: "Inspect the Pokedex contents.",
-			callback:    commandPokedex,
+			name:			"map",
+			description:	"Print Pokemon world locations.",
+			callback:		commandMap,
 		},
 	}
 }

repl_test.go

@@ -1,26 +1,26 @@
 package main
 
 import (
-	"fmt"
 	"testing"
+	"fmt"
 )
 
-func TestCleanInput(t *testing.T) {
+func TestCleanInput(t * testing.T) {
 	cases := []struct {
-		input    string
-		expected []string
+		input		string
+		expected	[]string
 	}{
 		{
-			input:    " hello world ",
-			expected: []string{"hello", "world"},
+			input: 		" hello world ",
+			expected: 	[]string{"hello", "world"},
 		},
 		{
-			input:    "Charmander Bulbasaur PIKACHU",
-			expected: []string{"charmander", "bulbasaur", "pikachu"},
+			input:		"Charmander Bulbasaur PIKACHU",
+			expected:	[]string{"charmander", "bulbasaur", "pikachu"},
 		},
 		{
-			input:    "",
-			expected: []string{},
+			input:		"",
+			expected:	[]string{},
 		},
 	}
 	successCount := 0
@@ -51,7 +51,7 @@ Output:		%v
 Input: 		%v
 Expected: 	%v
 Output:		%v
-`, c.input, c.expected, output)
+`, c.input, c.expected, output)	
 			successCount++
 		}
 	}