गो में कोबरा और वाइपर के साथ CLI ऐप्स बनाना

go mod init myapp
go get -u github.com/spf13/cobra@latest
go get -u github.com/spf13/viper@latest

go install github.com/spf13/cobra-cli@latest

// main.go
package main

import "mytasks/cmd"

func main() {
    cmd.Execute()
}

// cmd/root.go
package cmd

import (
    "fmt"
    "os"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var cfgFile string

var rootCmd = &cobra.Command{
    Use:   "mytasks",
    Short: "एक सरल टास्क प्रबंधन CLI",
    Long: `MyTasks एक CLI टास्क मैनेजर है जो आपको आसानी से
अपने दैनिक टास्क्स को संगठित करने में मदद करता है। Cobra और Viper के साथ बनाया गया।`,
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func init() {
    cobra.OnInitialize(initConfig)

    rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "",
        "कॉन्फ़िगरेशन फाइल (डिफ़ॉल्ट $HOME/.mytasks.yaml है)")
    rootCmd.PersistentFlags().String("db",
        "डेटाबेस फाइल स्थान")

    viper.BindPFlag("database", rootCmd.PersistentFlags().Lookup("db"))
}

func initConfig() {
    if cfgFile != "" {
        viper.SetConfigFile(cfgFile)
    } else {
        home, err := os.UserHomeDir()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            os.Exit(1)
        }

        viper.AddConfigPath(home)
        viper.AddConfigPath(".")
        viper.SetConfigType("yaml")
        viper.SetConfigName(".mytasks")
    }

    viper.SetEnvPrefix("MYTASKS")
    viper.AutomaticEnv()

    if err := viper.ReadInConfig(); err == nil {
        fmt.Println("कॉन्फ़िगरेशन फाइल का उपयोग कर रहा हूँ:", viper.ConfigFileUsed())
    }
}

// cmd/add.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var priority string

var addCmd = &cobra.Command{
    Use:   "add [टास्क विवरण]",
    Short: "एक नया टास्क जोड़ें",
    Args:  cobra.MinimumNArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        task := args[0]
        db := viper.GetString("database")

        fmt.Printf("टास्क जोड़ रहा हूँ: %s\n", task)
        fmt.Printf("प्राथमिकता: %s\n", priority)
        fmt.Printf("डेटाबेस: %s\n", db)

        // यहाँ आप वास्तविक टास्क स्टोरेज लागू करेंगे
    },
}

func init() {
    rootCmd.AddCommand(addCmd)

    addCmd.Flags().StringVarP(&priority, "priority", "p", "medium",
        "टास्क प्राथमिकता (कम, मध्यम, उच्च)")
}

// cmd/list.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var showCompleted bool

var listCmd = &cobra.Command{
    Use:   "list",
    Short: "सभी टास्क सूचीबद्ध करें",
    Run: func(cmd *cobra.Command, args []string) {
        db := viper.GetString("database")

        fmt.Printf("टास्क सूचीबद्ध कर रहा हूँ: %s\n", db)
        fmt.Printf("पूर्ण टास्क दिखाएं: %v\n", showCompleted)

        // यहाँ आप वास्तविक टास्क सूचीबद्ध करने का कार्य लागू करेंगे
    },
}

func init() {
    rootCmd.AddCommand(listCmd)

    listCmd.Flags().BoolVarP(&showCompleted, "completed", "c", false,
        "पूर्ण टास्क दिखाएं")
}

# .mytasks.yaml
database: ~/.mytasks.db
format: table
colors: true

notifications:
  enabled: true
  sound: true

priorities:
  high: red
  medium: yellow
  low: green

func getNotificationSettings() {
    enabled := viper.GetBool("notifications.enabled")
    sound := viper.GetBool("notifications.sound")

    fmt.Printf("नोटिफिकेशन्स सक्षम: %v\n", enabled)
    fmt.Printf("साउंड सक्षम: %v\n", sound)
}

func getPriorityColors() map[string]string {
    return viper.GetStringMapString("priorities")
}

export MYTASKS_DATABASE=/tmp/tasks.db
export MYTASKS_NOTIFICATIONS_ENABLED=false
mytasks list

func watchConfig() {
    viper.WatchConfig()
    viper.OnConfigChange(func(e fsnotify.Event) {
        fmt.Println("कॉन्फ़िगरेशन फाइल बदल गई:", e.Name)
        // कॉन्फ़िगरेशन-निर्भर घटकों को रीलोड करें
    })
}

cobra-cli init
cobra-cli add serve
cobra-cli add create

rootCmd.PersistentFlags().StringP("output", "o", "text",
    "आउटपुट फॉर्मेट (टेक्स्ट, जेसन, यामल)")

var rootCmd = &cobra.Command{
    Use:   "myapp",
    Short: "मेरा एप्लिकेशन",
    RunE: func(cmd *cobra.Command, args []string) error {
        if err := doSomething(); err != nil {
            return fmt.Errorf("कुछ करने में विफल: %w", err)
        }
        return nil
    },
}

var cmd = &cobra.Command{
    Use:   "deploy [environment]",
    Short: "एप्लिकेशन को निर्दिष्ट वातावरण में डिप्लॉय करें",
    Long: `डिप्लॉय बिल्ड और डिप्लॉय करता है
आपका एप्लिकेशन निर्दिष्ट वातावरण में। समर्थित वातावरण हैं:
  - विकास (dev)
  - स्टेजिंग
  - उत्पादन (prod)`,
    Example: `  myapp deploy staging
  myapp deploy production --version=1.2.3`,
}

func init() {
    viper.SetDefault("port", 8080)
    viper.SetDefault("timeout", "30s")
    viper.SetDefault("retries", 3)
}

func validateConfig() error {
    port := viper.GetInt("port")
    if port < 1024 || port > 65535 {
        return fmt.Errorf("अमान्य पोर्ट: %d", port)
    }
    return nil
}

// cmd/root_test.go
package cmd

import (
    "bytes"
    "testing"
)

func TestRootCommand(t *testing.T) {
    cmd := rootCmd
    b := bytes.NewBufferString("")
    cmd.SetOut(b)
    cmd.SetArgs([]string{"--help"})

    if err := cmd.Execute(); err != nil {
        t.Fatalf("command execution failed: %v", err)
    }
}

func TestWithConfig(t *testing.T) {
    viper.Set("database", "/tmp/test.db")
    viper.Set("debug", true)

    // अपने परीक्षण चलाएं

    viper.Reset() // साफ़-सफाई करें
}

// cmd/completion.go
package cmd

import (
    "os"
    "github.com/spf13/cobra"
)

var completionCmd = &cobra.Command{
    Use:   "completion [bash|zsh|fish|powershell]",
    Short: "पूर्णता स्क्रिप्ट उत्पन्न करें",
    Long: `पूर्णताओं को लोड करने के लिए:

Bash:
  $ source <(mytasks completion bash)

Zsh:
  $ source <(mytasks completion zsh)

Fish:
  $ mytasks completion fish | source

PowerShell:
  PS> mytasks completion powershell | Out-String | Invoke-Expression
`,
    DisableFlagsInUseLine: true,
    ValidArgs: []string{"bash", "zsh", "fish", "powershell"},
    Args: cobra.ExactValidArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        switch args[0] {
        case "bash":
            cmd.Root().GenBashCompletion(os.Stdout)
        case "zsh":
            cmd.Root().GenZshCompletion(os.Stdout)
        case "fish":
            cmd.Root().GenFishCompletion(os.Stdout, true)
        case "powershell":
            cmd.Root().GenPowerShellCompletionWithDesc(os.Stdout)
        }
    },
}

func init() {
    rootCmd.AddCommand(completionCmd)
}

# Linux
GOOS=linux GOARCH=amd64 go build -o mytasks-linux-amd64

# macOS
GOOS=darwin GOARCH=amd64 go build -o mytasks-darwin-amd64
GOOS=darwin GOARCH=arm64 go build -o mytasks-darwin-arm64

# Windows
GOOS=windows GOARCH=amd64 go build -o mytasks-windows-amd64.exe

go build -ldflags="-s -w" -o mytasks

// cmd/version.go
package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
)

var (
    Version   = "dev"
    Commit    = "none"
    BuildTime = "unknown"
)

var versionCmd = &cobra.Command{
    Use:   "version",
    Short: "संस्करण जानकारी प्रिंट करें",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("Version: %s\n", Version)
        fmt.Printf("Commit: %s\n", Commit)
        fmt.Printf("Built: %s\n", BuildTime)
    },
}

func init() {
    rootCmd.AddCommand(versionCmd)
}

go build -ldflags="-X 'mytasks/cmd.Version=1.0.0' \
    -X 'mytasks/cmd.Commit=$(git rev-parse HEAD)' \
    -X 'mytasks/cmd.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)'" \
    -o mytasks