ajour · casperstorm · Feb 14, 2021 · Jan 27, 2021 · Jan 28, 2021 · Jan 29, 2021
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,28 @@ and `Removed`.
 
 ## [Unreleased]
 
+## [0.7.1] - 2021-02-14
+
+### Added
+
+- Townlong Yak addons has been added to the Catalog.
+- Optional 'Categories' column for Catalog.
+- Optional 'Summary' column for My Addons.
+- New languages added to Ajour:
+  - 🇺🇦 Ukrainian (thanks Krapka and Orney)
+
+### Changed
+
+- Sorted language picker in Settings.
+- Tweaked catalog fuzzy search to weight title matches higher than description
+  matches.
+
+### Fixed
+
+- Multiple error messages are now correctly localized.
+- Corrected error in flavor detection if Ajour was launched before WoW had ever
+  been launched.
+
 ## [0.7.0] - 2021-01-26
 
 ### Added

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "ajour"
 description = "A World of Warcraft addon manager"
-version = "0.7.0"
+version = "0.7.1"
 authors = ["Casper Rogild Storm"]
 license = "MIT"
 homepage = "https://github.com/ajour/ajour"
@@ -17,9 +17,9 @@ wgpu = ["ajour-widgets/wgpu", "iced/wgpu", "iced/default_system_font"]
 opengl = ["ajour-widgets/opengl", "iced/glow", "iced/glow_default_system_font"]
 
 [dependencies]
-ajour-core = { version = "0.7.0", path = "crates/core", features=['gui'] }
-ajour-weak-auras = { version = "0.7.0", path = "crates/weak_auras" }
-ajour-widgets = { version = "0.7.0", path = "crates/widgets" }
+ajour-core = { version = "0.7.1", path = "crates/core", features=['gui'] }
+ajour-weak-auras = { version = "0.7.1", path = "crates/weak_auras" }
+ajour-widgets = { version = "0.7.1", path = "crates/widgets" }
 
 iced = { version = "0.2.0", default-features = false, features = ["debug"] }
 iced_futures = { version = "0.2", features = ["async-std"] }

diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "ajour-core"
 description = "Core library for Ajour"
-version = "0.7.0"
+version = "0.7.1"
 authors = ["Casper Rogild Storm"]
 license = "MIT"
 homepage = "https://github.com/ajour/ajour"

diff --git a/crates/core/src/addon.rs b/crates/core/src/addon.rs
@@ -219,7 +219,8 @@ impl Addon {
                         RepositoryKind::WowI => {
                             self.repository_id() == f.repository_identifiers.wowi.as_deref()
                         }
-                        // For git sources, prioritize the folder that has a version in it
+                        // For git & townlong sources, prioritize the folder that has a version in it
+                        RepositoryKind::TownlongYak => f.version.is_some(),
                         RepositoryKind::Git(_) => f.version.is_some(),
                     }
                 } else {
@@ -274,6 +275,13 @@ impl Addon {
         }
     }
 
+    /// Sets the file id of the addon
+    pub fn set_file_id(&mut self, file_id: i64) {
+        if let Some(metadata) = self.repository.as_mut().map(|r| &mut r.metadata) {
+            metadata.file_id = Some(file_id);
+        }
+    }
+
     /// Returns the title of the addon.
     pub fn title(&self) -> &str {
         let meta_title = self.metadata().map(|m| m.title.as_deref()).flatten();
@@ -413,6 +421,17 @@ impl Addon {
         }
     }
 
+    /// Returns the hub id of the addon, if applicable.
+    pub fn hub_id(&self) -> Option<i32> {
+        if self.repository_kind() == Some(RepositoryKind::TownlongYak) {
+            self.repository()
+                .map(|r| r.id.parse::<i32>().ok())
+                .flatten()
+        } else {
+            None
+        }
+    }
+
     pub fn remote_packages(&self) -> HashMap<ReleaseChannel, RemotePackage> {
         self.metadata()
             .map(|m| &m.remote_packages)

diff --git a/crates/core/src/cache.rs b/crates/core/src/cache.rs
@@ -195,6 +195,7 @@ pub struct AddonCacheEntry {
     pub primary_folder_id: String,
     pub folder_names: Vec<String>,
     pub modified: DateTime<Utc>,
+    pub external_release_id: Option<ExternalReleaseId>,
 }
 
 impl TryFrom<&Addon> for AddonCacheEntry {
@@ -207,13 +208,23 @@ impl TryFrom<&Addon> for AddonCacheEntry {
             let mut folder_names: Vec<_> = addon.folders.iter().map(|a| a.id.clone()).collect();
             folder_names.sort();
 
+            let external_release_id = if repository == RepositoryKind::TownlongYak {
+                addon.file_id().map(ExternalReleaseId::FileId)
+            } else {
+                addon
+                    .version()
+                    .map(str::to_string)
+                    .map(ExternalReleaseId::Version)
+            };
+
             Ok(AddonCacheEntry {
                 title: addon.title().to_owned(),
                 repository,
                 repository_id: repository_id.to_owned(),
                 primary_folder_id: addon.primary_folder_id.clone(),
                 folder_names,
                 modified: Utc::now(),
+                external_release_id,
             })
         } else {
             Err(CacheError::AddonMissingRepo {
@@ -223,6 +234,12 @@ impl TryFrom<&Addon> for AddonCacheEntry {
     }
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub enum ExternalReleaseId {
+    FileId(i64),
+    Version(String),
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct CatalogCache {
     etag: String,
@@ -307,6 +324,7 @@ mod test {
                         primary_folder_id: folders.first().map(|f| f.id.clone()).unwrap(),
                         folder_names: folders.iter().map(|f| f.id.clone()).collect(),
                         modified: Utc::now(),
+                        external_release_id: None,
                     }
                 }));
 

diff --git a/crates/core/src/catalog.rs b/crates/core/src/catalog.rs
@@ -7,7 +7,7 @@ use chrono::prelude::*;
 use isahc::ResponseExt;
 use serde::{Deserialize, Serialize};
 
-const CATALOG_URL: &str = "https://github.com/ajour/ajour-catalog/raw/master/catalog.json";
+const CATALOG_URL: &str = "https://github.com/ajour/ajour-catalog/raw/master/catalog-2.0.json";
 
 type Etag = Option<String>;
 
@@ -65,6 +65,10 @@ pub enum Source {
     Tukui,
     #[serde(alias = "wowi")]
     WowI,
+    #[serde(alias = "townlong-yak")]
+    TownlongYak,
+    #[serde(other)]
+    Other,
 }
 
 impl std::fmt::Display for Source {
@@ -73,6 +77,10 @@ impl std::fmt::Display for Source {
             Source::Curse => "Curse",
             Source::Tukui => "Tukui",
             Source::WowI => "WowInterface",
+            Source::TownlongYak => "TownlongYak",
+
+            // This is a fallback option.
+            Source::Other => "Unknown",
         };
         write!(f, "{}", s)
     }

diff --git a/crates/core/src/config/mod.rs b/crates/core/src/config/mod.rs
@@ -3,6 +3,7 @@ use glob::MatchOptions;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fmt::{self, Display, Formatter};
+use std::fs::create_dir_all;
 use std::path::PathBuf;
 
 mod addons;
@@ -60,9 +61,11 @@ impl Config {
     /// This will return `None` if no `wow_directory` is set in the config.
     pub fn get_addon_directory_for_flavor(&self, flavor: &Flavor) -> Option<PathBuf> {
         match &self.wow.directory {
-            Some(dir) => {
-                // The path to the directory containing the addons
-                let mut addon_dir = dir.join(&flavor.folder_name()).join("Interface/AddOns");
+            Some(wow_dir) => {
+                // The path to the flavor directory
+                let flavor_dir = wow_dir.join(&flavor.folder_name());
+                // The path to the addons directory
+                let mut addon_dir = flavor_dir.join("Interface/AddOns");
 
                 // If path doesn't exist, it could have been modified by the user.
                 // Check for a case-insensitive version and use that instead.
@@ -74,10 +77,7 @@ impl Config {
 
                     // For some reason the case insensitive pattern doesn't work
                     // unless we add an actual pattern symbol, hence the `?`.
-                    let pattern = format!(
-                        "{}/?nterface/?ddons",
-                        dir.join(&flavor.folder_name()).display()
-                    );
+                    let pattern = format!("{}/?nterface/?ddons", flavor_dir.display());
 
                     for entry in glob::glob_with(&pattern, options).unwrap() {
                         if let Ok(path) = entry {
@@ -86,6 +86,13 @@ impl Config {
                     }
                 }
 
+                // If flavor dir exists but not addon dir we try to create it.
+                // This state can happen if you do a fresh install of WoW and
+                // launch Ajour before you launch WoW.
+                if flavor_dir.exists() && !addon_dir.exists() {
+                    let _ = create_dir_all(&addon_dir);
+                }
+
                 Some(addon_dir)
             }
             None => None,
@@ -225,6 +232,7 @@ pub enum Language {
     Swedish,
     Spanish,
     Turkish,
+    Ukrainian,
 }
 
 impl std::fmt::Display for Language {
@@ -234,38 +242,41 @@ impl std::fmt::Display for Language {
             "{}",
             match self {
                 Language::Czech => "Čeština",
-                Language::English => "English",
                 Language::Danish => "Dansk",
-                Language::German => "Deutsch",
-                Language::Swedish => "Svenska",
+                Language::English => "English",
                 Language::French => "Français",
-                Language::Russian => "Pусский",
-                Language::Spanish => "Español",
+                Language::German => "Deutsch",
                 Language::Hungarian => "Magyar",
-                Language::Norwegian => "Bokmål",
+                Language::Norwegian => "Norsk Bokmål",
+                Language::Portuguese => "Português",
+                Language::Russian => "Pусский",
                 Language::Slovak => "Slovenčina",
+                Language::Spanish => "Español",
+                Language::Swedish => "Svenska",
                 Language::Turkish => "Türkçe",
-                Language::Portuguese => "Português",
+                Language::Ukrainian => "Yкраїнська",
             }
         )
     }
 }
 
 impl Language {
-    pub const ALL: [Language; 13] = [
+    // Alphabetically sorted based on their local name (@see `impl Display`).
+    pub const ALL: [Language; 14] = [
         Language::Czech,
         Language::Danish,
-        Language::English,
-        Language::French,
         Language::German,
-        Language::Russian,
+        Language::English,
         Language::Spanish,
-        Language::Swedish,
+        Language::French,
         Language::Hungarian,
         Language::Norwegian,
+        Language::Portuguese,
+        Language::Russian,
         Language::Slovak,
+        Language::Swedish,
         Language::Turkish,
-        Language::Portuguese,
+        Language::Ukrainian,
     ];
 
     pub const fn language_code(self) -> &'static str {
@@ -283,6 +294,7 @@ impl Language {
             Language::Slovak => "sk_SK",
             Language::Turkish => "tr_TR",
             Language::Portuguese => "pt_PT",
+            Language::Ukrainian => "uk_UA",
         }
     }
 }

diff --git a/crates/core/src/config/wow.rs b/crates/core/src/config/wow.rs
@@ -49,6 +49,14 @@ impl Flavor {
         }
     }
 
+    /// Returns flavor `String` in WowUp.Hub format
+    pub(crate) fn hub_format(self) -> String {
+        match self {
+            Flavor::Retail | Flavor::RetailPTR | Flavor::RetailBeta => "retail".to_owned(),
+            Flavor::Classic | Flavor::ClassicPTR => "classic".to_owned(),
+        }
+    }
+
     /// Returns `Flavor` which self relates to.
     pub fn base_flavor(self) -> Flavor {
         match self {

diff --git a/crates/core/src/error.rs b/crates/core/src/error.rs
@@ -79,6 +79,8 @@ pub enum RepositoryError {
     CurseMissingPackage { id: String },
     #[error("No package found for WowI id {id}")]
     WowIMissingPackage { id: String },
+    #[error("No package found for Hub id {id}")]
+    HubMissingPackage { id: String },
     #[error("No remote package found for channel {channel}")]
     MissingPackageChannel { channel: ReleaseChannel },
     #[error("Git repo must be created with `from_source_url`")]