Added more functionality to the Pokedex; WIP - add more testing and refactor

command_catch.go

@@ -0,0 +1,63 @@
+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() error {
+func commandExit(p *PokedexConfig, a *string) error {
 	fmt.Println("Closing the Pokedex... Goodbye!")
 	os.Exit(0)
 	return nil

command_explore.go

@@ -0,0 +1,43 @@
+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,11 +4,10 @@ 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

@@ -0,0 +1,45 @@
+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,5 +1,48 @@
 package main
 
-func commandMap() error {
+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"])
+	}
 	return nil
 }

command_mapb.go

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,16 @@
+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,3 +1,5 @@
 module k3gtpi.jumpingcrab.com/go-learning/pokedexcli
 
 go 1.24.5
+
+require gopkg.in/yaml.v2 v2.4.0

go.sum

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,70 @@
+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,31 +1,89 @@
 package main
 
 import (
-	"fmt"
-	"strings"
 	"bufio"
+	"fmt"
 	"os"
+	"strings"
+	"time"
+
+	"k3gtpi.jumpingcrab.com/go-learning/pokedexcli/internal/pokecache"
 )
 
 type cliCommand struct {
-	name		string
+	name        string
-	description	string
+	description string
-	callback	func() error
+	callback    func(*PokedexConfig, *string) error
 }
 
-var supportedCommands map[string]cliCommand
+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
+}
 
 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]
@@ -35,8 +93,14 @@ func startRepl() {
 			fmt.Println("Unknown command.")
 			continue
 		}
-		if err := command.callback(); err != nil {
+
-			fmt.Printf("Encountered error running command: %v\n", command.name)
+		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)
 		}
 	}
 }
@@ -51,22 +115,47 @@ func cleanInput(text string) []string {
 	return words
 }
 
-func getCommands() map[string]cliCommand{
+func getCommands() map[string]cliCommand {
 	return map[string]cliCommand{
 		"help": {
-			name:			"help",
+			name:        "help",
-			description:	"Prints this help menu.",
+			description: "Prints this help menu.",
-			callback:		commandHelp,
+			callback:    commandHelp,
 		},
 		"exit": {
-			name:			"exit",
+			name:        "exit",
-			description:	"Exits the Pokedex",
+			description: "Exits the Pokedex",
-			callback:		commandExit,
+			callback:    commandExit,
 		},
 		"map": {
-			name:			"map",
+			name:        "map",
-			description:	"Print Pokemon world locations.",
+			description: "Print Pokemon world locations.",
-			callback:		commandMap,
+			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,
 		},
 	}
 }

repl_test.go

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