Merge pull request #38 from OpenTabletDriver/main

Bump v4.x branch on release publish

Author: Kuuuube

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tabletdrivercleanup"
-version = "4.0.3"
+version = "4.1.1"
 edition = "2021"
 
 [profile.release]

Cargo.toml

@@ -62,3 +62,5 @@ For those who want to build the project from source:
 - Run `build.ps1` in the root directory
 
 The binaries will be in `build`.
+
+## [Dev Docs](./dev_docs.md)

README.md

@@ -54,6 +54,12 @@
     "display_name": "Huion ?Tablet",
     "display_version": "^15"
   },
+  {
+    "friendly_name": "Huion v20.x",
+    "uninstall_method": "Deferred",
+    "display_name": "Huion ?Tablet",
+    "display_version": "^20"
+  },
   {
     "friendly_name": "Kenting Tablet v14.x",
     "uninstall_method": "Normal",
@@ -114,6 +120,12 @@
     "display_name": "VKTabletDriver",
     "display_version": "^2"
   },
+  {
+    "friendly_name": "Veikk Tablet Driver v3.x",
+    "uninstall_method": "Deferred",
+    "display_name": "Veikk ?Tablet",
+    "display_version": "^3"
+  },
   {
     "friendly_name": "Wacom Tablet v6.3.x",
     "uninstall_method": "Normal",
@@ -155,17 +167,28 @@
     "display_name": "Veikk \\(WinUsb\\) USBVeikk"
   },
   {
-    "friendly_name": "Xencelabs v1.1",
+    "friendly_name": "Windows Driver Package - Veikk (vkmoufilter) Mouse",
+    "uninstall_method": "RegistryOnly",
+    "display_name": "Veikk \\(vkmoufilter\\) Mouse"
+  },
+  {
+    "friendly_name": "Xencelabs v1.1.x",
     "uninstall_method": "Deferred",
     "display_name": "Xencelabs",
     "display_version": "^1.1"
   },
   {
-    "friendly_name": "Xencelabs v1.2",
+    "friendly_name": "Xencelabs v1.2.x",
     "uninstall_method": "Deferred",
     "display_name": "Xencelabs",
     "display_version": "^1.2"
   },
+  {
+    "friendly_name": "Xencelabs v1.3.x",
+    "uninstall_method": "Deferred",
+    "display_name": "Xencelabs",
+    "display_version": "^1.3"
+  },
   {
     "friendly_name": "XENX Driver v1.x",
     "uninstall_method": "Deferred",
@@ -178,5 +201,12 @@
     "display_name": "Pentablet",
     "display_version": "^3",
     "publisher": "XP[-| ]?Pen"
+  },
+  {
+    "friendly_name": "XP-Pen Driver v4.x",
+    "uninstall_method": "Deferred",
+    "display_name": "XPPenTablet",
+    "display_version": "^4",
+    "publisher": "XP[-| ]?Pen"
   }
 ]

config/driver_package_identifiers.json

@@ -0,0 +1,37 @@
+## Config Files
+
+All config attributes are optional. Any omitted attributes will be ignored when matching.
+
+All regex matches are case insensitive. Use `\\` for backslashes, regex `\d` for example should be entered as `\\d`.
+
+### `device_identifiers.json`
+
+- `friendly_name`: Displayed to user, not matched against
+- `device_desc`: Regex match (`Device Description` in pnputil_devices dump)
+- `manufacturer`: Regex match (`Manufacturer Name` in pnputil_devices dump)
+- `hardware_id`: Regex match (`Instance ID` in pnputil_devices dump)
+- `class_uuid`: Exact string match (`Class GUID` in pnputil_devices dump)
+- `inf_provider`: Regex match (`Provider Name` in pnputil_devices dump)
+
+### `driver_identifiers.json`
+
+- `friendly_name`: Displayed to user, not matched against
+- `original_name`: Regex match (`Original Name` in pnputil_drivers dump)
+- `provider`: Regex match (`Provider Name` in pnputil_drivers dump)
+- `class`: Exact string match (`Class GUID` in pnputil_drivers dump)
+
+### `driver_package_identifiers.json`
+
+- `friendly_name`: Displayed to user, not matched against
+- `display_name`: Regex match
+- `display_version`: Regex match
+- `publisher`: Regex match
+- `uninstall_method`: `Normal|Deferred|RegistryOnly`
+
+## Github Release Instructions
+
+- Set the new version in `Cargo.toml` and let it propagate to `Cargo.lock`.
+- PR and merge the version bump change.
+- Push a tag with the new version and a draft release will be created.
+- Review the draft and set it to latest if it looks good.
+- A PR will be automatically created to pull the latest changes from `main` into the config branch.

dev_docs.md

@@ -148,36 +148,47 @@ struct DeviceDumper {}
 #[async_trait]
 impl Dumper for DeviceDumper {
     async fn dump(&self, state: &State) -> Result<(), ModuleError> {
-        let inf_regex = Regex::new(r"^oem[0-9]+\.inf$").unwrap();
-        let devices: Vec<Device> = enumerate_devices()
-            .into_module_report(DEVICE_MODULE_NAME)?
-            .into_iter()
-            .filter(|d| inf_regex.is_match(d.inf_name().unwrap_or("")))
-            .filter(is_of_interest)
-            .collect();
-
-        let file_path =
-            get_path_to_dump(state, "devices.json").into_module_report(DEVICE_MODULE_NAME)?;
-        let dump_file = create_dump_file(&file_path).into_module_report(DEVICE_MODULE_NAME)?;
-        let file_name = file_path.as_path().to_str().unwrap();
-
-        if devices.is_empty() {
-            println!("No devices to dump");
-            return Ok(());
-        }
+        dump_filtered(state, "devices.json", is_of_interest).await
+    }
 
-        serde_json::to_writer_pretty(dump_file, &devices)
-            .into_report()
-            .attach_printable_lazy(|| format!("failed to dump devices into '{}'", file_name))
-            .into_module_report(DEVICE_MODULE_NAME)?;
+    async fn dumpall(&self, state: &State) -> Result<(), ModuleError> {
+        dump_filtered(state, "devices-all.json", |_| true).await
+    }
+}
 
-        match devices.len() {
-            1 => println!("Dumped 1 device to {}", file_name),
-            n => println!("Dumped {} devices to {}", n, file_name),
-        }
+async fn dump_filtered<F: Fn(&Device) -> bool>(
+    state: &State,
+    output_file: &str,
+    filter_fn: F,
+) -> Result<(), ModuleError> {
+    let inf_regex = Regex::new(r"^oem[0-9]+\.inf$").unwrap();
+    let devices: Vec<Device> = enumerate_devices()
+        .into_module_report(DEVICE_MODULE_NAME)?
+        .into_iter()
+        .filter(|d| inf_regex.is_match(d.inf_name().unwrap_or("")))
+        .filter(filter_fn)
+        .collect();
+
+    let file_path = get_path_to_dump(state, output_file).into_module_report(DEVICE_MODULE_NAME)?;
+    let dump_file = create_dump_file(&file_path).into_module_report(DEVICE_MODULE_NAME)?;
+    let file_name = file_path.as_path().to_str().unwrap();
+
+    if devices.is_empty() {
+        println!("No devices to dump");
+        return Ok(());
+    }
 
-        Ok(())
+    serde_json::to_writer_pretty(dump_file, &devices)
+        .into_report()
+        .attach_printable_lazy(|| format!("failed to dump devices into '{}'", file_name))
+        .into_module_report(DEVICE_MODULE_NAME)?;
+
+    match devices.len() {
+        1 => println!("Dumped 1 device to {}", file_name),
+        n => println!("Dumped {} devices to {}", n, file_name),
     }
+
+    Ok(())
 }
 
 #[derive(Deserialize, Debug)]

src/cleanup_modules/device_cleanup.rs

@@ -124,34 +124,45 @@ struct DriverDumper {}
 #[async_trait]
 impl Dumper for DriverDumper {
     async fn dump(&self, state: &State) -> Result<(), ModuleError> {
-        let drivers: Vec<Driver> = enumerate_drivers()
-            .into_module_report(DRIVER_MODULE_NAME)?
-            .into_iter()
-            .filter(is_of_interest)
-            .collect();
-
-        let file_path =
-            get_path_to_dump(state, "drivers.json").into_module_report(DRIVER_MODULE_NAME)?;
-        let dump_file = create_dump_file(&file_path).into_module_report(DRIVER_MODULE_NAME)?;
-        let file_name = file_path.as_path().to_str().unwrap();
-
-        if drivers.is_empty() {
-            println!("No drivers to dump");
-            return Ok(());
-        }
+        dump_filtered(state, "drivers.json", is_of_interest).await
+    }
 
-        serde_json::to_writer_pretty(dump_file, &drivers)
-            .into_report()
-            .attach_printable_lazy(|| format!("failed to dump drivers into '{}'", file_name))
-            .into_module_report(DRIVER_MODULE_NAME)?;
+    async fn dumpall(&self, state: &State) -> Result<(), ModuleError> {
+        dump_filtered(state, "drivers-all.json", |_| true).await
+    }
+}
 
-        match drivers.len() {
-            1 => println!("Dumped 1 driver into '{}'", file_name),
-            n => println!("Dumped {} drivers into '{}'", n, file_name),
-        }
+async fn dump_filtered<F: Fn(&Driver) -> bool>(
+    state: &State,
+    output_file: &str,
+    filter_fn: F,
+) -> Result<(), ModuleError> {
+    let drivers: Vec<Driver> = enumerate_drivers()
+        .into_module_report(DRIVER_MODULE_NAME)?
+        .into_iter()
+        .filter(filter_fn)
+        .collect();
+
+    let file_path = get_path_to_dump(state, output_file).into_module_report(DRIVER_MODULE_NAME)?;
+    let dump_file = create_dump_file(&file_path).into_module_report(DRIVER_MODULE_NAME)?;
+    let file_name = file_path.as_path().to_str().unwrap();
+
+    if drivers.is_empty() {
+        println!("No drivers to dump");
+        return Ok(());
+    }
 
-        Ok(())
+    serde_json::to_writer_pretty(dump_file, &drivers)
+        .into_report()
+        .attach_printable_lazy(|| format!("failed to dump drivers into '{}'", file_name))
+        .into_module_report(DRIVER_MODULE_NAME)?;
+
+    match drivers.len() {
+        1 => println!("Dumped 1 driver into '{}'", file_name),
+        n => println!("Dumped {} drivers into '{}'", n, file_name),
     }
+
+    Ok(())
 }
 
 #[derive(Deserialize, Debug)]

src/cleanup_modules/driver_cleanup.rs

@@ -150,36 +150,45 @@ struct DriverPackageDumper {}
 #[async_trait]
 impl Dumper for DriverPackageDumper {
     async fn dump(&self, state: &State) -> Result<(), ModuleError> {
-        let driver_packages: Vec<DriverPackage> = enumerate_driver_packages()
-            .into_module_report(MODULE_NAME)?
-            .into_iter()
-            .filter(is_of_interest)
-            .collect();
-
-        let file_path =
-            get_path_to_dump(state, "driver-packages.json").into_module_report(MODULE_NAME)?;
-        let dump_file = create_dump_file(&file_path).into_module_report(MODULE_NAME)?;
-        let file_name = file_path.as_path().to_str().unwrap();
+        dump_filtered(state, "driver-packages.json", is_of_interest).await
+    }
 
-        if driver_packages.is_empty() {
-            println!("No driver packages to dump");
-            return Ok(());
-        }
+    async fn dumpall(&self, state: &State) -> Result<(), ModuleError> {
+        dump_filtered(state, "driver-packages-all.json", |_| true).await
+    }
+}
 
-        serde_json::to_writer_pretty(dump_file, &driver_packages)
-            .into_report()
-            .attach_printable_lazy(|| {
-                format!("failed to dump driver packages into '{}'", file_name)
-            })
-            .into_module_report(MODULE_NAME)?;
+async fn dump_filtered<F: Fn(&DriverPackage) -> bool>(
+    state: &State,
+    output_file: &str,
+    filter_fn: F,
+) -> Result<(), ModuleError> {
+    let driver_packages: Vec<DriverPackage> = enumerate_driver_packages()
+        .into_module_report(MODULE_NAME)?
+        .into_iter()
+        .filter(filter_fn)
+        .collect();
+
+    let file_path = get_path_to_dump(state, output_file).into_module_report(MODULE_NAME)?;
+    let dump_file = create_dump_file(&file_path).into_module_report(MODULE_NAME)?;
+    let file_name = file_path.as_path().to_str().unwrap();
+
+    if driver_packages.is_empty() {
+        println!("No driver packages to dump");
+        return Ok(());
+    }
 
-        match driver_packages.len() {
-            1 => println!("Dumped 1 driver package into '{}'", file_name),
-            n => println!("Dumped {} driver packages into '{}'", n, file_name),
-        }
+    serde_json::to_writer_pretty(dump_file, &driver_packages)
+        .into_report()
+        .attach_printable_lazy(|| format!("failed to dump driver packages into '{}'", file_name))
+        .into_module_report(MODULE_NAME)?;
 
-        Ok(())
+    match driver_packages.len() {
+        1 => println!("Dumped 1 driver package into '{}'", file_name),
+        n => println!("Dumped {} driver packages into '{}'", n, file_name),
     }
+
+    Ok(())
 }
 
 #[derive(Deserialize, Debug)]

src/cleanup_modules/driver_package_cleanup.rs

@@ -178,6 +178,7 @@ pub struct ModuleRunInfo {
 #[async_trait]
 pub trait Dumper {
     async fn dump(&self, state: &State) -> Result<(), ModuleError>;
+    async fn dumpall(&self, state: &State) -> Result<(), ModuleError>;
 }
 
 fn get_path_to_dump(state: &State, filename: &str) -> Result<PathBuf, std::io::Error> {

src/cleanup_modules/mod.rs

@@ -181,11 +181,13 @@ pub async fn dump(config: Config) {
             None => continue,
         };
 
-        let result = dumper.dump(&state).await;
-        if let Err(err) = result {
-            eprintln!("{:?}", err);
-            eprintln!()
-        }
+        let results = [dumper.dump(&state).await, dumper.dumpall(&state).await];
+        results.iter().for_each(|result| {
+            if let Err(err) = result {
+                eprintln!("{:?}", err);
+                eprintln!()
+            }
+        });
     }
 }