13 Commits

Author SHA1 Message Date
122cd5ed04 Fixed typo 2024-08-15 11:38:00 -05:00
3b8bcb4c8a Updated README 2024-08-15 11:37:13 -05:00
e7e7a247d8 Updated README 2024-08-15 10:19:52 -05:00
eb2a0a9122 If the color config file exists, load colors from it 2024-08-15 10:19:43 -05:00
46e3e9da85 Added function to load colors from a config file 2024-08-15 10:19:21 -05:00
5bb51fb90c Updated README 2024-08-14 12:21:58 -05:00
5da734e06d Fixed typo 2024-08-14 12:21:21 -05:00
925ef4df4b Updated README 2024-08-14 12:20:30 -05:00
79cd6dab8d Cosmetic changes 2024-08-14 12:16:41 -05:00
28ee686295 Fixed typo 2024-08-14 12:15:57 -05:00
5e0bbbec4f Added README 2024-08-14 12:15:19 -05:00
05f3ebc178 Updated TODO 2024-08-14 10:05:11 -05:00
a34f2309a8 Removed C file which was used for testing 2024-08-14 10:03:33 -05:00
5 changed files with 171 additions and 173 deletions

65
README.md Normal file
View File

@@ -0,0 +1,65 @@
## ccat
ccat is a file printing tool (like 'cat') which uses Regular Expressions to enable syntax highlighting.
---
### Features
- 11 colors are defined out-of-the-box: RED, BLUE, GREEN, MAGENTA, CYAN, BLACK, WHITE, YELLOW, GRAY, ORANGE and DARKBLUE.
- Support for defining custom colors via the `ccat.colors` file.
- Regex-color mappings are stored in configuration files.
- Uses the file extension to determine which configuration file to use.
- Highly extensible - to add a config file for an specific file type, name the file `<extension>.conf`.
- Support for printing line numbers with the `-n` flag.
- Statically linked Go binary - no runtime dependencies, config files are distributed along with the binary.
- Cross-platform
---
### Installing
If you have the `go` command installed, run `make` after cloning the repository.
---
### Supported Languages
The following languages have config files included by default:
- C
- Go
-
---
### Getting Started
The config files are embedded within the binary. They will automatically be installed to the correct location (`%APPDATA/ccat` on Windows, `~/.config/ccat` on UNIX) when the program is first run.
As written above, if provided a file with extension `.example`, the program will look for the config file named `example.conf`. If such a file doesn't exist, the file is printed out without any highlighting.
For example, if you want to create syntax highlighting for Java, create a file named `java.conf` in your config directory. In this file, include regular-expressions for each of the langauges's keywords, and provide a corresponding color. Use the provided `c.conf` and `go.conf` files as a starting point.
---
### Config Files
The config files are written in YAML. Each line has the following syntax:
`"<regex>": COLOR`
Note that the regex must be enclosed in double quotes, and the color must be capitalized.
---
### Custom Colors
To define a color of your own, create a file named `ccat.colors` in the config directory (mentioned above). The syntax of this file is the following:
`COLOR: <red> <green> <blue>`
Note that the color name must be capitalized (and shouldn't contain spaces). The RGB values must each be from 0 to 255.
---
### TODO:
- Allow users to provide a config file in the command-line, overriding the extension-based config file.
- Provide releases.

View File

@@ -2,8 +2,12 @@ package main
import (
"fmt"
"os"
"strconv"
"strings"
colorData "github.com/fatih/color"
"gopkg.in/yaml.v2"
)
// A color represents a possible color, which text can be printed out in.
@@ -14,6 +18,14 @@ type color struct {
colorObj *colorData.Color
}
// A RGB represents a Red, Blue, Green trio of values. Each value is represented as
// an int.
type RGB struct {
red int
blue int
green int
}
// The following is a list of all possible colors, stored in a map.
var possibleColors map[string]color = map[string]color{
"BLACK": {"BLACK", colorData.New(colorData.FgBlack)},
@@ -59,3 +71,89 @@ func newColorMust(colorString string) color {
return clr
}
}
// isValidColorName returns true if the given string only contains uppercase alphabetic
// characters.
func isValidColorName(colorName string) bool {
for _, ch := range colorName {
if ch > 'Z' || ch < 'A' {
return false
}
}
return true
}
// stringToRGB takes a string representing an RGB trio. It constructs and RGB type and
// returns it. Any errors encountered are returned. If an error is returned, it is safe to
// assume that the string doesn't represent an RGB trio.
func stringToRGB(rgbString string) (*RGB, error) {
values := strings.Split(rgbString, " ")
// There must be three space-separated strings.
if len(values) != 3 {
// TODO: Instead of ignoring these errors and returning a generic error (as I do in the
// callee), wrap the error returned from this function, inside the error returned by the callee.
return nil, fmt.Errorf("Error parsing RGB trio.")
}
// If any of the strings doesn't represent an integer (or is out of bounds), return an error.
// WARNING: LAZY CODE INCOMING
var toReturn RGB
var err error
toReturn.red, err = strconv.Atoi(values[0])
if err != nil {
return nil, fmt.Errorf("Error parsing RED integer: Invalid value.")
}
if toReturn.red < 0 || toReturn.red > 255 {
return nil, fmt.Errorf("Error parsing RED integer: Out-of-bounds.")
}
toReturn.blue, err = strconv.Atoi(values[1])
if err != nil {
return nil, fmt.Errorf("Error parsing BLUE integer: Invalid value.")
}
if toReturn.blue < 0 || toReturn.blue > 255 {
return nil, fmt.Errorf("Error parsing BLUE integer: Out-of-bounds.")
}
toReturn.green, err = strconv.Atoi(values[2])
if err != nil {
return nil, fmt.Errorf("Error parsing GREEN integer: Invalid value.")
}
if toReturn.green < 0 || toReturn.green > 255 {
return nil, fmt.Errorf("Error parsing GREEN integer: Out-of-bounds.")
}
return &toReturn, nil
}
// loadColorsFromFile loads the colors defined in the given config file, and adds them to
// the possibleColors map. This allows the user to define custom colors at run-time.
// The colors config file has the following syntax:
// COLOR: <RED> <GREEN> <BLUE>
//
// Note that the color must be capitalized (and not contain spaces), and the R, G and B
// values must be from 0 to 255.
func loadColorsFromFile(filepath string) error {
data, err := os.ReadFile(filepath)
if err != nil {
panic(err)
}
// Read color config file into a MapSlice
tempMapSlice := yaml.MapSlice{}
if err := yaml.Unmarshal(data, &tempMapSlice); err != nil {
return fmt.Errorf("Unable to read color config file: %s", filepath)
}
for _, item := range tempMapSlice {
if !(isValidColorName(item.Key.(string))) {
return fmt.Errorf("Invalid color name: %s", item.Key.(string))
}
var rgb *RGB
if rgb, err = stringToRGB(item.Value.(string)); err != nil {
return fmt.Errorf("Invalid RGB trio: %s", item.Value.(string))
}
// If we haven't returned an error yet, the color must be valid.
// Add it to the map. colorData.New() expects values of type colorData.Attribute,
// so we must cast our RGB values accordingly.
possibleColors[item.Key.(string)] = color{item.Key.(string), colorData.New(38, 2, colorData.Attribute(rgb.red), colorData.Attribute(rgb.blue), colorData.Attribute(rgb.green))}
}
return nil
}

View File

@@ -120,6 +120,13 @@ func main() {
}
// Assuming the file is not empty...
// If a ccat.colors file exists in the config directory, load all the colors in it
if fileExists(filepath.Join(configPath, "ccat.colors")) {
err := loadColorsFromFile(filepath.Join(configPath, "ccat.colors"))
if err != nil {
printErrAndExit(err.Error())
}
}
// If the given file has a config, load the config into a stack of regColors.
regColorStack, err := loadConfig(configFilename)
if err != nil {

173
test.c
View File

@@ -1,173 +0,0 @@
//go:build exclude
#include "easysock.h"
int create_socket(int network, char transport) {
int domain;
int type;
if (network == 4) {
domain = AF_INET;
} else if (network == 6) {
domain = AF_INET6;
} else {
return -1;
}
if (transport == 'T') {
type = SOCK_STREAM;
} else if (transport == 'U') {
type = SOCK_DGRAM;
} else {
return -1;
}
int newSock = socket(domain,type,0);
return newSock;
}
int create_addr(int network, char* address, int port,struct sockaddr* dest) {
if (network == 4) {
struct sockaddr_in listen_address;
listen_address.sin_family = AF_INET;
listen_address.sin_port = htons(port);
inet_pton(AF_INET,address,&listen_address.sin_addr);
memcpy(dest,&listen_address,sizeof(listen_address));
return 0;
} else if (network == 6) {
struct sockaddr_in6 listen_ipv6;
listen_ipv6.sin6_family = AF_INET6;
listen_ipv6.sin6_port = htons(port);
inet_pton(AF_INET6,address,&listen_ipv6.sin6_addr);
memcpy(dest,&listen_ipv6,sizeof(listen_ipv6));
return 0;
} else {
return -202;
}
}
int create_local (int network, char transport, char* address, int port,struct sockaddr* addr_struct) {
int socket = create_socket(network,transport);
if (socket < 0) {
return (-1 * errno);
}
create_addr(network,address,port,addr_struct);
int addrlen;
if (network == 4) {
addrlen = sizeof(struct sockaddr_in);
} else if (network == 6) {
addrlen = sizeof(struct sockaddr_in6);
} else {
return -202;
}
/* The value of addrlen should be the size of the 'sockaddr'.
This should be set to the size of 'sockaddr_in' for IPv4, and 'sockaddr_in6' for IPv6.
See https://stackoverflow.com/questions/73707162/socket-bind-failed-with-invalid-argument-error-for-program-running-on-macos */
int i = bind (socket,addr_struct,(socklen_t)addrlen);
if (i < 0) {
return (-1 * errno);
}
return socket;
}
int create_remote (int network,char transport,char* address,int port,struct sockaddr* remote_addr_struct) {
struct addrinfo hints; /* Used to tell getaddrinfo what kind of address we want */
struct addrinfo* results; /* Used by getaddrinfo to store the addresses */
if (check_ip_ver(address) < 0) { /* If the address is a domain name */
int err_code;
char* port_str = malloc(10 * sizeof(char));
sprintf(port_str,"%d",port); /* getaddrinfo expects a string for its port */
memset(&hints,'\0',sizeof(hints));
hints.ai_socktype = char_to_socktype(transport);
err_code = getaddrinfo(address,port_str,&hints,&results);
if (err_code != 0) {
return (-1 * err_code);
}
remote_addr_struct = results->ai_addr;
network = inet_to_int(results->ai_family);
} else {
create_addr(network,address,port,remote_addr_struct);
}
int socket = create_socket(network,transport);
if (socket < 0) {
return (-1 * errno);
}
int addrlen;
if (network == 4) {
addrlen = sizeof(struct sockaddr_in);
} else if (network == 6) {
addrlen = sizeof(struct sockaddr_in6);
} else {
return (-202);
}
/* The value of addrlen should be the size of the 'sockaddr'.
This should be set to the size of 'sockaddr_in' for IPv4, and 'sockaddr_in6' for IPv6.
See https://stackoverflow.com/questions/73707162/socket-bind-failed-with-invalid-argument-error-for-program-running-on-macos */
int i = connect(socket,remote_addr_struct,(socklen_t)addrlen);
if (i < 0) {
return (-1 * errno);
}
return socket;
}
int check_ip_ver(char* address) {
char buffer[16]; /* 16 chars - 128 bits - is enough to hold an ipv6 address */
if (inet_pton(AF_INET,address,buffer) == 1) {
return 4;
} else if (inet_pton(AF_INET6,address,buffer) == 1) {
return 6;
} else {
return -1;
}
}
int int_to_inet(int network) {
if (network == 4) {
return AF_INET;
} else if (network == 6) {
return AF_INET6;
} else {
return -202;
}
}
int inet_to_int(int af_type) {
if (af_type == AF_INET) {
return 4;
} else if (af_type == AF_INET6) {
return 6;
} else {
return -207;
}
}
int char_to_socktype(char transport) {
if (transport == 'T') {
return SOCK_STREAM;
} else if (transport == 'U') {
return SOCK_DGRAM;
} else {
return -250;
}
}

View File

@@ -1,4 +1,5 @@
1. Man page
2. README for GitHub Repo
2. Logging
3. Coloring functions
4. Flag to list all available colors for your terminal - some terminals will only support the predefined colors.