add: some commands for blogging

momeemt · momeemt · commit 8db9fdca7601 · 2024-12-03T17:50:49.000+09:00
diff --git a/src/anchor.rs b/src/anchor.rs
@@ -0,0 +1,43 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_anchor() -> Metadata {
+    Metadata {
+        command_name: "@".to_string(),
+        call_name: "anchor".to_string(),
+        argument_types: vec![
+            ("href".to_string(), Type::TInline),
+            ("text".to_string(), Type::TInline),
+        ],
+        return_type: Type::TInline,
+    }
+}
+
+#[plugin_fn]
+pub fn anchor(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 2 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: [ravenlog.@ href, text]"),
+            1,
+        ));
+    }
+    let href = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("href must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    let text = match &args[1] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("text must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<Anchor href=\"{}\">{}</Anchor>", href, text))
+}
diff --git a/src/block_math.rs b/src/block_math.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_block_math() ->Metadata {
+    Metadata {
+        command_name: "$".to_string(),
+        call_name: "block_formula".to_string(),
+        argument_types: vec![("formula".to_string(), Type::TInline)],
+        return_type: Type::TBlock,
+    }
+}
+
+#[plugin_fn]
+pub fn block_formula(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: {{ravenlog.$ text}}"),
+            1,
+        ));
+    }
+    let formula = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("formula must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<BlockMath>{}</BlockMath>", formula))
+}
diff --git a/src/block_quote.rs b/src/block_quote.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_block_quote() -> Metadata {
+    Metadata {
+        command_name: ">".to_string(),
+        call_name: "block_quote".to_string(),
+        argument_types: vec![("text".to_string(), Type::TInline)],
+        return_type: Type::TBlock,
+    }
+}
+
+#[plugin_fn]
+pub fn block_quote(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: {{ravenlog.> text}}"),
+            1,
+        ));
+    }
+    let text = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("text must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<BlockQuote>{}</BlockQuote>", text))
+}
diff --git a/src/bold.rs b/src/bold.rs
@@ -14,7 +14,7 @@ pub(crate) fn metadata_bold() -> Metadata {
 pub fn bold(Json(args): Json<Vec<Value>>) -> FnResult<String> {
     if args.len() != 1 {
         return Err(WithReturnCode::new(
-            anyhow::anyhow!("Usage: [rl.* text]"),
+            anyhow::anyhow!("Usage: [ravenlog.* text]"),
             1,
         ));
     }
diff --git a/src/code_block.rs b/src/code_block.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_code_block() -> Metadata {
+    Metadata {
+        command_name: "`".to_string(),
+        call_name: "code_block".to_string(),
+        argument_types: vec![("src".to_string(), Type::TInline)],
+        return_type: Type::TBlock,
+    }
+}
+
+#[plugin_fn]
+pub fn code_block(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: {{ravenlog.` src}}"),
+            1,
+        ));
+    }
+    let src = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("src must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<CodeBlock src=\"{}\"></CodeBlock>", src))
+}
diff --git a/src/image.rs b/src/image.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_image() -> Metadata {
+    Metadata {
+        command_name: "img".to_string(),
+        call_name: "image".to_string(),
+        argument_types: vec![("src".to_string(), Type::TInline)],
+        return_type: Type::TBlock,
+    }
+}
+
+#[plugin_fn]
+pub fn image(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: {{ravenlog.img src}}"),
+            1,
+        ));
+    }
+    let src = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("src must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<RavenlogImage src=\"{}\"></RavenlogImage>", src))
+}
diff --git a/src/inline_code.rs b/src/inline_code.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_inline_code() -> Metadata {
+    Metadata {
+        command_name: "`".to_string(),
+        call_name: "inline_code".to_string(),
+        argument_types: vec![("code".to_string(), Type::TInline)],
+        return_type: Type::TInline,
+    }
+}
+
+#[plugin_fn]
+pub fn inline_code(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: [ravenlog.` code]"),
+            1,
+        ));
+    }
+    let code = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("code must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<InlineCode>{}</InlineCode>", code))
+}
diff --git a/src/inline_math.rs b/src/inline_math.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_inline_math() -> Metadata {
+    Metadata {
+        command_name: "$".to_string(),
+        call_name: "inline_math".to_string(),
+        argument_types: vec![("formula".to_string(), Type::TInline)],
+        return_type: Type::TInline,
+    }
+}
+
+#[plugin_fn]
+pub fn inline_math(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: [ravenlog.$ formula]"),
+            1,
+        ));
+    }
+    let formula = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("formula must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<InlineMath>{}</InlineMath>", formula))
+}
diff --git a/src/inline_quote.rs b/src/inline_quote.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_inline_quote() -> Metadata {
+    Metadata {
+        command_name: ">".to_string(),
+        call_name: "inline_quote".to_string(),
+        argument_types: vec![("text".to_string(), Type::TInline)],
+        return_type: Type::TInline,
+    }
+}
+
+#[plugin_fn]
+pub fn inline_quote(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: [ravenlog.> text]"),
+            1,
+        ));
+    }
+    let text = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("text must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<InlineQuote>{}</InlineQuote>", text))
+}
diff --git a/src/italic.rs b/src/italic.rs
@@ -0,0 +1,31 @@
+use brack_pdk_rs::{metadata::Metadata, types::Type, values::Value};
+use extism_pdk::{plugin_fn, FnResult, Json, WithReturnCode};
+
+pub(crate) fn metadata_italic() -> Metadata {
+    Metadata {
+        command_name: "/".to_string(),
+        call_name: "italic".to_string(),
+        argument_types: vec![("text".to_string(), Type::TInline)],
+        return_type: Type::TInline,
+    }
+}
+
+#[plugin_fn]
+pub fn italic(Json(args): Json<Vec<Value>>) -> FnResult<String> {
+    if args.len() != 1 {
+        return Err(WithReturnCode::new(
+            anyhow::anyhow!("Usage: [ravenlog./ text]"),
+            1,
+        ));
+    }
+    let text = match &args[0] {
+        Value::Text(t) => t,
+        _ => {
+            return Err(WithReturnCode::new(
+                anyhow::anyhow!("text must be Value::Text"),
+                1,
+            ))
+        }
+    };
+    Ok(format!("<Italic>{}</Italic>", text))
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,15 +1,57 @@
+use anchor::metadata_anchor;
+use block_math::metadata_block_math;
+use block_quote::metadata_block_quote;
 use bold::metadata_bold;
-use heading::metadata_headings;
 use brack_pdk_rs::metadata::Metadata;
+use code_block::metadata_code_block;
 use extism_pdk::{plugin_fn, FnResult, Json};
+use heading::metadata_headings;
+use image::metadata_image;
+use inline_code::metadata_inline_code;
+use inline_math::metadata_inline_math;
+use inline_quote::metadata_inline_quote;
+use italic::metadata_italic;
+use ordered_list::metadata_ordered_list;
+use spotify::metadata_spotify;
+use stmt::metadata_stmt;
+use strike::metadata_strike;
+use unordered_list::metadata_unordered_list;
 
+pub mod anchor;
+pub mod block_math;
+pub mod block_quote;
 pub mod bold;
+pub mod code_block;
 pub mod heading;
+pub mod image;
+pub mod inline_code;
+pub mod inline_math;
+pub mod inline_quote;
+pub mod italic;
+pub mod ordered_list;
+pub mod spotify;
+pub mod stmt;
+pub mod strike;
+pub mod unordered_list;
 
 #[plugin_fn]
 pub fn get_metadata() -> FnResult<Json<Vec<Metadata>>> {
     let mut metadata = Vec::new();
+    metadata.push(metadata_anchor());
+    metadata.push(metadata_block_math());
+    metadata.push(metadata_block_quote());
     metadata.push(metadata_bold());
+    metadata.push(metadata_code_block());
     metadata.append(&mut metadata_headings());
+    metadata.push(metadata_image());
+    metadata.push(metadata_inline_code());
+    metadata.push(metadata_inline_quote());
+    metadata.push(metadata_inline_math());
+    metadata.push(metadata_italic());
+    metadata.push(metadata_ordered_list());
+    metadata.push(metadata_spotify());
+    metadata.push(metadata_stmt());
+    metadata.push(metadata_strike());
+    metadata.push(metadata_unordered_list());
     Ok(Json(metadata))
 }
diff --git a/src/ordered_list.rs b/src/ordered_list.rs
diff --git a/src/spotify.rs b/src/spotify.rs
diff --git a/src/stmt.rs b/src/stmt.rs
diff --git a/src/strike.rs b/src/strike.rs
diff --git a/src/unordered_list.rs b/src/unordered_list.rs

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ pub(crate) fn metadata_bold() -> Metadata {`
`14`	`14`	`pub fn bold(Json(args): Json<Vec<Value>>) -> FnResult<String> {`
`15`	`15`	`if args.len() != 1 {`
`16`	`16`	`return Err(WithReturnCode::new(`
`17`		`- anyhow::anyhow!("Usage: [rl.* text]"),`
	`17`	`+ anyhow::anyhow!("Usage: [ravenlog.* text]"),`
`18`	`18`	`1,`
`19`	`19`	`));`
`20`	`20`	`}`