feat: implement the Rules::iter() method.

This method returns an iterator that allows to iterate over the compiled rules, and access some information about each rule, like its identifier, namespace, tags, etc.

Author: plusvic

lib/src/compiler/rules.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use std::io::{BufWriter, Read, Write};
+use std::slice::Iter;
 #[cfg(feature = "logging")]
 use std::time::Instant;
 
@@ -20,7 +21,7 @@ use crate::compiler::{
 };
 use crate::re::{BckCodeLoc, FwdCodeLoc, RegexpAtom};
 use crate::string_pool::{BStringPool, StringPool};
-use crate::{re, types};
+use crate::{re, types, Rule};
 
 /// A set of YARA rules in compiled form.
 ///
@@ -201,6 +202,29 @@ impl Rules {
         Self::deserialize(bytes)
     }
 
+    /// Returns an iterator that yields the compiled rules.
+    ///
+    /// ```rust
+    /// # use yara_x::Compiler;
+    /// let mut compiler = Compiler::new();
+    ///
+    /// assert!(compiler
+    ///     .add_source("rule foo {condition: true}")
+    ///     .unwrap()
+    ///     .add_source("rule bar {condition: true}")
+    ///     .is_ok());
+    ///
+    /// let rules = compiler.build();
+    /// let mut iter = rules.iter();
+    ///
+    /// assert_eq!(iter.len(), 2);
+    /// assert_eq!(iter.next().map(|r| r.identifier()), Some("foo"));
+    /// assert_eq!(iter.next().map(|r| r.identifier()), Some("bar"));
+    /// ```
+    pub fn iter(&self) -> RulesIter {
+        RulesIter { rules: self, iterator: self.rules.iter() }
+    }
+
     /// Returns a [`RuleInfo`] given its [`RuleId`].
     ///
     /// # Panics
@@ -401,6 +425,32 @@ impl Rules {
     }
 }
 
+/// Iterator that yields the of the compiled rules.
+pub struct RulesIter<'a> {
+    rules: &'a Rules,
+    iterator: Iter<'a, RuleInfo>,
+}
+
+impl<'a> Iterator for RulesIter<'a> {
+    type Item = Rule<'a, 'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(Rule {
+            ctx: None,
+            data: None,
+            rules: self.rules,
+            rule_info: self.iterator.next()?,
+        })
+    }
+}
+
+impl ExactSizeIterator for RulesIter<'_> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.iterator.len()
+    }
+}
+
 fn serialize_wasm_mod<S>(
     wasm_mod: &wasmtime::Module,
     serializer: S,

lib/src/lib.rs

@@ -46,19 +46,19 @@ assert_eq!(results.matching_rules().len(), 1);
 pub use compiler::compile;
 pub use compiler::Compiler;
 pub use compiler::Rules;
+pub use compiler::RulesIter;
 pub use compiler::SourceCode;
-
+pub use models::Match;
+pub use models::Matches;
+pub use models::MetaValue;
+pub use models::Metadata;
+pub use models::Pattern;
+pub use models::Patterns;
+pub use models::Rule;
 pub use modules::mods;
-pub use scanner::Match;
-pub use scanner::Matches;
 pub use scanner::MatchingRules;
-pub use scanner::MetaValue;
-pub use scanner::Metadata;
 pub use scanner::ModuleOutputs;
 pub use scanner::NonMatchingRules;
-pub use scanner::Pattern;
-pub use scanner::Patterns;
-pub use scanner::Rule;
 pub use scanner::ScanError;
 pub use scanner::ScanOptions;
 pub use scanner::ScanResults;
@@ -75,6 +75,7 @@ mod types;
 mod variables;
 mod wasm;
 
+mod models;
 #[cfg(test)]
 mod tests;