1use std::borrow::Cow;
2use std::collections::HashMap;
3use std::fmt::{self, Debug};
4
5use anyhow::{anyhow, Context, Result};
6use clap::Parser;
7use gpui2::{hsla, rgb, serde_json, AssetSource, Hsla, Rgba, SharedString};
8use log::LevelFilter;
9use rust_embed::RustEmbed;
10use serde::de::Visitor;
11use serde::{Deserialize, Deserializer};
12use simplelog::SimpleLogger;
13use theme2::{PlayerTheme, SyntaxTheme, ThemeMetadata};
14
15#[derive(Parser)]
16#[command(author, version, about, long_about = None)]
17struct Args {
18 /// The name of the theme to convert.
19 theme: String,
20}
21
22fn main() -> Result<()> {
23 SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
24
25 let args = Args::parse();
26
27 let legacy_theme = load_theme(args.theme)?;
28
29 let theme = convert_theme(legacy_theme)?;
30
31 println!("{:#?}", ThemePrinter(theme));
32
33 Ok(())
34}
35
36#[derive(RustEmbed)]
37#[folder = "../../assets"]
38#[include = "fonts/**/*"]
39#[include = "icons/**/*"]
40#[include = "themes/**/*"]
41#[include = "sounds/**/*"]
42#[include = "*.md"]
43#[exclude = "*.DS_Store"]
44pub struct Assets;
45
46impl AssetSource for Assets {
47 fn load(&self, path: &str) -> Result<Cow<[u8]>> {
48 Self::get(path)
49 .map(|f| f.data)
50 .ok_or_else(|| anyhow!("could not find asset at path \"{}\"", path))
51 }
52
53 fn list(&self, path: &str) -> Result<Vec<SharedString>> {
54 Ok(Self::iter()
55 .filter(|p| p.starts_with(path))
56 .map(SharedString::from)
57 .collect())
58 }
59}
60
61#[derive(Clone, Copy)]
62pub struct PlayerThemeColors {
63 pub cursor: Hsla,
64 pub selection: Hsla,
65}
66
67impl PlayerThemeColors {
68 pub fn new(theme: &LegacyTheme, ix: usize) -> Self {
69 if ix < theme.players.len() {
70 Self {
71 cursor: theme.players[ix].cursor,
72 selection: theme.players[ix].selection,
73 }
74 } else {
75 Self {
76 cursor: rgb::<Hsla>(0xff00ff),
77 selection: rgb::<Hsla>(0xff00ff),
78 }
79 }
80 }
81}
82
83impl From<PlayerThemeColors> for PlayerTheme {
84 fn from(value: PlayerThemeColors) -> Self {
85 Self {
86 cursor: value.cursor,
87 selection: value.selection,
88 }
89 }
90}
91
92fn convert_theme(theme: LegacyTheme) -> Result<theme2::Theme> {
93 let transparent = hsla(0.0, 0.0, 0.0, 0.0);
94
95 let players: [PlayerTheme; 8] = [
96 PlayerThemeColors::new(&theme, 0).into(),
97 PlayerThemeColors::new(&theme, 1).into(),
98 PlayerThemeColors::new(&theme, 2).into(),
99 PlayerThemeColors::new(&theme, 3).into(),
100 PlayerThemeColors::new(&theme, 4).into(),
101 PlayerThemeColors::new(&theme, 5).into(),
102 PlayerThemeColors::new(&theme, 6).into(),
103 PlayerThemeColors::new(&theme, 7).into(),
104 ];
105
106 let theme = theme2::Theme {
107 metadata: theme2::ThemeMetadata {
108 name: theme.name.clone().into(),
109 is_light: theme.is_light,
110 },
111 transparent,
112 mac_os_traffic_light_red: rgb::<Hsla>(0xEC695E),
113 mac_os_traffic_light_yellow: rgb::<Hsla>(0xF4BF4F),
114 mac_os_traffic_light_green: rgb::<Hsla>(0x62C554),
115 border: theme.lowest.base.default.border,
116 border_variant: theme.lowest.variant.default.border,
117 border_focused: theme.lowest.accent.default.border,
118 border_transparent: transparent,
119 elevated_surface: theme.lowest.base.default.background,
120 surface: theme.middle.base.default.background,
121 background: theme.lowest.base.default.background,
122 filled_element: theme.lowest.base.default.background,
123 filled_element_hover: hsla(0.0, 0.0, 100.0, 0.12),
124 filled_element_active: hsla(0.0, 0.0, 100.0, 0.16),
125 filled_element_selected: theme.lowest.accent.default.background,
126 filled_element_disabled: transparent,
127 ghost_element: transparent,
128 ghost_element_hover: hsla(0.0, 0.0, 100.0, 0.08),
129 ghost_element_active: hsla(0.0, 0.0, 100.0, 0.12),
130 ghost_element_selected: theme.lowest.accent.default.background,
131 ghost_element_disabled: transparent,
132 text: theme.lowest.base.default.foreground,
133 text_muted: theme.lowest.variant.default.foreground,
134 /// TODO: map this to a real value
135 text_placeholder: theme.lowest.negative.default.foreground,
136 text_disabled: theme.lowest.base.disabled.foreground,
137 text_accent: theme.lowest.accent.default.foreground,
138 icon_muted: theme.lowest.variant.default.foreground,
139 syntax: SyntaxTheme {
140 highlights: theme
141 .syntax
142 .iter()
143 .map(|(token, color)| (token.clone(), color.clone().into()))
144 .collect(),
145 },
146 status_bar: theme.lowest.base.default.background,
147 title_bar: theme.lowest.base.default.background,
148 toolbar: theme.highest.base.default.background,
149 tab_bar: theme.middle.base.default.background,
150 editor: theme.highest.base.default.background,
151 editor_subheader: theme.middle.base.default.background,
152 terminal: theme.highest.base.default.background,
153 editor_active_line: theme.highest.on.default.background,
154 image_fallback_background: theme.lowest.base.default.background,
155
156 git_created: theme.lowest.positive.default.foreground,
157 git_modified: theme.lowest.accent.default.foreground,
158 git_deleted: theme.lowest.negative.default.foreground,
159 git_conflict: theme.lowest.warning.default.foreground,
160 git_ignored: theme.lowest.base.disabled.foreground,
161 git_renamed: theme.lowest.warning.default.foreground,
162
163 players,
164 };
165
166 Ok(theme)
167}
168
169#[derive(Deserialize)]
170struct JsonTheme {
171 pub base_theme: serde_json::Value,
172}
173
174/// Loads the [`Theme`] with the given name.
175pub fn load_theme(name: String) -> Result<LegacyTheme> {
176 let theme_contents = Assets::get(&format!("themes/{name}.json"))
177 .with_context(|| format!("theme file not found: '{name}'"))?;
178
179 let json_theme: JsonTheme = serde_json::from_str(std::str::from_utf8(&theme_contents.data)?)
180 .context("failed to parse legacy theme")?;
181
182 let legacy_theme: LegacyTheme = serde_json::from_value(json_theme.base_theme.clone())
183 .context("failed to parse `base_theme`")?;
184
185 Ok(legacy_theme)
186}
187
188#[derive(Deserialize, Clone, Default, Debug)]
189pub struct LegacyTheme {
190 pub name: String,
191 pub is_light: bool,
192 pub lowest: Layer,
193 pub middle: Layer,
194 pub highest: Layer,
195 pub popover_shadow: Shadow,
196 pub modal_shadow: Shadow,
197 #[serde(deserialize_with = "deserialize_player_colors")]
198 pub players: Vec<PlayerColors>,
199 #[serde(deserialize_with = "deserialize_syntax_colors")]
200 pub syntax: HashMap<String, Hsla>,
201}
202
203#[derive(Deserialize, Clone, Default, Debug)]
204pub struct Layer {
205 pub base: StyleSet,
206 pub variant: StyleSet,
207 pub on: StyleSet,
208 pub accent: StyleSet,
209 pub positive: StyleSet,
210 pub warning: StyleSet,
211 pub negative: StyleSet,
212}
213
214#[derive(Deserialize, Clone, Default, Debug)]
215pub struct StyleSet {
216 #[serde(rename = "default")]
217 pub default: ContainerColors,
218 pub hovered: ContainerColors,
219 pub pressed: ContainerColors,
220 pub active: ContainerColors,
221 pub disabled: ContainerColors,
222 pub inverted: ContainerColors,
223}
224
225#[derive(Deserialize, Clone, Default, Debug)]
226pub struct ContainerColors {
227 pub background: Hsla,
228 pub foreground: Hsla,
229 pub border: Hsla,
230}
231
232#[derive(Deserialize, Clone, Default, Debug)]
233pub struct PlayerColors {
234 pub selection: Hsla,
235 pub cursor: Hsla,
236}
237
238#[derive(Deserialize, Clone, Default, Debug)]
239pub struct Shadow {
240 pub blur: u8,
241 pub color: Hsla,
242 pub offset: Vec<u8>,
243}
244
245fn deserialize_player_colors<'de, D>(deserializer: D) -> Result<Vec<PlayerColors>, D::Error>
246where
247 D: Deserializer<'de>,
248{
249 struct PlayerArrayVisitor;
250
251 impl<'de> Visitor<'de> for PlayerArrayVisitor {
252 type Value = Vec<PlayerColors>;
253
254 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
255 formatter.write_str("an object with integer keys")
256 }
257
258 fn visit_map<A: serde::de::MapAccess<'de>>(
259 self,
260 mut map: A,
261 ) -> Result<Self::Value, A::Error> {
262 let mut players = Vec::with_capacity(8);
263 while let Some((key, value)) = map.next_entry::<usize, PlayerColors>()? {
264 if key < 8 {
265 players.push(value);
266 } else {
267 return Err(serde::de::Error::invalid_value(
268 serde::de::Unexpected::Unsigned(key as u64),
269 &"a key in range 0..7",
270 ));
271 }
272 }
273 Ok(players)
274 }
275 }
276
277 deserializer.deserialize_map(PlayerArrayVisitor)
278}
279
280fn deserialize_syntax_colors<'de, D>(deserializer: D) -> Result<HashMap<String, Hsla>, D::Error>
281where
282 D: serde::Deserializer<'de>,
283{
284 #[derive(Deserialize)]
285 struct ColorWrapper {
286 color: Hsla,
287 }
288
289 struct SyntaxVisitor;
290
291 impl<'de> Visitor<'de> for SyntaxVisitor {
292 type Value = HashMap<String, Hsla>;
293
294 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
295 formatter.write_str("a map with keys and objects with a single color field as values")
296 }
297
298 fn visit_map<M>(self, mut map: M) -> Result<HashMap<String, Hsla>, M::Error>
299 where
300 M: serde::de::MapAccess<'de>,
301 {
302 let mut result = HashMap::new();
303 while let Some(key) = map.next_key()? {
304 let wrapper: ColorWrapper = map.next_value()?; // Deserialize values as Hsla
305 result.insert(key, wrapper.color);
306 }
307 Ok(result)
308 }
309 }
310 deserializer.deserialize_map(SyntaxVisitor)
311}
312
313pub struct ThemePrinter(theme2::Theme);
314
315struct HslaPrinter(Hsla);
316
317impl Debug for HslaPrinter {
318 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
319 write!(f, "{:?}", IntoPrinter(&Rgba::from(self.0)))
320 }
321}
322
323struct IntoPrinter<'a, D: Debug>(&'a D);
324
325impl<'a, D: Debug> Debug for IntoPrinter<'a, D> {
326 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
327 write!(f, "{:?}.into()", self.0)
328 }
329}
330
331impl Debug for ThemePrinter {
332 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
333 f.debug_struct("Theme")
334 .field("metadata", &ThemeMetadataPrinter(self.0.metadata.clone()))
335 .field("transparent", &HslaPrinter(self.0.transparent))
336 .field(
337 "mac_os_traffic_light_red",
338 &HslaPrinter(self.0.mac_os_traffic_light_red),
339 )
340 .field(
341 "mac_os_traffic_light_yellow",
342 &HslaPrinter(self.0.mac_os_traffic_light_yellow),
343 )
344 .field(
345 "mac_os_traffic_light_green",
346 &HslaPrinter(self.0.mac_os_traffic_light_green),
347 )
348 .field("border", &HslaPrinter(self.0.border))
349 .field("border_variant", &HslaPrinter(self.0.border_variant))
350 .field("border_focused", &HslaPrinter(self.0.border_focused))
351 .field(
352 "border_transparent",
353 &HslaPrinter(self.0.border_transparent),
354 )
355 .field("elevated_surface", &HslaPrinter(self.0.elevated_surface))
356 .field("surface", &HslaPrinter(self.0.surface))
357 .field("background", &HslaPrinter(self.0.background))
358 .field("filled_element", &HslaPrinter(self.0.filled_element))
359 .field(
360 "filled_element_hover",
361 &HslaPrinter(self.0.filled_element_hover),
362 )
363 .field(
364 "filled_element_active",
365 &HslaPrinter(self.0.filled_element_active),
366 )
367 .field(
368 "filled_element_selected",
369 &HslaPrinter(self.0.filled_element_selected),
370 )
371 .field(
372 "filled_element_disabled",
373 &HslaPrinter(self.0.filled_element_disabled),
374 )
375 .field("ghost_element", &HslaPrinter(self.0.ghost_element))
376 .field(
377 "ghost_element_hover",
378 &HslaPrinter(self.0.ghost_element_hover),
379 )
380 .field(
381 "ghost_element_active",
382 &HslaPrinter(self.0.ghost_element_active),
383 )
384 .field(
385 "ghost_element_selected",
386 &HslaPrinter(self.0.ghost_element_selected),
387 )
388 .field(
389 "ghost_element_disabled",
390 &HslaPrinter(self.0.ghost_element_disabled),
391 )
392 .field("text", &HslaPrinter(self.0.text))
393 .field("text_muted", &HslaPrinter(self.0.text_muted))
394 .field("text_placeholder", &HslaPrinter(self.0.text_placeholder))
395 .field("text_disabled", &HslaPrinter(self.0.text_disabled))
396 .field("text_accent", &HslaPrinter(self.0.text_accent))
397 .field("icon_muted", &HslaPrinter(self.0.icon_muted))
398 .field("syntax", &SyntaxThemePrinter(self.0.syntax.clone()))
399 .field("status_bar", &HslaPrinter(self.0.status_bar))
400 .field("title_bar", &HslaPrinter(self.0.title_bar))
401 .field("toolbar", &HslaPrinter(self.0.toolbar))
402 .field("tab_bar", &HslaPrinter(self.0.tab_bar))
403 .field("editor", &HslaPrinter(self.0.editor))
404 .field("editor_subheader", &HslaPrinter(self.0.editor_subheader))
405 .field(
406 "editor_active_line",
407 &HslaPrinter(self.0.editor_active_line),
408 )
409 .field("terminal", &HslaPrinter(self.0.terminal))
410 .field(
411 "image_fallback_background",
412 &HslaPrinter(self.0.image_fallback_background),
413 )
414 .field("git_created", &HslaPrinter(self.0.git_created))
415 .field("git_modified", &HslaPrinter(self.0.git_modified))
416 .field("git_deleted", &HslaPrinter(self.0.git_deleted))
417 .field("git_conflict", &HslaPrinter(self.0.git_conflict))
418 .field("git_ignored", &HslaPrinter(self.0.git_ignored))
419 .field("git_renamed", &HslaPrinter(self.0.git_renamed))
420 .field("players", &self.0.players.map(PlayerThemePrinter))
421 .finish()
422 }
423}
424
425pub struct ThemeMetadataPrinter(ThemeMetadata);
426
427impl Debug for ThemeMetadataPrinter {
428 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
429 f.debug_struct("ThemeMetadata")
430 .field("name", &IntoPrinter(&self.0.name))
431 .field("is_light", &self.0.is_light)
432 .finish()
433 }
434}
435
436pub struct SyntaxThemePrinter(SyntaxTheme);
437
438impl Debug for SyntaxThemePrinter {
439 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
440 f.debug_struct("SyntaxTheme")
441 .field(
442 "highlights",
443 &VecPrinter(
444 &self
445 .0
446 .highlights
447 .iter()
448 .map(|(token, highlight)| {
449 (IntoPrinter(token), HslaPrinter(highlight.color.unwrap()))
450 })
451 .collect(),
452 ),
453 )
454 .finish()
455 }
456}
457
458pub struct VecPrinter<'a, T>(&'a Vec<T>);
459
460impl<'a, T: Debug> Debug for VecPrinter<'a, T> {
461 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
462 write!(f, "vec!{:?}", &self.0)
463 }
464}
465
466pub struct PlayerThemePrinter(PlayerTheme);
467
468impl Debug for PlayerThemePrinter {
469 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
470 f.debug_struct("PlayerTheme")
471 .field("cursor", &HslaPrinter(self.0.cursor))
472 .field("selection", &HslaPrinter(self.0.selection))
473 .finish()
474 }
475}