14898198268

Committed 08 May 2025 03:48AM UTC coverage: 27.953%. First build

Build # 14898198268

Build Type

Pull #1

github

Committed by

nightconcept

Commit Message

update README

Pull Request Pull Request #1: first files

Run Details

213 of 762 new or added lines in 11 files covered. (27.95%)

213 of 762 relevant lines covered (27.95%)

1.0 hits per line

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

80.95

/internal/cli/initcmd/initcmd.go

// Package commands contains the definitions for the almd CLI commands.
package initcmd

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

        // "github.com/BurntSushi/toml" // No longer directly used here
        "github.com/nightconcept/almandine-go/internal/core/config"
        "github.com/nightconcept/almandine-go/internal/core/project"
        "github.com/urfave/cli/v2"
)

// --- Structs for project.toml --- // These are now removed and defined in internal/project/project.go
//
// // PackageMeta holds the metadata for the [package] section
// type PackageMeta struct {
// Name        string `toml:"name"`
// Version     string `toml:"version"`
// Description string `toml:"description,omitempty"` // Use omitempty for optional fields
// License     string `toml:"license"`
// }
//
// // ProjectConfig represents the overall structure of project.toml
// type ProjectConfig struct {
// Package      PackageMeta       `toml:"package"`
// Scripts      map[string]string `toml:"scripts"`
// Dependencies map[string]string `toml:"dependencies,omitempty"` // Use omitempty if no dependencies
// }

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

nightconcept / almandine-go / 14898198268

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