Merge pull request #63 from digitalghost-dev/0.7.0

0.7.0

Author: digitalghost-dev

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ on:
     branches:
       - main
 env:
-  VERSION_NUMBER: 'v0.6.5'
+  VERSION_NUMBER: 'v0.7.0'
   REGISTRY_NAME: digitalghostdev/poke-cli
 
 jobs:

README.md

@@ -2,7 +2,7 @@
     <img height="250" width="350" src="https://cdn.simpleicons.org/pokemon/FFCC00" alt="pokemon-logo"/>
     <h1>Pokémon CLI</h1>
     <img src="https://img.shields.io/github/v/release/digitalghost-dev/poke-cli?style=flat-square&logo=git&logoColor=FFCC00&label=Release%20Version&labelColor=EEE&color=FFCC00" alt="version-label">
-    <img src="https://img.shields.io/docker/image-size/digitalghostdev/poke-cli/v0.6.5?arch=arm64&style=flat-square&logo=docker&logoColor=FFCC00&labelColor=EEE&color=FFCC00" alt="docker-image-size">
+    <img src="https://img.shields.io/docker/image-size/digitalghostdev/poke-cli/v0.7.0?arch=arm64&style=flat-square&logo=docker&logoColor=FFCC00&labelColor=EEE&color=FFCC00" alt="docker-image-size">
     <img src="https://img.shields.io/github/actions/workflow/status/digitalghost-dev/poke-cli/ci.yml?branch=main&style=flat-square&logo=github&logoColor=FFCC00&label=CI&labelColor=EEE&color=FFCC00">
 </div>
 
@@ -40,7 +40,7 @@ _Taskfile can build the executable for you_
 _Use a Docker Image_
 
 ```bash
-docker run --rm -it digitalghostdev/poke-cli:v0.6.5 [command] [subcommand] [flag]
+docker run --rm -it digitalghostdev/poke-cli:v0.7.0 [command] [subcommand] [flag]
 ```
 
 ### Go Build

cli_test.go

@@ -17,7 +17,7 @@ func stripANSI(input string) string {
 }
 
 func TestMainFunction(t *testing.T) {
-	version := "v0.6.4"
+	version := "v0.6.5"
 
 	// Backup the original exit function and stdout/stderr
 	originalExit := exit
@@ -81,6 +81,26 @@ func TestMainFunction(t *testing.T) {
 				"╰──────────────────────────────────────────────────────╯\n",
 			expectedExit: 0,
 		},
+		{
+			args:           []string{"pokemon", "kingambit"},
+			expectedOutput: "Your selected Pokémon: Kingambit\nNational Pokédex #: 983\n",
+			expectedExit:   0,
+		},
+		{
+			args:           []string{"pokemon", "cradily", "--types"},
+			expectedOutput: "Your selected Pokémon: Cradily\nNational Pokédex #: 346\n──────\nTyping\nType 1: rock\nType 2: grass\n",
+			expectedExit:   0,
+		},
+		{
+			args:           []string{"pokemon", "giratina-altered", "--abilities"},
+			expectedOutput: "Your selected Pokémon: Giratina-Altered\nNational Pokédex #: 487\n─────────\nAbilities\nAbility 1: pressure\nHidden Ability: telepathy\n",
+			expectedExit:   0,
+		},
+		{
+			args:           []string{"pokemon", "coPPeraJAH", "-t", "-a"},
+			expectedOutput: "Your selected Pokémon: Copperajah\nNational Pokédex #: 879\n──────\nTyping\nType 1: steel\n─────────\nAbilities\nAbility 1: sheer-force\nHidden Ability: heavy-metal\n",
+			expectedExit:   0,
+		},
 	}
 
 	for _, test := range tests {

cmd/types.go

@@ -6,6 +6,7 @@ import (
 	"github.com/charmbracelet/bubbles/table"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/x/term"
 	"github.com/digitalghost-dev/poke-cli/connections"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -26,8 +27,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "q", "ctrl+c":
-			// Fully quiting the program while
-			// the table is in selection mode
+			// Quit the program when in selection mode
 			m.selectedOption = "quit"
 			return m, tea.Quit
 		case "enter":
@@ -51,30 +51,108 @@ func (m model) View() string {
 	return "Select a type! Hit 'Q' or 'CTRL-C' to quit.\n" + typesTableBorder.Render(m.table.View()) + "\n"
 }
 
-// Creating a separate function that handles all the logic for building the table.
-func tableGeneration(endpoint string) table.Model {
-	columns := []table.Column{
-		{Title: "Type", Width: 16},
+// Helper function to get color for a given type name from colorMap
+func getTypeColor(typeName string) string {
+	color := colorMap[typeName]
+
+	return color
+}
+
+// Function to display type details after a type is selected
+func displayTypeDetails(typesName string, endpoint string) {
+
+	// Setting up variables to style the list
+	var columnWidth = 13
+	var subtle = lipgloss.AdaptiveColor{Light: "#D9DCCF", Dark: "#383838"}
+	var list = lipgloss.NewStyle().Border(lipgloss.NormalBorder(), false, true, false, false).BorderForeground(subtle).MarginRight(2).Height(8).Width(columnWidth + 1)
+	var listHeader = lipgloss.NewStyle().BorderStyle(lipgloss.NormalBorder()).BorderBottom(true).BorderForeground(subtle).MarginRight(2).Render
+	var listItem = lipgloss.NewStyle().Render
+	var docStyle = lipgloss.NewStyle().Padding(1, 1, 1, 1)
+
+	baseURL := "https://pokeapi.co/api/v2/"
+	typesStruct, typeName, _ := connections.TypesApiCall(endpoint, typesName, baseURL)
+
+	// Format selected type
+	selectedType := cases.Title(language.English).String(typeName)
+	coloredType := lipgloss.NewStyle().Foreground(lipgloss.Color(getTypeColor(typeName))).Render(selectedType)
+
+	fmt.Printf("You selected the %s type.\nNumber of Pokémon with type: %d\n", coloredType, len(typesStruct.Pokemon))
+	fmt.Println("----------")
+	fmt.Println(styleBold.Render("Damage Chart:"))
+
+	physicalWidth, _, _ := term.GetSize(uintptr(int(os.Stdout.Fd())))
+	doc := strings.Builder{}
+
+	// Helper function to build list items
+	buildListItems := func(items []struct{ Name, URL string }) string {
+		var itemList []string
+		for _, item := range items {
+			color := getTypeColor(item.Name)
+			coloredStyle := lipgloss.NewStyle().Foreground(lipgloss.Color(color))
+			coloredItem := coloredStyle.Render(cases.Title(language.English).String(item.Name))
+			itemList = append(itemList, listItem(coloredItem))
+		}
+		return lipgloss.JoinVertical(lipgloss.Left, itemList...)
 	}
 
+	// Render lists based on Damage Relations
+	lists := lipgloss.JoinHorizontal(lipgloss.Top,
+		list.Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("Weakness"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.DoubleDamageFrom)),
+			),
+		),
+		list.Width(columnWidth).Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("x2 Damage"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.DoubleDamageTo)),
+			),
+		),
+		list.Width(columnWidth).Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("Resists"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.HalfDamageFrom)),
+			),
+		),
+		list.Width(columnWidth).Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("x0.5 Damage"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.HalfDamageTo)),
+			),
+		),
+		list.Width(columnWidth).Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("Immune"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.NoDamageFrom)),
+			),
+		),
+		list.Width(columnWidth).Render(
+			lipgloss.JoinVertical(lipgloss.Left,
+				listHeader("x0 Damage"),
+				buildListItems([]struct{ Name, URL string }(typesStruct.DamageRelations.NoDamageTo)),
+			),
+		),
+	)
+
+	// Append lists to document
+	doc.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, lists))
+
+	if physicalWidth > 0 {
+		docStyle = docStyle.MaxWidth(physicalWidth)
+	}
+
+	// Print the rendered document
+	fmt.Println(docStyle.Render(doc.String()))
+}
+
+// Function that generates and handles the type selection table
+func tableGeneration(endpoint string) table.Model {
+	columns := []table.Column{{Title: "Type", Width: 16}}
 	rows := []table.Row{
-		{"Normal"},
-		{"Fire"},
-		{"Water"},
-		{"Electric"},
-		{"Grass"},
-		{"Ice"},
-		{"Fighting"},
-		{"Poison"},
-		{"Ground"},
-		{"Flying"},
-		{"Psychic"},
-		{"Bug"},
-		{"Rock"},
-		{"Ghost"},
-		{"Dragon"},
-		{"Steel"},
-		{"Fairy"},
+		{"Normal"}, {"Fire"}, {"Water"}, {"Electric"}, {"Grass"}, {"Ice"},
+		{"Fighting"}, {"Poison"}, {"Ground"}, {"Flying"}, {"Psychic"}, {"Bug"},
+		{"Rock"}, {"Ghost"}, {"Dragon"}, {"Steel"}, {"Fairy"},
 	}
 
 	t := table.New(
@@ -85,15 +163,8 @@ func tableGeneration(endpoint string) table.Model {
 	)
 
 	s := table.DefaultStyles()
-	s.Header = s.Header.
-		BorderStyle(lipgloss.NormalBorder()).
-		BorderForeground(lipgloss.Color("#FFCC00")).
-		BorderBottom(true).
-		Bold(false)
-	s.Selected = s.Selected.
-		Foreground(lipgloss.Color("#000")).
-		Background(lipgloss.Color("#FFCC00")).
-		Bold(false)
+	s.Header = s.Header.BorderStyle(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color("#FFCC00")).BorderBottom(true)
+	s.Selected = s.Selected.Foreground(lipgloss.Color("#000")).Background(lipgloss.Color("#FFCC00"))
 	t.SetStyles(s)
 
 	m := model{table: t}
@@ -103,40 +174,22 @@ func tableGeneration(endpoint string) table.Model {
 		os.Exit(1)
 	}
 
-	// Type assert to model and access the selected option
+	// Access the selected option from the model
 	finalModel, ok := programModel.(model)
 	if !ok {
 		fmt.Println("Error: could not retrieve final model")
 		os.Exit(1)
 	}
 
-	// Check if the user quit the program by pressing 'Q' or 'CTRL-C'
-	if finalModel.selectedOption == "quit" {
-		// Return early to prevent further execution
-		return t
+	if finalModel.selectedOption != "quit" {
+		typesName := strings.ToLower(finalModel.selectedOption)
+		displayTypeDetails(typesName, endpoint) // Call function to display type details
 	}
 
-	// Proceed with the API call only if a type was selected
-	typesName := strings.ToLower(finalModel.selectedOption)
-
-	baseURL := "https://pokeapi.co/api/v2/"
-	typeResponse, typeName, _ := connections.TypesApiCall(endpoint, typesName, baseURL)
-
-	selectedType := cases.Title(language.English).String(typeName)
-
-	pokemonCount := len(typeResponse.Pokemon)
-
-	// Picking the type's color from the colorMap map in cmd/styles.go:
-	coloredStyle := lipgloss.NewStyle().Foreground(lipgloss.Color(colorMap[typeName]))
-	coloredType := coloredStyle.Render(selectedType)
-
-	fmt.Printf("You selected Type: %s\nNumber of Pokémon with type: %d\n", coloredType, pokemonCount)
 	return t
 }
 
 func TypesCommand() {
-	styleBold = lipgloss.NewStyle().Bold(true)
-	styleItalic = lipgloss.NewStyle().Italic(true)
 
 	flag.Usage = func() {
 		helpMessage := helpBorder.Render(
@@ -153,13 +206,11 @@ func TypesCommand() {
 
 	flag.Parse()
 
-	err := ValidateTypesArgs(os.Args)
-	if err != nil {
+	if err := ValidateTypesArgs(os.Args); err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)
 	}
 
 	endpoint := strings.ToLower(os.Args[1])[0:4]
-
 	tableGeneration(endpoint)
 }

connections/connection.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"github.com/charmbracelet/lipgloss"
 	"io"
-	"log"
 	"net/http"
 )
 
@@ -39,46 +38,73 @@ type TypesJSONStruct struct {
 		} `json:"pokemon"`
 		Slot int `json:"slot"`
 	} `json:"pokemon"`
+	DamageRelations struct {
+		DoubleDamageFrom []struct {
+			Name string `json:"name"`
+			URL  string `json:"url"`
+		} `json:"double_damage_from"`
+		DoubleDamageTo []struct {
+			Name string `json:"name"`
+			URL  string `json:"url"`
+		} `json:"double_damage_to"`
+		HalfDamageFrom []struct {
+			Name string `json:"name"`
+			URL  string `json:"url"`
+		} `json:"half_damage_from"`
+		HalfDamageTo []struct {
+			Name string `json:"name"`
+			URL  string `json:"ul"`
+		} `json:"half_damage_to"`
+		NoDamageFrom []struct {
+			Name string `json:"name"`
+			URL  string `json:"url"`
+		} `json:"no_damage_from"`
+		NoDamageTo []struct {
+			Name string `json:"name"`
+			URL  string `json:"url"`
+		} `json:"no_damage_to"`
+	} `json:"damage_relations"`
 }
 
 var httpGet = http.Get
 var red = lipgloss.Color("#F2055C")
 var errorColor = lipgloss.NewStyle().Foreground(red)
 
 // ApiCallSetup Helper function to handle API calls and JSON unmarshalling
-func ApiCallSetup(url string, target interface{}) {
+func ApiCallSetup(url string, target interface{}) error {
 	res, err := httpGet(url)
 	if err != nil {
-		log.Fatalf("Error making GET request: %v", err)
+		return fmt.Errorf("error making GET request: %w", err)
 	}
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			log.Printf("Failed to close body: %v", err)
-		}
-	}(res.Body)
+	defer res.Body.Close()
 
 	if res.StatusCode == http.StatusNotFound {
 		fmt.Println(errorColor.Render("Page not found. 404 error."))
+		return fmt.Errorf("page not found: 404 error")
 	}
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Fatalf("Error reading response body: %v", err)
+		return fmt.Errorf("error reading response body: %w", err)
 	}
 
 	err = json.Unmarshal(body, target)
 	if err != nil {
-		log.Fatalf("Error unmarshalling JSON: %v", err)
+		return fmt.Errorf("error unmarshalling JSON: %w", err)
 	}
+
+	return nil
 }
 
 func PokemonApiCall(endpoint string, pokemonName string, baseURL string) (PokemonJSONStruct, string, int) {
 
 	url := baseURL + endpoint + "/" + pokemonName
 	var pokemonStruct PokemonJSONStruct
 
-	ApiCallSetup(url, &pokemonStruct)
+	err := ApiCallSetup(url, &pokemonStruct)
+	if err != nil {
+		return PokemonJSONStruct{}, "", 0
+	}
 
 	return pokemonStruct, pokemonStruct.Name, pokemonStruct.ID
 }
@@ -88,7 +114,10 @@ func TypesApiCall(endpoint string, typesName string, baseURL string) (TypesJSONS
 	url := baseURL + endpoint + "/" + typesName
 	var typesStruct TypesJSONStruct
 
-	ApiCallSetup(url, &typesStruct)
+	err := ApiCallSetup(url, &typesStruct)
+	if err != nil {
+		return TypesJSONStruct{}, "", 0
+	}
 
 	return typesStruct, typesStruct.Name, typesStruct.ID
 }