Base stemmer function

src/stemmer.rs

@@ -84,12 +84,22 @@ impl Stemmer {
         stemmed_words.join(" ")
     }
 
+    /// Stem a singular word to its common stem form.
+    ///
+    /// Example: `mengalahkan` to `kalah`
     fn stem_singular_word(&self, word: &str) -> String {
         let mut context = Context::new(word, &self.dictionary, None);
         context.execute();
         context.get_resulting_word()
     }
 
+    /// Stem a plural word to its common stem form.
+    ///
+    /// Example: `bersama-sama` to `sama`
+    ///
+    /// # Reference
+    /// - Asian J. (2007) “Effective Techniques for Indonesian Text Retrieval” page 76-77.
+    /// - http://researchbank.rmit.edu.au/eserv/rmit:6312/Asian.pdf
     fn stem_plural_word(&self, word: &str) -> String {
         todo!()
     }

src/stemmer/context.rs

@@ -1,7 +1,8 @@
+use std::ops::Not;
 use crate::dictionary::Dictionary;
 use crate::stemmer::confix_stripping::precedence_adjustment::PrecedenceAdjustment;
 // use crate::stemmer::context::removal::{Removal};
-use crate::stemmer::context::visitor::{Visitor, VisitorConfiguration, VisitorResult};
+use crate::stemmer::context::visitor::{Visitor, VisitorConfiguration};
 use crate::stemmer::context::visitor::dont_stem_short_word::DontStemShortWord;
 
 // pub mod removal;
@@ -46,12 +47,20 @@ impl<'a> Context<'a> {
 
         // Iterate each visitor and run its modifier
         for visitor in &(self.general_visitors) {
-            let visitor_result: VisitorResult = visitor.visit(&self);
-            match visitor_result {
-                VisitorResult::StopProcess => { self.is_process_stopped = true; }
-                VisitorResult::DoNothing => {}
+            let optional_context_result = visitor.visit(&self);
+            if optional_context_result.is_some() {
+                let context_result = optional_context_result.unwrap();
+
+                if context_result.current_word.eq(&self.current_word).not() {
+                    self.current_word = context_result.current_word.clone()
+                }
+
+                if context_result.should_process_stop == true {
+                    self.is_process_stopped = true;
+                }
             }
-            if !self.is_process_stopped {
+
+            if self.is_process_stopped.not() {
                 break;
             }
         }

src/stemmer/context/visitor.rs

@@ -10,15 +10,9 @@ pub enum VisitorType {
     SuffixVisitor,
 }
 
-#[derive(PartialEq, Debug)]
-pub enum VisitorResult {
-    StopProcess,
-    DoNothing,
-}
-
 pub trait Visitor {
     fn get_visitor_type(&self) -> VisitorType;
-    fn visit(&self, context: &Context) -> VisitorResult;
+    fn visit<'a>(&'a self, context: &'a Context) -> Option<VisitorResult>;
 }
 
 pub struct VisitorConfiguration {
@@ -41,4 +35,23 @@ impl VisitorConfiguration {
             ],
         }
     }
+}
+
+pub struct VisitorResult {
+    pub original_word: String,
+    pub current_word: String,
+    pub result_word: Option<String>,
+    pub should_process_stop: bool,
+}
+
+impl VisitorResult {
+    /// Initialize VisitorResult object that only serve as stop_process flag
+    pub fn stop_process(original_word: String, current_word: String, result_word: Option<String>) -> Self {
+        Self {
+            original_word: original_word.clone(),
+            current_word: current_word.clone(),
+            result_word: result_word.clone(),
+            should_process_stop: true,
+        }
+    }
 }

src/stemmer/context/visitor/dont_stem_short_word.rs

@@ -8,11 +8,15 @@ impl Visitor for DontStemShortWord {
         VisitorType::GeneralVisitor
     }
 
-    fn visit(&self, context: &Context) -> VisitorResult {
+    fn visit<'a>(&'a self, context: &'a Context) -> Option<VisitorResult> {
         if self.is_short_word(&(context.current_word)) {
-            return VisitorResult::StopProcess
+            return Some(VisitorResult::stop_process(
+                context.original_word.clone().to_string(),
+                context.current_word.clone(),
+                None
+            ))
         }
-        VisitorResult::DoNothing
+        None
     }
 }
 
@@ -51,22 +55,25 @@ mod dont_stem_short_word_test {
     }
 
     #[test]
-    fn short_word_should_return_stop_process() {
+    fn short_word_should_return_result_with_stop_process() {
         let dictionary = Dictionary::new();
         let mut context = Context::new("iya", &dictionary, None);
 
-        let object = DontStemShortWord;
-        let result = object.visit(&context);
-        assert_eq!(result, VisitorResult::StopProcess);
+        let object = DontStemShortWord {};
+        let optional_context_result = object.visit(&context);
+        assert_eq!(optional_context_result.is_some(), true);
+
+        let context_result = optional_context_result.unwrap();
+        assert_eq!(context_result.should_process_stop, true);
     }
 
     #[test]
-    fn long_word_should_return_do_nothing() {
+    fn long_word_should_not_return_visitor_result() {
         let dictionary = Dictionary::new();
         let mut context = Context::new("kambing", &dictionary, None);
 
-        let object = DontStemShortWord;
-        let result = object.visit(&context);
-        assert_eq!(result, VisitorResult::DoNothing);
+        let object = DontStemShortWord {};
+        let optional_context_result = object.visit(&context);
+        assert_eq!(optional_context_result.is_none(), true);
     }
 }

tests/stemmer.rs

@@ -3,7 +3,6 @@ mod stemmer_test {
     use rustrawi::stemmer::Stemmer;
 
     #[test]
-    #[ignore]
     fn should_initialize_stemmer_with_default_dictionary() {
         let stemmer = Stemmer::new();
         assert_eq!(stemmer.len(), 29932);