Use "rules" for config.

Dirbaio · Dirbaio · commit fc1adb575027 · 2025-07-04T13:21:03.000+02:00
diff --git a/java-spaghetti-gen/src/config.rs b/java-spaghetti-gen/src/config.rs
@@ -1,6 +1,5 @@
 //! java-spaghetti.toml configuration file structures and parsing APIs.
 
-use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::{fs, io};
 
@@ -10,9 +9,6 @@ fn default_proxy_path_prefix() -> String {
     "java_spaghetti/proxy".to_string()
 }
 
-fn default_empty() -> String {
-    String::new()
-}
 fn default_slash() -> String {
     String::from("/")
 }
@@ -73,16 +69,6 @@ pub struct DocPattern {
     /// | jni_prefix = ""       | field_url_pattern = "https://developer.android.com/reference/{CLASS}.html#{FIELD}"
     pub field_url_pattern: Option<String>,
 
-    /// What java class(es) to match against.  This takes the form of a simple prefix to a JNI path with no wildcards.
-    ///
-    /// | To Match:                 | Use a JNI Prefix:                     |
-    /// | ------------------------- | ------------------------------------- |
-    /// | *                         | jni_prefix = ""
-    /// | java.lang.*               | jni_prefix = "java/lang/"
-    /// | name.spaces.OuterClass.*  | jni_prefix = "name/spaces/OuterClass$"
-    #[serde(default = "default_empty")]
-    pub jni_prefix: String,
-
     /// What to use in the {CLASS} portion of URLs to separate namespaces.  Defaults to "/".
     #[serde(default = "default_slash")]
     pub class_namespace_separator: String,
@@ -104,6 +90,35 @@ pub struct DocPattern {
     pub argument_seperator: String,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct Rule {
+    /// What java class(es) to match against.  This takes the form of a simple prefix to a JNI path with no wildcards.
+    ///
+    /// | To Match:                 | Use a JNI Prefix:                     |
+    /// | ------------------------- | ------------------------------------- |
+    /// | *                         | jni_prefix = ""
+    /// | java.lang.*               | jni_prefix = "java/lang/"
+    /// | name.spaces.OuterClass.*  | jni_prefix = "name/spaces/OuterClass$"
+    #[serde(default)]
+    pub prefix: String,
+
+    #[serde(default)]
+    pub include: Option<bool>,
+
+    #[serde(default)]
+    pub proxy: Option<bool>,
+
+    #[serde(default)]
+    pub doc_pattern: Option<DocPattern>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ClassConfig<'a> {
+    pub include: bool,
+    pub proxy: bool,
+    pub doc_pattern: Option<&'a DocPattern>,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct Config {
     #[serde(default = "default_proxy_path_prefix")]
@@ -112,18 +127,11 @@ pub struct Config {
     pub(crate) input: Vec<PathBuf>,
     pub(crate) output: PathBuf,
 
-    #[serde(default)]
-    pub(crate) doc_patterns: Vec<DocPattern>,
     #[serde(default)]
     pub(crate) logging_verbose: bool,
 
-    #[serde(rename = "include")]
     #[serde(default)]
-    pub(crate) include_classes: HashSet<String>,
-
-    #[serde(rename = "include_proxy")]
-    #[serde(default = "HashSet::new")]
-    pub(crate) include_proxies: HashSet<String>,
+    pub(crate) rules: Vec<Rule>,
 }
 
 impl Config {
@@ -140,8 +148,13 @@ impl Config {
     pub fn read_str(buffer: &str, dir: &Path) -> io::Result<Self> {
         let mut config: Config = toml::from_str(buffer).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
 
-        if config.include_classes.is_empty() {
-            config.include_classes.insert("*".to_string());
+        if config.rules.is_empty() {
+            config.rules.push(Rule {
+                prefix: "".to_string(),
+                include: Some(true),
+                doc_pattern: None,
+                proxy: None,
+            })
         }
 
         config.output = resolve_file(&config.output, dir);
@@ -181,6 +194,30 @@ impl Config {
             }
         }
     }
+
+    pub fn resolve_class(&self, class: &str) -> ClassConfig<'_> {
+        let mut res = ClassConfig {
+            include: false,
+            proxy: false,
+            doc_pattern: None,
+        };
+
+        for r in &self.rules {
+            if class.starts_with(&r.prefix) {
+                if let Some(include) = r.include {
+                    res.include = include;
+                }
+                if let Some(proxy) = r.proxy {
+                    res.proxy = proxy;
+                }
+                if let Some(doc_pattern) = &r.doc_pattern {
+                    res.doc_pattern = Some(doc_pattern);
+                }
+            }
+        }
+
+        res
+    }
 }
 
 fn resolve_file(path: &Path, dir: &Path) -> PathBuf {
diff --git a/java-spaghetti-gen/src/emit_rust/classes.rs b/java-spaghetti-gen/src/emit_rust/classes.rs
@@ -20,10 +20,10 @@ pub(crate) struct StructPaths {
 }
 
 impl StructPaths {
-    pub(crate) fn new(context: &Context, class: Id) -> Result<Self, Box<dyn Error>> {
+    pub(crate) fn new(class: Id) -> Result<Self, Box<dyn Error>> {
         Ok(Self {
-            mod_: Class::mod_for(context, class)?,
-            struct_name: Class::name_for(context, class)?,
+            mod_: Class::mod_for(class)?,
+            struct_name: Class::name_for(class)?,
         })
     }
 }
@@ -47,7 +47,7 @@ fn rust_id(id: &str) -> Result<String, Box<dyn Error>> {
 }
 
 impl Class {
-    pub(crate) fn mod_for(_context: &Context, class: Id) -> Result<String, Box<dyn Error>> {
+    pub(crate) fn mod_for(class: Id) -> Result<String, Box<dyn Error>> {
         let mut buf = String::new();
         for component in class {
             match component {
@@ -64,7 +64,7 @@ impl Class {
         Ok(buf)
     }
 
-    pub(crate) fn name_for(_context: &Context, class: Id) -> Result<String, Box<dyn Error>> {
+    pub(crate) fn name_for(class: Id) -> Result<String, Box<dyn Error>> {
         let mut buf = String::new();
         for component in class.iter() {
             match component {
@@ -76,13 +76,15 @@ impl Class {
         Ok(buf)
     }
 
-    pub(crate) fn new(context: &mut Context, java: JavaClass) -> Result<Self, Box<dyn Error>> {
-        let rust = StructPaths::new(context, java.path())?;
+    pub(crate) fn new(java: JavaClass) -> Result<Self, Box<dyn Error>> {
+        let rust = StructPaths::new(java.path())?;
 
         Ok(Self { rust, java })
     }
 
     pub(crate) fn write(&self, context: &Context) -> anyhow::Result<TokenStream> {
+        let cc = context.config.resolve_class(self.java.path().as_str());
+
         // Ignored access_flags: SUPER, SYNTHETIC, ANNOTATION, ABSTRACT
 
         let keyword = if self.java.is_interface() {
@@ -103,7 +105,7 @@ impl Class {
             false => quote!(),
         };
 
-        let docs = match KnownDocsUrl::from_class(context, self.java.path()) {
+        let docs = match KnownDocsUrl::from_class(&cc, self.java.path()) {
             Some(url) => format!("{visibility} {keyword} {url}"),
             None => format!("{visibility} {keyword} {}", self.java.path().as_str()),
         };
@@ -174,31 +176,31 @@ impl Class {
         let mut methods: Vec<Method> = self
             .java
             .methods()
-            .map(|m| Method::new(context, &self.java, m))
+            .map(|m| Method::new(&self.java, m))
             .filter(|m| m.java.is_public() && !m.java.is_bridge())
             .collect();
         let mut fields: Vec<Field> = self
             .java
             .fields()
-            .map(|f| Field::new(context, &self.java, f))
+            .map(|f| Field::new(&self.java, f))
             .filter(|f| f.java.is_public())
             .collect();
 
         self.resolve_collisions(&mut methods, &fields)?;
 
         for method in &mut methods {
-            let res = method.emit(context, &self.rust.mod_).unwrap();
+            let res = method.emit(context, &cc, &self.rust.mod_).unwrap();
             contents.extend(res);
         }
 
         for field in &mut fields {
-            let res = field.emit(context, &self.rust.mod_).unwrap();
+            let res = field.emit(context, &cc, &self.rust.mod_).unwrap();
             contents.extend(res);
         }
 
         out.extend(quote!(impl #rust_name { #contents }));
 
-        if context.proxy_included(self.java.path().as_str()) {
+        if cc.proxy {
             out.extend(self.write_proxy(context, &methods)?);
         }
 
diff --git a/java-spaghetti-gen/src/emit_rust/fields.rs b/java-spaghetti-gen/src/emit_rust/fields.rs
@@ -6,6 +6,7 @@ use quote::{format_ident, quote};
 
 use super::cstring;
 use super::known_docs_url::KnownDocsUrl;
+use crate::config::ClassConfig;
 use crate::emit_rust::Context;
 use crate::identifiers::{FieldMangling, IdentifierManglingError, mangle_field};
 use crate::parser_util::{Id, JavaClass, JavaField};
@@ -17,15 +18,15 @@ pub struct Field<'a> {
 }
 
 impl<'a> Field<'a> {
-    pub fn new(_context: &Context, class: &'a JavaClass, java: &'a cafebabe::FieldInfo<'a>) -> Self {
+    pub fn new(class: &'a JavaClass, java: &'a cafebabe::FieldInfo<'a>) -> Self {
         Self {
             class,
             java: JavaField::from(java),
             rust_names: mangle_field(JavaField::from(java)),
         }
     }
 
-    pub fn emit(&self, context: &Context, mod_: &str) -> anyhow::Result<TokenStream> {
+    pub fn emit(&self, context: &Context, cc: &ClassConfig, mod_: &str) -> anyhow::Result<TokenStream> {
         let mut emit_reject_reasons = Vec::new();
 
         if !self.java.is_public() {
@@ -91,7 +92,7 @@ impl<'a> Field<'a> {
         };
 
         let docs = match KnownDocsUrl::from_field(
-            context,
+            cc,
             self.class.path().as_str(),
             self.java.name(),
             self.java.descriptor().clone(),
diff --git a/java-spaghetti-gen/src/emit_rust/known_docs_url.rs b/java-spaghetti-gen/src/emit_rust/known_docs_url.rs
@@ -3,7 +3,7 @@ use std::fmt::{self, Display, Formatter};
 use cafebabe::descriptors::{FieldDescriptor, FieldType};
 
 use super::methods::Method;
-use crate::emit_rust::Context;
+use crate::config::ClassConfig;
 use crate::parser_util::Id;
 
 pub(crate) struct KnownDocsUrl {
@@ -18,13 +18,9 @@ impl Display for KnownDocsUrl {
 }
 
 impl KnownDocsUrl {
-    pub(crate) fn from_class(context: &Context, java_class: Id) -> Option<KnownDocsUrl> {
+    pub(crate) fn from_class(config: &ClassConfig, java_class: Id) -> Option<KnownDocsUrl> {
         let java_class = java_class.as_str();
-        let pattern = context
-            .config
-            .doc_patterns
-            .iter()
-            .find(|pattern| java_class.starts_with(pattern.jni_prefix.as_str()))?;
+        let pattern = config.doc_pattern?;
 
         for ch in java_class.chars() {
             match ch {
@@ -56,14 +52,10 @@ impl KnownDocsUrl {
         })
     }
 
-    pub(crate) fn from_method(context: &Context, method: &Method) -> Option<KnownDocsUrl> {
+    pub(crate) fn from_method(config: &ClassConfig, method: &Method) -> Option<KnownDocsUrl> {
         let is_constructor = method.java.is_constructor();
 
-        let pattern = context
-            .config
-            .doc_patterns
-            .iter()
-            .find(|pattern| method.class.path().as_str().starts_with(pattern.jni_prefix.as_str()))?;
+        let pattern = config.doc_pattern?;
         let url_pattern = if is_constructor {
             pattern
                 .constructor_url_pattern
@@ -188,16 +180,12 @@ impl KnownDocsUrl {
     }
 
     pub(crate) fn from_field(
-        context: &Context,
+        config: &ClassConfig,
         java_class: &str,
         java_field: &str,
         _java_descriptor: FieldDescriptor,
     ) -> Option<KnownDocsUrl> {
-        let pattern = context
-            .config
-            .doc_patterns
-            .iter()
-            .find(|pattern| java_class.starts_with(pattern.jni_prefix.as_str()))?;
+        let pattern = config.doc_pattern?;
         let field_url_pattern = pattern.field_url_pattern.as_ref()?;
 
         for ch in java_class.chars() {
diff --git a/java-spaghetti-gen/src/emit_rust/methods.rs b/java-spaghetti-gen/src/emit_rust/methods.rs
@@ -5,6 +5,7 @@ use quote::{format_ident, quote};
 use super::cstring;
 use super::fields::{RustTypeFlavor, emit_fragment_type, emit_rust_type};
 use super::known_docs_url::KnownDocsUrl;
+use crate::config::ClassConfig;
 use crate::emit_rust::Context;
 use crate::identifiers::MethodManglingStyle;
 use crate::parser_util::{JavaClass, JavaMethod};
@@ -17,7 +18,7 @@ pub struct Method<'a> {
 }
 
 impl<'a> Method<'a> {
-    pub fn new(_context: &Context, class: &'a JavaClass, java: &'a cafebabe::MethodInfo<'a>) -> Self {
+    pub fn new(class: &'a JavaClass, java: &'a cafebabe::MethodInfo<'a>) -> Self {
         let mut result = Self {
             class,
             java: JavaMethod::from(java),
@@ -40,7 +41,7 @@ impl<'a> Method<'a> {
             .ok()
     }
 
-    pub fn emit(&self, context: &Context, mod_: &str) -> anyhow::Result<TokenStream> {
+    pub fn emit(&self, context: &Context, cc: &ClassConfig, mod_: &str) -> anyhow::Result<TokenStream> {
         let mut emit_reject_reasons = Vec::new();
 
         let descriptor = self.java.descriptor();
@@ -123,7 +124,7 @@ impl<'a> Method<'a> {
             quote!()
         };
 
-        let docs = match KnownDocsUrl::from_method(context, self) {
+        let docs = match KnownDocsUrl::from_method(cc, self) {
             Some(url) => format!("{url}"),
             None => self.java.name().to_string(),
         };
diff --git a/java-spaghetti-gen/src/emit_rust/mod.rs b/java-spaghetti-gen/src/emit_rust/mod.rs
