refactor: rearrange the project structure

Author: pplmx

cmd/root.go

@@ -0,0 +1,76 @@
+package cmd
+
+import (
+	"context"
+	"log"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/pplmx/setup-my-action/internal/api"
+	"github.com/pplmx/setup-my-action/internal/config"
+	"github.com/pplmx/setup-my-action/internal/file"
+	"github.com/pplmx/setup-my-action/internal/output"
+	"github.com/pplmx/setup-my-action/internal/text"
+)
+
+const contextTimeout = 15 * time.Second
+
+// Execute is the main entry point for the cmd package, orchestrating the main program flow.
+func Execute() {
+	configPath := os.Getenv("INPUT_CONFIG_PATH")
+	cfg, err := config.LoadConfig(configPath)
+	if err != nil {
+		log.Fatalf("Failed to load configuration: %v", err)
+	}
+
+	// Process text
+	if err := processText(cfg); err != nil {
+		log.Fatalf("Text processing error: %v", err)
+	}
+
+	// Process numbers
+	if err := processNumbers(cfg); err != nil {
+		log.Fatalf("Number processing error: %v", err)
+	}
+
+	// Process files
+	if err := processFiles(cfg); err != nil {
+		log.Fatalf("File processing error: %v", err)
+	}
+
+	// Check API reachability
+	if err := checkAPI(cfg); err != nil {
+		log.Fatalf("API check error: %v", err)
+	}
+}
+
+func processText(cfg *config.Config) error {
+	processedText, wordCount := text.ProcessText(cfg.InputText, cfg.FindWord, cfg.ReplaceWord)
+	if err := output.SetOutput("processed_text", processedText); err != nil {
+		return err
+	}
+	return output.SetOutput("word_count", strconv.Itoa(wordCount))
+}
+
+func processNumbers(cfg *config.Config) error {
+	sum, average := text.CalculateSumAndAverage(cfg.NumberList)
+	if err := output.SetOutput("sum", strconv.FormatFloat(sum, 'f', -1, 64)); err != nil {
+		return err
+	}
+	return output.SetOutput("average", strconv.FormatFloat(average, 'f', -1, 64))
+}
+
+func processFiles(cfg *config.Config) error {
+	return file.ReadAndAppendToFile(cfg.InputFile, cfg.OutputFile, cfg.AppendText)
+}
+
+func checkAPI(cfg *config.Config) error {
+	ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
+	defer cancel()
+
+	if err := api.CheckAPIReachability(ctx, cfg.ApiURL); err != nil {
+		return err
+	}
+	return output.SetOutput("response_field", "API Reachable")
+}

docs/development.md

@@ -0,0 +1,40 @@
+# DEVELOPMENT.md
+
+## Project Overview
+
+This document provides an overview of the directory structure and components of the project. The project is organized to
+ensure clear separation of concerns, ease of maintenance, and scalability. Below is a breakdown of each directory and
+its purpose.
+
+## Directory Structure
+
+```
+setup-my-action/
+│
+├── main.go                 // Entry point of the application
+├── cmd/
+│   └── root.go             // Root command and setup for executing commands
+├── internal/
+│   ├── config/
+│   │   └── config.go       // Configuration loading and validation
+│   ├── text/
+│   │   └── text.go         // Text processing functions
+│   ├── file/
+│   │   └── file.go         // File operations
+│   ├── api/
+│   │   └── api.go          // API-related operations
+│   └── output/
+│       └── output.go       // Output handling
+└── go.mod                  // Go module file
+```
+
+## Contributing
+
+When contributing to this project, please ensure that any changes are well-documented and tested. Follow the existing
+code style and structure for consistency.
+
+## Conclusion
+
+This project structure helps keep the codebase modular and maintainable. By separating different concerns into distinct
+packages, we ensure that each component can be developed and tested independently, making the application easier to
+understand and extend.

internal/.gitkeep

@@ -0,0 +1,39 @@
+// internal/api/api.go
+
+package api
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+const httpTimeout = 10 * time.Second
+
+func CheckAPIReachability(ctx context.Context, apiURL string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	client := &http.Client{Timeout: httpTimeout}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to make API request: %w", err)
+	}
+	defer func(Body io.ReadCloser) {
+		err := Body.Close()
+		if err != nil {
+			log.Printf("Failed to close response body: %v", err)
+		}
+	}(resp.Body)
+
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return fmt.Errorf("API is not reachable, status code: %d", resp.StatusCode)
+	}
+
+	return nil
+}

internal/api/api.go

@@ -0,0 +1,52 @@
+// internal/config/config.go
+
+package config
+
+import (
+	"fmt"
+
+	"github.com/BurntSushi/toml"
+)
+
+type Config struct {
+	InputText   string    `toml:"input_text"`
+	FindWord    string    `toml:"find_word"`
+	ReplaceWord string    `toml:"replace_word"`
+	NumberList  []float64 `toml:"number_list"`
+	InputFile   string    `toml:"input_file"`
+	OutputFile  string    `toml:"output_file"`
+	AppendText  string    `toml:"append_text"`
+	ApiURL      string    `toml:"api_url"`
+}
+
+const defaultConfigPath = ".github/configs/setup-my-action.toml"
+
+func LoadConfig(path string) (*Config, error) {
+	if path == "" {
+		path = defaultConfigPath
+	}
+
+	var config Config
+	if _, err := toml.DecodeFile(path, &config); err != nil {
+		return nil, fmt.Errorf("failed to decode TOML file: %w", err)
+	}
+
+	if err := validateConfig(&config); err != nil {
+		return nil, fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	return &config, nil
+}
+
+func validateConfig(cfg *Config) error {
+	if cfg.InputText == "" {
+		return fmt.Errorf("input_text is required")
+	}
+	if cfg.InputFile == "" || cfg.OutputFile == "" {
+		return fmt.Errorf("input_file and output_file are required")
+	}
+	if cfg.ApiURL == "" {
+		return fmt.Errorf("api_url is required")
+	}
+	return nil
+}

internal/config/config.go

@@ -0,0 +1,19 @@
+// internal/file/file.go
+
+package file
+
+import (
+	"fmt"
+	"os"
+)
+
+func ReadAndAppendToFile(inputFile, outputFile, appendText string) error {
+	content, err := os.ReadFile(inputFile)
+	if err != nil {
+		return fmt.Errorf("failed to read input file: %w", err)
+	}
+
+	modifiedContent := string(content) + "\n" + appendText
+
+	return os.WriteFile(outputFile, []byte(modifiedContent), 0644)
+}

internal/file/file.go

@@ -0,0 +1,29 @@
+// internal/output/output.go
+
+package output
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+func SetOutput(name, value string) error {
+	envFile := os.Getenv("GITHUB_OUTPUT")
+	f, err := os.OpenFile(envFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to open GITHUB_OUTPUT file: %w", err)
+	}
+	defer func(f *os.File) {
+		err := f.Close()
+		if err != nil {
+			log.Printf("Failed to close GITHUB_OUTPUT file: %v", err)
+		}
+	}(f)
+
+	_, err = fmt.Fprintf(f, "%s=%s\n", name, value)
+	if err != nil {
+		return fmt.Errorf("failed to write to GITHUB_OUTPUT file: %w", err)
+	}
+	return nil
+}

internal/output/output.go

@@ -0,0 +1,20 @@
+// internal/text/text.go
+
+package text
+
+import "strings"
+
+func ProcessText(inputText, findWord, replaceWord string) (string, int) {
+	processedText := strings.ReplaceAll(inputText, findWord, replaceWord)
+	wordCount := len(strings.Fields(inputText))
+	return processedText, wordCount
+}
+
+func CalculateSumAndAverage(numbers []float64) (float64, float64) {
+	sum := 0.0
+	for _, num := range numbers {
+		sum += num
+	}
+	average := sum / float64(len(numbers))
+	return sum, average
+}