Module: Template

Included in:

Exer::Make

Defined in:

lib/exer/template/main.rb,
lib/exer/template/functions.rb

Overview

Set of predefined functions in go language. Consist of function definitions, and main function that run it.

Constant Summary

MAIN_FUNCTION =

Main functions in golang file.

{
  binary_exist: 'BinaryExist("COMMAND")',
  ruby_exist: 'RubyExist()',
  ruby_exec: 'RubyExec("COMMAND")',
  gem_install: 'GemInstall("COMMAND")',
  gem_run: 'GemRun("COMMAND")'
}.freeze

WAIT_FOR_ENTER =

Wait for user to press enter before exit. Useful only when you install gem without running.

<<~CODE

   fmt.Println("")
   fmt.Println("Press [ENTER] key to exit")
  var reader = bufio.NewReader(os.Stdin)
  reader.ReadString('\\n')
CODE

GO_PACKAGES =

<<~CODE
  package main
  import ("bytes"; "fmt"; "os"; "os/exec"; "syscall"; "runtime";)
CODE

BINARY_EXIST =

<<~CODE
  func BinaryExist(binary string) (string, error) {
    path, err := exec.LookPath(binary)
    if err == nil {
        fmt.Println("[+] Found", binary, "binary:", path)
    } else {
        fmt.Println("[-]", binary, "binary not found in path")
    }
    return path, err
  }
CODE

RUBY_EXIST =

<<~CODE
  func RubyExist() (string, error) {
    rbin, rerr := BinaryExist("ruby")

    if rerr == nil {
        RubyExec("print '[+] Ruby Version: ' + RUBY_VERSION")
        RubyExec("print '[+] Ruby Platform: ' + RUBY_PLATFORM")
    } else {
        fmt.Println("Error:", rerr)
        os.Exit(1)
    }
    return rbin, rerr
  }
CODE

RUBY_EXEC =

<<~CODE
  func RubyExec(command string) (string, string, error) {
    var stdout bytes.Buffer
    var stderr bytes.Buffer

    cmd := exec.Command("ruby", "-e", command)

    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    err := cmd.Run()

    sout := stdout.String()
    serr := stderr.String()

    if err == nil {
        fmt.Println(sout)
    } else {
        fmt.Println("Error:", serr, err)
    }
    return sout, serr, err
  }
CODE

GEM_INSTALL =

<<~CODE
  func GemInstall(gem string) (string, string, error) {
    _, gerr := exec.LookPath("gem")
    if gerr != nil { fmt.Println(gerr); os.Exit(1) }

    var stdout bytes.Buffer
    var stderr bytes.Buffer

    cmd := exec.Command("gem", "install", gem, "--no-doc")

    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    err := cmd.Run()

    sout := stdout.String()
    serr := stderr.String()

    if err == nil {
        fmt.Println(sout)
    } else {
        fmt.Println("Error:", serr, err)
    }
    return sout, serr, err
  }
CODE

GEM_RUN =

<<~CODE
  func GemRun(command string) {
    envs := os.Environ()
    cpath, cerr := BinaryExist(command)
    if cerr != nil { GemInstall(command); cpath, cerr = BinaryExist(command) }

    os := runtime.GOOS
    switch os {
    case "windows":
        cmd := exec.Command("cmd", "/c", "start", cpath)
        err := cmd.Run()
        if err != nil { fmt.Println(err) }
    case "linux", "darwin":
        com := []string{command}
        err := syscall.Exec(cpath, com, envs)
        if err != nil { fmt.Println(err) }
    }
  }
CODE

FUNCTION =

Predefined functions in golang. go_packages always go first.

{
  go_packages: GO_PACKAGES,
  binary_exist: BINARY_EXIST,
  ruby_exist: RUBY_EXIST,
  ruby_exec: RUBY_EXEC,
  gem_install: GEM_INSTALL,
  gem_run: GEM_RUN
}.freeze