+
+`, htmlSig, dps.FuncName))
for _, doc := range dps.Doc {
if !strings.HasPrefix(doc, "---") {
- f.WriteString(doc + "\n")
+ f.WriteString(doc + " \n")
}
}
- f.WriteString("\n")
+ f.WriteString("#### Parameters\n")
+ if len(dps.Params) == 0 {
+ f.WriteString("This function has no parameters. \n")
+ }
+ for _, p := range dps.Params {
+ isVariadic := false
+ typ := p.Type
+ if strings.HasPrefix(p.Type, "...") {
+ isVariadic = true
+ typ = p.Type[3:]
+ }
+
+ f.WriteString(fmt.Sprintf("`%s` **`%s`**", typ, p.Name))
+ if isVariadic {
+ f.WriteString(" (This type is variadic. You can pass an infinite amount of parameters with this type.)")
+ }
+ f.WriteString(" \n")
+ f.WriteString(strings.Join(p.Doc, " "))
+ f.WriteString("\n\n")
+ }
+ if codeExample := dps.Tags["example"]; codeExample != nil {
+ f.WriteString("#### Example\n")
+ f.WriteString(fmt.Sprintf("```lua\n%s\n````\n", strings.Join(codeExample[0].fields, "\n")))
+ }
+ f.WriteString("
")
+ f.WriteString("\n\n")
}
}
if len(modu.Types) != 0 {
f.WriteString("## Types\n")
for _, dps := range modu.Types {
+ f.WriteString("\n\n")
f.WriteString(fmt.Sprintf("## %s\n", dps.FuncName))
for _, doc := range dps.Doc {
if !strings.HasPrefix(doc, "---") {
@@ -484,12 +598,18 @@ func main() {
}
}
if len(dps.Properties) != 0 {
- f.WriteString("### Properties\n")
- for _, dps := range dps.Properties {
- f.WriteString(fmt.Sprintf("- `%s`: ", dps.FuncName))
- f.WriteString(strings.Join(dps.Doc, " "))
- f.WriteString("\n")
+ f.WriteString("## Object properties\n")
+
+ mdTable := md.NewTable(len(dps.Properties), 2)
+ mdTable.SetTitle(0, "")
+ mdTable.SetTitle(1, "")
+
+ for i, d := range dps.Properties {
+ mdTable.SetContent(i, 0, d.FuncName)
+ mdTable.SetContent(i, 1, strings.Join(d.Doc, " "))
}
+ f.WriteString(mdTable.String())
+ f.WriteString("\n")
}
f.WriteString("\n")
f.WriteString("### Methods\n")
diff --git a/website/content/docs/_index.md b/docs/_index.md
similarity index 100%
rename from website/content/docs/_index.md
rename to docs/_index.md
diff --git a/docs/api/bait.md b/docs/api/bait.md
index a70eb17..9bed78d 100644
--- a/docs/api/bait.md
+++ b/docs/api/bait.md
@@ -8,27 +8,156 @@ menu:
---
## Introduction
-Bait is the event emitter for Hilbish. Why name it bait? Why not.
-It throws hooks that you can catch. This is what you will use if
-you want to listen in on hooks to know when certain things have
-happened, like when you've changed directory, a command has failed,
-etc. To find all available hooks thrown by Hilbish, see doc hooks.
+
+Bait is the event emitter for Hilbish. Much like Node.js and
+its `events` system, many actions in Hilbish emit events.
+Unlike Node.js, Hilbish events are global. So make sure to
+pick a unique name!
+
+Usage of the Bait module consists of userstanding
+event-driven architecture, but it's pretty simple:
+If you want to act on a certain event, you can `catch` it.
+You can act on events via callback functions.
+
+Examples of this are in the Hilbish default config!
+Consider this part of it:
+```lua
+bait.catch('command.exit', function(code)
+ running = false
+ doPrompt(code ~= 0)
+ doNotifyPrompt()
+end)
+```
+
+What this does is, whenever the `command.exit` event is thrown,
+this function will set the user prompt.
## Functions
-### catch(name, cb)
-Catches a hook with `name`. Runs the `cb` when it is thrown
+|||
+|----|----|
+|catch(name, cb)|Catches an event. This function can be used to act on events.|
+|catchOnce(name, cb)|Catches an event, but only once. This will remove the hook immediately after it runs for the first time.|
+|hooks(name) -> table|Returns a list of callbacks that are hooked on an event with the corresponding `name`.|
+|release(name, catcher)|Removes the `catcher` for the event with `name`.|
+|throw(name, ...args)|Throws a hook with `name` with the provided `args`.|
-### catchOnce(name, cb)
-Same as catch, but only runs the `cb` once and then removes the hook
+
-### hooks(name) -> table
-Returns a table with hooks (callback functions) on the event with `name`.
+Catches an event. This function can be used to act on events.
+
+
+#### Parameters
+`string` **`name`**
+The name of the hook.
-### release(name, catcher)
-Removes the `catcher` for the event with `name`.
-For this to work, `catcher` has to be the same function used to catch
-an event, like one saved to a variable.
+`function` **`cb`**
+The function that will be called when the hook is thrown.
-### throw(name, ...args)
-Throws a hook with `name` with the provided `args`
+#### Example
+```lua
+bait.catch('hilbish.exit', function()
+ print 'Goodbye Hilbish!'
+end)
+````
+
+
+Catches an event, but only once. This will remove the hook immediately after it runs for the first time.
+#### Parameters
+`string` **`name`**
+The name of the event
+
+`function` **`cb`**
+The function that will be called when the event is thrown.
+
+
+
+Returns a list of callbacks that are hooked on an event with the corresponding `name`.
+#### Parameters
+`string` **`name`**
+The name of the function
+
+
+
+Removes the `catcher` for the event with `name`.
+For this to work, `catcher` has to be the same function used to catch
+an event, like one saved to a variable.
+
+
+#### Parameters
+`string` **`name`**
+Name of the event the hook is on
+
+`function` **`catcher`**
+Hook function to remove
+
+#### Example
+```lua
+local hookCallback = function() print 'hi' end
+
+bait.catch('event', hookCallback)
+
+-- a little while later....
+bait.release('event', hookCallback)
+-- and now hookCallback will no longer be ran for the event.
+````
+
+
+Throws a hook with `name` with the provided `args`.
+
+
+#### Parameters
+`string` **`name`**
+The name of the hook.
+
+`any` **`args`** (This type is variadic. You can pass an infinite amount of parameters with this type.)
+The arguments to pass to the hook.
+
+#### Example
+```lua
+bait.throw('greeting', 'world')
+
+-- This can then be listened to via
+bait.catch('gretting', function(greetTo)
+ print('Hello ' .. greetTo)
+end)
+````
+
diff --git a/docs/api/commander.md b/docs/api/commander.md
index 341eeda..3614f90 100644
--- a/docs/api/commander.md
+++ b/docs/api/commander.md
@@ -9,11 +9,10 @@ menu:
## Introduction
-Commander is a library for writing custom commands in Lua.
-In order to make it easier to write commands for Hilbish,
-not require separate scripts and to be able to use in a config,
-the Commander library exists. This is like a very simple wrapper
-that works with Hilbish for writing commands. Example:
+Commander is the library which handles Hilbish commands. This makes
+the user able to add Lua-written commands to their shell without making
+a separate script in a bin folder. Instead, you may simply use the Commander
+library in your Hilbish config.
```lua
local commander = require 'commander'
@@ -28,19 +27,65 @@ that will print `Hello world!` to output. One question you may
have is: What is the `sinks` parameter?
The `sinks` parameter is a table with 3 keys: `in`, `out`,
-and `err`. The values of these is a Sink.
+and `err`. All of them are a Sink.
-- `in` is the standard input. You can read from this sink
-to get user input. (**This is currently unimplemented.**)
-- `out` is standard output. This is usually where text meant for
-output should go.
-- `err` is standard error. This sink is for writing errors, as the
-name would suggest.
+- `in` is the standard input.
+You may use the read functions on this sink to get input from the user.
+- `out` is standard output.
+This is usually where command output should go.
+- `err` is standard error.
+This sink is for writing errors, as the name would suggest.
## Functions
-### deregister(name)
-Deregisters any command registered with `name`
+|||
+|----|----|
+|deregister(name)|Removes the named command. Note that this will only remove Commander-registered commands.|
+|register(name, cb)|Adds a new command with the given `name`. When Hilbish has to run a command with a name,|
-### register(name, cb)
-Register a command with `name` that runs `cb` when ran
+
+
+Removes the named command. Note that this will only remove Commander-registered commands.
+#### Parameters
+`string` **`name`**
+Name of the command to remove.
+
+
+
+Adds a new command with the given `name`. When Hilbish has to run a command with a name,
+it will run the function providing the arguments and sinks.
+
+
+#### Parameters
+`string` **`name`**
+Name of the command
+
+`function` **`cb`**
+Callback to handle command invocation
+
+#### Example
+```lua
+-- When you run the command `hello` in the shell, it will print `Hello world`.
+-- If you run it with, for example, `hello Hilbish`, it will print 'Hello Hilbish'
+commander.register('hello', function(args, sinks)
+ local name = 'world'
+ if #args > 0 then name = args[1] end
+
+ sinks.out:writeln('Hello ' .. name)
+end)
+````
+
diff --git a/docs/api/fs.md b/docs/api/fs.md
index ee6949f..0bda1c8 100644
--- a/docs/api/fs.md
+++ b/docs/api/fs.md
@@ -8,44 +8,223 @@ menu:
---
## Introduction
-The fs module provides easy and simple access to filesystem functions
-and other things, and acts an addition to the Lua standard library's
-I/O and filesystem functions.
+
+The fs module provides filesystem functions to Hilbish. While Lua's standard
+library has some I/O functions, they're missing a lot of the basics. The `fs`
+library offers more functions and will work on any operating system Hilbish does.
## Functions
-### abs(path) -> string
-Gives an absolute version of `path`.
+|||
+|----|----|
+|abs(path) -> string|Returns an absolute version of the `path`.|
+|basename(path) -> string|Returns the "basename," or the last part of the provided `path`. If path is empty,|
+|cd(dir)|Changes Hilbish's directory to `dir`.|
+|dir(path) -> string|Returns the directory part of `path`. If a file path like|
+|glob(pattern) -> matches (table)|Match all files based on the provided `pattern`.|
+|join(...path) -> string|Takes any list of paths and joins them based on the operating system's path separator.|
+|mkdir(name, recursive)|Creates a new directory with the provided `name`.|
+|readdir(path) -> table[string]|Returns a list of all files and directories in the provided path.|
+|stat(path) -> {}|Returns the information about a given `path`.|
-### basename(path) -> string
-Gives the basename of `path`. For the rules,
-see Go's filepath.Base
+## Static module fields
+|||
+|----|----|
+|pathSep|The operating system's path separator.|
-### cd(dir)
-Changes directory to `dir`
+
-### dir(path) -> string
-Returns the directory part of `path`. For the rules, see Go's
-filepath.Dir
+Returns an absolute version of the `path`.
+This can be used to resolve short paths like `..` to `/home/user`.
+#### Parameters
+`string` **`path`**
-### glob(pattern) -> matches (table)
-Glob all files and directories that match the pattern.
-For the rules, see Go's filepath.Glob
-### join(...) -> string
-Takes paths and joins them together with the OS's
-directory separator (forward or backward slash).
+
-### mkdir(name, recursive)
-Makes a directory called `name`. If `recursive` is true, it will create its parent directories.
+
-### readdir(dir) -> {}
-Returns a table of files in `dir`.
+Returns the "basename," or the last part of the provided `path`. If path is empty,
+`.` will be returned.
+#### Parameters
+`string` **`path`**
+Path to get the base name of.
-### stat(path) -> {}
-Returns a table of info about the `path`.
-It contains the following keys:
-name (string) - Name of the path
-size (number) - Size of the path
-mode (string) - Permission mode in an octal format string (with leading 0)
-isDir (boolean) - If the path is a directory
+
+
+Returns the directory part of `path`. If a file path like
+`~/Documents/doc.txt` then this function will return `~/Documents`.
+#### Parameters
+`string` **`path`**
+Path to get the directory for.
+
+
+
+Match all files based on the provided `pattern`.
+For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match
+
+
+#### Parameters
+`string` **`pattern`**
+Pattern to compare files with.
+
+#### Example
+```lua
+--[[
+ Within a folder that contains the following files:
+ a.txt
+ init.lua
+ code.lua
+ doc.pdf
+]]--
+local matches = fs.glob './*.lua'
+print(matches)
+-- -> {'init.lua', 'code.lua'}
+````
+
+
+Takes any list of paths and joins them based on the operating system's path separator.
+
+
+#### Parameters
+`string` **`path`** (This type is variadic. You can pass an infinite amount of parameters with this type.)
+Paths to join together
+
+#### Example
+```lua
+-- This prints the directory for Hilbish's config!
+print(fs.join(hilbish.userDir.config, 'hilbish'))
+-- -> '/home/user/.config/hilbish' on Linux
+````
+
+
+Creates a new directory with the provided `name`.
+With `recursive`, mkdir will create parent directories.
+
+-- This will create the directory foo, then create the directory bar in the
+-- foo directory. If recursive is false in this case, it will fail.
+fs.mkdir('./foo/bar', true)
+#### Parameters
+`string` **`name`**
+Name of the directory
+
+`boolean` **`recursive`**
+Whether to create parent directories for the provided name
+
+#### Example
+```lua
+
+````
+
+
+Returns the information about a given `path`.
+The returned table contains the following values:
+name (string) - Name of the path
+size (number) - Size of the path in bytes
+mode (string) - Unix permission mode in an octal format string (with leading 0)
+isDir (boolean) - If the path is a directory
+
+
+#### Parameters
+`string` **`path`**
+
+
+#### Example
+```lua
+local inspect = require 'inspect'
+
+local stat = fs.stat '~'
+print(inspect(stat))
+--[[
+Would print the following:
+{
+ isDir = true,
+ mode = "0755",
+ name = "username",
+ size = 12288
+}
+]]--
+````
+
diff --git a/docs/api/hilbish/_index.md b/docs/api/hilbish/_index.md
index a683172..8278376 100644
--- a/docs/api/hilbish/_index.md
+++ b/docs/api/hilbish/_index.md
@@ -11,108 +11,313 @@ menu:
The Hilbish module includes the core API, containing
interfaces and functions which directly relate to shell functionality.
-## Interface fields
-- `ver`: The version of Hilbish
-- `goVersion`: The version of Go that Hilbish was compiled with
-- `user`: Username of the user
-- `host`: Hostname of the machine
-- `dataDir`: Directory for Hilbish data files, including the docs and default modules
-- `interactive`: Is Hilbish in an interactive shell?
-- `login`: Is Hilbish the login shell?
-- `vimMode`: Current Vim input mode of Hilbish (will be nil if not in Vim input mode)
-- `exitCode`: xit code of the last executed command
-
## Functions
-### alias(cmd, orig)
-Sets an alias of `cmd` to `orig`
+|||
+|----|----|
+|alias(cmd, orig)|Sets an alias of `cmd` to `orig`|
+|appendPath(dir)|Appends `dir` to $PATH|
+|complete(scope, cb)|Registers a completion handler for `scope`.|
+|cwd() -> string|Returns the current directory of the shell|
+|exec(cmd)|Replaces running hilbish with `cmd`|
+|goro(fn)|Puts `fn` in a goroutine|
+|highlighter(line)|Line highlighter handler. This is mainly for syntax highlighting, but in|
+|hinter(line, pos)|The command line hint handler. It gets called on every key insert to|
+|inputMode(mode)|Sets the input mode for Hilbish's line reader. Accepts either emacs or vim|
+|interval(cb, time) -> @Timer|Runs the `cb` function every `time` milliseconds.|
+|multiprompt(str)|Changes the continued line prompt to `str`|
+|prependPath(dir)|Prepends `dir` to $PATH|
+|prompt(str, typ)|Changes the shell prompt to `str`|
+|read(prompt) -> input (string)|Read input from the user, using Hilbish's line editor/input reader.|
+|run(cmd, returnOut) -> exitCode (number), stdout (string), stderr (string)|Runs `cmd` in Hilbish's sh interpreter.|
+|runnerMode(mode)|Sets the execution/runner mode for interactive Hilbish. This determines whether|
+|timeout(cb, time) -> @Timer|Runs the `cb` function after `time` in milliseconds.|
+|which(name) -> string|Checks if `name` is a valid command.|
-### appendPath(dir)
-Appends `dir` to $PATH
+## Static module fields
+|||
+|----|----|
+|ver|The version of Hilbish|
+|goVersion|The version of Go that Hilbish was compiled with|
+|user|Username of the user|
+|host|Hostname of the machine|
+|dataDir|Directory for Hilbish data files, including the docs and default modules|
+|interactive|Is Hilbish in an interactive shell?|
+|login|Is Hilbish the login shell?|
+|vimMode|Current Vim input mode of Hilbish (will be nil if not in Vim input mode)|
+|exitCode|Exit code of the last executed command|
-### complete(scope, cb)
-Registers a completion handler for `scope`.
-A `scope` is currently only expected to be `command.`,
-replacing with the name of the command (for example `command.git`).
-`cb` must be a function that returns a table of "completion groups."
-Check `doc completions` for more information.
+
-### cwd() -> string
-Returns the current directory of the shell
+Sets an alias of `cmd` to `orig`
+#### Parameters
+This function has no parameters.
+
-### exec(cmd)
-Replaces running hilbish with `cmd`
+
-### goro(fn)
-Puts `fn` in a goroutine
+Appends `dir` to $PATH
+#### Parameters
+This function has no parameters.
+
-### highlighter(line)
-Line highlighter handler. This is mainly for syntax highlighting, but in
-reality could set the input of the prompt to *display* anything. The
-callback is passed the current line and is expected to return a line that
-will be used as the input display.
-Note that to set a highlighter, one has to override this function.
-Example:
-```
-function hilbish.highlighter(line)
- return line:gsub('"%w+"', function(c) return lunacolors.green(c) end)
-end
-```
-This code will highlight all double quoted strings in green.
+
-### hinter(line, pos)
-The command line hint handler. It gets called on every key insert to
-determine what text to use as an inline hint. It is passed the current
-line and cursor position. It is expected to return a string which is used
-as the text for the hint. This is by default a shim. To set hints,
-override this function with your custom handler.
+Registers a completion handler for `scope`.
+A `scope` is currently only expected to be `command.`,
+replacing with the name of the command (for example `command.git`).
+`cb` must be a function that returns a table of "completion groups."
+Check `doc completions` for more information.
+#### Parameters
+This function has no parameters.
+
-### inputMode(mode)
-Sets the input mode for Hilbish's line reader. Accepts either emacs or vim
+
-### interval(cb, time) -> Timer
-Runs the `cb` function every `time` milliseconds.
-This creates a timer that starts immediately.
+Returns the current directory of the shell
+#### Parameters
+This function has no parameters.
+
-### multiprompt(str)
-Changes the continued line prompt to `str`
+
-### prependPath(dir)
-Prepends `dir` to $PATH
+Replaces running hilbish with `cmd`
+#### Parameters
+This function has no parameters.
+
-### prompt(str, typ)
-Changes the shell prompt to `str`
-There are a few verbs that can be used in the prompt text.
-These will be formatted and replaced with the appropriate values.
-`%d` - Current working directory
-`%u` - Name of current user
-`%h` - Hostname of device
+
-### read(prompt) -> input (string)
-Read input from the user, using Hilbish's line editor/input reader.
-This is a separate instance from the one Hilbish actually uses.
-Returns `input`, will be nil if ctrl + d is pressed, or an error occurs (which shouldn't happen)
+Puts `fn` in a goroutine
+#### Parameters
+This function has no parameters.
+
-### run(cmd, returnOut) -> exitCode (number), stdout (string), stderr (string)
-Runs `cmd` in Hilbish's sh interpreter.
-If returnOut is true, the outputs of `cmd` will be returned as the 2nd and
-3rd values instead of being outputted to the terminal.
+
-### runnerMode(mode)
-Sets the execution/runner mode for interactive Hilbish. This determines whether
-Hilbish wll try to run input as Lua and/or sh or only do one of either.
-Accepted values for mode are hybrid (the default), hybridRev (sh first then Lua),
-sh, and lua. It also accepts a function, to which if it is passed one
-will call it to execute user input instead.
+Line highlighter handler. This is mainly for syntax highlighting, but in
+reality could set the input of the prompt to *display* anything. The
+callback is passed the current line and is expected to return a line that
+will be used as the input display.
+Note that to set a highlighter, one has to override this function.
+Example:
+```
+function hilbish.highlighter(line)
+ return line:gsub('"%w+"', function(c) return lunacolors.green(c) end)
+end
+```
+This code will highlight all double quoted strings in green.
+#### Parameters
+This function has no parameters.
+
-### timeout(cb, time) -> Timer
-Runs the `cb` function after `time` in milliseconds.
-This creates a timer that starts immediately.
+
-### which(name) -> string
-Checks if `name` is a valid command.
-Will return the path of the binary, or a basename if it's a commander.
+The command line hint handler. It gets called on every key insert to
+determine what text to use as an inline hint. It is passed the current
+line and cursor position. It is expected to return a string which is used
+as the text for the hint. This is by default a shim. To set hints,
+override this function with your custom handler.
+#### Parameters
+This function has no parameters.
+
+
+Runs the `cb` function every `time` milliseconds.
+This creates a timer that starts immediately.
+#### Parameters
+This function has no parameters.
+
+
+Changes the shell prompt to `str`
+There are a few verbs that can be used in the prompt text.
+These will be formatted and replaced with the appropriate values.
+`%d` - Current working directory
+`%u` - Name of current user
+`%h` - Hostname of device
+#### Parameters
+This function has no parameters.
+
+
+Read input from the user, using Hilbish's line editor/input reader.
+This is a separate instance from the one Hilbish actually uses.
+Returns `input`, will be nil if ctrl + d is pressed, or an error occurs (which shouldn't happen)
+#### Parameters
+This function has no parameters.
+
+
+Runs `cmd` in Hilbish's sh interpreter.
+If returnOut is true, the outputs of `cmd` will be returned as the 2nd and
+3rd values instead of being outputted to the terminal.
+#### Parameters
+This function has no parameters.
+
+
+Sets the execution/runner mode for interactive Hilbish. This determines whether
+Hilbish wll try to run input as Lua and/or sh or only do one of either.
+Accepted values for mode are hybrid (the default), hybridRev (sh first then Lua),
+sh, and lua. It also accepts a function, to which if it is passed one
+will call it to execute user input instead.
+#### Parameters
+This function has no parameters.
+
+
+Runs the `cb` function after `time` in milliseconds.
+This creates a timer that starts immediately.
+#### Parameters
+This function has no parameters.
+
+
+Checks if `name` is a valid command.
+Will return the path of the binary, or a basename if it's a commander.
+#### Parameters
+This function has no parameters.
+
## Types
+
+
## Sink
A sink is a structure that has input and/or output to/from
a desination.
diff --git a/docs/api/hilbish/hilbish.aliases.md b/docs/api/hilbish/hilbish.aliases.md
index bae5bfc..4cd5187 100644
--- a/docs/api/hilbish/hilbish.aliases.md
+++ b/docs/api/hilbish/hilbish.aliases.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.aliases
+title: Module hilbish.aliases
description: command aliasing
layout: doc
menu:
@@ -11,15 +11,62 @@ menu:
The alias interface deals with all command aliases in Hilbish.
## Functions
-### add(alias, cmd)
-This is an alias (ha) for the `hilbish.alias` function.
+|||
+|----|----|
+|add(alias, cmd)|This is an alias (ha) for the `hilbish.alias` function.|
+|delete(name)|Removes an alias.|
+|list() -> table|Get a table of all aliases, with string keys as the alias and the value as the command.|
+|resolve(alias) -> command (string)|Tries to resolve an alias to its command.|
-### delete(name)
-Removes an alias.
+
-### list() -> table\
-Get a table of all aliases, with string keys as the alias and the value as the command.
+This is an alias (ha) for the `hilbish.alias` function.
+#### Parameters
+This function has no parameters.
+
-### resolve(alias) -> command (string)
-Tries to resolve an alias to its command.
+
+
+Tries to resolve an alias to its command.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.completions.md b/docs/api/hilbish/hilbish.completions.md
index 6f8740f..53b1db6 100644
--- a/docs/api/hilbish/hilbish.completions.md
+++ b/docs/api/hilbish/hilbish.completions.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.completions
+title: Module hilbish.completions
description: tab completions
layout: doc
menu:
@@ -11,19 +11,66 @@ menu:
The completions interface deals with tab completions.
## Functions
-### call(name, query, ctx, fields) -> completionGroups (table), prefix (string)
-Calls a completer function. This is mainly used to call
-a command completer, which will have a `name` in the form
-of `command.name`, example: `command.git`.
-You can check `doc completions` for info on the `completionGroups` return value.
+|||
+|----|----|
+|call(name, query, ctx, fields) -> completionGroups (table), prefix (string)|Calls a completer function. This is mainly used to call|
+|handler(line, pos)|The handler function is the callback for tab completion in Hilbish.|
+|bins(query, ctx, fields) -> entries (table), prefix (string)|Returns binary/executale completion candidates based on the provided query.|
+|files(query, ctx, fields) -> entries (table), prefix (string)|Returns file completion candidates based on the provided query.|
-### handler(line, pos)
-The handler function is the callback for tab completion in Hilbish.
-You can check the completions doc for more info.
+
-### bins(query, ctx, fields) -> entries (table), prefix (string)
-Returns binary/executale completion candidates based on the provided query.
+Calls a completer function. This is mainly used to call
+a command completer, which will have a `name` in the form
+of `command.name`, example: `command.git`.
+You can check `doc completions` for info on the `completionGroups` return value.
+#### Parameters
+This function has no parameters.
+
-### files(query, ctx, fields) -> entries (table), prefix (string)
-Returns file completion candidates based on the provided query.
+
+
+The handler function is the callback for tab completion in Hilbish.
+You can check the completions doc for more info.
+#### Parameters
+This function has no parameters.
+
+
+Returns file completion candidates based on the provided query.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.editor.md b/docs/api/hilbish/hilbish.editor.md
index d75d4c2..52e6dfc 100644
--- a/docs/api/hilbish/hilbish.editor.md
+++ b/docs/api/hilbish/hilbish.editor.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.editor
+title: Module hilbish.editor
description: interactions for Hilbish's line reader
layout: doc
menu:
@@ -12,19 +12,77 @@ The hilbish.editor interface provides functions to
directly interact with the line editor in use.
## Functions
-### getLine() -> string
-Returns the current input line.
+|||
+|----|----|
+|getLine() -> string|Returns the current input line.|
+|getVimRegister(register) -> string|Returns the text that is at the register.|
+|insert(text)|Inserts text into the line.|
+|getChar() -> string|Reads a keystroke from the user. This is in a format|
+|setVimRegister(register, text)|Sets the vim register at `register` to hold the passed text.|
-### getVimRegister(register) -> string
-Returns the text that is at the register.
+
-### setVimRegister(register, text)
-Sets the vim register at `register` to hold the passed text.
+Returns the text that is at the register.
+#### Parameters
+This function has no parameters.
+
+
+Sets the vim register at `register` to hold the passed text.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.history.md b/docs/api/hilbish/hilbish.history.md
index 9fa9b01..802ea42 100644
--- a/docs/api/hilbish/hilbish.history.md
+++ b/docs/api/hilbish/hilbish.history.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.history
+title: Module hilbish.history
description: command history
layout: doc
menu:
@@ -13,18 +13,76 @@ This includes the ability to override functions to change the main
method of saving history.
## Functions
-### add(cmd)
-Adds a command to the history.
+|||
+|----|----|
+|add(cmd)|Adds a command to the history.|
+|all() -> table|Retrieves all history.|
+|clear()|Deletes all commands from the history.|
+|get(idx)|Retrieves a command from the history based on the `idx`.|
+|size() -> number|Returns the amount of commands in the history.|
-### all() -> table
-Retrieves all history.
+
+
+Returns the amount of commands in the history.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.jobs.md b/docs/api/hilbish/hilbish.jobs.md
index e41be2c..a640726 100644
--- a/docs/api/hilbish/hilbish.jobs.md
+++ b/docs/api/hilbish/hilbish.jobs.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.jobs
+title: Module hilbish.jobs
description: background job management
layout: doc
menu:
@@ -15,32 +15,95 @@ Jobs are the name of background tasks/commands. A job can be started via
interactive usage or with the functions defined below for use in external runners.
## Functions
-### add(cmdstr, args, execPath)
-Adds a new job to the job table. Note that this does not immediately run it.
+|||
+|----|----|
+|add(cmdstr, args, execPath)|Adds a new job to the job table. Note that this does not immediately run it.|
+|all() -> table<@Job>|Returns a table of all job objects.|
+|disown(id)|Disowns a job. This deletes it from the job table.|
+|get(id) -> @Job|Get a job object via its ID.|
+|last() -> @Job|Returns the last added job from the table.|
-### all() -> table\<Job>
-Returns a table of all job objects.
+
-### disown(id)
-Disowns a job. This deletes it from the job table.
+Adds a new job to the job table. Note that this does not immediately run it.
+#### Parameters
+This function has no parameters.
+
-### get(id) -> Job
-Get a job object via its ID.
+
-### last() -> Job
-Returns the last added job from the table.
+Returns a table of all job objects.
+#### Parameters
+This function has no parameters.
+
+
+Returns the last added job from the table.
+#### Parameters
+This function has no parameters.
+
## Types
+
+
## Job
The Job type describes a Hilbish job.
-### Properties
-- `cmd`: The user entered command string for the job.
-- `running`: Whether the job is running or not.
-- `id`: The ID of the job in the job table
-- `pid`: The Process ID
-- `exitCode`: The last exit code of the job.
-- `stdout`: The standard output of the job. This just means the normal logs of the process.
-- `stderr`: The standard error stream of the process. This (usually) includes error messages of the job.
+## Object properties
+|||
+|----|----|
+|cmd|The user entered command string for the job.|
+|running|Whether the job is running or not.|
+|id|The ID of the job in the job table|
+|pid|The Process ID|
+|exitCode|The last exit code of the job.|
+|stdout|The standard output of the job. This just means the normal logs of the process.|
+|stderr|The standard error stream of the process. This (usually) includes error messages of the job.|
+
### Methods
#### background()
diff --git a/docs/api/hilbish/hilbish.module.md b/docs/api/hilbish/hilbish.module.md
index e88ac2c..7a000c1 100644
--- a/docs/api/hilbish/hilbish.module.md
+++ b/docs/api/hilbish/hilbish.module.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.module
+title: Module hilbish.module
description: native module loading
layout: doc
menu:
@@ -43,11 +43,27 @@ func Loader(rtm *rt.Runtime) rt.Value {
This can be compiled with `go build -buildmode=plugin plugin.go`.
If you attempt to require and print the result (`print(require 'plugin')`), it will show "hello world!"
-## Interface fields
-- `paths`: A list of paths to search when loading native modules. This is in the style of Lua search paths and will be used when requiring native modules. Example: `?.so;?/?.so`
-
## Functions
-### load(path)
-Loads a module at the designated `path`.
-It will throw if any error occurs.
+|||
+|----|----|
+|load(path)|Loads a module at the designated `path`.|
+
+## Static module fields
+|||
+|----|----|
+|paths|A list of paths to search when loading native modules. This is in the style of Lua search paths and will be used when requiring native modules. Example: `?.so;?/?.so`|
+
+
+
+Loads a module at the designated `path`.
+It will throw if any error occurs.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.os.md b/docs/api/hilbish/hilbish.os.md
index aa2198e..7749e3d 100644
--- a/docs/api/hilbish/hilbish.os.md
+++ b/docs/api/hilbish/hilbish.os.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.os
+title: Module hilbish.os
description: OS Info
layout: doc
menu:
@@ -12,8 +12,10 @@ The `os` interface provides simple text information properties about
the current OS on the systen. This mainly includes the name and
version.
-## Interface fields
-- `family`: Family name of the current OS
-- `name`: Pretty name of the current OS
-- `version`: Version of the current OS
+## Static module fields
+|||
+|----|----|
+|family|Family name of the current OS|
+|name|Pretty name of the current OS|
+|version|Version of the current OS|
diff --git a/docs/api/hilbish/hilbish.runner.md b/docs/api/hilbish/hilbish.runner.md
index 68ffdc6..c3e2c19 100644
--- a/docs/api/hilbish/hilbish.runner.md
+++ b/docs/api/hilbish/hilbish.runner.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.runner
+title: Module hilbish.runner
description: interactive command runner customization
layout: doc
menu:
@@ -15,17 +15,53 @@ language or script of their choosing. A good example is using it to
write command in Fennel.
## Functions
-### setMode(cb)
-This is the same as the `hilbish.runnerMode` function. It takes a callback,
-which will be used to execute all interactive input.
-In normal cases, neither callbacks should be overrided by the user,
-as the higher level functions listed below this will handle it.
+|||
+|----|----|
+|setMode(cb)|This is the same as the `hilbish.runnerMode` function. It takes a callback,|
+|lua(cmd)|Evaluates `cmd` as Lua input. This is the same as using `dofile`|
+|sh(cmd)|Runs a command in Hilbish's shell script interpreter.|
-### lua(cmd)
-Evaluates `cmd` as Lua input. This is the same as using `dofile`
-or `load`, but is appropriated for the runner interface.
+
-### sh(cmd)
-Runs a command in Hilbish's shell script interpreter.
-This is the equivalent of using `source`.
+This is the same as the `hilbish.runnerMode` function. It takes a callback,
+which will be used to execute all interactive input.
+In normal cases, neither callbacks should be overrided by the user,
+as the higher level functions listed below this will handle it.
+#### Parameters
+This function has no parameters.
+
+
+Evaluates `cmd` as Lua input. This is the same as using `dofile`
+or `load`, but is appropriated for the runner interface.
+#### Parameters
+This function has no parameters.
+
+
+Runs a command in Hilbish's shell script interpreter.
+This is the equivalent of using `source`.
+#### Parameters
+This function has no parameters.
+
diff --git a/docs/api/hilbish/hilbish.timers.md b/docs/api/hilbish/hilbish.timers.md
index e899d1d..3c0fadb 100644
--- a/docs/api/hilbish/hilbish.timers.md
+++ b/docs/api/hilbish/hilbish.timers.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.timers
+title: Module hilbish.timers
description: timeout and interval API
layout: doc
menu:
@@ -30,25 +30,57 @@ t:start()
print(t.running) // true
```
-## Interface fields
-- `INTERVAL`: Constant for an interval timer type
-- `TIMEOUT`: Constant for a timeout timer type
-
## Functions
-### create(type, time, callback) -> Timer
-Creates a timer that runs based on the specified `time` in milliseconds.
-The `type` can either be `hilbish.timers.INTERVAL` or `hilbish.timers.TIMEOUT`
+|||
+|----|----|
+|create(type, time, callback) -> @Timer|Creates a timer that runs based on the specified `time` in milliseconds.|
+|get(id) -> @Timer|Retrieves a timer via its ID.|
-### get(id) -> Timer
-Retrieves a timer via its ID.
+## Static module fields
+|||
+|----|----|
+|INTERVAL|Constant for an interval timer type|
+|TIMEOUT|Constant for a timeout timer type|
+
+
+
+hilbish.timers.create(type, time, callback) -> Timer
+
+
+
+
+
+Creates a timer that runs based on the specified `time` in milliseconds.
+The `type` can either be `hilbish.timers.INTERVAL` or `hilbish.timers.TIMEOUT`
+#### Parameters
+This function has no parameters.
+
+
+Retrieves a timer via its ID.
+#### Parameters
+This function has no parameters.
+
## Types
+
+
## Timer
The Job type describes a Hilbish timer.
-### Properties
-- `type`: What type of timer it is
-- `running`: If the timer is running
-- `duration`: The duration in milliseconds that the timer will run
+## Object properties
+|||
+|----|----|
+|type|What type of timer it is|
+|running|If the timer is running|
+|duration|The duration in milliseconds that the timer will run|
+
### Methods
#### start()
diff --git a/docs/api/hilbish/hilbish.userDir.md b/docs/api/hilbish/hilbish.userDir.md
index 0b95057..a2b7337 100644
--- a/docs/api/hilbish/hilbish.userDir.md
+++ b/docs/api/hilbish/hilbish.userDir.md
@@ -1,5 +1,5 @@
---
-title: Interface hilbish.userDir
+title: Module hilbish.userDir
description: user-related directories
layout: doc
menu:
@@ -12,7 +12,9 @@ This interface just contains properties to know about certain user directories.
It is equivalent to XDG on Linux and gets the user's preferred directories
for configs and data.
-## Interface fields
-- `config`: The user's config directory
-- `data`: The user's directory for program data
+## Static module fields
+|||
+|----|----|
+|config|The user's config directory|
+|data|The user's directory for program data|
diff --git a/docs/api/terminal.md b/docs/api/terminal.md
index 99d4b49..6e72d84 100644
--- a/docs/api/terminal.md
+++ b/docs/api/terminal.md
@@ -11,16 +11,63 @@ menu:
The terminal library is a simple and lower level library for certain terminal interactions.
## Functions
-### restoreState()
-Restores the last saved state of the terminal
+|||
+|----|----|
+|restoreState()|Restores the last saved state of the terminal|
+|saveState()|Saves the current state of the terminal|
+|setRaw()|Puts the terminal in raw mode|
+|size()|Gets the dimensions of the terminal. Returns a table with `width` and `height`|
-### saveState()
-Saves the current state of the terminal
+
-### setRaw()
-Puts the terminal in raw mode
+Restores the last saved state of the terminal
+#### Parameters
+This function has no parameters.
+
-### size()
-Gets the dimensions of the terminal. Returns a table with `width` and `height`
-Note: this is not the size in relation to the dimensions of the display
+
+
+Gets the dimensions of the terminal. Returns a table with `width` and `height`
+Note: this is not the size in relation to the dimensions of the display
+#### Parameters
+This function has no parameters.
+
diff --git a/website/content/docs/faq.md b/docs/faq.md
similarity index 74%
rename from website/content/docs/faq.md
rename to docs/faq.md
index 997fbaa..f89f269 100644
--- a/website/content/docs/faq.md
+++ b/docs/faq.md
@@ -15,11 +15,12 @@ It compiles for Windows (CI ensures it does), but otherwise it is not
directly supported. If you'd like to improve this situation,
checkout [the discussion](https://github.com/Rosettea/Hilbish/discussions/165).
-# Where is the API documentation?
-The builtin `doc` command supplies all documentation of Hilbish provided
-APIs. You can also check the sidebar.
-
# Why?
Hilbish emerged from the desire of a Lua configured shell.
It was the initial reason that it was created, but now it's more:
to be hyper extensible, simpler and more user friendly.
+
+# Does it have "autocompletion" or "tab completion"
+Of course! This is a modern shell. Hilbish provides a way for users
+to write tab completion for any command and/or the whole shell.
+Inline hinting and syntax highlighting are also available.
diff --git a/website/content/docs/features/_index.md b/docs/features/_index.md
similarity index 100%
rename from website/content/docs/features/_index.md
rename to docs/features/_index.md
diff --git a/website/content/docs/features/notifications.md b/docs/features/notifications.md
similarity index 100%
rename from website/content/docs/features/notifications.md
rename to docs/features/notifications.md
diff --git a/website/content/docs/features/runner-mode.md b/docs/features/runner-mode.md
similarity index 100%
rename from website/content/docs/features/runner-mode.md
rename to docs/features/runner-mode.md
diff --git a/website/content/docs/getting-started.md b/docs/getting-started.md
similarity index 100%
rename from website/content/docs/getting-started.md
rename to docs/getting-started.md
diff --git a/docs/hooks/_index.md b/docs/hooks/_index.md
index 6616b05..bb23477 100644
--- a/docs/hooks/_index.md
+++ b/docs/hooks/_index.md
@@ -1,13 +1,11 @@
-Here is a list of bait hooks that are thrown by Hilbish. If a hook is related
-to a command, it will have the `command` scope, as example.
+---
+title: Hooks
+description:
+layout: doc
+weight: -50
+menu:
+ docs
+---
-Here is the format for a doc for a hook:
-+ -> >
-
-`` just means the arguments of the hook. If a hook doc has the format
-of `arg...`, it means the hook can take/recieve any number of `arg`.
-
-+ error -> eventName, handler, err > Emitted when there is an error in
-an event handler. The `eventName` is the name of the event the handler
-is for, the `handler` is the callback function, and `err` is the error
-message.
+Hooks are Hilbish's versions of events, which are used via the [Bait](../api/bait) module.
+For more detail on how to act on these hooks, you may check the Bait page.
diff --git a/docs/hooks/command.md b/docs/hooks/command.md
index 2d29f4b..ee47db7 100644
--- a/docs/hooks/command.md
+++ b/docs/hooks/command.md
@@ -1,12 +1,21 @@
-+ `command.preexec` -> input, cmdStr > Thrown before a command
+---
+title: Command
+description:
+layout: doc
+menu:
+ docs:
+ parent: "Hooks"
+---
+
+- `command.preexec` -> input, cmdStr > Thrown before a command
is executed. The `input` is the user written command, while `cmdStr`
is what will be executed (`input` will have aliases while `cmdStr`
will have alias resolved input).
-+ `command.exit` -> code, cmdStr > Thrown when a command exits.
+- `command.exit` -> code, cmdStr > Thrown when a command exits.
`code` is the exit code of the command, and `cmdStr` is the command that was run.
-+ `command.not-found` -> cmdStr > Thrown when a command is not found.
+- `command.not-found` -> cmdStr > Thrown when a command is not found.
-+ `command.not-executable` -> cmdStr > Thrown when Hilbish attempts to run a file
+- `command.not-executable` -> cmdStr > Thrown when Hilbish attempts to run a file
that is not executable.
diff --git a/docs/hooks/hilbish.md b/docs/hooks/hilbish.md
index 7118901..b240683 100644
--- a/docs/hooks/hilbish.md
+++ b/docs/hooks/hilbish.md
@@ -1,3 +1,12 @@
+---
+title: Hilbish
+description:
+layout: doc
+menu:
+ docs:
+ parent: "Hooks"
+---
+
+ `hilbish.exit` > Sent when Hilbish is about to exit.
+ `hilbish.vimMode` -> modeName > Sent when Hilbish's Vim mode is changed (example insert to normal mode),
diff --git a/docs/hooks/signal.md b/docs/hooks/signal.md
index ac5deed..317ab79 100644
--- a/docs/hooks/signal.md
+++ b/docs/hooks/signal.md
@@ -1,3 +1,12 @@
+---
+title: Signal
+description:
+layout: doc
+menu:
+ docs:
+ parent: "Hooks"
+---
+
+ `signal.sigint` > Sent when Hilbish receives SIGINT (on Ctrl-C).
+ `signal.resize` > Sent when the terminal is resized.
diff --git a/emmyLuaDocs/bait.lua b/emmyLuaDocs/bait.lua
index 35a37ed..09f3d98 100644
--- a/emmyLuaDocs/bait.lua
+++ b/emmyLuaDocs/bait.lua
@@ -2,31 +2,27 @@
local bait = {}
---- Catches a hook with `name`. Runs the `cb` when it is thrown
---- @param name string
---- @param cb function
+--- Catches an event. This function can be used to act on events.
+---
+---
function bait.catch(name, cb) end
---- Same as catch, but only runs the `cb` once and then removes the hook
---- @param name string
---- @param cb function
+--- Catches an event, but only once. This will remove the hook immediately after it runs for the first time.
function bait.catchOnce(name, cb) end
---- Returns a table with hooks (callback functions) on the event with `name`.
---- @param name string
---- @returns table
+--- Returns a list of callbacks that are hooked on an event with the corresponding `name`.
function bait.hooks(name) end
--- Removes the `catcher` for the event with `name`.
--- For this to work, `catcher` has to be the same function used to catch
--- an event, like one saved to a variable.
---- @param name string
---- @param catcher function
+---
+---
function bait.release(name, catcher) end
---- Throws a hook with `name` with the provided `args`
---- @param name string
---- @vararg any
+--- Throws a hook with `name` with the provided `args`.
+---
+---
function bait.throw(name, ...args) end
return bait
diff --git a/emmyLuaDocs/commander.lua b/emmyLuaDocs/commander.lua
index c6738dd..285c4b5 100644
--- a/emmyLuaDocs/commander.lua
+++ b/emmyLuaDocs/commander.lua
@@ -2,13 +2,13 @@
local commander = {}
---- Deregisters any command registered with `name`
---- @param name string
+--- Removes the named command. Note that this will only remove Commander-registered commands.
function commander.deregister(name) end
---- Register a command with `name` that runs `cb` when ran
---- @param name string
---- @param cb function
+--- Adds a new command with the given `name`. When Hilbish has to run a command with a name,
+--- it will run the function providing the arguments and sinks.
+---
+---
function commander.register(name, cb) end
return commander
diff --git a/emmyLuaDocs/fs.lua b/emmyLuaDocs/fs.lua
index e974ab9..6efc2eb 100644
--- a/emmyLuaDocs/fs.lua
+++ b/emmyLuaDocs/fs.lua
@@ -2,56 +2,51 @@
local fs = {}
---- Gives an absolute version of `path`.
---- @param path string
---- @returns string
+--- Returns an absolute version of the `path`.
+--- This can be used to resolve short paths like `..` to `/home/user`.
function fs.abs(path) end
---- Gives the basename of `path`. For the rules,
---- see Go's filepath.Base
---- @returns string
+--- Returns the "basename," or the last part of the provided `path`. If path is empty,
+--- `.` will be returned.
function fs.basename(path) end
---- Changes directory to `dir`
---- @param dir string
+--- Changes Hilbish's directory to `dir`.
function fs.cd(dir) end
---- Returns the directory part of `path`. For the rules, see Go's
---- filepath.Dir
---- @param path string
---- @returns string
+--- Returns the directory part of `path`. If a file path like
+--- `~/Documents/doc.txt` then this function will return `~/Documents`.
function fs.dir(path) end
---- Glob all files and directories that match the pattern.
---- For the rules, see Go's filepath.Glob
---- @param pattern string
---- @returns table
+--- Match all files based on the provided `pattern`.
+--- For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match
+---
+---
function fs.glob(pattern) end
---- Takes paths and joins them together with the OS's
---- directory separator (forward or backward slash).
---- @vararg string
---- @returns string
-function fs.join(...) end
+--- Takes any list of paths and joins them based on the operating system's path separator.
+---
+---
+function fs.join(...path) end
---- Makes a directory called `name`. If `recursive` is true, it will create its parent directories.
---- @param name string
---- @param recursive boolean
+--- Creates a new directory with the provided `name`.
+--- With `recursive`, mkdir will create parent directories.
+---
+--- -- This will create the directory foo, then create the directory bar in the
+--- -- foo directory. If recursive is false in this case, it will fail.
+--- fs.mkdir('./foo/bar', true)
function fs.mkdir(name, recursive) end
---- Returns a table of files in `dir`.
---- @param dir string
---- @return table
-function fs.readdir(dir) end
+--- Returns a list of all files and directories in the provided path.
+function fs.readdir(path) end
---- Returns a table of info about the `path`.
---- It contains the following keys:
+--- Returns the information about a given `path`.
+--- The returned table contains the following values:
--- name (string) - Name of the path
---- size (number) - Size of the path
---- mode (string) - Permission mode in an octal format string (with leading 0)
+--- size (number) - Size of the path in bytes
+--- mode (string) - Unix permission mode in an octal format string (with leading 0)
--- isDir (boolean) - If the path is a directory
---- @param path string
---- @returns table
+---
+---
function fs.stat(path) end
return fs
diff --git a/go.mod b/go.mod
index 1549f76..7bf5efd 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.17
require (
github.com/arnodel/golua v0.0.0-20220221163911-dfcf252b6f86
+ github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504
github.com/blackfireio/osinfo v1.0.3
github.com/maxlandon/readline v0.1.0-beta.0.20211027085530-2b76cabb8036
github.com/pborman/getopt v1.1.0
diff --git a/go.sum b/go.sum
index 7c36fa0..f82ef01 100644
--- a/go.sum
+++ b/go.sum
@@ -8,6 +8,8 @@ github.com/arnodel/edit v0.0.0-20220202110212-dfc8d7a13890/go.mod h1:AcpttpuZBaL
github.com/arnodel/strftime v0.1.6 h1:0hc0pUvk8KhEMXE+htyaOUV42zNcf/csIbjzEFCJqsw=
github.com/arnodel/strftime v0.1.6/go.mod h1:5NbK5XqYK8QpRZpqKNt4OlxLtIB8cotkLk4KTKzJfWs=
github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504 h1:R1/AOzdMbopSliUTTEHvHbyNmnZ3YxY5GvdhTkpPsSY=
+github.com/atsushinee/go-markdown-generator v0.0.0-20191121114853-83f9e1f68504/go.mod h1:kHBCvAXJIatTX1pw6tLiOspjGc3MhUDRlog9yrCUS+k=
github.com/blackfireio/osinfo v1.0.3 h1:Yk2t2GTPjBcESv6nDSWZKO87bGMQgO+Hi9OoXPpxX8c=
github.com/blackfireio/osinfo v1.0.3/go.mod h1:Pd987poVNmd5Wsx6PRPw4+w7kLlf9iJxoRKPtPAjOrA=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
diff --git a/golibs/bait/bait.go b/golibs/bait/bait.go
index 3f3c34e..8f24d17 100644
--- a/golibs/bait/bait.go
+++ b/golibs/bait/bait.go
@@ -1,9 +1,28 @@
// the event emitter
-// Bait is the event emitter for Hilbish. Why name it bait? Why not.
-// It throws hooks that you can catch. This is what you will use if
-// you want to listen in on hooks to know when certain things have
-// happened, like when you've changed directory, a command has failed,
-// etc. To find all available hooks thrown by Hilbish, see doc hooks.
+/*
+Bait is the event emitter for Hilbish. Much like Node.js and
+its `events` system, many actions in Hilbish emit events.
+Unlike Node.js, Hilbish events are global. So make sure to
+pick a unique name!
+
+Usage of the Bait module consists of userstanding
+event-driven architecture, but it's pretty simple:
+If you want to act on a certain event, you can `catch` it.
+You can act on events via callback functions.
+
+Examples of this are in the Hilbish default config!
+Consider this part of it:
+```lua
+bait.catch('command.exit', function(code)
+ running = false
+ doPrompt(code ~= 0)
+ doNotifyPrompt()
+end)
+```
+
+What this does is, whenever the `command.exit` event is thrown,
+this function will set the user prompt.
+*/
package bait
import (
@@ -228,31 +247,17 @@ func handleHook(t *rt.Thread, c *rt.GoCont, name string, catcher *rt.Closure, ar
}
}
-// throw(name, ...args)
-// Throws a hook with `name` with the provided `args`
-// --- @param name string
-// --- @vararg any
-func (b *Bait) bthrow(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- if err := c.Check1Arg(); err != nil {
- return nil, err
- }
- name, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
- ifaceSlice := make([]interface{}, len(c.Etc()))
- for i, v := range c.Etc() {
- ifaceSlice[i] = v
- }
- b.Emit(name, ifaceSlice...)
-
- return c.Next(), nil
-}
-
// catch(name, cb)
-// Catches a hook with `name`. Runs the `cb` when it is thrown
-// --- @param name string
-// --- @param cb function
+// Catches an event. This function can be used to act on events.
+// #param name string The name of the hook.
+// #param cb function The function that will be called when the hook is thrown.
+/*
+#example
+bait.catch('hilbish.exit', function()
+ print 'Goodbye Hilbish!'
+end)
+#example
+*/
func (b *Bait) bcatch(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
name, catcher, err := util.HandleStrCallback(t, c)
if err != nil {
@@ -265,9 +270,9 @@ func (b *Bait) bcatch(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
}
// catchOnce(name, cb)
-// Same as catch, but only runs the `cb` once and then removes the hook
-// --- @param name string
-// --- @param cb function
+// Catches an event, but only once. This will remove the hook immediately after it runs for the first time.
+// #param name string The name of the event
+// #param cb function The function that will be called when the event is thrown.
func (b *Bait) bcatchOnce(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
name, catcher, err := util.HandleStrCallback(t, c)
if err != nil {
@@ -279,27 +284,10 @@ func (b *Bait) bcatchOnce(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
return c.Next(), nil
}
-// release(name, catcher)
-// Removes the `catcher` for the event with `name`.
-// For this to work, `catcher` has to be the same function used to catch
-// an event, like one saved to a variable.
-// --- @param name string
-// --- @param catcher function
-func (b *Bait) brelease(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- name, catcher, err := util.HandleStrCallback(t, c)
- if err != nil {
- return nil, err
- }
-
- b.OffLua(name, catcher)
-
- return c.Next(), nil
-}
-
// hooks(name) -> table
-// Returns a table with hooks (callback functions) on the event with `name`.
-// --- @param name string
-// --- @returns table
+// Returns a list of callbacks that are hooked on an event with the corresponding `name`.
+// #param name string The name of the function
+// #returns table
func (b *Bait) bhooks(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
if err := c.Check1Arg(); err != nil {
return nil, err
@@ -327,3 +315,62 @@ func (b *Bait) bhooks(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
return c.PushingNext1(t.Runtime, rt.TableValue(luaHandlers)), nil
}
+
+// release(name, catcher)
+// Removes the `catcher` for the event with `name`.
+// For this to work, `catcher` has to be the same function used to catch
+// an event, like one saved to a variable.
+// #param name string Name of the event the hook is on
+// #param catcher function Hook function to remove
+/*
+#example
+local hookCallback = function() print 'hi' end
+
+bait.catch('event', hookCallback)
+
+-- a little while later....
+bait.release('event', hookCallback)
+-- and now hookCallback will no longer be ran for the event.
+#example
+*/
+func (b *Bait) brelease(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ name, catcher, err := util.HandleStrCallback(t, c)
+ if err != nil {
+ return nil, err
+ }
+
+ b.OffLua(name, catcher)
+
+ return c.Next(), nil
+}
+
+// throw(name, ...args)
+// #param name string The name of the hook.
+// #param args ...any The arguments to pass to the hook.
+// Throws a hook with `name` with the provided `args`.
+/*
+#example
+bait.throw('greeting', 'world')
+
+-- This can then be listened to via
+bait.catch('gretting', function(greetTo)
+ print('Hello ' .. greetTo)
+end)
+#example
+*/
+func (b *Bait) bthrow(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ if err := c.Check1Arg(); err != nil {
+ return nil, err
+ }
+ name, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+ ifaceSlice := make([]interface{}, len(c.Etc()))
+ for i, v := range c.Etc() {
+ ifaceSlice[i] = v
+ }
+ b.Emit(name, ifaceSlice...)
+
+ return c.Next(), nil
+}
diff --git a/golibs/commander/commander.go b/golibs/commander/commander.go
index c639cf9..ea2da7a 100644
--- a/golibs/commander/commander.go
+++ b/golibs/commander/commander.go
@@ -1,10 +1,9 @@
// library for custom commands
/*
-Commander is a library for writing custom commands in Lua.
-In order to make it easier to write commands for Hilbish,
-not require separate scripts and to be able to use in a config,
-the Commander library exists. This is like a very simple wrapper
-that works with Hilbish for writing commands. Example:
+Commander is the library which handles Hilbish commands. This makes
+the user able to add Lua-written commands to their shell without making
+a separate script in a bin folder. Instead, you may simply use the Commander
+library in your Hilbish config.
```lua
local commander = require 'commander'
@@ -19,14 +18,14 @@ that will print `Hello world!` to output. One question you may
have is: What is the `sinks` parameter?
The `sinks` parameter is a table with 3 keys: `in`, `out`,
-and `err`. The values of these is a @Sink.
+and `err`. All of them are a @Sink.
-- `in` is the standard input. You can read from this sink
-to get user input. (**This is currently unimplemented.**)
-- `out` is standard output. This is usually where text meant for
-output should go.
-- `err` is standard error. This sink is for writing errors, as the
-name would suggest.
+- `in` is the standard input.
+You may use the read functions on this sink to get input from the user.
+- `out` is standard output.
+This is usually where command output should go.
+- `err` is standard error.
+This sink is for writing errors, as the name would suggest.
*/
package commander
@@ -67,9 +66,22 @@ func (c *Commander) loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
}
// register(name, cb)
-// Register a command with `name` that runs `cb` when ran
-// --- @param name string
-// --- @param cb function
+// Adds a new command with the given `name`. When Hilbish has to run a command with a name,
+// it will run the function providing the arguments and sinks.
+// #param name string Name of the command
+// #param cb function Callback to handle command invocation
+/*
+#example
+-- When you run the command `hello` in the shell, it will print `Hello world`.
+-- If you run it with, for example, `hello Hilbish`, it will print 'Hello Hilbish'
+commander.register('hello', function(args, sinks)
+ local name = 'world'
+ if #args > 0 then name = args[1] end
+
+ sinks.out:writeln('Hello ' .. name)
+end)
+#example
+*/
func (c *Commander) cregister(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
cmdName, cmd, err := util.HandleStrCallback(t, ct)
if err != nil {
@@ -82,8 +94,8 @@ func (c *Commander) cregister(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
}
// deregister(name)
-// Deregisters any command registered with `name`
-// --- @param name string
+// Removes the named command. Note that this will only remove Commander-registered commands.
+// #param name string Name of the command to remove.
func (c *Commander) cderegister(t *rt.Thread, ct *rt.GoCont) (rt.Cont, error) {
if err := ct.Check1Arg(); err != nil {
return nil, err
diff --git a/golibs/fs/fs.go b/golibs/fs/fs.go
index 1c1a5ca..848d82c 100644
--- a/golibs/fs/fs.go
+++ b/golibs/fs/fs.go
@@ -1,7 +1,10 @@
// filesystem interaction and functionality library
-// The fs module provides easy and simple access to filesystem functions
-// and other things, and acts an addition to the Lua standard library's
-// I/O and filesystem functions.
+/*
+The fs module provides filesystem functions to Hilbish. While Lua's standard
+library has some I/O functions, they're missing a lot of the basics. The `fs`
+library offers more functions and will work on any operating system Hilbish does.
+#field pathSep The operating system's path separator.
+*/
package fs
import (
@@ -42,9 +45,46 @@ func loaderFunc(rtm *rt.Runtime) (rt.Value, func()) {
return rt.TableValue(mod), nil
}
+// abs(path) -> string
+// Returns an absolute version of the `path`.
+// This can be used to resolve short paths like `..` to `/home/user`.
+// #param path string
+// #returns string
+func fabs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ path, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+ path = util.ExpandHome(path)
+
+ abspath, err := filepath.Abs(path)
+ if err != nil {
+ return nil, err
+ }
+
+ return c.PushingNext1(t.Runtime, rt.StringValue(abspath)), nil
+}
+
+// basename(path) -> string
+// Returns the "basename," or the last part of the provided `path`. If path is empty,
+// `.` will be returned.
+// #param path string Path to get the base name of.
+// #returns string
+func fbasename(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ if err := c.Check1Arg(); err != nil {
+ return nil, err
+ }
+ path, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+
+ return c.PushingNext(t.Runtime, rt.StringValue(filepath.Base(path))), nil
+}
+
// cd(dir)
-// Changes directory to `dir`
-// --- @param dir string
+// Changes Hilbish's directory to `dir`.
+// #param dir string Path to change directory to.
func fcd(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
if err := c.Check1Arg(); err != nil {
return nil, err
@@ -63,10 +103,102 @@ func fcd(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
return c.Next(), err
}
+// dir(path) -> string
+// Returns the directory part of `path`. If a file path like
+// `~/Documents/doc.txt` then this function will return `~/Documents`.
+// #param path string Path to get the directory for.
+// #returns string
+func fdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ if err := c.Check1Arg(); err != nil {
+ return nil, err
+ }
+ path, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+
+ return c.PushingNext(t.Runtime, rt.StringValue(filepath.Dir(path))), nil
+}
+
+// glob(pattern) -> matches (table)
+// Match all files based on the provided `pattern`.
+// For the syntax' refer to Go's filepath.Match function: https://pkg.go.dev/path/filepath#Match
+// #param pattern string Pattern to compare files with.
+// #returns table A list of file names/paths that match.
+/*
+#example
+--[[
+ Within a folder that contains the following files:
+ a.txt
+ init.lua
+ code.lua
+ doc.pdf
+]]--
+local matches = fs.glob './*.lua'
+print(matches)
+-- -> {'init.lua', 'code.lua'}
+#example
+*/
+func fglob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ if err := c.Check1Arg(); err != nil {
+ return nil, err
+ }
+ pattern, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+
+ matches, err := filepath.Glob(pattern)
+ if err != nil {
+ return nil, err
+ }
+
+ luaMatches := rt.NewTable()
+
+ for i, match := range matches {
+ luaMatches.Set(rt.IntValue(int64(i + 1)), rt.StringValue(match))
+ }
+
+ return c.PushingNext(t.Runtime, rt.TableValue(luaMatches)), nil
+}
+
+// join(...path) -> string
+// Takes any list of paths and joins them based on the operating system's path separator.
+// #param path ...string Paths to join together
+// #returns string The joined path.
+/*
+#example
+-- This prints the directory for Hilbish's config!
+print(fs.join(hilbish.userDir.config, 'hilbish'))
+-- -> '/home/user/.config/hilbish' on Linux
+#example
+*/
+func fjoin(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ strs := make([]string, len(c.Etc()))
+ for i, v := range c.Etc() {
+ if v.Type() != rt.StringType {
+ // +2; go indexes of 0 and first arg from above
+ return nil, fmt.Errorf("bad argument #%d to run (expected string, got %s)", i + 1, v.TypeName())
+ }
+ strs[i] = v.AsString()
+ }
+
+ res := filepath.Join(strs...)
+
+ return c.PushingNext(t.Runtime, rt.StringValue(res)), nil
+}
+
// mkdir(name, recursive)
-// Makes a directory called `name`. If `recursive` is true, it will create its parent directories.
-// --- @param name string
-// --- @param recursive boolean
+// Creates a new directory with the provided `name`.
+// With `recursive`, mkdir will create parent directories.
+// #param name string Name of the directory
+// #param recursive boolean Whether to create parent directories for the provided name
+/*
+#example
+-- This will create the directory foo, then create the directory bar in the
+-- foo directory. If recursive is false in this case, it will fail.
+fs.mkdir('./foo/bar', true)
+*/
func fmkdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
if err := c.CheckNArgs(2); err != nil {
return nil, err
@@ -93,15 +225,58 @@ func fmkdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
return c.Next(), err
}
+// readdir(path) -> table[string]
+// Returns a list of all files and directories in the provided path.
+// #param dir string
+// #returns table
+func freaddir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+ if err := c.Check1Arg(); err != nil {
+ return nil, err
+ }
+ dir, err := c.StringArg(0)
+ if err != nil {
+ return nil, err
+ }
+ dir = util.ExpandHome(dir)
+ names := rt.NewTable()
+
+ dirEntries, err := os.ReadDir(dir)
+ if err != nil {
+ return nil, err
+ }
+ for i, entry := range dirEntries {
+ names.Set(rt.IntValue(int64(i + 1)), rt.StringValue(entry.Name()))
+ }
+
+ return c.PushingNext1(t.Runtime, rt.TableValue(names)), nil
+}
+
// stat(path) -> {}
-// Returns a table of info about the `path`.
-// It contains the following keys:
+// Returns the information about a given `path`.
+// The returned table contains the following values:
// name (string) - Name of the path
-// size (number) - Size of the path
-// mode (string) - Permission mode in an octal format string (with leading 0)
+// size (number) - Size of the path in bytes
+// mode (string) - Unix permission mode in an octal format string (with leading 0)
// isDir (boolean) - If the path is a directory
-// --- @param path string
-// --- @returns table
+// #param path string
+// #returns table
+/*
+#example
+local inspect = require 'inspect'
+
+local stat = fs.stat '~'
+print(inspect(stat))
+--[[
+Would print the following:
+{
+ isDir = true,
+ mode = "0755",
+ name = "username",
+ size = 12288
+}
+]]--
+#example
+*/
func fstat(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
if err := c.Check1Arg(); err != nil {
return nil, err
@@ -125,128 +300,3 @@ func fstat(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
return c.PushingNext1(t.Runtime, rt.TableValue(statTbl)), nil
}
-// readdir(dir) -> {}
-// Returns a table of files in `dir`.
-// --- @param dir string
-// --- @return table
-func freaddir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- if err := c.Check1Arg(); err != nil {
- return nil, err
- }
- dir, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
- dir = util.ExpandHome(dir)
- names := rt.NewTable()
-
- dirEntries, err := os.ReadDir(dir)
- if err != nil {
- return nil, err
- }
- for i, entry := range dirEntries {
- names.Set(rt.IntValue(int64(i + 1)), rt.StringValue(entry.Name()))
- }
-
- return c.PushingNext1(t.Runtime, rt.TableValue(names)), nil
-}
-
-// abs(path) -> string
-// Gives an absolute version of `path`.
-// --- @param path string
-// --- @returns string
-func fabs(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- path, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
- path = util.ExpandHome(path)
-
- abspath, err := filepath.Abs(path)
- if err != nil {
- return nil, err
- }
-
- return c.PushingNext1(t.Runtime, rt.StringValue(abspath)), nil
-}
-
-// basename(path) -> string
-// Gives the basename of `path`. For the rules,
-// see Go's filepath.Base
-// --- @returns string
-func fbasename(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- if err := c.Check1Arg(); err != nil {
- return nil, err
- }
- path, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
-
- return c.PushingNext(t.Runtime, rt.StringValue(filepath.Base(path))), nil
-}
-
-// dir(path) -> string
-// Returns the directory part of `path`. For the rules, see Go's
-// filepath.Dir
-// --- @param path string
-// --- @returns string
-func fdir(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- if err := c.Check1Arg(); err != nil {
- return nil, err
- }
- path, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
-
- return c.PushingNext(t.Runtime, rt.StringValue(filepath.Dir(path))), nil
-}
-
-// glob(pattern) -> matches (table)
-// Glob all files and directories that match the pattern.
-// For the rules, see Go's filepath.Glob
-// --- @param pattern string
-// --- @returns table
-func fglob(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- if err := c.Check1Arg(); err != nil {
- return nil, err
- }
- pattern, err := c.StringArg(0)
- if err != nil {
- return nil, err
- }
-
- matches, err := filepath.Glob(pattern)
- if err != nil {
- return nil, err
- }
-
- luaMatches := rt.NewTable()
-
- for i, match := range matches {
- luaMatches.Set(rt.IntValue(int64(i + 1)), rt.StringValue(match))
- }
-
- return c.PushingNext(t.Runtime, rt.TableValue(luaMatches)), nil
-}
-
-// join(...) -> string
-// Takes paths and joins them together with the OS's
-// directory separator (forward or backward slash).
-// --- @vararg string
-// --- @returns string
-func fjoin(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
- strs := make([]string, len(c.Etc()))
- for i, v := range c.Etc() {
- if v.Type() != rt.StringType {
- // +2; go indexes of 0 and first arg from above
- return nil, fmt.Errorf("bad argument #%d to run (expected string, got %s)", i + 1, v.TypeName())
- }
- strs[i] = v.AsString()
- }
-
- res := filepath.Join(strs...)
-
- return c.PushingNext(t.Runtime, rt.StringValue(res)), nil
-}
diff --git a/nature/commands/doc.lua b/nature/commands/doc.lua
index ee1e37c..fc12a4f 100644
--- a/nature/commands/doc.lua
+++ b/nature/commands/doc.lua
@@ -89,7 +89,7 @@ Available sections: ]] .. table.concat(modules, ', ')
local size = terminal.size()
self.region = {
width = size.width,
- height = size.height - 3
+ height = size.height - 2
}
end
gh:resize()
@@ -102,7 +102,8 @@ Available sections: ]] .. table.concat(modules, ', ')
workingPage = self.specialPage
end
- self.sink:write(ansikit.getCSI(self.region.height + 2 .. ';1', 'H'))
+ self.sink:write(ansikit.getCSI(self.region.height + 1 .. ';1', 'H'))
+ self.sink:write(ansikit.getCSI(0, 'J'))
if not self.isSpecial then
if args[1] == 'api' then
self.sink:writeln(lunacolors.reset(string.format('%s', workingPage.title)))
diff --git a/website/config.toml b/website/config.toml
index 31f42d5..174c434 100644
--- a/website/config.toml
+++ b/website/config.toml
@@ -1,5 +1,5 @@
-baseURL = 'https://rosettea.github.io/Hilbish/'
languageCode = 'en-us'
+baseURL = 'https://rosettea.github.io/Hilbish/'
title = 'Hilbish'
theme = 'hsh'
enableGitInfo = true
@@ -29,6 +29,13 @@ enableGitInfo = true
[markup.goldmark.renderer]
unsafe = true
+[markup.highlight]
+lineNos = true
+lineNumbersInTable = false
+noClasses = false
+codeFences = true
+guessSyntax = true
+
[author]
[author.sammyette]
name = 'sammyette'
diff --git a/website/content/docs b/website/content/docs
new file mode 120000
index 0000000..92a7f82
--- /dev/null
+++ b/website/content/docs
@@ -0,0 +1 @@
+../../docs
\ No newline at end of file
diff --git a/website/content/docs/api b/website/content/docs/api
deleted file mode 120000
index 1c5c360..0000000
--- a/website/content/docs/api
+++ /dev/null
@@ -1 +0,0 @@
-../../../docs/api/
\ No newline at end of file
diff --git a/website/themes/hsh/assets/css/syntax.css b/website/themes/hsh/assets/css/syntax.css
new file mode 100644
index 0000000..c4885c0
--- /dev/null
+++ b/website/themes/hsh/assets/css/syntax.css
@@ -0,0 +1,89 @@
+.chroma {
+ display: inline-block;
+ padding: 0.5em;
+}
+/* Background */ .bg { background-color: #F7F7F7; }
+/* PreWrapper */ .chroma { background-color: #F7F7F7; }
+/* Other */ .chroma .x { }
+/* Error */ .chroma .err { color: #a61717; background-color: #e3d2d2 }
+/* CodeLine */ .chroma .cl { }
+/* LineTableTD */ .chroma .lntd { vertical-align: top; padding: 0; margin: 0; border: 0; }
+/* LineTable */ .chroma .lntable { border-spacing: 0; padding: 0; margin: 0; border: 0; }
+/* LineHighlight */ .chroma .hl { background-color: #F7F7F7 }
+/* LineNumbersTable */ .chroma .lnt { white-space: pre; user-select: none; margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f }
+/* LineNumbers */ .chroma .ln { white-space: pre; user-select: none; margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f }
+/* Line */ .chroma .line { display: flex; }
+/* Keyword */ .chroma .k { color: #008800; font-weight: bold }
+/* KeywordConstant */ .chroma .kc { color: #008800; font-weight: bold }
+/* KeywordDeclaration */ .chroma .kd { color: #008800; font-weight: bold }
+/* KeywordNamespace */ .chroma .kn { color: #008800; font-weight: bold }
+/* KeywordPseudo */ .chroma .kp { color: #008800 }
+/* KeywordReserved */ .chroma .kr { color: #008800; font-weight: bold }
+/* KeywordType */ .chroma .kt { color: #888888; font-weight: bold }
+/* Name */ .chroma .n { }
+/* NameAttribute */ .chroma .na { color: #336699 }
+/* NameBuiltin */ .chroma .nb { color: #003388 }
+/* NameBuiltinPseudo */ .chroma .bp { }
+/* NameClass */ .chroma .nc { color: #bb0066; font-weight: bold }
+/* NameConstant */ .chroma .no { color: #003366; font-weight: bold }
+/* NameDecorator */ .chroma .nd { color: #555555 }
+/* NameEntity */ .chroma .ni { }
+/* NameException */ .chroma .ne { color: #bb0066; font-weight: bold }
+/* NameFunction */ .chroma .nf { color: #0066bb; font-weight: bold }
+/* NameFunctionMagic */ .chroma .fm { }
+/* NameLabel */ .chroma .nl { color: #336699; font-style: italic }
+/* NameNamespace */ .chroma .nn { color: #bb0066; font-weight: bold }
+/* NameOther */ .chroma .nx { }
+/* NameProperty */ .chroma .py { color: #336699; font-weight: bold }
+/* NameTag */ .chroma .nt { color: #bb0066; font-weight: bold }
+/* NameVariable */ .chroma .nv { color: #336699 }
+/* NameVariableClass */ .chroma .vc { color: #336699 }
+/* NameVariableGlobal */ .chroma .vg { color: #dd7700 }
+/* NameVariableInstance */ .chroma .vi { color: #3333bb }
+/* NameVariableMagic */ .chroma .vm { }
+/* Literal */ .chroma .l { }
+/* LiteralDate */ .chroma .ld { }
+/* LiteralString */ .chroma .s { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringAffix */ .chroma .sa { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringBacktick */ .chroma .sb { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringChar */ .chroma .sc { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringDelimiter */ .chroma .dl { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringDoc */ .chroma .sd { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringDouble */ .chroma .s2 { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringEscape */ .chroma .se { color: #0044dd; background-color: #fff0f0 }
+/* LiteralStringHeredoc */ .chroma .sh { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringInterpol */ .chroma .si { color: #3333bb; background-color: #fff0f0 }
+/* LiteralStringOther */ .chroma .sx { color: #22bb22; background-color: #f0fff0 }
+/* LiteralStringRegex */ .chroma .sr { color: #008800; background-color: #fff0ff }
+/* LiteralStringSingle */ .chroma .s1 { color: #dd2200; background-color: #fff0f0 }
+/* LiteralStringSymbol */ .chroma .ss { color: #aa6600; background-color: #fff0f0 }
+/* LiteralNumber */ .chroma .m { color: #0000dd; font-weight: bold }
+/* LiteralNumberBin */ .chroma .mb { color: #0000dd; font-weight: bold }
+/* LiteralNumberFloat */ .chroma .mf { color: #0000dd; font-weight: bold }
+/* LiteralNumberHex */ .chroma .mh { color: #0000dd; font-weight: bold }
+/* LiteralNumberInteger */ .chroma .mi { color: #0000dd; font-weight: bold }
+/* LiteralNumberIntegerLong */ .chroma .il { color: #0000dd; font-weight: bold }
+/* LiteralNumberOct */ .chroma .mo { color: #0000dd; font-weight: bold }
+/* Operator */ .chroma .o { }
+/* OperatorWord */ .chroma .ow { color: #008800 }
+/* Punctuation */ .chroma .p { }
+/* Comment */ .chroma .c { color: #888888 }
+/* CommentHashbang */ .chroma .ch { color: #888888 }
+/* CommentMultiline */ .chroma .cm { color: #888888 }
+/* CommentSingle */ .chroma .c1 { color: #888888 }
+/* CommentSpecial */ .chroma .cs { color: #cc0000; background-color: #fff0f0; font-weight: bold }
+/* CommentPreproc */ .chroma .cp { color: #cc0000; font-weight: bold }
+/* CommentPreprocFile */ .chroma .cpf { color: #cc0000; font-weight: bold }
+/* Generic */ .chroma .g { }
+/* GenericDeleted */ .chroma .gd { color: #000000; background-color: #ffdddd }
+/* GenericEmph */ .chroma .ge { font-style: italic }
+/* GenericError */ .chroma .gr { color: #aa0000 }
+/* GenericHeading */ .chroma .gh { color: #333333 }
+/* GenericInserted */ .chroma .gi { color: #000000; background-color: #ddffdd }
+/* GenericOutput */ .chroma .go { color: #888888 }
+/* GenericPrompt */ .chroma .gp { color: #555555 }
+/* GenericStrong */ .chroma .gs { font-weight: bold }
+/* GenericSubheading */ .chroma .gu { color: #666666 }
+/* GenericTraceback */ .chroma .gt { color: #aa0000 }
+/* GenericUnderline */ .chroma .gl { text-decoration: underline }
+/* TextWhitespace */ .chroma .w { color: #bbbbbb }
diff --git a/website/themes/hsh/layouts/partials/head.html b/website/themes/hsh/layouts/partials/head.html
index fca4558..147fb11 100644
--- a/website/themes/hsh/layouts/partials/head.html
+++ b/website/themes/hsh/layouts/partials/head.html
@@ -23,7 +23,10 @@
+ {{ $syntax := resources.Get "css/syntax.css" | resources.Minify | resources.Fingerprint }}
+
+