From f5c9a102d575f9f61f30b926ac258393203fed64 Mon Sep 17 00:00:00 2001
From: Christopher Serr <christopher.serr@gmail.com>
Date: Thu, 16 May 2019 01:05:07 +0200
Subject: [PATCH 1/3] Implement Custom Variables

This Pull Request adds custom key value pairs to Runs. They can be
created by the runner in the Run Editor and can store arbitrary string
based values that the runner wishes to store with the splits. Components
can then use these variables to visualize them. In particular, the text
component can visualize these variables as key value pairs. Variables
can also be provided by auto splitters, components or through other
means. There is a distinction between permanent and temporary variables.
Most automatically provided variables are temporary by default, but they
can be turned into permanent ones. The permanent ones can be created by
the runner in the run editor and will be stored in the splits files
unlike the temporary ones.
---
 capi/bind_gen/src/typescript.ts               |  19 ++-
 capi/src/lib.rs                               |   8 +-
 capi/src/run_editor.rs                        |  33 +++-
 capi/src/run_metadata.rs                      |   8 +-
 .../src/run_metadata_speedrun_com_variable.rs |  35 +++++
 ...un_metadata_speedrun_com_variables_iter.rs |  38 +++++
 capi/src/run_metadata_variable.rs             |  31 ----
 capi/src/run_metadata_variables_iter.rs       |  34 ----
 capi/src/text_component.rs                    |  13 +-
 capi/src/text_component_state.rs              |  11 +-
 src/component/{text.rs => text/mod.rs}        | 146 ++++++++++++++----
 src/component/text/tests.rs                   |  75 +++++++++
 src/layout/component.rs                       |   2 +-
 src/platform/no_std/indexmap.rs               |  46 ++++++
 src/rendering/component/text.rs               |   6 +-
 src/run/editor/mod.rs                         |  51 +++++-
 src/run/editor/tests/custom_variables.rs      |  45 ++++++
 src/run/editor/tests/dissociate_run.rs        |  33 +++-
 src/run/editor/tests/mark_as_modified.rs      |  35 ++++-
 src/run/editor/tests/mod.rs                   |   1 +
 src/run/mod.rs                                |   2 +-
 src/run/parser/face_split.rs                  |  17 +-
 src/run/parser/livesplit.rs                   |  18 ++-
 src/run/parser/splits_io.rs                   |  36 +++++
 src/run/parser/splitterz.rs                   |  24 ++-
 src/run/parser/worstrun.rs                    |   2 +-
 src/run/parser/wsplit.rs                      |   9 +-
 src/run/run_metadata.rs                       |  82 ++++++++--
 src/run/saver/livesplit.rs                    |  20 ++-
 src/timing/timer/mod.rs                       |  12 ++
 src/timing/timer/tests/mark_as_modified.rs    |  24 ++-
 src/timing/timer/tests/mod.rs                 |   1 +
 src/timing/timer/tests/variables.rs           | 115 ++++++++++++++
 33 files changed, 869 insertions(+), 163 deletions(-)
 create mode 100644 capi/src/run_metadata_speedrun_com_variable.rs
 create mode 100644 capi/src/run_metadata_speedrun_com_variables_iter.rs
 delete mode 100644 capi/src/run_metadata_variable.rs
 delete mode 100644 capi/src/run_metadata_variables_iter.rs
 rename src/component/{text.rs => text/mod.rs} (63%)
 create mode 100644 src/component/text/tests.rs
 create mode 100644 src/run/editor/tests/custom_variables.rs
 create mode 100644 src/timing/timer/tests/variables.rs

diff --git a/capi/bind_gen/src/typescript.ts b/capi/bind_gen/src/typescript.ts
index d2c9f77a..9f774f88 100644
--- a/capi/bind_gen/src/typescript.ts
+++ b/capi/bind_gen/src/typescript.ts
@@ -658,11 +658,22 @@ export interface RunMetadataJson {
      */
     region_name: string,
     /**
-     * Stores all the variables. A variable is an arbitrary key value pair
-     * storing additional information about the category. An example of this
-     * may be whether Amiibos are used in this category.
+     * Stores all the speedrun.com variables. A variable is an arbitrary key
+     * value pair storing additional information about the category. An example
+     * of this may be whether Amiibos are used in this category.
      */
-    variables: { [key: string]: string },
+    speedrun_com_variables: { [key: string]: string | undefined },
+    custom_variables: { [key: string]: CustomVariableJson | undefined },
+}
+
+export interface CustomVariableJson {
+    // TODO:
+    value: string,
+    /**
+     * States whether the variable is permanent. Temporary variables don't get
+     * stored in splits files. They also don't get shown in the run editor.
+     */
+    is_permanent: boolean,
 }
 
 /**
diff --git a/capi/src/lib.rs b/capi/src/lib.rs
index 8d0e4d1d..879949e1 100644
--- a/capi/src/lib.rs
+++ b/capi/src/lib.rs
@@ -37,8 +37,8 @@ pub mod previous_segment_component;
 pub mod run;
 pub mod run_editor;
 pub mod run_metadata;
-pub mod run_metadata_variable;
-pub mod run_metadata_variables_iter;
+pub mod run_metadata_speedrun_com_variable;
+pub mod run_metadata_speedrun_com_variables_iter;
 pub mod segment;
 pub mod segment_history;
 pub mod segment_history_element;
@@ -64,7 +64,7 @@ pub mod title_component;
 pub mod title_component_state;
 pub mod total_playtime_component;
 
-use crate::run_metadata_variable::RunMetadataVariable;
+use crate::run_metadata_speedrun_com_variable::RunMetadataSpeedrunComVariable;
 use crate::segment_history_element::SegmentHistoryElement;
 use livesplit_core::{Time, TimeSpan};
 
@@ -78,7 +78,7 @@ thread_local! {
     static TIME_SPAN: Cell<TimeSpan> = Cell::default();
     static TIME: Cell<Time> = Cell::default();
     static SEGMENT_HISTORY_ELEMENT: Cell<SegmentHistoryElement> = Cell::default();
-    static RUN_METADATA_VARIABLE: Cell<RunMetadataVariable> = Cell::new((ptr::null(), ptr::null()));
+    static RUN_METADATA_SPEEDRUN_COM_VARIABLE: Cell<RunMetadataSpeedrunComVariable> = Cell::new((ptr::null(), ptr::null()));
 }
 
 fn output_time_span(time_span: TimeSpan) -> *const TimeSpan {
diff --git a/capi/src/run_editor.rs b/capi/src/run_editor.rs
index e70bb893..e2a5e592 100644
--- a/capi/src/run_editor.rs
+++ b/capi/src/run_editor.rs
@@ -164,18 +164,43 @@ pub extern "C" fn RunEditor_set_emulator_usage(this: &mut RunEditor, uses_emulat
 /// in this category. If the variable doesn't exist yet, it is being
 /// inserted.
 #[no_mangle]
-pub unsafe extern "C" fn RunEditor_set_variable(
+pub unsafe extern "C" fn RunEditor_set_speedrun_com_variable(
     this: &mut RunEditor,
     name: *const c_char,
     value: *const c_char,
 ) {
-    this.set_variable(str(name), str(value));
+    this.set_speedrun_com_variable(str(name), str(value));
 }
 
 /// Removes the variable with the name specified.
 #[no_mangle]
-pub unsafe extern "C" fn RunEditor_remove_variable(this: &mut RunEditor, name: *const c_char) {
-    this.remove_variable(str(name));
+pub unsafe extern "C" fn RunEditor_remove_speedrun_com_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+) {
+    this.remove_speedrun_com_variable(str(name));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_add_custom_variable(this: &mut RunEditor, name: *const c_char) {
+    this.add_custom_variable(str(name));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_set_custom_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+    value: *const c_char,
+) {
+    this.set_custom_variable(str(name), str(value));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_remove_custom_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+) {
+    this.remove_custom_variable(str(name));
 }
 
 /// Resets all the Metadata Information.
diff --git a/capi/src/run_metadata.rs b/capi/src/run_metadata.rs
index aae87b43..b1e39550 100644
--- a/capi/src/run_metadata.rs
+++ b/capi/src/run_metadata.rs
@@ -2,7 +2,7 @@
 //! platform and region of the game. All of this information is optional.
 
 use super::output_str;
-use crate::run_metadata_variables_iter::OwnedRunMetadataVariablesIter;
+use crate::run_metadata_speedrun_com_variables_iter::OwnedRunMetadataSpeedrunComVariablesIter;
 use livesplit_core::RunMetadata;
 use std::os::raw::c_char;
 
@@ -42,8 +42,8 @@ pub extern "C" fn RunMetadata_region_name(this: &RunMetadata) -> *const c_char {
 /// Returns an iterator iterating over all the variables and their values
 /// that have been specified.
 #[no_mangle]
-pub extern "C" fn RunMetadata_variables(
+pub extern "C" fn RunMetadata_speedrun_com_variables(
     this: &'static RunMetadata,
-) -> OwnedRunMetadataVariablesIter {
-    Box::new(this.variables())
+) -> OwnedRunMetadataSpeedrunComVariablesIter {
+    Box::new(this.speedrun_com_variables())
 }
diff --git a/capi/src/run_metadata_speedrun_com_variable.rs b/capi/src/run_metadata_speedrun_com_variable.rs
new file mode 100644
index 00000000..8d0d5540
--- /dev/null
+++ b/capi/src/run_metadata_speedrun_com_variable.rs
@@ -0,0 +1,35 @@
+//! A Run Metadata variable is an arbitrary key value pair storing additional
+//! information about the category. An example of this may be whether Amiibos
+//! are used in the category.
+
+use super::output_str;
+use std::os::raw::c_char;
+
+/// type
+pub type RunMetadataSpeedrunComVariable = (*const String, *const String);
+/// type
+pub type NullableRunMetadataSpeedrunComVariable = RunMetadataSpeedrunComVariable;
+/// type
+pub type OwnedRunMetadataSpeedrunComVariable = Box<RunMetadataSpeedrunComVariable>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariable_drop(this: OwnedRunMetadataSpeedrunComVariable) {
+    drop(this);
+}
+
+/// Accesses the name of this Run Metadata variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_name(
+    this: &RunMetadataSpeedrunComVariable,
+) -> *const c_char {
+    output_str(&*this.0)
+}
+
+/// Accesses the value of this Run Metadata variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_value(
+    this: &RunMetadataSpeedrunComVariable,
+) -> *const c_char {
+    output_str(&*this.1)
+}
diff --git a/capi/src/run_metadata_speedrun_com_variables_iter.rs b/capi/src/run_metadata_speedrun_com_variables_iter.rs
new file mode 100644
index 00000000..e8a5dbee
--- /dev/null
+++ b/capi/src/run_metadata_speedrun_com_variables_iter.rs
@@ -0,0 +1,38 @@
+//! An iterator iterating over all the Run Metadata variables and their values
+//! that have been specified.
+
+use super::RUN_METADATA_SPEEDRUN_COM_VARIABLE;
+use crate::run_metadata_speedrun_com_variable::{
+    NullableRunMetadataSpeedrunComVariable, RunMetadataSpeedrunComVariable,
+};
+use livesplit_core::indexmap;
+use std::ptr;
+
+/// type
+pub type RunMetadataSpeedrunComVariablesIter = indexmap::map::Iter<'static, String, String>;
+/// type
+pub type OwnedRunMetadataSpeedrunComVariablesIter = Box<RunMetadataSpeedrunComVariablesIter>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariablesIter_drop(
+    this: OwnedRunMetadataSpeedrunComVariablesIter,
+) {
+    drop(this);
+}
+
+/// Accesses the next Run Metadata variable. Returns <NULL> if there are no more
+/// variables.
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariablesIter_next(
+    this: &mut RunMetadataSpeedrunComVariablesIter,
+) -> *const NullableRunMetadataSpeedrunComVariable {
+    if let Some((name, value)) = this.next() {
+        RUN_METADATA_SPEEDRUN_COM_VARIABLE.with(|output| {
+            output.set((name, value));
+            output.as_ptr() as *const RunMetadataSpeedrunComVariable
+        })
+    } else {
+        ptr::null()
+    }
+}
diff --git a/capi/src/run_metadata_variable.rs b/capi/src/run_metadata_variable.rs
deleted file mode 100644
index 81dd7a9e..00000000
--- a/capi/src/run_metadata_variable.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! A Run Metadata variable is an arbitrary key value pair storing additional
-//! information about the category. An example of this may be whether Amiibos
-//! are used in the category.
-
-use super::output_str;
-use std::os::raw::c_char;
-
-/// type
-pub type RunMetadataVariable = (*const String, *const String);
-/// type
-pub type NullableRunMetadataVariable = RunMetadataVariable;
-/// type
-pub type OwnedRunMetadataVariable = Box<RunMetadataVariable>;
-
-/// drop
-#[no_mangle]
-pub extern "C" fn RunMetadataVariable_drop(this: OwnedRunMetadataVariable) {
-    drop(this);
-}
-
-/// Accesses the name of this Run Metadata variable.
-#[no_mangle]
-pub unsafe extern "C" fn RunMetadataVariable_name(this: &RunMetadataVariable) -> *const c_char {
-    output_str(&*this.0)
-}
-
-/// Accesses the value of this Run Metadata variable.
-#[no_mangle]
-pub unsafe extern "C" fn RunMetadataVariable_value(this: &RunMetadataVariable) -> *const c_char {
-    output_str(&*this.1)
-}
diff --git a/capi/src/run_metadata_variables_iter.rs b/capi/src/run_metadata_variables_iter.rs
deleted file mode 100644
index 270d5214..00000000
--- a/capi/src/run_metadata_variables_iter.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! An iterator iterating over all the Run Metadata variables and their values
-//! that have been specified.
-
-use super::RUN_METADATA_VARIABLE;
-use crate::run_metadata_variable::{NullableRunMetadataVariable, RunMetadataVariable};
-use livesplit_core::indexmap;
-use std::ptr;
-
-/// type
-pub type RunMetadataVariablesIter = indexmap::map::Iter<'static, String, String>;
-/// type
-pub type OwnedRunMetadataVariablesIter = Box<RunMetadataVariablesIter>;
-
-/// drop
-#[no_mangle]
-pub extern "C" fn RunMetadataVariablesIter_drop(this: OwnedRunMetadataVariablesIter) {
-    drop(this);
-}
-
-/// Accesses the next Run Metadata variable. Returns <NULL> if there are no more
-/// variables.
-#[no_mangle]
-pub extern "C" fn RunMetadataVariablesIter_next(
-    this: &mut RunMetadataVariablesIter,
-) -> *const NullableRunMetadataVariable {
-    if let Some((name, value)) = this.next() {
-        RUN_METADATA_VARIABLE.with(|output| {
-            output.set((name, value));
-            output.as_ptr() as *const RunMetadataVariable
-        })
-    } else {
-        ptr::null()
-    }
-}
diff --git a/capi/src/text_component.rs b/capi/src/text_component.rs
index 0f53cb38..ee68067d 100644
--- a/capi/src/text_component.rs
+++ b/capi/src/text_component.rs
@@ -5,7 +5,7 @@
 use super::{output_vec, str, Json};
 use crate::component::OwnedComponent;
 use crate::text_component_state::OwnedTextComponentState;
-use livesplit_core::component::text::Component as TextComponent;
+use livesplit_core::{component::text::Component as TextComponent, Timer};
 use std::os::raw::c_char;
 
 /// type
@@ -32,9 +32,9 @@ pub extern "C" fn TextComponent_into_generic(this: OwnedTextComponent) -> OwnedC
 
 /// Encodes the component's state information as JSON.
 #[no_mangle]
-pub extern "C" fn TextComponent_state_as_json(this: &TextComponent) -> Json {
+pub extern "C" fn TextComponent_state_as_json(this: &TextComponent, timer: &Timer) -> Json {
     output_vec(|o| {
-        this.state().write_json(o).unwrap();
+        this.state(timer).write_json(o).unwrap();
     })
 }
 
@@ -61,6 +61,9 @@ pub unsafe extern "C" fn TextComponent_set_right(this: &mut TextComponent, text:
 
 /// Calculates the component's state.
 #[no_mangle]
-pub extern "C" fn TextComponent_state(this: &TextComponent) -> OwnedTextComponentState {
-    Box::new(this.state())
+pub extern "C" fn TextComponent_state(
+    this: &TextComponent,
+    timer: &Timer,
+) -> OwnedTextComponentState {
+    Box::new(this.state(timer))
 }
diff --git a/capi/src/text_component_state.rs b/capi/src/text_component_state.rs
index 04c3dd83..42f98565 100644
--- a/capi/src/text_component_state.rs
+++ b/capi/src/text_component_state.rs
@@ -1,8 +1,7 @@
 //! The state object describes the information to visualize for this component.
 
 use super::output_str;
-use livesplit_core::component::text::State as TextComponentState;
-use livesplit_core::component::text::Text;
+use livesplit_core::component::text::{State as TextComponentState, TextState};
 use std::os::raw::c_char;
 
 /// type
@@ -18,7 +17,7 @@ pub extern "C" fn TextComponentState_drop(this: OwnedTextComponentState) {
 /// string is returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_left(this: &TextComponentState) -> *const c_char {
-    if let Text::Split(left, _) = &this.text {
+    if let TextState::Split(left, _) = &this.text {
         output_str(left)
     } else {
         output_str("")
@@ -29,7 +28,7 @@ pub extern "C" fn TextComponentState_left(this: &TextComponentState) -> *const c
 /// string is returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_right(this: &TextComponentState) -> *const c_char {
-    if let Text::Split(_, right) = &this.text {
+    if let TextState::Split(_, right) = &this.text {
         output_str(right)
     } else {
         output_str("")
@@ -40,7 +39,7 @@ pub extern "C" fn TextComponentState_right(this: &TextComponentState) -> *const
 /// returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_center(this: &TextComponentState) -> *const c_char {
-    if let Text::Center(center) = &this.text {
+    if let TextState::Center(center) = &this.text {
         output_str(center)
     } else {
         output_str("")
@@ -50,7 +49,7 @@ pub extern "C" fn TextComponentState_center(this: &TextComponentState) -> *const
 /// Returns whether the text is split up into a left and right part.
 #[no_mangle]
 pub extern "C" fn TextComponentState_is_split(this: &TextComponentState) -> bool {
-    if let Text::Split(_, _) = this.text {
+    if let TextState::Split(_, _) = this.text {
         true
     } else {
         false
diff --git a/src/component/text.rs b/src/component/text/mod.rs
similarity index 63%
rename from src/component/text.rs
rename to src/component/text/mod.rs
index 626ed727..9c3c5899 100644
--- a/src/component/text.rs
+++ b/src/component/text/mod.rs
@@ -5,11 +5,18 @@
 
 use super::key_value;
 use crate::platform::prelude::*;
-use crate::settings::{Color, Field, Gradient, SettingsDescription, Value};
+use crate::{
+    settings::{Color, Field, Gradient, SettingsDescription, Value},
+    timing::formatter,
+    Timer,
+};
 use alloc::borrow::Cow;
 use core::mem::replace;
 use serde::{Deserialize, Serialize};
 
+#[cfg(test)]
+mod tests;
+
 /// The Text Component simply visualizes any given text. This can either be a
 /// single centered text, or split up into a left and right text, which is
 /// suitable for a situation where you have a label and a value.
@@ -47,14 +54,26 @@ pub enum Text {
     /// A text that is split up into a left and right part. This is suitable for
     /// a situation where you have a label and a value.
     Split(String, String),
+    Variable(String, bool),
+}
+
+/// The text that is supposed to be shown.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TextState {
+    /// A single centered text.
+    Center(String),
+    /// A text that is split up into a left and right part. This is suitable for
+    /// a situation where you have a label and a value.
+    Split(String, String),
 }
 
 impl Text {
     /// Returns whether the text is split up into a left and right part.
     pub fn is_split(&self) -> bool {
-        match self {
+        match *self {
             Text::Split(_, _) => true,
             Text::Center(_) => false,
+            Text::Variable(_, is_split) => is_split,
         }
     }
 
@@ -109,7 +128,7 @@ pub struct State {
     /// from the layout.
     pub right_color: Option<Color>,
     /// The text to show for the component.
-    pub text: Text,
+    pub text: TextState,
 }
 
 impl Default for Settings {
@@ -169,6 +188,7 @@ impl Component {
                 name.push_str(right);
                 name.into()
             }
+            Text::Variable(var_name, _) => var_name.as_str().into(),
         };
 
         if name.trim().is_empty() {
@@ -179,43 +199,84 @@ impl Component {
     }
 
     /// Calculates the component's state.
-    pub fn state(&self) -> State {
+    pub fn state(&self, timer: &Timer) -> State {
         State {
             background: self.settings.background,
             display_two_rows: self.settings.text.is_split() && self.settings.display_two_rows,
             left_center_color: self.settings.left_center_color,
             right_color: self.settings.right_color,
-            text: self.settings.text.clone(),
+            text: match &self.settings.text {
+                Text::Center(center) => TextState::Center(center.clone()),
+                Text::Split(left, right) => TextState::Split(left.clone(), right.clone()),
+                Text::Variable(var_name, is_split) => {
+                    let value = timer
+                        .run()
+                        .metadata()
+                        .custom_variable(&var_name)
+                        .map(|var| var.value.as_str())
+                        .filter(|value| !value.trim_start().is_empty())
+                        .unwrap_or(formatter::DASH);
+
+                    if *is_split {
+                        TextState::Split(var_name.clone(), value.to_owned())
+                    } else {
+                        TextState::Center(value.to_owned())
+                    }
+                }
+            },
         }
     }
 
     /// Accesses a generic description of the settings available for this
     /// component and their current values.
     pub fn settings_description(&self) -> SettingsDescription {
-        let (first, second, color_name) = match &self.settings.text {
-            Text::Center(text) => (
-                Field::new("Text".into(), text.to_string().into()),
-                None,
-                "Text Color",
-            ),
-            Text::Split(left, right) => (
-                Field::new("Left".into(), left.to_string().into()),
-                Some(Field::new("Right".into(), right.to_string().into())),
-                "Left Color",
-            ),
-        };
+        let (first, second, is_variable, is_split, left_color, right_color) =
+            match &self.settings.text {
+                Text::Center(text) => (
+                    Field::new("Text".into(), text.to_string().into()),
+                    None,
+                    false,
+                    false,
+                    "Text Color",
+                    "",
+                ),
+                Text::Split(left, right) => (
+                    Field::new("Left".into(), left.to_string().into()),
+                    Some(Field::new("Right".into(), right.to_string().into())),
+                    false,
+                    true,
+                    "Left Color",
+                    "Right Color",
+                ),
+                Text::Variable(var_name, is_split) => (
+                    Field::new("Variable".into(), var_name.to_string().into()),
+                    None,
+                    true,
+                    *is_split,
+                    if *is_split {
+                        "Name Color"
+                    } else {
+                        "Value Color"
+                    },
+                    "Value Color",
+                ),
+            };
 
         let mut fields = vec![
             Field::new("Background".into(), self.settings.background.into()),
-            Field::new("Split".into(), second.is_some().into()),
+            Field::new("Use Variable".into(), is_variable.into()),
+            Field::new("Split".into(), is_split.into()),
             first,
-            Field::new(color_name.into(), self.settings.left_center_color.into()),
+            Field::new(left_color.into(), self.settings.left_center_color.into()),
         ];
 
         if let Some(second) = second {
             fields.push(second);
+        }
+
+        if is_split {
             fields.push(Field::new(
-                "Right Color".into(),
+                right_color.into(),
                 self.settings.right_color.into(),
             ));
             fields.push(Field::new(
@@ -234,10 +295,33 @@ impl Component {
     /// This panics if the type of the value to be set is not compatible with
     /// the type of the setting's value. A panic can also occur if the index of
     /// the setting provided is out of bounds.
-    pub fn set_value(&mut self, index: usize, value: Value) {
+    pub fn set_value(&mut self, mut index: usize, value: Value) {
+        if index >= 5 {
+            if let Text::Variable(_, _) = &self.settings.text {
+                index += 1;
+            }
+        }
+
         match index {
             0 => self.settings.background = value.into(),
             1 => {
+                self.settings.text = match (value.into_bool().unwrap(), &mut self.settings.text) {
+                    (false, Text::Variable(name, true)) => {
+                        Text::Split(replace(name, String::new()), String::new())
+                    }
+                    (false, Text::Variable(name, false)) => {
+                        Text::Center(replace(name, String::new()))
+                    }
+                    (true, Text::Center(center)) => {
+                        Text::Variable(replace(center, String::new()), false)
+                    }
+                    (true, Text::Split(left, _)) => {
+                        Text::Variable(replace(left, String::new()), true)
+                    }
+                    _ => return,
+                };
+            }
+            2 => {
                 self.settings.text = match (value.into_bool().unwrap(), &mut self.settings.text) {
                     (true, Text::Center(center)) => {
                         self.settings.right_color = self.settings.left_center_color;
@@ -255,20 +339,28 @@ impl Component {
 
                         Text::Center(value)
                     }
+                    (should_be_split, Text::Variable(_, is_split)) => {
+                        *is_split = should_be_split;
+                        return;
+                    }
                     _ => return,
                 };
             }
-            2 => match &mut self.settings.text {
+            3 => match &mut self.settings.text {
                 Text::Center(center) => *center = value.into(),
                 Text::Split(left, _) => *left = value.into(),
+                Text::Variable(var_name, _) => *var_name = value.into(),
             },
-            3 => self.settings.left_center_color = value.into(),
-            4 => match &mut self.settings.text {
-                Text::Center(_) => panic!("Set right text when there's only a center text"),
+            4 => self.settings.left_center_color = value.into(),
+            5 => match &mut self.settings.text {
+                Text::Center(_) => panic!("Can't set right text when there's only a center text"),
                 Text::Split(_, right) => *right = value.into(),
+                Text::Variable(_, _) => {
+                    unreachable!("Shouldn't be able to set value for a variable")
+                }
             },
-            5 => self.settings.right_color = value.into(),
-            6 => self.settings.display_two_rows = value.into(),
+            6 => self.settings.right_color = value.into(),
+            7 => self.settings.display_two_rows = value.into(),
             _ => panic!("Unsupported Setting Index"),
         }
     }
diff --git a/src/component/text/tests.rs b/src/component/text/tests.rs
new file mode 100644
index 00000000..b654b1cc
--- /dev/null
+++ b/src/component/text/tests.rs
@@ -0,0 +1,75 @@
+use super::{Component, Text, TextState};
+use crate::{tests_helper::create_run, timing::formatter, Timer};
+
+#[test]
+fn resolves_variables() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::from("4:20:00");
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from("4:20:00"))
+    );
+
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), false);
+
+    let state = component.state(&timer);
+
+    assert_eq!(state.text, TextState::Center(String::from("4:20:00")));
+}
+
+#[test]
+fn uses_dash_for_non_existing_variables() {
+    let run = create_run(&["A"]);
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
+
+#[test]
+fn uses_dash_for_empty_string_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::new();
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
+
+#[test]
+fn uses_dash_for_whitespace_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::from("    ");
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
diff --git a/src/layout/component.rs b/src/layout/component.rs
index 46bcdbf4..499fb932 100644
--- a/src/layout/component.rs
+++ b/src/layout/component.rs
@@ -83,7 +83,7 @@ impl Component {
                 ComponentState::Splits(component.state(timer, layout_settings))
             }
             Component::SumOfBest(component) => ComponentState::KeyValue(component.state(timer)),
-            Component::Text(component) => ComponentState::Text(component.state()),
+            Component::Text(component) => ComponentState::Text(component.state(timer)),
             Component::Timer(component) => {
                 ComponentState::Timer(component.state(timer, layout_settings))
             }
diff --git a/src/platform/no_std/indexmap.rs b/src/platform/no_std/indexmap.rs
index 37836340..3bc31c2e 100644
--- a/src/platform/no_std/indexmap.rs
+++ b/src/platform/no_std/indexmap.rs
@@ -29,6 +29,29 @@ pub mod map {
             }
         }
 
+        /// Return a reference to the value stored for key, if it is present, else None.
+        pub fn get<K2>(&self, key: &K2) -> Option<&V>
+        where
+            K: core::borrow::Borrow<K2>,
+            K2: ?Sized + PartialEq,
+        {
+            if let Some(index) = self.0.iter().position(|(k, _)| k.borrow() == key) {
+                Some(&self.0[index].1)
+            } else {
+                None
+            }
+        }
+
+        /// Get the given key’s corresponding entry in the map for insertion
+        /// and/or in-place manipulation.
+        pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+            Entry {
+                index: self.0.iter().position(|(k, _)| *k == key),
+                map: self,
+                key,
+            }
+        }
+
         /// Remove the key-value pair equivalent to key.
         pub fn shift_remove<K2>(&mut self, key: &K2)
         where
@@ -51,6 +74,29 @@ pub mod map {
         }
     }
 
+    pub struct Entry<'a, K, V> {
+        map: &'a mut IndexMap<K, V>,
+        index: Option<usize>,
+        key: K,
+    }
+
+    impl<'a, K, V> Entry<'a, K, V> {
+        /// Inserts a default-constructed value in the entry if it is vacant and
+        /// returns a mutable reference to it. Otherwise a mutable reference to
+        /// an already existent value is returned.
+        pub fn or_default(self) -> &'a mut V
+        where
+            V: Default,
+        {
+            if let Some(index) = self.index {
+                &mut self.map.0[index].1
+            } else {
+                self.map.0.push((self.key, Default::default()));
+                &mut self.map.0.last_mut().unwrap().1
+            }
+        }
+    }
+
     impl<'a, K, V> Iterator for Iter<'a, K, V> {
         type Item = (&'a K, &'a V);
         fn next(&mut self) -> Option<Self::Item> {
diff --git a/src/rendering/component/text.rs b/src/rendering/component/text.rs
index 7581b332..8cca984e 100644
--- a/src/rendering/component/text.rs
+++ b/src/rendering/component/text.rs
@@ -1,5 +1,5 @@
 use crate::{
-    component::text::{State, Text},
+    component::text::{State, TextState},
     layout::{LayoutDirection, LayoutState},
     rendering::{Backend, RenderContext, DEFAULT_TEXT_SIZE, PADDING, TEXT_ALIGN_TOP},
 };
@@ -12,7 +12,7 @@ pub(in crate::rendering) fn render(
 ) {
     context.render_rectangle([0.0, 0.0], [width, height], &component.background);
     match &component.text {
-        Text::Center(text) => context.render_text_centered(
+        TextState::Center(text) => context.render_text_centered(
             text,
             PADDING,
             width - PADDING,
@@ -22,7 +22,7 @@ pub(in crate::rendering) fn render(
                 .left_center_color
                 .unwrap_or(layout_state.text_color),
         ),
-        Text::Split(left, right) => context.render_key_value_component(
+        TextState::Split(left, right) => context.render_key_value_component(
             &left,
             &[],
             &right,
diff --git a/src/run/editor/mod.rs b/src/run/editor/mod.rs
index c84b31f4..1a847ba9 100644
--- a/src/run/editor/mod.rs
+++ b/src/run/editor/mod.rs
@@ -327,24 +327,67 @@ impl Editor {
     /// about the category. An example of this may be whether Amiibos are used
     /// in this category. If the variable doesn't exist yet, it is being
     /// inserted.
-    pub fn set_variable<N, V>(&mut self, name: N, value: V)
+    pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
         V: Into<String>,
     {
-        self.run.metadata_mut().set_variable(name, value);
+        self.run
+            .metadata_mut()
+            .set_speedrun_com_variable(name, value);
         self.metadata_modified();
     }
 
     /// Removes the variable with the name specified.
-    pub fn remove_variable<S>(&mut self, name: S)
+    pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
     {
-        self.run.metadata_mut().remove_variable(name);
+        self.run.metadata_mut().remove_speedrun_com_variable(name);
         self.metadata_modified();
     }
 
+    pub fn add_custom_variable<N>(&mut self, name: N)
+    where
+        N: Into<String>,
+    {
+        self.run
+            .metadata_mut()
+            .custom_variable_mut(name)
+            .permanent();
+        self.raise_run_edited();
+    }
+
+    pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
+    where
+        N: Into<String>,
+        V: AsRef<str>,
+    {
+        let name = name.into();
+        if self.run.metadata().custom_variable(&name).is_none() {
+            return;
+        }
+        let variable = self.run.metadata_mut().custom_variable_mut(name);
+        if variable.is_permanent {
+            variable.value.clear();
+            variable.value.push_str(value.as_ref());
+            self.raise_run_edited();
+        }
+    }
+
+    pub fn remove_custom_variable<N>(&mut self, name: N)
+    where
+        N: AsRef<str>,
+    {
+        let name = name.as_ref();
+        if let Some(variable) = self.run.metadata().custom_variable(name) {
+            if variable.is_permanent {
+                self.run.metadata_mut().remove_custom_variable(name);
+                self.raise_run_edited();
+            }
+        }
+    }
+
     /// Resets all the Metadata Information.
     pub fn clear_metadata(&mut self) {
         self.run.metadata_mut().clear();
diff --git a/src/run/editor/tests/custom_variables.rs b/src/run/editor/tests/custom_variables.rs
new file mode 100644
index 00000000..440706f8
--- /dev/null
+++ b/src/run/editor/tests/custom_variables.rs
@@ -0,0 +1,45 @@
+use super::super::Editor;
+use crate::tests_helper::create_run;
+
+#[test]
+fn cant_edit_temporary_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .set_value("Bar");
+    let mut editor = Editor::new(run).unwrap();
+
+    editor.set_custom_variable("Foo", "No");
+
+    assert_eq!(
+        editor
+            .run()
+            .metadata()
+            .custom_variable("Foo")
+            .unwrap()
+            .value,
+        "Bar",
+    );
+}
+
+#[test]
+fn can_edit_permanent_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
+    let mut editor = Editor::new(run).unwrap();
+
+    editor.set_custom_variable("Foo", "Ok");
+
+    assert_eq!(
+        editor
+            .run()
+            .metadata()
+            .custom_variable("Foo")
+            .unwrap()
+            .value,
+        "Ok",
+    );
+}
diff --git a/src/run/editor/tests/dissociate_run.rs b/src/run/editor/tests/dissociate_run.rs
index 90ee318b..81d3f84a 100644
--- a/src/run/editor/tests/dissociate_run.rs
+++ b/src/run/editor/tests/dissociate_run.rs
@@ -5,6 +5,10 @@ fn base() -> Editor {
     let mut run = Run::new();
     run.push_segment(Segment::new(""));
     run.push_segment(Segment::new(""));
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
 
     let mut editor = Editor::new(run).unwrap();
 
@@ -157,16 +161,16 @@ fn when_setting_emulator_usage() {
 }
 
 #[test]
-fn when_setting_variable() {
+fn when_setting_speedrun_com_variable() {
     let mut editor = base();
-    editor.set_variable("ok", "ok");
+    editor.set_speedrun_com_variable("ok", "ok");
     assert_eq!(editor.run().metadata().run_id, "");
 }
 
 #[test]
-fn when_removing_variable() {
+fn when_removing_speedrun_com_variable() {
     let mut editor = base();
-    editor.remove_variable("ok");
+    editor.remove_speedrun_com_variable("ok");
     assert_eq!(editor.run().metadata().run_id, "");
 }
 
@@ -183,3 +187,24 @@ fn not_when_generating_goal_comparison() {
     editor.generate_goal_comparison(TimeSpan::from_seconds(30.0));
     assert_ne!(editor.run().metadata().run_id, "");
 }
+
+#[test]
+fn not_when_creating_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Hello", "World");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
+
+#[test]
+fn not_when_setting_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Foo", "Bar2");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
+
+#[test]
+fn not_when_removing_custom_variable() {
+    let mut editor = base();
+    editor.remove_custom_variable("Foo");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
diff --git a/src/run/editor/tests/mark_as_modified.rs b/src/run/editor/tests/mark_as_modified.rs
index 78172e41..aa47a5c2 100644
--- a/src/run/editor/tests/mark_as_modified.rs
+++ b/src/run/editor/tests/mark_as_modified.rs
@@ -5,6 +5,10 @@ fn base() -> Editor {
     let mut run = Run::new();
     run.push_segment(Segment::new(""));
     run.push_segment(Segment::new(""));
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
 
     let mut editor = Editor::new(run).unwrap();
 
@@ -23,7 +27,7 @@ fn base() -> Editor {
     editor.add_comparison("Other Comparison").unwrap();
     editor.active_segment().set_icon(&[2]);
     editor.set_game_icon(&[2]);
-    editor.set_variable("remove", "me");
+    editor.set_speedrun_com_variable("remove", "me");
 
     let mut run = editor.close();
     run.mark_as_unmodified();
@@ -190,16 +194,16 @@ fn when_setting_emulator_usage() {
 }
 
 #[test]
-fn when_setting_variable() {
+fn when_setting_speedrun_com_variable() {
     let mut editor = base();
-    editor.set_variable("some", "variable");
+    editor.set_speedrun_com_variable("some", "variable");
     assert!(editor.run().has_been_modified());
 }
 
 #[test]
-fn when_removing_variable() {
+fn when_removing_speedrun_com_variable() {
     let mut editor = base();
-    editor.remove_variable("remove");
+    editor.remove_speedrun_com_variable("remove");
     assert!(editor.run().has_been_modified());
 }
 
@@ -315,3 +319,24 @@ fn when_generating_goal_comparison() {
 }
 
 // FIXME: Cleaning Sum of Best
+
+#[test]
+fn when_creating_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Hello", "World");
+    assert!(editor.run().has_been_modified());
+}
+
+#[test]
+fn when_setting_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Foo", "Bar2");
+    assert!(editor.run().has_been_modified());
+}
+
+#[test]
+fn when_removing_custom_variable() {
+    let mut editor = base();
+    editor.remove_custom_variable("Foo");
+    assert!(editor.run().has_been_modified());
+}
diff --git a/src/run/editor/tests/mod.rs b/src/run/editor/tests/mod.rs
index c1e2a1b2..8194f2a9 100644
--- a/src/run/editor/tests/mod.rs
+++ b/src/run/editor/tests/mod.rs
@@ -2,6 +2,7 @@ use super::Editor;
 use crate::{Run, Segment};
 
 mod comparison;
+mod custom_variables;
 mod dissociate_run;
 mod mark_as_modified;
 
diff --git a/src/run/mod.rs b/src/run/mod.rs
index bccb6a35..b0b1d894 100644
--- a/src/run/mod.rs
+++ b/src/run/mod.rs
@@ -528,7 +528,7 @@ impl Run {
             };
 
             if show_variables {
-                for (name, value) in self.metadata.variables() {
+                for (name, value) in self.metadata.speedrun_com_variables() {
                     let name = name.trim_end_matches('?');
 
                     if unicase::eq(value.as_str(), "yes") {
diff --git a/src/run/parser/face_split.rs b/src/run/parser/face_split.rs
index 0d916c40..4bf27b34 100644
--- a/src/run/parser/face_split.rs
+++ b/src/run/parser/face_split.rs
@@ -18,6 +18,13 @@ pub enum Error {
         /// The underlying error.
         source: io::Error,
     },
+    /// Expected the goal, but didn't find it.
+    ExpectedGoal,
+    /// Failed to read the goal.
+    ReadGoal {
+        /// The underlying error.
+        source: io::Error,
+    },
     /// Expected the attempt count, but didn't find it.
     ExpectedAttemptCount,
     /// Failed to read the attempt count.
@@ -86,7 +93,15 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
     let mut lines = source.lines();
 
     run.set_category_name(lines.next().context(ExpectedTitle)?.context(ReadTitle)?);
-    lines.next(); // FIXME: Store Goal
+
+    let goal = lines.next().context(ExpectedGoal)?.context(ReadGoal)?;
+    if !goal.trim_start().is_empty() {
+        run.metadata_mut()
+            .custom_variable_mut("Goal")
+            .permanent()
+            .set_value(goal);
+    }
+
     run.set_attempt_count(
         lines
             .next()
diff --git a/src/run/parser/livesplit.rs b/src/run/parser/livesplit.rs
index 5b6fcf12..1df6de23 100644
--- a/src/run/parser/livesplit.rs
+++ b/src/run/parser/livesplit.rs
@@ -61,6 +61,8 @@ pub enum Error {
     },
     /// Failed to parse a boolean.
     ParseBool,
+    /// Failed to parse the scope of a custom variable.
+    Scope,
 }
 
 /// The Result type for the LiveSplit Parser.
@@ -218,7 +220,7 @@ fn parse_metadata<R: BufRead>(
                 text(reader, tag.into_buf(), |t| metadata.set_platform_name(t))
             } else if tag.name() == b"Region" {
                 text(reader, tag.into_buf(), |t| metadata.set_region_name(t))
-            } else if tag.name() == b"Variables" {
+            } else if tag.name() == b"Variables" || tag.name() == b"SpeedrunComVariables" {
                 parse_children(reader, tag.into_buf(), |reader, tag| {
                     let mut name = String::new();
                     let mut value = String::new();
@@ -228,7 +230,19 @@ fn parse_metadata<R: BufRead>(
                     type_hint(text(reader, tag.into_buf(), |t| {
                         value = t.into_owned();
                     }))?;
-                    metadata.set_variable(name, value);
+                    metadata.set_speedrun_com_variable(name, value);
+                    Ok(())
+                })
+            } else if tag.name() == b"CustomVariables" {
+                parse_children(reader, tag.into_buf(), |reader, tag| {
+                    let mut name = String::new();
+                    type_hint(attribute(&tag, b"name", |t| {
+                        name = t.into_owned();
+                    }))?;
+                    let var = metadata.custom_variable_mut(name).permanent();
+                    type_hint(text(reader, tag.into_buf(), |t| {
+                        var.set_value(t);
+                    }))?;
                     Ok(())
                 })
             } else {
diff --git a/src/run/parser/splits_io.rs b/src/run/parser/splits_io.rs
index 2c119a0c..da09fb3b 100644
--- a/src/run/parser/splits_io.rs
+++ b/src/run/parser/splits_io.rs
@@ -301,6 +301,42 @@ pub fn parse<R: Read>(source: R) -> Result<(Run, String)> {
         }
     }
 
+    if let Some(runner) = splits.runners.as_ref().and_then(|runners| runners.first()) {
+        let name = runner.longname.as_ref().unwrap_or(&runner.shortname);
+        if !name.trim_start().is_empty() {
+            run.metadata_mut()
+                .custom_variable_mut("Runner")
+                .permanent()
+                .set_value(name);
+        }
+        if let Some(links) = &runner.links {
+            if let Some(twitter_id) = &links.twitter_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Twitter")
+                    .permanent()
+                    .set_value(twitter_id);
+            }
+            if let Some(twitch_id) = &links.twitch_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Twitch")
+                    .permanent()
+                    .set_value(twitch_id);
+            }
+            if let Some(speedruncom_id) = &links.speedruncom_id {
+                run.metadata_mut()
+                    .custom_variable_mut("speedrun.com")
+                    .permanent()
+                    .set_value(speedruncom_id);
+            }
+            if let Some(splitsio_id) = &links.splitsio_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Splits I/O")
+                    .permanent()
+                    .set_value(splitsio_id);
+            }
+        }
+    }
+
     for split in splits.segments.into_iter().flatten() {
         let mut segment = LiveSplitSegment::new(split.name.unwrap_or_default());
         segment.set_personal_best_split_time(split.ended_at.into());
diff --git a/src/run/parser/splitterz.rs b/src/run/parser/splitterz.rs
index 581631cb..c38d2ace 100644
--- a/src/run/parser/splitterz.rs
+++ b/src/run/parser/splitterz.rs
@@ -48,6 +48,11 @@ pub enum Error {
         /// The underlying error.
         source: io::Error,
     },
+    /// Failed to read a counter line.
+    CounterLine {
+        /// The underlying error.
+        source: io::Error,
+    },
 }
 
 /// The Result type for the SplitterZ parser.
@@ -74,7 +79,6 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
     let mut lines = source.lines();
     let line = lines.next().ok_or(Error::Empty)?.context(TitleLine)?;
     let mut splits = line.split(',');
-    // Title Stuff here, do later
     run.set_category_name(unescape(splits.next().ok_or(Error::ExpectedCategoryName)?));
     run.set_attempt_count(
         splits
@@ -84,7 +88,7 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
             .context(ParseAttemptCount)?,
     );
 
-    for line in lines {
+    for line in &mut lines {
         let line = line.context(Line)?;
         if !line.is_empty() {
             let mut splits = line.split(',');
@@ -128,6 +132,18 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
         }
     }
 
+    for line in lines {
+        if let Some(counter) = line.context(CounterLine)?.split(',').next() {
+            run.metadata_mut()
+                .custom_variable_mut(unescape(counter))
+                .permanent()
+                .set_value("0");
+        }
+        // The other two lines are not that useful. The number is how much to
+        // increment the counter each time and the other is a boolean that does
+        // not seem to be exposed to the UI.
+    }
+
     Ok(run)
 }
 
@@ -143,10 +159,12 @@ SegmentName,0:00:00.00,0.00
 SegmentName,0:00:00.00,0.00
 
 Counter,1,True
-Counter,1,True
+Counter2,1,True
 "#;
 
         let run = parse(RUN, false).unwrap();
         assert_eq!(run.len(), 3);
+        assert_eq!(run.metadata.custom_variable_value("Counter"), Some("0"));
+        assert_eq!(run.metadata.custom_variable_value("Counter2"), Some("0"));
     }
 }
diff --git a/src/run/parser/worstrun.rs b/src/run/parser/worstrun.rs
index 26b13b56..70303c45 100644
--- a/src/run/parser/worstrun.rs
+++ b/src/run/parser/worstrun.rs
@@ -19,7 +19,7 @@ pub enum Error {
     },
 }
 
-/// The Result type for the Urn Parser.
+/// The Result type for the worstrun Parser.
 pub type Result<T> = StdResult<T, Error>;
 
 #[derive(Deserialize)]
diff --git a/src/run/parser/wsplit.rs b/src/run/parser/wsplit.rs
index efef860e..ed7a4d2c 100644
--- a/src/run/parser/wsplit.rs
+++ b/src/run/parser/wsplit.rs
@@ -136,8 +136,10 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
         if run.category_name().is_empty() {
             run.set_category_name(goal);
         } else {
-            let category_name = format!("{} (Goal: {})", run.category_name(), goal);
-            run.set_category_name(category_name);
+            run.metadata_mut()
+                .custom_variable_mut("Goal")
+                .permanent()
+                .set_value(goal);
         }
     }
 
@@ -169,7 +171,8 @@ Jimmy,0,219.68,134.2
 "#;
 
         let run = parse(RUN, false).unwrap();
-        assert_eq!(run.category_name(), "WarioWare, Inc (Goal: sub 2h)");
+        assert_eq!(run.category_name(), "WarioWare, Inc");
+        assert_eq!(run.metadata().custom_variable_value("Goal"), Some("sub 2h"));
         assert_eq!(run.len(), 2);
     }
 
diff --git a/src/run/run_metadata.rs b/src/run/run_metadata.rs
index 2e3e26f5..828a5171 100644
--- a/src/run/run_metadata.rs
+++ b/src/run/run_metadata.rs
@@ -2,6 +2,31 @@ use crate::indexmap::map::{IndexMap, Iter};
 use crate::platform::prelude::*;
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CustomVariable {
+    pub value: String,
+    /// States whether the variable is permanent. Temporary variables don't get
+    /// stored in splits files. They also don't get shown in the run editor.
+    pub is_permanent: bool,
+}
+
+impl CustomVariable {
+    pub fn permanent(&mut self) -> &mut Self {
+        self.is_permanent = true;
+        self
+    }
+    pub fn set_value<S>(&mut self, value: S)
+    where
+        S: AsRef<str>,
+    {
+        self.value.clear();
+        self.value.push_str(value.as_ref());
+    }
+    pub fn clear_value(&mut self) {
+        self.value.clear();
+    }
+}
+
 /// The Run Metadata stores additional information about a run, like the
 /// platform and region of the game. All of this information is optional.
 #[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -19,10 +44,11 @@ pub struct RunMetadata {
     /// The name of the region this game is from. This may be empty if it's not
     /// specified.
     pub region_name: String,
-    /// Stores all the variables. A variable is an arbitrary key value pair
-    /// storing additional information about the category. An example of this
-    /// may be whether Amiibos are used in this category.
-    pub variables: IndexMap<String, String>,
+    /// Stores all the speedrun.com variables. A variable is an arbitrary key
+    /// value pair storing additional information about the category. An example
+    /// of this may be whether Amiibos are used in this category.
+    pub speedrun_com_variables: IndexMap<String, String>,
+    pub custom_variables: IndexMap<String, CustomVariable>,
 }
 
 impl RunMetadata {
@@ -108,26 +134,59 @@ impl RunMetadata {
     /// about the category. An example of this may be whether Amiibos are used
     /// in this category. If the variable doesn't exist yet, it is being
     /// inserted.
-    pub fn set_variable<N, V>(&mut self, name: N, value: V)
+    pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
         V: Into<String>,
     {
-        self.variables.insert(name.into(), value.into());
+        self.speedrun_com_variables
+            .insert(name.into(), value.into());
     }
 
     /// Removes the variable with the name specified.
-    pub fn remove_variable<S>(&mut self, name: S)
+    pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
     {
-        self.variables.shift_remove(name.as_ref());
+        self.speedrun_com_variables.shift_remove(name.as_ref());
     }
 
     /// Returns an iterator iterating over all the variables and their values
     /// that have been specified.
-    pub fn variables(&self) -> Iter<'_, String, String> {
-        self.variables.iter()
+    pub fn speedrun_com_variables(&self) -> Iter<'_, String, String> {
+        self.speedrun_com_variables.iter()
+    }
+
+    pub fn custom_variable<S>(&self, name: S) -> Option<&CustomVariable>
+    where
+        S: AsRef<str>,
+    {
+        self.custom_variables.get(name.as_ref())
+    }
+
+    pub fn custom_variable_value<S>(&self, name: S) -> Option<&str>
+    where
+        S: AsRef<str>,
+    {
+        Some(&self.custom_variable(name)?.value)
+    }
+
+    pub fn custom_variable_mut<S>(&mut self, name: S) -> &mut CustomVariable
+    where
+        S: Into<String>,
+    {
+        self.custom_variables.entry(name.into()).or_default()
+    }
+
+    pub fn remove_custom_variable<S>(&mut self, name: S)
+    where
+        S: AsRef<str>,
+    {
+        self.custom_variables.shift_remove(name.as_ref());
+    }
+
+    pub fn custom_variables(&self) -> Iter<'_, String, CustomVariable> {
+        self.custom_variables.iter()
     }
 
     /// Resets all the Metadata Information.
@@ -136,6 +195,7 @@ impl RunMetadata {
         self.platform_name.clear();
         self.region_name.clear();
         self.uses_emulator = false;
-        self.variables.clear();
+        self.speedrun_com_variables.clear();
+        self.custom_variables.clear();
     }
 }
diff --git a/src/run/saver/livesplit.rs b/src/run/saver/livesplit.rs
index afe6f8d1..86226659 100644
--- a/src/run/saver/livesplit.rs
+++ b/src/run/saver/livesplit.rs
@@ -250,7 +250,7 @@ pub fn save_run<W: Write>(run: &Run, writer: W) -> Result<()> {
 
     writer.write_event(Event::Decl(BytesDecl::new(b"1.0", Some(b"UTF-8"), None)))?;
     writer.write_event(Event::Start(BytesStart::borrowed(
-        br#"Run version="1.7.1""#,
+        br#"Run version="1.8.0""#,
         3,
     )))?;
 
@@ -279,14 +279,28 @@ pub fn save_run<W: Write>(run: &Run, writer: W) -> Result<()> {
 
     scoped_iter(
         writer,
-        new_tag(b"Variables"),
-        metadata.variables(),
+        new_tag(b"SpeedrunComVariables"),
+        metadata.speedrun_com_variables(),
         |writer, (name, value)| {
             let mut tag = new_tag(b"Variable");
             tag.push_attribute((&b"name"[..], name.as_bytes()));
             text(writer, tag, value)
         },
     )?;
+
+    scoped_iter(
+        writer,
+        new_tag(b"CustomVariables"),
+        metadata
+            .custom_variables()
+            .filter(|(_, var)| var.is_permanent),
+        |writer, (name, var)| {
+            let mut tag = new_tag(b"Variable");
+            tag.push_attribute((&b"name"[..], name.as_bytes()));
+            text(writer, tag, &var.value)
+        },
+    )?;
+
     write_end(writer, b"Metadata")?;
 
     time_span(writer, new_tag(b"Offset"), run.offset(), buf)?;
diff --git a/src/timing/timer/mod.rs b/src/timing/timer/mod.rs
index 82cc7c78..9d7fc48a 100644
--- a/src/timing/timer/mod.rs
+++ b/src/timing/timer/mod.rs
@@ -599,6 +599,18 @@ impl Timer {
         }
     }
 
+    pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
+    where
+        N: Into<String>,
+        V: AsRef<str>,
+    {
+        let var = self.run.metadata_mut().custom_variable_mut(name);
+        var.set_value(value);
+        if var.is_permanent {
+            self.run.mark_as_modified();
+        }
+    }
+
     fn update_attempt_history(&mut self) {
         let time = if self.phase == Ended {
             self.current_time()
diff --git a/src/timing/timer/tests/mark_as_modified.rs b/src/timing/timer/tests/mark_as_modified.rs
index 6c023589..a2a146c7 100644
--- a/src/timing/timer/tests/mark_as_modified.rs
+++ b/src/timing/timer/tests/mark_as_modified.rs
@@ -1,8 +1,12 @@
 use crate::{Run, Segment, TimeSpan, Timer, TimingMethod};
 
 fn timer() -> Timer {
-    use super::timer;
-    let timer = timer();
+    use super::run;
+    let mut run = run();
+    run.metadata_mut()
+        .custom_variable_mut("Permanent")
+        .permanent();
+    let timer = Timer::new(run).unwrap();
     assert!(!timer.run().has_been_modified());
     timer
 }
@@ -163,3 +167,19 @@ fn not_when_pausing_resuming_or_setting_game_time_without_an_attempt() {
     timer.set_loading_times(TimeSpan::default());
     assert!(!timer.run().has_been_modified());
 }
+
+#[test]
+fn when_setting_permanent_custom_variables() {
+    let mut timer = timer();
+    timer.set_custom_variable("Permanent", "okok");
+    assert!(timer.run().has_been_modified());
+}
+
+#[test]
+fn not_when_setting_temporary_custom_variables() {
+    let mut timer = timer();
+    timer.set_custom_variable("Foo", "Bar");
+    assert!(!timer.run().has_been_modified());
+    timer.set_custom_variable("Foo", "Bar2");
+    assert!(!timer.run().has_been_modified());
+}
diff --git a/src/timing/timer/tests/mod.rs b/src/timing/timer/tests/mod.rs
index d8677e27..5b35777a 100644
--- a/src/timing/timer/tests/mod.rs
+++ b/src/timing/timer/tests/mod.rs
@@ -3,6 +3,7 @@ use crate::tests_helper::{run_with_splits, run_with_splits_opt, start_run};
 use crate::{Run, Segment, TimeSpan, Timer, TimerPhase, TimingMethod};
 
 mod mark_as_modified;
+mod variables;
 
 fn run() -> Run {
     let mut run = Run::new();
diff --git a/src/timing/timer/tests/variables.rs b/src/timing/timer/tests/variables.rs
new file mode 100644
index 00000000..1d319cf2
--- /dev/null
+++ b/src/timing/timer/tests/variables.rs
@@ -0,0 +1,115 @@
+use crate::tests_helper::create_timer;
+
+#[test]
+fn can_set_variable() {
+    let mut timer = create_timer(&["A"]);
+
+    assert!(timer.run().metadata().custom_variable("Points").is_none());
+
+    timer.set_custom_variable("Points", "10");
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "10"
+    );
+
+    timer.start();
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "10"
+    );
+
+    timer.set_custom_variable("Points", "20");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "20"
+    );
+
+    timer.set_custom_variable("Points", "30");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "30"
+    );
+
+    timer.split();
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "30"
+    );
+
+    timer.set_custom_variable("Points", "40");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "40"
+    );
+
+    timer.set_custom_variable("Points", "50");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "50"
+    );
+
+    timer.reset(true);
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "50"
+    );
+
+    timer.set_custom_variable("Points", "60");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "60"
+    );
+
+    assert!(
+        !timer
+            .run()
+            .metadata()
+            .custom_variable("Points")
+            .unwrap()
+            .is_permanent,
+    );
+}

From d31389729128ba2ed060dfd770fbcfda29b09a2b Mon Sep 17 00:00:00 2001
From: Christopher Serr <christopher.serr@gmail.com>
Date: Mon, 6 Jan 2020 18:01:22 +0100
Subject: [PATCH 2/3] Add Documentation

---
 capi/bind_gen/src/typescript.ts               | 23 +++++++-
 capi/src/lib.rs                               |  4 ++
 capi/src/run_editor.rs                        | 11 +++-
 capi/src/run_metadata.rs                      | 14 ++++-
 capi/src/run_metadata_custom_variable.rs      | 49 +++++++++++++++++
 .../src/run_metadata_custom_variables_iter.rs | 36 +++++++++++++
 .../src/run_metadata_speedrun_com_variable.rs |  6 +--
 ...un_metadata_speedrun_com_variables_iter.rs |  4 +-
 src/component/text/mod.rs                     |  3 ++
 src/run/editor/mod.rs                         | 22 +++++---
 src/run/editor/tests/mark_as_modified.rs      |  2 +-
 src/run/mod.rs                                |  2 +-
 src/run/run_metadata.rs                       | 53 +++++++++++++++----
 src/run/tests/metadata.rs                     | 20 ++++---
 src/timing/timer/mod.rs                       |  3 ++
 15 files changed, 215 insertions(+), 37 deletions(-)
 create mode 100644 capi/src/run_metadata_custom_variable.rs
 create mode 100644 capi/src/run_metadata_custom_variables_iter.rs

diff --git a/capi/bind_gen/src/typescript.ts b/capi/bind_gen/src/typescript.ts
index 9f774f88..c3e2cd29 100644
--- a/capi/bind_gen/src/typescript.ts
+++ b/capi/bind_gen/src/typescript.ts
@@ -663,11 +663,30 @@ export interface RunMetadataJson {
      * of this may be whether Amiibos are used in this category.
      */
     speedrun_com_variables: { [key: string]: string | undefined },
+    /**
+     * Stores all the custom variables. A custom variable is a key value pair
+     * storing additional information about a run. Unlike the speedrun.com
+     * variables, these can be fully custom and don't need to correspond to
+     * anything on speedrun.com. Permanent custom variables can be specified by
+     * the runner. Additionally auto splitters or other sources may provide
+     * temporary custom variables that are not stored in the splits files.
+     */
     custom_variables: { [key: string]: CustomVariableJson | undefined },
 }
-
+/**
+ * A custom variable is a key value pair storing additional information about a
+ * run. Unlike the speedrun.com variables, these can be fully custom and don't
+ * need to correspond to anything on speedrun.com. Permanent custom variables
+ * can be specified by the runner. Additionally auto splitters or other sources
+ * may provide temporary custom variables that are not stored in the splits
+ * files.
+ */
 export interface CustomVariableJson {
-    // TODO:
+    /**
+     * The current value of the custom variable. This may be provided by the
+     * runner in the run editor or it may be provided through other means such
+     * as an auto splitter.
+     */
     value: string,
     /**
      * States whether the variable is permanent. Temporary variables don't get
diff --git a/capi/src/lib.rs b/capi/src/lib.rs
index 879949e1..ed069d38 100644
--- a/capi/src/lib.rs
+++ b/capi/src/lib.rs
@@ -37,6 +37,8 @@ pub mod previous_segment_component;
 pub mod run;
 pub mod run_editor;
 pub mod run_metadata;
+pub mod run_metadata_custom_variable;
+pub mod run_metadata_custom_variables_iter;
 pub mod run_metadata_speedrun_com_variable;
 pub mod run_metadata_speedrun_com_variables_iter;
 pub mod segment;
@@ -64,6 +66,7 @@ pub mod title_component;
 pub mod title_component_state;
 pub mod total_playtime_component;
 
+use crate::run_metadata_custom_variable::RunMetadataCustomVariable;
 use crate::run_metadata_speedrun_com_variable::RunMetadataSpeedrunComVariable;
 use crate::segment_history_element::SegmentHistoryElement;
 use livesplit_core::{Time, TimeSpan};
@@ -79,6 +82,7 @@ thread_local! {
     static TIME: Cell<Time> = Cell::default();
     static SEGMENT_HISTORY_ELEMENT: Cell<SegmentHistoryElement> = Cell::default();
     static RUN_METADATA_SPEEDRUN_COM_VARIABLE: Cell<RunMetadataSpeedrunComVariable> = Cell::new((ptr::null(), ptr::null()));
+    static RUN_METADATA_CUSTOM_VARIABLE: Cell<RunMetadataCustomVariable> = Cell::new((ptr::null(), ptr::null()));
 }
 
 fn output_time_span(time_span: TimeSpan) -> *const TimeSpan {
diff --git a/capi/src/run_editor.rs b/capi/src/run_editor.rs
index e2a5e592..5f580316 100644
--- a/capi/src/run_editor.rs
+++ b/capi/src/run_editor.rs
@@ -158,7 +158,7 @@ pub extern "C" fn RunEditor_set_emulator_usage(this: &mut RunEditor, uses_emulat
     this.set_emulator_usage(uses_emulator);
 }
 
-/// Sets the variable with the name specified to the value specified. A
+/// Sets the speedrun.com variable with the name specified to the value specified. A
 /// variable is an arbitrary key value pair storing additional information
 /// about the category. An example of this may be whether Amiibos are used
 /// in this category. If the variable doesn't exist yet, it is being
@@ -172,7 +172,7 @@ pub unsafe extern "C" fn RunEditor_set_speedrun_com_variable(
     this.set_speedrun_com_variable(str(name), str(value));
 }
 
-/// Removes the variable with the name specified.
+/// Removes the speedrun.com variable with the name specified.
 #[no_mangle]
 pub unsafe extern "C" fn RunEditor_remove_speedrun_com_variable(
     this: &mut RunEditor,
@@ -181,11 +181,16 @@ pub unsafe extern "C" fn RunEditor_remove_speedrun_com_variable(
     this.remove_speedrun_com_variable(str(name));
 }
 
+/// Adds a new permanent custom variable. If there's a temporary variable with
+/// the same name, it gets turned into a permanent variable and its value stays.
+/// If a permanent variable with the name already exists, nothing happens.
 #[no_mangle]
 pub unsafe extern "C" fn RunEditor_add_custom_variable(this: &mut RunEditor, name: *const c_char) {
     this.add_custom_variable(str(name));
 }
 
+/// Sets the value of a custom variable with the name specified. If the custom
+/// variable does not exist, or is not a permanent variable, nothing happens.
 #[no_mangle]
 pub unsafe extern "C" fn RunEditor_set_custom_variable(
     this: &mut RunEditor,
@@ -195,6 +200,8 @@ pub unsafe extern "C" fn RunEditor_set_custom_variable(
     this.set_custom_variable(str(name), str(value));
 }
 
+/// Removes the custom variable with the name specified. If the custom variable
+/// does not exist, or is not a permanent variable, nothing happens.
 #[no_mangle]
 pub unsafe extern "C" fn RunEditor_remove_custom_variable(
     this: &mut RunEditor,
diff --git a/capi/src/run_metadata.rs b/capi/src/run_metadata.rs
index b1e39550..0d2f0548 100644
--- a/capi/src/run_metadata.rs
+++ b/capi/src/run_metadata.rs
@@ -2,6 +2,7 @@
 //! platform and region of the game. All of this information is optional.
 
 use super::output_str;
+use crate::run_metadata_custom_variables_iter::OwnedRunMetadataCustomVariablesIter;
 use crate::run_metadata_speedrun_com_variables_iter::OwnedRunMetadataSpeedrunComVariablesIter;
 use livesplit_core::RunMetadata;
 use std::os::raw::c_char;
@@ -39,11 +40,20 @@ pub extern "C" fn RunMetadata_region_name(this: &RunMetadata) -> *const c_char {
     output_str(this.region_name())
 }
 
-/// Returns an iterator iterating over all the variables and their values
-/// that have been specified.
+/// Returns an iterator iterating over all the speedrun.com variables and their
+/// values that have been specified.
 #[no_mangle]
 pub extern "C" fn RunMetadata_speedrun_com_variables(
     this: &'static RunMetadata,
 ) -> OwnedRunMetadataSpeedrunComVariablesIter {
     Box::new(this.speedrun_com_variables())
 }
+
+/// Returns an iterator iterating over all the custom variables and their
+/// values. This includes both temporary and permanent variables.
+#[no_mangle]
+pub extern "C" fn RunMetadata_custom_variables(
+    this: &'static RunMetadata,
+) -> OwnedRunMetadataCustomVariablesIter {
+    Box::new(this.custom_variables())
+}
diff --git a/capi/src/run_metadata_custom_variable.rs b/capi/src/run_metadata_custom_variable.rs
new file mode 100644
index 00000000..3666ee0b
--- /dev/null
+++ b/capi/src/run_metadata_custom_variable.rs
@@ -0,0 +1,49 @@
+//! A custom variable is a key value pair storing additional information about a
+//! run. Unlike the speedrun.com variables, these can be fully custom and don't
+//! need to correspond to anything on speedrun.com. Permanent custom variables
+//! can be specified by the runner. Additionally auto splitters or other sources
+//! may provide temporary custom variables that are not stored in the splits
+//! files.
+
+use super::output_str;
+use livesplit_core::run::CustomVariable;
+use std::os::raw::c_char;
+
+/// type
+pub type RunMetadataCustomVariable = (*const String, *const CustomVariable);
+/// type
+pub type NullableRunMetadataCustomVariable = RunMetadataCustomVariable;
+/// type
+pub type OwnedRunMetadataCustomVariable = Box<RunMetadataCustomVariable>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariable_drop(this: OwnedRunMetadataCustomVariable) {
+    drop(this);
+}
+
+/// Accesses the name of this custom variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_name(
+    this: &RunMetadataCustomVariable,
+) -> *const c_char {
+    output_str(&*this.0)
+}
+
+/// Accesses the value of this custom variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_value(
+    this: &RunMetadataCustomVariable,
+) -> *const c_char {
+    output_str(&(*this.1).value)
+}
+
+/// Returns <TRUE> if the custom variable is permanent. Permanent variables get
+/// stored in the splits file and are visible in the run editor. Temporary
+/// variables are not.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_is_permanent(
+    this: &RunMetadataCustomVariable,
+) -> bool {
+    (*this.1).is_permanent
+}
diff --git a/capi/src/run_metadata_custom_variables_iter.rs b/capi/src/run_metadata_custom_variables_iter.rs
new file mode 100644
index 00000000..cc8e82e4
--- /dev/null
+++ b/capi/src/run_metadata_custom_variables_iter.rs
@@ -0,0 +1,36 @@
+//! An iterator iterating over all the custom variables and their values
+//! that have been specified.
+
+use super::RUN_METADATA_CUSTOM_VARIABLE;
+use crate::run_metadata_custom_variable::{
+    NullableRunMetadataCustomVariable, RunMetadataCustomVariable,
+};
+use livesplit_core::{indexmap, run::CustomVariable};
+use std::ptr;
+
+/// type
+pub type RunMetadataCustomVariablesIter = indexmap::map::Iter<'static, String, CustomVariable>;
+/// type
+pub type OwnedRunMetadataCustomVariablesIter = Box<RunMetadataCustomVariablesIter>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariablesIter_drop(this: OwnedRunMetadataCustomVariablesIter) {
+    drop(this);
+}
+
+/// Accesses the next custom variable. Returns <NULL> if there are no more
+/// variables.
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariablesIter_next(
+    this: &mut RunMetadataCustomVariablesIter,
+) -> *const NullableRunMetadataCustomVariable {
+    if let Some((name, value)) = this.next() {
+        RUN_METADATA_CUSTOM_VARIABLE.with(|output| {
+            output.set((name, value));
+            output.as_ptr() as *const RunMetadataCustomVariable
+        })
+    } else {
+        ptr::null()
+    }
+}
diff --git a/capi/src/run_metadata_speedrun_com_variable.rs b/capi/src/run_metadata_speedrun_com_variable.rs
index 8d0d5540..07e5ee32 100644
--- a/capi/src/run_metadata_speedrun_com_variable.rs
+++ b/capi/src/run_metadata_speedrun_com_variable.rs
@@ -1,4 +1,4 @@
-//! A Run Metadata variable is an arbitrary key value pair storing additional
+//! A speedrun.com variable is an arbitrary key value pair storing additional
 //! information about the category. An example of this may be whether Amiibos
 //! are used in the category.
 
@@ -18,7 +18,7 @@ pub extern "C" fn RunMetadataSpeedrunComVariable_drop(this: OwnedRunMetadataSpee
     drop(this);
 }
 
-/// Accesses the name of this Run Metadata variable.
+/// Accesses the name of this speedrun.com variable.
 #[no_mangle]
 pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_name(
     this: &RunMetadataSpeedrunComVariable,
@@ -26,7 +26,7 @@ pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_name(
     output_str(&*this.0)
 }
 
-/// Accesses the value of this Run Metadata variable.
+/// Accesses the value of this speedrun.com variable.
 #[no_mangle]
 pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_value(
     this: &RunMetadataSpeedrunComVariable,
diff --git a/capi/src/run_metadata_speedrun_com_variables_iter.rs b/capi/src/run_metadata_speedrun_com_variables_iter.rs
index e8a5dbee..12357f73 100644
--- a/capi/src/run_metadata_speedrun_com_variables_iter.rs
+++ b/capi/src/run_metadata_speedrun_com_variables_iter.rs
@@ -1,4 +1,4 @@
-//! An iterator iterating over all the Run Metadata variables and their values
+//! An iterator iterating over all the speedrun.com variables and their values
 //! that have been specified.
 
 use super::RUN_METADATA_SPEEDRUN_COM_VARIABLE;
@@ -21,7 +21,7 @@ pub extern "C" fn RunMetadataSpeedrunComVariablesIter_drop(
     drop(this);
 }
 
-/// Accesses the next Run Metadata variable. Returns <NULL> if there are no more
+/// Accesses the next speedrun.com variable. Returns <NULL> if there are no more
 /// variables.
 #[no_mangle]
 pub extern "C" fn RunMetadataSpeedrunComVariablesIter_next(
diff --git a/src/component/text/mod.rs b/src/component/text/mod.rs
index 9c3c5899..6c5f1b57 100644
--- a/src/component/text/mod.rs
+++ b/src/component/text/mod.rs
@@ -54,6 +54,9 @@ pub enum Text {
     /// A text that is split up into a left and right part. This is suitable for
     /// a situation where you have a label and a value.
     Split(String, String),
+    /// A custom variable with the name specified is supposed to be shown. The
+    /// boolean indicates whether the name should also be shown as a key value
+    /// pair.
     Variable(String, bool),
 }
 
diff --git a/src/run/editor/mod.rs b/src/run/editor/mod.rs
index 1a847ba9..e3c6a7ed 100644
--- a/src/run/editor/mod.rs
+++ b/src/run/editor/mod.rs
@@ -322,11 +322,11 @@ impl Editor {
         self.metadata_modified();
     }
 
-    /// Sets the variable with the name specified to the value specified. A
-    /// variable is an arbitrary key value pair storing additional information
-    /// about the category. An example of this may be whether Amiibos are used
-    /// in this category. If the variable doesn't exist yet, it is being
-    /// inserted.
+    /// Sets the speedrun.com variable with the name specified to the value
+    /// specified. A variable is an arbitrary key value pair storing additional
+    /// information about the category. An example of this may be whether
+    /// Amiibos are used in this category. If the variable doesn't exist yet, it
+    /// is being inserted.
     pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
@@ -338,7 +338,7 @@ impl Editor {
         self.metadata_modified();
     }
 
-    /// Removes the variable with the name specified.
+    /// Removes the speedrun.com variable with the name specified.
     pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
@@ -347,6 +347,10 @@ impl Editor {
         self.metadata_modified();
     }
 
+    /// Adds a new permanent custom variable. If there's a temporary variable
+    /// with the same name, it gets turned into a permanent variable and its
+    /// value stays. If a permanent variable with the name already exists,
+    /// nothing happens.
     pub fn add_custom_variable<N>(&mut self, name: N)
     where
         N: Into<String>,
@@ -358,6 +362,9 @@ impl Editor {
         self.raise_run_edited();
     }
 
+    /// Sets the value of a custom variable with the name specified. If the
+    /// custom variable does not exist, or is not a permanent variable, nothing
+    /// happens.
     pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
@@ -375,6 +382,9 @@ impl Editor {
         }
     }
 
+    /// Removes the custom variable with the name specified. If the custom
+    /// variable does not exist, or is not a permanent variable, nothing
+    /// happens.
     pub fn remove_custom_variable<N>(&mut self, name: N)
     where
         N: AsRef<str>,
diff --git a/src/run/editor/tests/mark_as_modified.rs b/src/run/editor/tests/mark_as_modified.rs
index aa47a5c2..9a1fbbd9 100644
--- a/src/run/editor/tests/mark_as_modified.rs
+++ b/src/run/editor/tests/mark_as_modified.rs
@@ -323,7 +323,7 @@ fn when_generating_goal_comparison() {
 #[test]
 fn when_creating_custom_variable() {
     let mut editor = base();
-    editor.set_custom_variable("Hello", "World");
+    editor.add_custom_variable("Hello");
     assert!(editor.run().has_been_modified());
 }
 
diff --git a/src/run/mod.rs b/src/run/mod.rs
index b0b1d894..e53c4025 100644
--- a/src/run/mod.rs
+++ b/src/run/mod.rs
@@ -30,7 +30,7 @@ mod tests;
 
 pub use attempt::Attempt;
 pub use editor::{Editor, RenameError};
-pub use run_metadata::RunMetadata;
+pub use run_metadata::{CustomVariable, RunMetadata};
 pub use segment::Segment;
 pub use segment_history::SegmentHistory;
 
diff --git a/src/run/run_metadata.rs b/src/run/run_metadata.rs
index 828a5171..98444500 100644
--- a/src/run/run_metadata.rs
+++ b/src/run/run_metadata.rs
@@ -2,8 +2,17 @@ use crate::indexmap::map::{IndexMap, Iter};
 use crate::platform::prelude::*;
 use serde::{Deserialize, Serialize};
 
+/// A custom variable is a key value pair storing additional information about a
+/// run. Unlike the speedrun.com variables, these can be fully custom and don't
+/// need to correspond to anything on speedrun.com. Permanent custom variables
+/// can be specified by the runner. Additionally auto splitters or other sources
+/// may provide temporary custom variables that are not stored in the splits
+/// files.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CustomVariable {
+    /// The current value of the custom variable. This may be provided by the
+    /// runner in the run editor or it may be provided through other means such
+    /// as an auto splitter.
     pub value: String,
     /// States whether the variable is permanent. Temporary variables don't get
     /// stored in splits files. They also don't get shown in the run editor.
@@ -11,10 +20,14 @@ pub struct CustomVariable {
 }
 
 impl CustomVariable {
+    /// Turns the custom variable into a permanent one. If it already is
+    /// permanent variable, nothing happens.
     pub fn permanent(&mut self) -> &mut Self {
         self.is_permanent = true;
         self
     }
+
+    /// Sets the value of the custom variable.
     pub fn set_value<S>(&mut self, value: S)
     where
         S: AsRef<str>,
@@ -22,6 +35,9 @@ impl CustomVariable {
         self.value.clear();
         self.value.push_str(value.as_ref());
     }
+
+    /// Clears the value of the custom variable. This does not delete the custom
+    /// variable.
     pub fn clear_value(&mut self) {
         self.value.clear();
     }
@@ -44,10 +60,18 @@ pub struct RunMetadata {
     /// The name of the region this game is from. This may be empty if it's not
     /// specified.
     pub region_name: String,
-    /// Stores all the speedrun.com variables. A variable is an arbitrary key
+    /// Stores all the speedrun.com variables. A speedrun.com variable is a key
     /// value pair storing additional information about the category. An example
-    /// of this may be whether Amiibos are used in this category.
+    /// of this may be whether Amiibos are used in this category. Use a custom
+    /// variable for storing arbitrary key value pairs that are independent of
+    /// speedrun.com.
     pub speedrun_com_variables: IndexMap<String, String>,
+    /// Stores all the custom variables. A custom variable is a key value pair
+    /// storing additional information about a run. Unlike the speedrun.com
+    /// variables, these can be fully custom and don't need to correspond to
+    /// anything on speedrun.com. Permanent custom variables can be specified by
+    /// the runner. Additionally auto splitters or other sources may provide
+    /// temporary custom variables that are not stored in the splits files.
     pub custom_variables: IndexMap<String, CustomVariable>,
 }
 
@@ -129,11 +153,11 @@ impl RunMetadata {
         self.region_name.push_str(region_name.as_ref());
     }
 
-    /// Sets the variable with the name specified to the value specified. A
-    /// variable is an arbitrary key value pair storing additional information
-    /// about the category. An example of this may be whether Amiibos are used
-    /// in this category. If the variable doesn't exist yet, it is being
-    /// inserted.
+    /// Sets the speedrun.com variable with the name specified to the value
+    /// specified. A speedrun.com variable is an arbitrary key value pair
+    /// storing additional information about the category. An example of this
+    /// may be whether Amiibos are used in this category. If the variable
+    /// doesn't exist yet, it is being inserted.
     pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
@@ -143,7 +167,7 @@ impl RunMetadata {
             .insert(name.into(), value.into());
     }
 
-    /// Removes the variable with the name specified.
+    /// Removes the speedrun.com variable with the name specified.
     pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
@@ -151,12 +175,13 @@ impl RunMetadata {
         self.speedrun_com_variables.shift_remove(name.as_ref());
     }
 
-    /// Returns an iterator iterating over all the variables and their values
-    /// that have been specified.
+    /// Returns an iterator iterating over all the speedrun.com variables and
+    /// their values that have been specified.
     pub fn speedrun_com_variables(&self) -> Iter<'_, String, String> {
         self.speedrun_com_variables.iter()
     }
 
+    /// Accesses the custom variable with the name specified if there is one.
     pub fn custom_variable<S>(&self, name: S) -> Option<&CustomVariable>
     where
         S: AsRef<str>,
@@ -164,6 +189,8 @@ impl RunMetadata {
         self.custom_variables.get(name.as_ref())
     }
 
+    /// Accesses the value of the custom variable with the name specified if
+    /// there is one.
     pub fn custom_variable_value<S>(&self, name: S) -> Option<&str>
     where
         S: AsRef<str>,
@@ -171,6 +198,8 @@ impl RunMetadata {
         Some(&self.custom_variable(name)?.value)
     }
 
+    /// Mutably accesses the custom variable with the name specified. If the
+    /// variable does not exist, it gets created as a temporary variable.
     pub fn custom_variable_mut<S>(&mut self, name: S) -> &mut CustomVariable
     where
         S: Into<String>,
@@ -178,6 +207,8 @@ impl RunMetadata {
         self.custom_variables.entry(name.into()).or_default()
     }
 
+    /// Removes the custom variable with the name specified. Nothing happens if
+    /// the variable does not exist.
     pub fn remove_custom_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
@@ -185,6 +216,8 @@ impl RunMetadata {
         self.custom_variables.shift_remove(name.as_ref());
     }
 
+    /// Returns an iterator iterating over all the custom variables and their
+    /// values. This includes both temporary and permanent variables.
     pub fn custom_variables(&self) -> Iter<'_, String, CustomVariable> {
         self.custom_variables.iter()
     }
diff --git a/src/run/tests/metadata.rs b/src/run/tests/metadata.rs
index 380057c2..44f78a4d 100644
--- a/src/run/tests/metadata.rs
+++ b/src/run/tests/metadata.rs
@@ -1,19 +1,23 @@
 use super::super::RunMetadata;
 
 #[test]
-fn removing_shifts_the_variables() {
+fn removing_shifts_the_speedrun_com_variables() {
     let mut data = RunMetadata::new();
-    data.set_variable("A", "A");
-    data.set_variable("B", "B");
-    data.set_variable("C", "C");
-    data.set_variable("D", "D");
+    data.set_speedrun_com_variable("A", "A");
+    data.set_speedrun_com_variable("B", "B");
+    data.set_speedrun_com_variable("C", "C");
+    data.set_speedrun_com_variable("D", "D");
     assert_eq!(
-        data.variables().map(|(k, _)| k).collect::<Vec<_>>(),
+        data.speedrun_com_variables()
+            .map(|(k, _)| k)
+            .collect::<Vec<_>>(),
         ["A", "B", "C", "D"]
     );
-    data.remove_variable("B");
+    data.remove_speedrun_com_variable("B");
     assert_eq!(
-        data.variables().map(|(k, _)| k).collect::<Vec<_>>(),
+        data.speedrun_com_variables()
+            .map(|(k, _)| k)
+            .collect::<Vec<_>>(),
         ["A", "C", "D"]
     );
 }
diff --git a/src/timing/timer/mod.rs b/src/timing/timer/mod.rs
index 9d7fc48a..3472241f 100644
--- a/src/timing/timer/mod.rs
+++ b/src/timing/timer/mod.rs
@@ -599,6 +599,9 @@ impl Timer {
         }
     }
 
+    /// Sets the value of a custom variable with the name specified. If the
+    /// variable does not exist, a temporary variable gets created that will not
+    /// be stored in the splits file.
     pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,

From aa8dd0bcf70810a2dab26285af0028916702e06b Mon Sep 17 00:00:00 2001
From: Christopher Serr <christopher.serr@gmail.com>
Date: Tue, 7 Jan 2020 00:55:20 +0100
Subject: [PATCH 3/3] Disable Rendering Tests on x86_64-unknown-linux-musl

This temporarily mitigates the floating point inconsistencies introduced
by switching to lyon 0.15.

cc #287
---
 src/rendering/software/mod.rs | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/rendering/software/mod.rs b/src/rendering/software/mod.rs
index cbecc502..be5b94f9 100644
--- a/src/rendering/software/mod.rs
+++ b/src/rendering/software/mod.rs
@@ -4,14 +4,26 @@
 
 #[cfg(all(
     test,
-
-    // Without MMX the floating point calculations don't follow IEEE 754. So the
-    // tests fail to produce the correct checksums.
-    // FIXME: We use SSE as an approximation for the cfg, because MMX isn't
-    // supported by Rust just yet.
-    not(all(
-        target_arch = "x86",
-        not(target_feature = "sse"),
+    not(any(
+        // Without MMX the floating point calculations don't follow IEEE 754. So the
+        // tests fail to produce the correct checksums.
+        // FIXME: We use SSE as an approximation for the cfg, because MMX isn't
+        // supported by Rust just yet.
+        all(
+            target_arch = "x86",
+            not(target_feature = "sse"),
+        ),
+        // Additionally the x86_64-unknown-linux-musl target seems to be failing
+        // with lyon 0.15. I'd assume it's because of musl's libm doing
+        // something different than the glibc one, but I'm honestly not sure.
+        // FIXME: We likely want a perceptual image hash instead, which would be
+        // much more robust.
+        // https://github.com/LiveSplit/livesplit-core/issues/287
+        all(
+            target_os = "linux",
+            target_arch = "x86_64",
+            target_env = "musl",
+        ),
     )),
 ))]
 mod tests;