Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/zyedidia/highlight
A Go package for syntax highlighting
https://github.com/zyedidia/highlight
golang syntax-highlighting
Last synced: 6 days ago
JSON representation
A Go package for syntax highlighting
- Host: GitHub
- URL: https://github.com/zyedidia/highlight
- Owner: zyedidia
- License: other
- Created: 2017-02-12T16:21:15.000Z (almost 8 years ago)
- Default Branch: master
- Last Pushed: 2023-07-19T17:12:05.000Z (over 1 year ago)
- Last Synced: 2024-12-10T19:36:34.388Z (15 days ago)
- Topics: golang, syntax-highlighting
- Language: Go
- Homepage:
- Size: 1.02 MB
- Stars: 55
- Watchers: 6
- Forks: 33
- Open Issues: 8
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Highlight
[](https://goreportcard.com/report/github.com/zyedidia/highlight)
[](http://godoc.org/github.com/zyedidia/highlight)
[](https://github.com/zyedidia/highlight/blob/master/LICENSE)
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("highlight/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.HighlightString(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 == highlight.Groups["statement"] {
color.Set(color.FgGreen)
} else if group == highlight.Groups["preproc"] {
color.Set(color.FgHiRed)
} else if group == highlight.Groups["special"] {
color.Set(color.FgBlue)
} else if group == highlight.Groups["constant.string"] {
color.Set(color.FgCyan)
} else if group == highlight.Groups["constant.specialChar"] {
color.Set(color.FgHiMagenta)
} else if group == highlight.Groups["type"] {
color.Set(color.FgYellow)
} else if group == highlight.Groups["constant.number"] {
color.Set(color.FgCyan)
} else if group == highlight.Groups["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 == highlight.Groups["default"] || group == highlight.Groups[""] {
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.FileType)
```
For a full example, see the [`syncat`](./examples) example which acts like cat but will syntax highlight the output (if highlight recognizes the filetype).