mirror of
https://github.com/rwinkhart/go-highlite.git
synced 2026-08-29 05:16:26 -04:00
131 lines
4.2 KiB
Markdown
131 lines
4.2 KiB
Markdown
# Highlight
|
|
|
|
This is a package for syntax highlighting a large number of different languages. To see the list of
|
|
languages currently supported, see the [`syntax_files`](./syntax_files) directory.
|
|
|
|
Highlight allows you to pass in a string and get back all the information you need to syntax highlight
|
|
that string well.
|
|
|
|
This project is still a work in progress and more features and documentation will be coming later.
|
|
|
|
# Installation
|
|
|
|
```
|
|
go get github.com/zyedidia/highlight
|
|
```
|
|
|
|
# Usage
|
|
|
|
Here is how to use this package to highlight a string. We will also be using `github.com/fatih/color` to actually
|
|
colorize the output to the console.
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"strings"
|
|
|
|
"github.com/fatih/color"
|
|
"github.com/zyedidia/highlight"
|
|
)
|
|
|
|
func main() {
|
|
// Here is the go code we will highlight
|
|
inputString := `
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
// A hello world program
|
|
func main() {
|
|
fmt.Println("Hello world")
|
|
}
|
|
`
|
|
|
|
// Load the go syntax file
|
|
// Make sure that the syntax_files directory is in the current directory
|
|
syntaxFile, _ := ioutil.ReadFile("syntax_files/go.yaml")
|
|
|
|
// Parse it into a `*highlight.Def`
|
|
syntaxDef, err := highlight.ParseDef(syntaxFile)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
|
|
// Make a new highlighter from the definition
|
|
h := highlight.NewHighlighter(syntaxDef)
|
|
// Highlight the string
|
|
// Matches is an array of maps which point to groups
|
|
// matches[lineNum][colNum] will give you the change in group at that line and column number
|
|
// Note that there is only a group at a line and column number if the syntax highlighting changed at that position
|
|
matches := h.Highlight(inputString)
|
|
|
|
// We split the string into a bunch of lines
|
|
// Now we will print the string
|
|
lines := strings.Split(inputString, "\n")
|
|
for lineN, l := range lines {
|
|
for colN, c := range l {
|
|
// Check if the group changed at the current position
|
|
if group, ok := matches[lineN][colN]; ok {
|
|
// Check the group name and set the color accordingly (the colors chosen are arbitrary)
|
|
if group == "statement" {
|
|
color.Set(color.FgGreen)
|
|
} else if group == "identifier" {
|
|
color.Set(color.FgBlue)
|
|
} else if group == "preproc" {
|
|
color.Set(color.FgHiRed)
|
|
} else if group == "special" {
|
|
color.Set(color.FgRed)
|
|
} else if group == "constant.string" {
|
|
color.Set(color.FgCyan)
|
|
} else if group == "constant" {
|
|
color.Set(color.FgCyan)
|
|
} else if group == "constant.specialChar" {
|
|
color.Set(color.FgHiMagenta)
|
|
} else if group == "type" {
|
|
color.Set(color.FgYellow)
|
|
} else if group == "constant.number" {
|
|
color.Set(color.FgCyan)
|
|
} else if group == "comment" {
|
|
color.Set(color.FgHiGreen)
|
|
} else {
|
|
color.Unset()
|
|
}
|
|
}
|
|
// Print the character
|
|
fmt.Print(string(c))
|
|
}
|
|
// This is at a newline, but highlighting might have been turned off at the very end of the line so we should check that.
|
|
if group, ok := matches[lineN][len(l)]; ok {
|
|
if group == "" {
|
|
color.Unset()
|
|
}
|
|
}
|
|
|
|
fmt.Print("\n")
|
|
}
|
|
}
|
|
```
|
|
|
|
If you would like to automatically detect the filetype of a file based on the filename, and have the appropriate definition returned,
|
|
you can use the `DetectFiletype` function:
|
|
|
|
```go
|
|
// Name of the file
|
|
filename := ...
|
|
// The first line of the file (needed to check the filetype by header: e.g. `#!/bin/bash` means shell)
|
|
firstLine := ...
|
|
|
|
// Parse all the syntax files in an array with type []*highlight.Def
|
|
var defs []*highlight.Def
|
|
...
|
|
|
|
def := highlight.DetectFiletype(defs, filename, firstLine)
|
|
fmt.Println("Filetype is", def.ft)
|
|
```
|
|
|
|
For a full example, see the [`syncat`](./examples) example which acts like cat but will syntax highlight the output (if highlight recognizes the filetype).
|