gfu/main.go

/*
gfu - gophermap format utility

`gfu` manipulates gophermaps (gopher menus). It is intended to be used as part of an automation chain for managing a gopherhole using maps as the main doctype, easily allowing any document to contain links.

`gfu` can:
- Convert all lines in a file that are not valid gopher links into gopher info text (item type 'i') lines
- Deconstructing all gopher info text lines in a file back to plain text for easy editing

There are also plans to include additional features, such as:
- Adding the contents of a header file into the gophermap
- Adding the contents of a footer file into the gophermap
*Please note - Many servers already support includes, so the above may not be needed. If you are interested in this feature, you may want to check your server documentation first.*
*

Documentation

For information on using `gfu`, see the help information:
 gfu --help

Information on building, downloading and installing `gfu` can be found at:
https://tildegit.org/sloum/gfu

Further information on gfu can be found at the `gfu` homepage:
https://rawtext.club/~sloum/gfu.html
*/
package main

import (
	"bufio"
	"bytes"
	"flag"
	"fmt"
	"io"
	"os"
	"regexp"
	"strings"
)

var re = regexp.MustCompile(`.+\t.*\t.*\t.*`)

func errorExit(e error, msg string) {
	if e != nil {
		fmt.Print(msg)
		os.Exit(1)
	}
}

func buildInfoText(ln string) string {
	var out strings.Builder
	out.Grow(20 + len(ln))
	out.WriteString("i")
	out.WriteString(ln)
	out.WriteString("\tfalse\tnull.host\t1")
	return out.String()
}

func deconstructInfoText(ln string) string {
	text := strings.SplitN(ln, "\t", 2)
	infotext := text[0]
	if len(infotext) > 1 {
		return infotext[1:]
	}
	return ""
}

func readFile(path string, build bool) bytes.Buffer {
	file, err := os.Open(path)
	errorExit(err, fmt.Sprintf("Unable to open file for reading: %s\n", path))
	defer file.Close()
	return processFile(file, build)
}

func processFile(file io.Reader, build bool) bytes.Buffer {
	scanner := bufio.NewScanner(file)
	var outFile bytes.Buffer

	if build {
		for scanner.Scan() {
			l := scanner.Text()
			if exp := re.MatchString(l); exp {
				outFile.WriteString(l)
			} else {
				outFile.WriteString(buildInfoText(l))
			}
			outFile.WriteString("\n")
		}
	} else {
		for scanner.Scan() {
			l := scanner.Text()
			if exp := re.MatchString(l); exp && l[0] == 'i' {
				outFile.WriteString(deconstructInfoText(l))
			} else {
				outFile.WriteString(l)
			}
			outFile.WriteString("\n")
		}
	}
	if err := scanner.Err(); err != nil {
		errorExit(err, fmt.Sprintf("Error while reading file\n"))
	}
	return outFile
}

func writeFile(path string, outFile bytes.Buffer) {
	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0)
	errorExit(err, fmt.Sprintf("Unable to open file for writing: %s\n", path))
	defer file.Close()
	file.Write(outFile.Bytes())
}

func PrintHelp() {
	art := `gfu - gophermap formatting utility

syntax: gfu [flags...] [filepath]

example: gfu -d ~/gopher/phlog/gophermap

default
	Convert plain text lines to gophermap info text (item type 'i') lines
`
	fmt.Fprint(os.Stderr, art)
	flag.PrintDefaults()
}

func main() {
	//command-line flags and responses
	deconstructInfoTextLines := flag.Bool("d", false, "Deconstruct a gophermap's info text lines back to plain text")
	header := flag.String("head", "", "Path to a file containing header content")
	footer := flag.String("foot", "", "Path to a file containing footer content")
	stdout := flag.Bool("stdout", false, "Instead of writing changes to a file, return them to stdout")
	flag.Usage = PrintHelp

	flag.Parse()
	args := flag.Args()

	if l := len(args); l != 1 {
		fmt.Printf("Incorrect number of arguments. Expected 1, got %d\n", l)
		os.Exit(1)
	}

	//main program
	if *header != "" {
		fmt.Println("Header functionality is not built yet, proceeding with general gophermap conversion...")
	}

	if *footer != "" {
		fmt.Println("Footer functionality is not built yet, proceeding with general gophermap conversion...")
	}

	outFile := readFile(args[0], !*deconstructInfoTextLines)

	if *stdout {
		fmt.Print(outFile.String())
	} else {
		writeFile(args[0], outFile)
	}
	os.Exit(0)
}