14899621655

Committed 08 May 2025 05:51AM UTC coverage: 39.562%. First build

Build # 14899621655

Build Type

Pull #1

github

Committed by

nightconcept

Commit Message

task 5.2.7 done

Pull Request Pull Request #1: first files

Run Details

307 of 776 new or added lines in 11 files covered. (39.56%)

307 of 776 relevant lines covered (39.56%)

1.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.95

/internal/cli/initcmd/initcmd.go

package initcmd

import (
        "bufio"
        "fmt"
        "os"
        "strings"

        "github.com/nightconcept/almandine-go/internal/core/config"
        "github.com/nightconcept/almandine-go/internal/core/project"
        "github.com/urfave/cli/v2"
)

// Helper function to prompt user and get input with a default value
func promptWithDefault(reader *bufio.Reader, promptText string, defaultValue string) (string, error) {
        // Show default if not empty
        if defaultValue != "" {
                fmt.Printf("%s (default: %s): ", promptText, defaultValue)
        } else {
                fmt.Printf("%s: ", promptText)
        }

        input, err := reader.ReadString('\n')
        if err != nil {
                // Return specific error for prompt context
                return "", fmt.Errorf("failed to read input for '%s': %w", promptText, err)
        }
        input = strings.TrimSpace(input)
        if input == "" {
                return defaultValue, nil // Return default if input is empty
        }
        return input, nil
}

// GetInitCommand returns the definition for the "init" command.
func GetInitCommand() *cli.Command {
        return &cli.Command{
                Name:  "init",
                Usage: "Initialize a new Almandine project (creates project.toml)",
                Action: func(c *cli.Context) error {
                        fmt.Println("Starting project initialization...")

                        reader := bufio.NewReader(os.Stdin)

                        var packageName, version, license, description string
                        var err error

                        // Prompt for package name
                        packageName, err = promptWithDefault(reader, "Package name", "my-almandine-project")
                        if err != nil {
                                return cli.Exit(err.Error(), 1)
                        }

                        // Prompt for version
                        version, err = promptWithDefault(reader, "Version", "0.1.0")
                        if err != nil {
                                return cli.Exit(err.Error(), 1)
                        }

                        // Prompt for license
                        license, err = promptWithDefault(reader, "License", "MIT")
                        if err != nil {
                                return cli.Exit(err.Error(), 1)
                        }

                        // Prompt for description (optional, default is empty)
                        description, err = promptWithDefault(reader, "Description (optional)", "")
                        if err != nil {
                                return cli.Exit(err.Error(), 1)
                        }

                        fmt.Println("\n--- Collected Metadata ---")
                        fmt.Printf("Package Name: %s\n", packageName)
                        fmt.Printf("Version:      %s\n", version)
                        fmt.Printf("License:      %s\n", license)
                        fmt.Printf("Description:  %s\n", description)
                        fmt.Println("--------------------------")

                        // --- Task 1.3: Implement Interactive Prompts for Scripts ---
                        scripts := make(map[string]string)
                        fmt.Println("\nEnter scripts (leave script name empty to finish):")

                        for {
                                scriptName, errLFSN := promptWithDefault(reader, "Script name", "") // Renamed err to avoid conflict
                                if errLFSN != nil {
                                        return cli.Exit(fmt.Sprintf("Error reading script name: %v", errLFSN), 1)
                                }

                                if scriptName == "" {
                                        break
                                }

                                scriptCmd, errLFSC := promptWithDefault(reader, fmt.Sprintf("Command for script '%s'", scriptName), "") // Renamed err
                                if errLFSC != nil {
                                        return cli.Exit(fmt.Sprintf("Error reading command for script '%s': %v", scriptName, errLFSC), 1)
                                }
                                scripts[scriptName] = scriptCmd
                        }

                        if _, exists := scripts["run"]; !exists {
                                scripts["run"] = "lua src/main.lua"
                        }

                        fmt.Println("-------------------------")

                        // --- Task 1.4: Implement Interactive Prompts for Dependencies (Placeholders) ---
                        dependencies := make(map[string]string)
                        fmt.Println("\nEnter dependencies (leave dependency name empty to finish):")

                        for {
                                depName, errLFDN := promptWithDefault(reader, "Dependency name", "") // Renamed err
                                if errLFDN != nil {
                                        return cli.Exit(fmt.Sprintf("Error reading dependency name: %v", errLFDN), 1)
                                }

                                if depName == "" {
                                        break
                                }

                                depSource, errLFDS := promptWithDefault(reader, fmt.Sprintf("Source/Version for dependency '%s'", depName), "") // Renamed err
                                if errLFDS != nil {
                                        return cli.Exit(fmt.Sprintf("Error reading source for dependency '%s': %v", depName, errLFDS), 1)
                                }
                                dependencies[depName] = depSource
                        }

                        fmt.Println("\n--- Collected Dependencies ---")
                        if len(dependencies) > 0 {
                                for name, source := range dependencies {
                                        fmt.Printf("%s = \"%s\"\n", name, source)
                                }
                        } else {
                                fmt.Println("(No dependencies defined)")
                        }
                        fmt.Println("----------------------------")

                        // Transform collected placeholder dependencies into the correct structure
                        projectDependencies := make(map[string]project.Dependency)
                        for name, source := range dependencies {
                                projectDependencies[name] = project.Dependency{
                                        Source: source, // The collected placeholder string
                                        Path:   "",     // Path is not determined at init for placeholders
                                }
                        }

                        // Populate the project structure
                        projectData := project.Project{
                                Package: &project.PackageInfo{
                                        Name:        packageName,
                                        Version:     version,
                                        License:     license,
                                        Description: description,
                                },
                                Scripts:      scripts,
                                Dependencies: projectDependencies, // Use the transformed map
                        }

                        // Write to project.toml using the centralized function
                        err = config.WriteProjectToml("project.toml", &projectData)
                        if err != nil {
                                return cli.Exit(fmt.Sprintf("Error writing project.toml: %v", err), 1)
                        }

                        fmt.Println("\nSuccessfully initialized project and wrote project.toml.")
                        return nil
                },
        }
}

1	package initcmd
2
3	import (
4	"bufio"
5	"fmt"
6	"os"
7	"strings"
8
9	"github.com/nightconcept/almandine-go/internal/core/config"
10	"github.com/nightconcept/almandine-go/internal/core/project"
11	"github.com/urfave/cli/v2"
12	)
13
14	// Helper function to prompt user and get input with a default value
15	func promptWithDefault(reader *bufio.Reader, promptText string, defaultValue string) (string, error) {	14✔
16	// Show default if not empty	14✔
17	if defaultValue != "" {	20✔
18	fmt.Printf("%s (default: %s): ", promptText, defaultValue)	6✔
19	} else {	14✔
20	fmt.Printf("%s: ", promptText)	8✔
21	}	8✔
22
23	input, err := reader.ReadString('\n')	14✔
24	if err != nil {	14✔
NEW 25	// Return specific error for prompt context	×
NEW 26	return "", fmt.Errorf("failed to read input for '%s': %w", promptText, err)	×
NEW 27	}	×
28	input = strings.TrimSpace(input)	14✔
29	if input == "" {	21✔
30	return defaultValue, nil // Return default if input is empty	7✔
31	}	7✔
32	return input, nil	7✔
33	}
34
35	// GetInitCommand returns the definition for the "init" command.
36	func GetInitCommand() *cli.Command {	2✔
37	return &cli.Command{	2✔
38	Name: "init",	2✔
39	Usage: "Initialize a new Almandine project (creates project.toml)",	2✔
40	Action: func(c *cli.Context) error {	4✔
41	fmt.Println("Starting project initialization...")	2✔
42		2✔
43	reader := bufio.NewReader(os.Stdin)	2✔
44		2✔
45	var packageName, version, license, description string	2✔
46	var err error	2✔
47		2✔
48	// Prompt for package name	2✔
49	packageName, err = promptWithDefault(reader, "Package name", "my-almandine-project")	2✔
50	if err != nil {	2✔
NEW 51	return cli.Exit(err.Error(), 1)	×
NEW 52	}	×
53
54	// Prompt for version
55	version, err = promptWithDefault(reader, "Version", "0.1.0")	2✔
56	if err != nil {	2✔
NEW 57	return cli.Exit(err.Error(), 1)	×
NEW 58	}	×
59
60	// Prompt for license
61	license, err = promptWithDefault(reader, "License", "MIT")	2✔
62	if err != nil {	2✔
NEW 63	return cli.Exit(err.Error(), 1)	×
NEW 64	}	×
65
66	// Prompt for description (optional, default is empty)
67	description, err = promptWithDefault(reader, "Description (optional)", "")	2✔
68	if err != nil {	2✔
NEW 69	return cli.Exit(err.Error(), 1)	×
NEW 70	}	×
71
72	fmt.Println("\n--- Collected Metadata ---")	2✔
73	fmt.Printf("Package Name: %s\n", packageName)	2✔
74	fmt.Printf("Version: %s\n", version)	2✔
75	fmt.Printf("License: %s\n", license)	2✔
76	fmt.Printf("Description: %s\n", description)	2✔
77	fmt.Println("--------------------------")	2✔
78		2✔
79	// --- Task 1.3: Implement Interactive Prompts for Scripts ---	2✔
80	scripts := make(map[string]string)	2✔
81	fmt.Println("\nEnter scripts (leave script name empty to finish):")	2✔
82		2✔
83	for {	4✔
84	scriptName, errLFSN := promptWithDefault(reader, "Script name", "") // Renamed err to avoid conflict	2✔
85	if errLFSN != nil {	2✔
NEW 86	return cli.Exit(fmt.Sprintf("Error reading script name: %v", errLFSN), 1)	×
NEW 87	}	×
88
89	if scriptName == "" {	4✔
90	break	2✔
91	}
92
NEW 93	scriptCmd, errLFSC := promptWithDefault(reader, fmt.Sprintf("Command for script '%s'", scriptName), "") // Renamed err	×
NEW 94	if errLFSC != nil {	×
NEW 95	return cli.Exit(fmt.Sprintf("Error reading command for script '%s': %v", scriptName, errLFSC), 1)	×
NEW 96	}	×
NEW 97	scripts[scriptName] = scriptCmd	×
98	}
99
100	if _, exists := scripts["run"]; !exists {	4✔
101	scripts["run"] = "lua src/main.lua"	2✔
102	}	2✔
103
104	fmt.Println("-------------------------")	2✔
105		2✔
106	// --- Task 1.4: Implement Interactive Prompts for Dependencies (Placeholders) ---	2✔
107	dependencies := make(map[string]string)	2✔
108	fmt.Println("\nEnter dependencies (leave dependency name empty to finish):")	2✔
109		2✔
110	for {	5✔
111	depName, errLFDN := promptWithDefault(reader, "Dependency name", "") // Renamed err	3✔
112	if errLFDN != nil {	3✔
NEW 113	return cli.Exit(fmt.Sprintf("Error reading dependency name: %v", errLFDN), 1)	×
NEW 114	}	×
115
116	if depName == "" {	5✔
117	break	2✔
118	}
119
120	depSource, errLFDS := promptWithDefault(reader, fmt.Sprintf("Source/Version for dependency '%s'", depName), "") // Renamed err	1✔
121	if errLFDS != nil {	1✔
NEW 122	return cli.Exit(fmt.Sprintf("Error reading source for dependency '%s': %v", depName, errLFDS), 1)	×
NEW 123	}	×
124	dependencies[depName] = depSource	1✔
125	}
126
127	fmt.Println("\n--- Collected Dependencies ---")	2✔
128	if len(dependencies) > 0 {	3✔
129	for name, source := range dependencies {	2✔
130	fmt.Printf("%s = \"%s\"\n", name, source)	1✔
131	}	1✔
132	} else {	1✔
133	fmt.Println("(No dependencies defined)")	1✔
134	}	1✔
135	fmt.Println("----------------------------")	2✔
136		2✔
137	// Transform collected placeholder dependencies into the correct structure	2✔
138	projectDependencies := make(map[string]project.Dependency)	2✔
139	for name, source := range dependencies {	3✔
140	projectDependencies[name] = project.Dependency{	1✔
141	Source: source, // The collected placeholder string	1✔
142	Path: "", // Path is not determined at init for placeholders	1✔
143	}	1✔
144	}	1✔
145
146	// Populate the project structure
147	projectData := project.Project{	2✔
148	Package: &project.PackageInfo{	2✔
149	Name: packageName,	2✔
150	Version: version,	2✔
151	License: license,	2✔
152	Description: description,	2✔
153	},	2✔
154	Scripts: scripts,	2✔
155	Dependencies: projectDependencies, // Use the transformed map	2✔
156	}	2✔
157		2✔
158	// Write to project.toml using the centralized function	2✔
159	err = config.WriteProjectToml("project.toml", &projectData)	2✔
160	if err != nil {	2✔
NEW 161	return cli.Exit(fmt.Sprintf("Error writing project.toml: %v", err), 1)	×
NEW 162	}	×
163
164	fmt.Println("\nSuccessfully initialized project and wrote project.toml.")	2✔
165	return nil	2✔
166	},
167	}
168	}

nightconcept / almandine-go / 14899621655

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous