build(flake): Update

build(flake): Switch back to stable rust
build(trinitry/Cargo.toml): Remove unneeded dependencies
2023-11-01 13:26:07 +01:00 · 2023-11-01 13:25:37 +01:00 · 2023-11-01 13:25:08 +01:00 · 2023-11-01 13:24:30 +01:00 · 2023-11-01 13:19:55 +01:00 · 2023-11-01 13:19:22 +01:00
12 changed files with 1759 additions and 13 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1270,9 +1270,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.0.2"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897"
+checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
 dependencies = [
 "equivalent",
 "hashbrown 0.14.2",
@ -2678,7 +2678,7 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.0.2",
+ "indexmap 2.1.0",
 "toml_datetime",
 "winnow",
 ]
@ -2729,7 +2729,7 @@ dependencies = [
 "cli-log",
 "crossterm",
 "directories",
- "indexmap 2.0.2",
+ "indexmap 2.1.0",
 "language_macros",
 "matrix-sdk",
 "mlua",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -28,7 +28,7 @@ tui-textarea = { version = "0.2", features = ["crossterm"], optional = true }
 crossterm = { version = "0.25", optional = true }
 tokio-util = { version = "0.7", optional = true }
 serde = { version = "1.0", optional = true }
-indexmap = { version = "2.0.2", optional = true }
+indexmap = { version = "2.1.0", optional = true }
 directories = "5.0.1"

 [dev-dependencies]
--- a/flake.lock
+++ b/flake.lock
@ -89,11 +89,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1698726852,
-        "narHash": "sha256-V1S4TTzg++GzPc96i/yy4jib+7/xU0LXHcggm9MllMM=",
+        "lastModified": 1698804896,
+        "narHash": "sha256-vSms7A9bWHC00343qyXuNVm65LZDagDkukpkpwC2VxY=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "ec19bd20af08f3b004089cc12ab54c823ed899b7",
+        "rev": "c5f8326c668b78275eccce90839861a3c8e1d3b2",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@ -42,7 +42,7 @@
        overlays = [(import rust-overlay)];
      };

-      nightly = true;
+      nightly = false;
      rust =
        if nightly
        then
--- a/trinitry/.gitignore
+++ b/trinitry/.gitignore
@ -0,0 +1,6 @@
+# build
+/target
+/result
+
+# It is a library
+Cargo.lock
--- a/trinitry/Cargo.toml
+++ b/trinitry/Cargo.toml
@ -0,0 +1,14 @@
+[package]
+name = "trinitry"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+pest = "2.7.5"
+pest_derive = {version = "2.7.5", features = ["grammar-extras"]}
+
+# The header imports katex, a js latex parser, into the doc comments
+[package.metadata.docs.rs]
+rustdoc-args = [ "--html-in-header", "./docs-header.html" ]
--- a/trinitry/docs-header.html
+++ b/trinitry/docs-header.html
@ -0,0 +1,45 @@
+<!doctype html>
+<!-- KaTeX requires the use of the HTML5 doctype. Without it, KaTeX may not render properly -->
+<html>
+  <head>
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css"
+      integrity="sha384-n8MVd4RsNIU0tAv4ct0nTaAbDJwPJzDEaqSD1odI+WdtXRGWt2kTvGFasHpSy3SV"
+      crossorigin="anonymous"
+    />
+
+    <!-- The loading of KaTeX is deferred to speed up page rendering -->
+    <script
+      defer
+      src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.js"
+      integrity="sha384-XjKyOOlGwcjNTAIQHIpgOno0Hl1YQqzUOEleOLALmuqehneUG+vnGctmUb0ZY0l8"
+      crossorigin="anonymous"
+    ></script>
+
+    <!-- To automatically render math in text elements, include the auto-render extension: -->
+    <script
+      defer
+      src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/contrib/auto-render.min.js"
+      integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05"
+      crossorigin="anonymous"
+    ></script>
+    <script>
+      document.addEventListener("DOMContentLoaded", function () {
+        renderMathInElement(document.body, {
+          delimiters: [
+            { left: "$$", right: "$$", display: true },
+            { left: "\\(", right: "\\)", display: false },
+            { left: "$", right: "$", display: false },
+            { left: "\\[", right: "\\]", display: true },
+          ]
+          // FIXME(@soispha): This removes the quotes completely <2023-10-31>
+          // macros: {
+          //   "”": "\\noexpand ”",
+          //   "“": "\\noexpand “",
+          // },
+        });
+      });
+    </script>
+  </head>
+</html>
--- a/trinitry/src/lib.rs
+++ b/trinitry/src/lib.rs
@ -0,0 +1,192 @@
+//! This crate is a parser for the 'Trinitry' (not 'Trinity') language, used to map all sort of
+//! Functions to a memorable command.
+//!
+//! This parser is more of a validator, as Trinitry does not support any language features besides
+//! the aforementioned commands and arguments. That includes some simple constructs like: '||' (OR)
+//! or '&&' (AND). If you need these features, simple write them in the language, you've written your
+//! Function in.
+//!
+//! # General specification
+//! ## Command
+//! Basically every command can be a series of alphanumeric ASCII values.
+//!
+//! Correctly spoken, the Language, containing all valid command names, is just the Kleene closure
+//! over an Alphabet $\Sigma$, which contains all alphanumeric characters:
+//! $$ \Sigma_{cmd} = \\{x | 0 \leqslant x \leqslant 9\\} \cup \\{x | "a" \leqslant x \leqslant "z"\\} \cup \\{x | "A" \leqslant x \leqslant "Z"\\} \cup \\{"\\_", "\text{-}", "."\\} $$
+//!
+//! ## Argument
+//! Arguments are similar to the command, although they can also contain spaces and quotes,
+//! if it's quoted and additional characters (here notated as "$\\dots{}$"):
+//! $$ \Sigma_{args-quoted} = \Sigma_{cmd} \cup \\{"\\text{"}", "\\ ", \\dots{}\\} $$
+//! $$ \Sigma_{args-single-quoted} = \Sigma_{cmd} \cup \\{"'", "\\ ", \\dots{}\\} $$
+//! $$ \Sigma_{args} = \Sigma_{cmd} \cup \\{\\dots{}\\} $$
+//! Look at the [trinitry.pest](../../../src/trinitry.pest) file for a full list of the additional
+//! allowed characters.
+//!
+//! # Examples
+//! ## Command
+//! A valid command would be something like that:
+//! ```text
+//! quit
+//! ```
+//! something like that would not be valid however, as Trinitry does not support these 'complex'
+//! language features:
+//! ```text
+//! write && quit
+//! ```
+//! ## Arguments
+//! A valid argumented command would be:
+//! ```text
+//! lua "function() print('Hi!') end"
+//! ```
+//! Whilst this would not be valid (that is, it would very likely not be what you want):
+//! ```text
+//! lua "function() print("Hi!") end"
+//! ```
+//! as the double quotes in the print statement actually unquote the argument, leaving you with
+//! three arguments:
+//! 1. `function() print(`
+//! 1. `Hi!`
+//! 1. `) end`
+use std::fmt::Display;
+
+use pest::{error::Error, Parser};
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "trinitry.pest"]
+pub struct Trinitry {
+    command: String,
+    arguments: Vec<String>,
+}
+
+impl Trinitry {
+    pub fn new(input: &str) -> Result<Self, Error<Rule>> {
+        let parsed = Self::parse(Rule::trinitry, input)?;
+
+        let command = {
+            let command: Vec<_> = parsed.clone().find_tagged("command").collect();
+
+            // Ensure that we have only one command
+            // This should be ensured by the grammar, thus the 'debug_assert'
+            debug_assert_eq!(command.len(), 1);
+
+            // PERFORMANCE(@soispha): Replace this with `mem::take` (when pairs implements Default)
+            // <2023-11-01>
+            command
+                .first()
+                .expect("This should contain exactly one element")
+                .to_owned()
+        };
+        let arguments: Vec<_> = parsed.clone().find_tagged("argument").collect();
+
+        Ok(Trinitry {
+            command: command.as_str().to_owned(),
+            arguments: arguments
+                .iter()
+                .map(|arg| {
+                    let mut arg = arg.as_str().trim();
+                    arg = if let Some(new_arg) = arg.strip_prefix("\"") {
+                        new_arg
+                    } else {
+                        arg
+                    };
+                    arg = if let Some(new_arg) = arg.strip_suffix("\"") {
+                        new_arg
+                    } else {
+                        arg
+                    };
+
+                    arg = if let Some(new_arg) = arg.strip_prefix("'") {
+                        new_arg
+                    } else {
+                        arg
+                    };
+                    arg = if let Some(new_arg) = arg.strip_suffix("'") {
+                        new_arg
+                    } else {
+                        arg
+                    };
+                    arg.to_owned()
+                })
+                .collect(),
+        })
+    }
+}
+
+impl Display for Trinitry {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.arguments.is_empty() {
+            f.write_str(&self.command)
+        } else {
+            f.write_fmt(format_args!(
+                "{} {}",
+                &self.command,
+                &self.arguments.join(" ")
+            ))
+        }
+    }
+}
+
+mod tests;
+
+#[cfg(test)]
+mod test {
+    use crate::Trinitry;
+
+    #[test]
+    fn parse_cmd() {
+        let string = "quit";
+        let p = Trinitry::new(string).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(&p.command, "quit");
+        assert!(&p.arguments.is_empty());
+    }
+
+    #[test]
+    fn parse_arg_clean() {
+        let string = r##"lua print("Hi")"##;
+        let p = Trinitry::new(string).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(&p.command, "lua");
+        assert_eq!(&p.arguments[0], r#"print("Hi")"#);
+    }
+
+    #[test]
+    fn parse_arg_quote() {
+        let string = r##"write "some 'file' name""##;
+        let p = Trinitry::new(string).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(&p.command, "write");
+        assert_eq!(&p.arguments[0], "some 'file' name");
+    }
+
+    #[test]
+    fn parse_arg_single_quote() {
+        let string = r##"write 'some "file" name'"##;
+        let p = Trinitry::new(string).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(&p.command, "write");
+        assert_eq!(&p.arguments[0], "some \"file\" name");
+    }
+
+    #[test]
+    fn parse_arg_multi() {
+        let string = r##"write 'some "file" name' "other name" last"##;
+        let p = Trinitry::new(string).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+
+        let expected_args = vec!["some \"file\" name", "other name", "last"]
+            .iter()
+            .map(|str| (*str).to_owned())
+            .collect::<Vec<String>>();
+
+        assert_eq!(&p.command, "write");
+        assert_eq!(&p.arguments, &expected_args);
+    }
+}
--- a/trinitry/src/tests.rs
+++ b/trinitry/src/tests.rs
--- a/trinitry/src/trinitry.pest
+++ b/trinitry/src/trinitry.pest
@ -0,0 +1,25 @@
+chars = { ASCII_ALPHANUMERIC | "_" | "-" | "."  }
+
+// TODO(@soispha): Are these all the valid characters? <2023-11-01>
+argument_chars = { chars | "(" | ")" | "{" | "}" | "<" | ">" | "?" | "!" | "+" | "^" | "@"
+| "&" | "*" | "~" | "|" | "=" | "," | "\\" | "/" }
+whitespace = _{ " " } // lower case to avoid special treatment of 'WHITESPACE'
+
+quote = _{ "\"" }
+q = _{ quote }
+
+single_quote = _{ "'" }
+sq = _{ single_quote }
+
+
+
+command = { chars+ }
+
+arg_quoted = { q ~ (!q ~ (argument_chars | " " | "'" ))+ ~ q }
+arg_single_quoted = { sq ~ (!sq ~ (argument_chars | " " | "\"" ))+ ~ sq }
+arg = { (argument_chars | "\"" | "'")+ }
+
+argument = { whitespace+ ~ (arg_quoted | arg_single_quoted | arg )}
+
+
+trinitry = { SOI ~ #command = command ~ (#argument = argument)* ~ EOI }
--- a/trinitry/update.sh
+++ b/trinitry/update.sh
@ -0,0 +1,88 @@
+#!/usr/bin/env sh
+
+# Library {{{
+mktmp() {
+	ensure_tmp_dir
+	mktemp -p "$LIB_TEMP_DIR_FOR_SCRIPT"
+}
+ensure_tmp_dir() {
+	if ! [ -d "$LIB_TEMP_DIR_FOR_SCRIPT" ]; then
+		LIB_TEMP_DIR_FOR_SCRIPT="$(mktemp -d)"
+		export LIB_TEMP_DIR_FOR_SCRIPT
+	fi
+}
+remove_tmp_dir() {
+	# The test is here because some scripts still delete this on their own
+	if [ -d "$LIB_TEMP_DIR_FOR_SCRIPT" ]; then
+		rm -r "$LIB_TEMP_DIR_FOR_SCRIPT"
+	fi
+}
+
+trap remove_tmp_dir EXIT
+ensure_tmp_dir # ensure that the variable has been set, even in subshells
+# }}}
+
+tmp="$(mktmp)"
+
+curl https://raw.githubusercontent.com/minimaxir/big-list-of-naughty-strings/master/blns.txt |
+	awk '!/^#/' |
+	awk '!/^[\s\t]*$/' |
+	awk -v s="'" '!/.*s.*/' |
+
+	# This entry contains duplicated spaces, just ignore it
+	awk '!/Power/' |
+	iconv -c -f utf-8 -t ascii \
+		>"$tmp"
+
+counter=0
+
+cat <<EOF
+// DO NOT EDIT
+// This file is automatically generated by the 'update.sh' file, with data from:
+// https://raw.githubusercontent.com/minimaxir/big-list-of-naughty-strings/master/blns.txt
+
+#[cfg(test)]
+mod test {
+    use crate::Trinitry;
+EOF
+
+while read -r name; do
+	tmp2="$(mktmp)"
+	printf "%s" "$name" >"$tmp2"
+	if rg '^[A-Za-z0-9_.-]+$' "$tmp2" -q; then
+		cat <<EOF
+    #[test]
+    fn parse_$counter() {
+        let p = Trinitry::new(r##"$name"##).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(r##"$name"##, &p.to_string());
+    }
+EOF
+	elif rg '^[A-Za-z0-9_.-]+ [A-Za-z0-9_.(){}<>?!+^@&*~|=,/\\ -]*$' "$tmp2" -q; then
+		cat <<EOF
+    #[test]
+    fn parse_$counter() {
+        let p = Trinitry::new(r##"$name"##).unwrap_or_else(|e| {
+            panic!("{}", e);
+        });
+        assert_eq!(r##"$name"##, &p.to_string());
+    }
+EOF
+	else
+		cat <<EOF
+    #[test]
+    fn parse_$counter() {
+        let p = Trinitry::new(r##"$name"##);
+        assert!(p.is_err());
+    }
+EOF
+	fi
+	counter=$((counter + 1))
+done <"$tmp"
+
+cat <<EOF
+}
+EOF
+
+# vim: ft=sh
--- a/update.sh
+++ b/update.sh
@ -1,13 +1,24 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh


 cargo update && cargo upgrade

 cd ./language_macros || (echo "No language_macros directory" && exit 1)
-
 cargo update && cargo upgrade
-
 cd ..
-git add Cargo.lock Cargo.toml flake.lock ./language_macros/Cargo.toml
+
+cd ./trinitry || (echo "No trinitry directory" && exit 1)
+cargo update && cargo upgrade
+./update.sh > ./src/tests.rs
+cd ..
+
+
+
+git add \
+    Cargo.lock Cargo.toml \
+    flake.lock \
+    ./language_macros/Cargo.toml \
+    ./trinitry/Cargo.toml \
+    ./trinitry/src/tests.rs

 # vim: ft=sh
Author	SHA1	Message	Date
Benedikt Peetz	27d8a2fd0c	build(flake): Update	2023-11-01 13:26:07 +01:00
Benedikt Peetz	c66358261c	build(flake): Switch back to stable rust	2023-11-01 13:25:37 +01:00
Benedikt Peetz	c3ba5ad5a5	build(trinitry/Cargo.toml): Remove unneeded dependencies	2023-11-01 13:25:08 +01:00
Benedikt Peetz	3702788285	build(update.sh): Do not append to the `src/tests.rs` file	2023-11-01 13:24:30 +01:00
Benedikt Peetz	d6cc3422e4	build(update.sh): Add trinitry to the crates to update	2023-11-01 13:19:55 +01:00
Benedikt Peetz	43d991871f	tests(trinitry): Add some sort of fuzzing	2023-11-01 13:19:22 +01:00
Benedikt Peetz	091d77089b	feat(trinitry): Initialize the parsing crate	2023-11-01 13:15:27 +01:00