rewrite soap to focus on brain rot detection

Author: dreamer-coding

code/logic/fossil/io/soap.h

@@ -15,56 +15,49 @@
 #define FOSSIL_IO_SOAP_H
 
 #include <stdint.h>
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
- * Setup soap to have a preloaded list of words for use in the sanitize step.
- */
-void fossil_io_soap_create(void);
-
-/**
- * Sanitize a string by replacing curse words with asterisks.
- * This function scans the input string for offensive words and replaces them with asterisks,
- * thereby making the string suitable for use in contexts where offensive language is not allowed.
- * The input string is modified in place.
+ * @brief Sanitize input text by removing or replacing "rot-brain" and meme-based language.
  *
- * @param input The input string to be sanitized in-place.
- * @return The sanitized string.
+ * @param text The input text to sanitize.
+ * @return A dynamically allocated sanitized string (must be freed by the caller).
  */
-char *fossil_io_soap_sanitize(const char *input);
+char *fossil_io_soap_sanitize(const char *text);
 
 /**
- * Check if a word is an offensive word or phrase.
- * Returns EXIT_FAILURE if the word is considered offensive, EXIT_SUCCESS otherwise.
- */
-int32_t fossil_io_soap_is_offensive(const char *word);
-
-/**
- * Check if a word is meme speak.
- * Returns EXIT_FAILURE if the word is considered meme speak, EXIT_SUCCESS otherwise.
+ * @brief Suggest proper alternatives for rot-brain words or grammar fixes.
+ *
+ * @param text The input text.
+ * @param format_type Custom format for output (e.g., "*" or "#").
+ * @return A dynamically allocated string with suggestions (must be freed by the caller).
  */
-int32_t fossil_io_soap_is_rotbrain(const char *word);
+char *fossil_io_soap_suggest(const char *text, char format_type);
 
 /**
- * Count offensive words in a string.
- * Returns the number of offensive words found in the input string.
+ * @brief Add a custom word or phrase to the filter.
+ *
+ * @param phrase The phrase to add.
+ * @return 0 on success, nonzero on failure.
  */
-int32_t fossil_io_soap_count_offensive(const char *input);
+int fossil_io_soap_add_custom_filter(const char *phrase);
 
 /**
- * Count meme speak words in a string.
- * Returns the number of meme speak words found in the input string.
+ * @brief Clear all custom filters.
  */
-int32_t fossil_io_soap_count_rotbrain(const char *input);
+void fossil_io_soap_clear_custom_filters(void);
 
 /**
- * Count positive words in a string.
- * Returns the number of positive words found in the input string.
+ * @brief Detect the tone of a sentence.
+ *
+ * @param text The input text.
+ * @return A string representing the detected tone ("formal", "casual", "sarcastic", etc.).
  */
-int32_t fossil_io_soap_count_positive(const char *input);
+const char *fossil_io_soap_detect_tone(const char *text);
 
 #ifdef __cplusplus
 }
@@ -86,119 +79,94 @@ namespace fossil {
         class Soap {
         public:
             /**
-             * Setup soap to have a preloaded list of words for use in the sanitize step.
-             */
-            Soap() {
-                fossil_io_soap_create();
-            }
-
-            /**
-             * Destructor.
-             */
-            ~Soap() = default;
-
-            /**
-             * Sanitize a string by replacing curse words with asterisks.
-             * This function scans the input string for offensive words and replaces them with asterisks,
-             * thereby making the string suitable for use in contexts where offensive language is not allowed.
-             * The input string is modified in place.
+             * Sanitize input text by removing or replacing "rot-brain" and meme-based language.
              *
-             * @param input The input string to be sanitized in-place.
+             * @param text The input text to sanitize.
+             * @param censor_char Character to use for censoring (default: '*').
+             * @return A dynamically allocated sanitized string (must be freed by the caller).
              */
-            static void sanitize(std::string &input) {
-                fossil_io_soap_sanitize(&input[0]);
+            static std::string sanitize(const std::string &text, char censor_char = '*') {
+                return fossil_io_soap_sanitize(text.c_str());
             }
 
             /**
-             * Sanitize a C string by replacing curse words with asterisks.
-             * This function scans the input string for offensive words and replaces them with asterisks,
-             * thereby making the string suitable for use in contexts where offensive language is not allowed.
-             * The input string is modified in place.
+             * Suggest proper alternatives for rot-brain words or grammar fixes.
              *
-             * @param input The input C string to be sanitized in-place.
-             */
-            static void sanitize(char *input) {
-                fossil_io_soap_sanitize(input);
-            }
-
-            /**
-             * Check if a word is an offensive word or phrase.
-             * Returns EXIT_FAILURE if the word is considered offensive, EXIT_SUCCESS otherwise.
+             * @param text The input text.
+             * @param format_type Custom format for output (e.g., "*" or "#").
+             * @return A dynamically allocated string with suggestions (must be freed by the caller).
              */
-            static int32_t is_offensive(const std::string &word) {
-                return fossil_io_soap_is_offensive(word.c_str());
+            static std::string suggest(const std::string &text, char format_type = '*') {
+                return fossil_io_soap_suggest(text.c_str(), format_type);
             }
 
             /**
-             * Check if a C string word is an offensive word or phrase.
-             * Returns EXIT_FAILURE if the word is considered offensive, EXIT_SUCCESS otherwise.
-             */
-            static int32_t is_offensive(const char *word) {
-                return fossil_io_soap_is_offensive(word);
-            }
-
-            /**
-             * Check if a word is meme speak.
-             * Returns EXIT_FAILURE if the word is considered meme speak, EXIT_SUCCESS otherwise.
-             */
-            static int32_t is_rotbrain(const std::string &word) {
-                return fossil_io_soap_is_rotbrain(word.c_str());
-            }
-
-            /**
-             * Check if a C string word is meme speak.
-             * Returns EXIT_FAILURE if the word is considered meme speak, EXIT_SUCCESS otherwise.
+             * Add a custom word or phrase to the filter.
+             *
+             * @param phrase The phrase to add.
+             * @return 0 on success, nonzero on failure.
              */
-            static int32_t is_rotbrain(const char *word) {
-                return fossil_io_soap_is_rotbrain(word);
+            static int add_custom_filter(const std::string &phrase) {
+                return fossil_io_soap_add_custom_filter(phrase.c_str());
             }
 
             /**
-             * Count offensive words in a string.
-             * Returns the number of offensive words found in the input string.
+             * Clear all custom filters.
              */
-            static int32_t count_offensive(const std::string &input) {
-                return fossil_io_soap_count_offensive(input.c_str());
+            static void clear_custom_filters() {
+                fossil_io_soap_clear_custom_filters();
             }
 
             /**
-             * Count offensive words in a C string.
-             * Returns the number of offensive words found in the input string.
+             * Detect the tone of a sentence.
+             *
+             * @param text The input text.
+             * @return A string representing the detected tone ("formal", "casual", "sarcastic", etc.).
              */
-            static int32_t count_offensive(const char *input) {
-                return fossil_io_soap_count_offensive(input);
+            static std::string detect_tone(const std::string &text) {
+                return fossil_io_soap_detect_tone(text.c_str());
             }
 
             /**
-             * Count meme speak words in a string.
-             * Returns the number of meme speak words found in the input string.
+             * Sanitize input text by removing or replacing "rot-brain" and meme-based language.
+             *
+             * @param text The input text to sanitize.
+             * @param censor_char Character to use for censoring (default: '*').
+             * @return A dynamically allocated sanitized string (must be freed by the caller).
              */
-            static int32_t count_rotbrain(const std::string &input) {
-                return fossil_io_soap_count_rotbrain(input.c_str());
+            static char* sanitize(const char* text, char censor_char = '*') {
+                return fossil_io_soap_sanitize(text);
             }
 
             /**
-             * Count meme speak words in a C string.
-             * Returns the number of meme speak words found in the input string.
+             * Suggest proper alternatives for rot-brain words or grammar fixes.
+             *
+             * @param text The input text.
+             * @param format_type Custom format for output (e.g., "*" or "#").
+             * @return A dynamically allocated string with suggestions (must be freed by the caller).
              */
-            static int32_t count_rotbrain(const char *input) {
-                return fossil_io_soap_count_rotbrain(input);
+            static char* suggest(const char* text, char format_type = '*') {
+                return fossil_io_soap_suggest(text, format_type);
             }
 
             /**
-             * Count positive words in a string.
-             * Returns the number of positive words found in the input string.
+             * Add a custom word or phrase to the filter.
+             *
+             * @param phrase The phrase to add.
+             * @return 0 on success, nonzero on failure.
              */
-            static int32_t count_positive(const std::string &input) {
-                return fossil_io_soap_count_positive(input.c_str());
+            static int add_custom_filter(const char* phrase) {
+                return fossil_io_soap_add_custom_filter(phrase);
             }
 
             /**
-             * Count positive words in a C string.
-             * Returns the number of positive words found in the input string.
+             * Detect the tone of a sentence.
+             *
+             * @param text The input text.
+             * @return A string representing the detected tone ("formal", "casual", "sarcastic", etc.).
              */
-            static int32_t count_positive(const char *input) {
-                return fossil_io_soap_count_positive(input);
+            static const char* detect_tone(const char* text) {
+                return fossil_io_soap_detect_tone(text);
             }
 
         };