Skip to main content

scrobble_scrubber/
default_rules.rs

1use crate::rewrite::{RewriteRule, SdRule};
2use serde::{Deserialize, Serialize};
3
4/// Structures for default rule import
5#[derive(Serialize, Deserialize, Clone, Debug)]
6pub struct DefaultRulePattern {
7    pub find: String,
8    pub replace: String,
9}
10
11#[derive(Serialize, Deserialize, Clone, Debug)]
12pub struct DefaultRule {
13    pub name: String,
14    pub description: String,
15    pub examples: Vec<String>,
16    pub track_name: Option<DefaultRulePattern>,
17    pub artist_name: Option<DefaultRulePattern>,
18    pub album_name: Option<DefaultRulePattern>,
19    pub album_artist_name: Option<DefaultRulePattern>,
20    pub requires_confirmation: bool,
21    /// Optional flag: require MusicBrainz confirmation of the rewritten metadata
22    #[serde(default)]
23    pub requires_musicbrainz_confirmation: bool,
24}
25
26#[derive(Serialize, Deserialize, Clone, Debug)]
27pub struct DefaultRuleSet {
28    pub title: String,
29    pub description: String,
30    pub version: String,
31    pub rules: Vec<DefaultRule>,
32}
33
34/// Convert default rule to RewriteRule
35impl From<DefaultRule> for RewriteRule {
36    fn from(default_rule: DefaultRule) -> Self {
37        RewriteRule {
38            name: Some(default_rule.name),
39            track_name: default_rule.track_name.map(|p| SdRule {
40                find: p.find,
41                replace: p.replace,
42                flags: Some("i".to_string()), // Default to case-insensitive
43            }),
44            artist_name: default_rule.artist_name.map(|p| SdRule {
45                find: p.find,
46                replace: p.replace,
47                flags: Some("i".to_string()),
48            }),
49            album_name: default_rule.album_name.map(|p| SdRule {
50                find: p.find,
51                replace: p.replace,
52                flags: Some("i".to_string()),
53            }),
54            album_artist_name: default_rule.album_artist_name.map(|p| SdRule {
55                find: p.find,
56                replace: p.replace,
57                flags: Some("i".to_string()),
58            }),
59            requires_confirmation: default_rule.requires_confirmation,
60            requires_musicbrainz_confirmation: default_rule.requires_musicbrainz_confirmation,
61            musicbrainz_release_filters: None, // Default rules use default MusicBrainz filters
62        }
63    }
64}
65
66/// Load default rewrite rules from embedded JSON
67pub fn load_default_rewrite_rules() -> Result<DefaultRuleSet, Box<dyn std::error::Error>> {
68    let json_content = include_str!("../assets/default_rewrite_rules.json");
69    let rule_set: DefaultRuleSet = serde_json::from_str(json_content)?;
70    Ok(rule_set)
71}
72
73/// Backwards compatibility - redirect to load_default_rewrite_rules
74pub fn load_default_remaster_rules() -> Result<DefaultRuleSet, Box<dyn std::error::Error>> {
75    load_default_rewrite_rules()
76}
77
78/// Load all default rules - now just loads from the single consolidated file
79pub fn load_all_default_rules() -> Result<Vec<DefaultRule>, Box<dyn std::error::Error>> {
80    let rule_set = load_default_rewrite_rules()?;
81    Ok(rule_set.rules)
82}