70887b7 · helix · git.iko.soy

4 str,

5};

6

7−use anyhow::{anyhow, Context, Result};

7+use anyhow::{anyhow, Result};

8use helix_core::hashmap;

9use helix_loader::merge_toml_values;

10use log::warn;

209

210impl From<Value> for Theme {

211 fn from(value: Value) -> Self {

212− let values: Result<HashMap<String, Value>> =

212+ if let Value::Table(table) = value {

213− toml::from_str(&value.to_string()).context("Failed to load theme");

214−

215− let (styles, scopes, highlights) = build_theme_values(values);

213+ let (styles, scopes, highlights) = build_theme_values(table);

216−

214+

217− Self {

215+ Self {

218− styles,

216+ styles,

219− scopes,

217+ scopes,

220− highlights,

218+ highlights,

221− ..Default::default()

219+ ..Default::default()

220+ }

221+ } else {

222+ warn!("Expected theme TOML value to be a table, found {:?}", value);

223+ Default::default()

222 }

224 }

223 }

225 }

224}

226}

228 where

230 where

229 D: Deserializer<'de>,

231 D: Deserializer<'de>,

230 {

232 {

231− let values = HashMap::<String, Value>::deserialize(deserializer)?;

233+ let values = Map::<String, Value>::deserialize(deserializer)?;

232

234

233− let (styles, scopes, highlights) = build_theme_values(Ok(values));

235+ let (styles, scopes, highlights) = build_theme_values(values);

234

236

235 Ok(Self {

237 Ok(Self {

236 styles,

238 styles,

242}

244}

243

245

244fn build_theme_values(

246fn build_theme_values(

245− values: Result<HashMap<String, Value>>,

247+ mut values: Map<String, Value>,

246) -> (HashMap<String, Style>, Vec<String>, Vec<Style>) {

248) -> (HashMap<String, Style>, Vec<String>, Vec<Style>) {

247 let mut styles = HashMap::new();

249 let mut styles = HashMap::new();

248 let mut scopes = Vec::new();

250 let mut scopes = Vec::new();

249 let mut highlights = Vec::new();

251 let mut highlights = Vec::new();

250

252

251− if let Ok(mut colors) = values {

252− // TODO: alert user of parsing failures in editor

253+ // TODO: alert user of parsing failures in editor

253− let palette = colors

254+ let palette = values

254− .remove("palette")

255+ .remove("palette")

255− .map(|value| {

256+ .map(|value| {

256− ThemePalette::try_from(value).unwrap_or_else(|err| {

257+ ThemePalette::try_from(value).unwrap_or_else(|err| {

257− warn!("{}", err);

258− ThemePalette::default()

259− })

260− })

261− .unwrap_or_default();

262− // remove inherits from value to prevent errors

263− let _ = colors.remove("inherits");

264− styles.reserve(colors.len());

265− scopes.reserve(colors.len());

266− highlights.reserve(colors.len());

267− for (name, style_value) in colors {

268− let mut style = Style::default();

269− if let Err(err) = palette.parse_style(&mut style, style_value) {

270 warn!("{}", err);

258 warn!("{}", err);

259+ ThemePalette::default()

271− }

260+ })

272−

261+ })

273− // these are used both as UI and as highlights

262+ .unwrap_or_default();

274− styles.insert(name.clone(), style);

263+ // remove inherits from value to prevent errors

275− scopes.push(name);

264+ let _ = values.remove("inherits");

265+ styles.reserve(values.len());

266+ scopes.reserve(values.len());

276− highlights.push(style);

267+ highlights.reserve(values.len());

268+ for (name, style_value) in values {

269+ let mut style = Style::default();

270+ if let Err(err) = palette.parse_style(&mut style, style_value) {

271+ warn!("{}", err);

277 }

272 }

273+

274+ // these are used both as UI and as highlights

275+ styles.insert(name.clone(), style);

276+ scopes.push(name);

277+ highlights.push(style);

278 }

279

280 (styles, scopes, highlights)