Update CI Script

CryZe · CryZe · commit eb2a7ebb1f99 · 2017-06-11T15:55:19.000+02:00
diff --git a/ci/install.sh b/ci/install.sh
@@ -1,12 +1,9 @@
 set -ex
 
 main() {
-    curl https://sh.rustup.rs -sSf | \
-        sh -s -- -y --default-toolchain $TRAVIS_RUST_VERSION
-
     local target=
     if [ $TRAVIS_OS_NAME = linux ]; then
-        target=x86_64-unknown-linux-gnu
+        target=x86_64-unknown-linux-musl
         sort=sort
     else
         target=x86_64-apple-darwin
@@ -34,10 +31,10 @@ main() {
     # This fetches latest stable release
     local tag=$(git ls-remote --tags --refs --exit-code https://github.com/japaric/cross \
                        | cut -d/ -f3 \
-                       | grep -E '^v[0-9.]+$' \
+                       | grep -E '^v[0.1.0-9.]+$' \
                        | $sort --version-sort \
                        | tail -n1)
-    echo cross version: $tag
+
     curl -LSfs https://japaric.github.io/trust/install.sh | \
         sh -s -- \
            --force \
diff --git a/src/analysis/current_pace.rs b/src/analysis/current_pace.rs
@@ -11,13 +11,15 @@ pub fn calculate(timer: &Timer, comparison: &str) -> Option<TimeSpan> {
                                                  timer.current_split_index() as usize,
                                                  comparison,
                                                  timing_method)
-                    .unwrap_or_default();
+                .unwrap_or_default();
 
-            let live_delta =
-                TimeSpan::option_op(timer.current_time()[timing_method],
-                                    timer.current_split().unwrap().comparison(comparison)
-                                        [timing_method],
-                                    |a, b| a - b);
+            let live_delta = TimeSpan::option_op(timer.current_time()[timing_method],
+                                                 timer
+                                                     .current_split()
+                                                     .unwrap()
+                                                     .comparison(comparison)
+                                                     [timing_method],
+                                                 |a, b| a - b);
 
             if let Some(live_delta) = live_delta {
                 if live_delta > delta {
diff --git a/src/analysis/delta.rs b/src/analysis/delta.rs
@@ -14,11 +14,13 @@ pub fn calculate(timer: &Timer, comparison: &str) -> (Option<TimeSpan>, bool) {
                                                  comparison,
                                                  timing_method);
 
-            let live_delta =
-                TimeSpan::option_op(timer.current_time()[timing_method],
-                                    timer.current_split().unwrap().comparison(comparison)
-                                        [timing_method],
-                                    |a, b| a - b);
+            let live_delta = TimeSpan::option_op(timer.current_time()[timing_method],
+                                                 timer
+                                                     .current_split()
+                                                     .unwrap()
+                                                     .comparison(comparison)
+                                                     [timing_method],
+                                                 |a, b| a - b);
 
             if let Some(live_delta) = live_delta {
                 if live_delta > delta.unwrap_or_default() {
diff --git a/src/analysis/state_helper.rs b/src/analysis/state_helper.rs
@@ -47,12 +47,10 @@ fn segment_time_or_segment_delta(timer: &Timer,
             if let Some(split_time) = segment.split_time()[method] {
                 if segment_time {
                     return Some(current_time - split_time);
-                } else if let Some(comparison) =
-                    segment.comparison_timing_method(comparison, method) {
-                    return split_number_comparison.map(|s| {
-                                                           (current_time - s) -
-                                                           (split_time - comparison)
-                                                       });
+                } else if let Some(comparison) = segment
+                              .comparison_timing_method(comparison, method) {
+                    return split_number_comparison
+                        .map(|s| (current_time - s) - (split_time - comparison));
                 }
             }
         }
diff --git a/src/analysis/sum_of_segments/best.rs b/src/analysis/sum_of_segments/best.rs
@@ -18,10 +18,8 @@ fn populate_predictions(segments: &[Segment],
                         method: TimingMethod) {
     if let Some(current_time) = current_time {
         populate_prediction(&mut predictions[segment_index + 1],
-                            segments[segment_index].best_segment_time()[method].map(|t| {
-                                                                                        t +
-                                                                                        current_time
-                                                                                    }));
+                            segments[segment_index].best_segment_time()[method]
+                                .map(|t| t + current_time));
         if !simple_calculation {
             for &(null_segment_index, _) in
                 segments[segment_index]
diff --git a/src/analysis/sum_of_segments/mod.rs b/src/analysis/sum_of_segments/mod.rs
@@ -66,8 +66,9 @@ fn track_personal_best_run(segments: &[Segment],
     if let Some(first_split_time) =
         segment_index
             .checked_sub(1)
-            .map_or(Some(TimeSpan::zero()),
-                    |i| segments[i].personal_best_split_time()[method]) {
+            .map_or(Some(TimeSpan::zero()), |i| {
+                segments[i].personal_best_split_time()[method]
+            }) {
         for (segment_index, segment) in segments.iter().enumerate().skip(segment_index) {
             let second_split_time = segment.personal_best_split_time()[method];
             if let Some(second_split_time) = second_split_time {
diff --git a/src/analysis/sum_of_segments/worst.rs b/src/analysis/sum_of_segments/worst.rs
@@ -17,10 +17,8 @@ fn populate_predictions(segments: &[Segment],
                         method: TimingMethod) {
     if let Some(current_time) = current_time {
         populate_prediction(&mut predictions[segment_index + 1],
-                            segments[segment_index].best_segment_time()[method].map(|t| {
-                                                                                        t +
-                                                                                        current_time
-                                                                                    }));
+                            segments[segment_index].best_segment_time()[method]
+                                .map(|t| t + current_time));
         for &(segment_history_index, _) in segments[segment_index].segment_history().iter() {
             let should_track_branch =
                 segment_index
diff --git a/src/comparison/latest_run.rs b/src/comparison/latest_run.rs
@@ -20,10 +20,7 @@ fn generate(segments: &mut [Segment], method: TimingMethod) {
 
         let mut total_time = TimeSpan::zero();
         while let Some(segment) = remaining_segments.next() {
-            let segment_time = segment
-                .segment_history()
-                .get(attempt_id)
-                .map(|t| t[method]);
+            let segment_time = segment.segment_history().get(attempt_id).map(|t| t[method]);
 
             let split_time = match segment_time {
                 Some(Some(segment_time)) => {
diff --git a/src/component/possible_time_save.rs b/src/component/possible_time_save.rs
@@ -67,9 +67,10 @@ pub fn get_possible_time_save(timer: &Timer,
         }
     }
 
-    let mut time = TimeSpan::option_op(segment.comparison(comparison)[method],
-                                       best_segments,
-                                       |c, b| c - b - prev_time);
+    let mut time = TimeSpan::option_op(segment.comparison(comparison)[method], best_segments, |c,
+     b| {
+        c - b - prev_time
+    });
 
     if live && segment_index == timer.current_split_index() as usize {
         let segment_delta = analysis::live_segment_delta(timer, segment_index, comparison, method);
diff --git a/src/component/splits.rs b/src/component/splits.rs
@@ -142,10 +142,7 @@ impl Component {
                     };
 
                     SplitState {
-                        icon_change: segment
-                            .icon()
-                            .check_for_change(icon_id)
-                            .map(str::to_owned),
+                        icon_change: segment.icon().check_for_change(icon_id).map(str::to_owned),
                         name: segment.name().to_string(),
                         delta: delta,
                         time: Regular::new().format(time).to_string(),
diff --git a/src/component/timer.rs b/src/component/timer.rs
@@ -44,7 +44,7 @@ impl Component {
                                 false,
                                 current_comparison,
                                 method)
-                            .or(Color::AheadGainingTime)
+                        .or(Color::AheadGainingTime)
                 } else {
                     Color::AheadGainingTime
                 }
diff --git a/src/component/title.rs b/src/component/title.rs
@@ -35,8 +35,7 @@ impl Component {
                 .check_for_change(&mut self.icon_id)
                 .map(str::to_owned),
             game: run.game_name().to_string(),
-            category: run.extended_category_name(false, false, true)
-                .into_owned(),
+            category: run.extended_category_name(false, false, true).into_owned(),
             attempts: run.attempt_count(),
         }
     }
diff --git a/src/hotkey_system.rs b/src/hotkey_system.rs
@@ -32,12 +32,14 @@ impl HotkeySystem {
         hook.register(config.pause, move || { inner.write().pause(); })?;
 
         let inner = timer.clone();
-        hook.register(config.previous_comparison,
-                      move || { inner.write().switch_to_previous_comparison(); })?;
+        hook.register(config.previous_comparison, move || {
+            inner.write().switch_to_previous_comparison();
+        })?;
 
         let inner = timer.clone();
-        hook.register(config.next_comparison,
-                      move || { inner.write().switch_to_next_comparison(); })?;
+        hook.register(config.next_comparison, move || {
+            inner.write().switch_to_next_comparison();
+        })?;
 
         Ok(Self {
                config: config,
@@ -100,8 +102,9 @@ impl HotkeySystem {
         self.hook.unregister(self.config.previous_comparison)?;
         let inner = self.timer.clone();
         self.hook
-            .register(hotkey,
-                      move || { inner.write().switch_to_previous_comparison(); })?;
+            .register(hotkey, move || {
+                inner.write().switch_to_previous_comparison();
+            })?;
         self.config.previous_comparison = hotkey;
         Ok(())
     }
diff --git a/src/parser/face_split.rs b/src/parser/face_split.rs
@@ -52,10 +52,7 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
 
     run.set_category_name(lines.next().ok_or(Error::ExpectedTitle)??);
     lines.next(); // TODO Store Goal
-    run.set_attempt_count(lines
-                              .next()
-                              .ok_or(Error::ExpectedAttemptCount)??
-                              .parse()?);
+    run.set_attempt_count(lines.next().ok_or(Error::ExpectedAttemptCount)??.parse()?);
     lines.next(); // TODO Store runs completed somehow
 
     for line in lines {
diff --git a/src/parser/livesplit.rs b/src/parser/livesplit.rs
@@ -234,10 +234,7 @@ pub fn parse<R: Read>(source: R, path: Option<PathBuf>) -> Result<Run> {
         metadata.set_region_name(text(&child(&node, "Region")?, buf));
 
         let variables = child(&node, "Variables")?;
-        for variable in variables
-                .children()
-                .into_iter()
-                .filter_map(|c| c.element()) {
+        for variable in variables.children().into_iter().filter_map(|c| c.element()) {
             let name = attribute(&variable, "name")?;
             let value = text(&variable, buf);
             metadata.add_variable(name, value);
@@ -254,10 +251,7 @@ pub fn parse<R: Read>(source: R, path: Option<PathBuf>) -> Result<Run> {
 
     let segments = child(&node, "Segments")?;
 
-    for node in segments
-            .children()
-            .into_iter()
-            .filter_map(|c| c.element()) {
+    for node in segments.children().into_iter().filter_map(|c| c.element()) {
         let mut segment = Segment::new(text(&child(&node, "Name")?, buf));
         segment.set_icon(image(&child(&node, "Icon")?, icon_buf, buf));
 
@@ -291,10 +285,7 @@ pub fn parse<R: Read>(source: R, path: Option<PathBuf>) -> Result<Run> {
         }
 
         let history = child(&node, "SegmentHistory")?;
-        for node in history
-                .children()
-                .into_iter()
-                .filter_map(|c| c.element()) {
+        for node in history.children().into_iter().filter_map(|c| c.element()) {
             let index = attribute(&node, "id")?.parse()?;
             let time = if version >= Version(1, 4, 1, 0) {
                 time(&node, buf)?
diff --git a/src/parser/llanfair2.rs b/src/parser/llanfair2.rs
@@ -51,8 +51,7 @@ fn image<'b>(node: &Element,
     let node = child(&node, "javax.swing.ImageIcon")?;
 
     let default = child(&node, "default")?;
-    let height = text(&child(&default, "height")?, str_buf)
-        .parse::<u32>()?;
+    let height = text(&child(&default, "height")?, str_buf).parse::<u32>()?;
     let width = text(&child(&default, "width")?, str_buf).parse::<u32>()?;
 
     buf.clear();
@@ -115,10 +114,7 @@ pub fn parse<R: Read>(mut source: R) -> Result<Run> {
 
     let segments = child(&node, "segments")?;
 
-    for node in segments
-            .children()
-            .into_iter()
-            .filter_map(|c| c.element()) {
+    for node in segments.children().into_iter().filter_map(|c| c.element()) {
         let mut segment = Segment::new(child(&node, "name").ok().map_or("", |n| text(&n, buf)));
 
         if let Ok(image) = image(&node, &mut byte_buf, &mut byte_buf2, buf) {
diff --git a/src/parser/llanfair_gered.rs b/src/parser/llanfair_gered.rs
@@ -114,10 +114,7 @@ pub fn parse<R: Read>(mut source: R) -> Result<Run> {
 
     let mut total_time = TimeSpan::zero();
 
-    for node in segments
-            .children()
-            .into_iter()
-            .filter_map(|c| c.element()) {
+    for node in segments.children().into_iter().filter_map(|c| c.element()) {
         let node = child(&node, "Segment")?;
         let node = child(&node, "default")?;
 
diff --git a/src/parser/portal2_live_timer.rs b/src/parser/portal2_live_timer.rs
@@ -116,10 +116,7 @@ pub fn parse<R: BufRead>(source: R) -> Result<Run> {
             if map_name != map {
                 return Err(Error::ExpectedDifferentMapName);
             }
-            let start_ticks: f64 = splits
-                .next()
-                .ok_or(Error::ExpectedStartTicks)?
-                .parse()?;
+            let start_ticks: f64 = splits.next().ok_or(Error::ExpectedStartTicks)?.parse()?;
             let end_ticks: f64 = splits.next().ok_or(Error::ExpectedEndTicks)?.parse()?;
             let map_ticks = end_ticks - start_ticks;
             aggregate_ticks += map_ticks;
diff --git a/src/parser/shit_split.rs b/src/parser/shit_split.rs
@@ -37,10 +37,7 @@ pub fn parse<R: BufRead>(source: R) -> Result<Run> {
         return Err(Error::ExpectedCategoryName);
     }
     run.set_category_name(&category_name[1..]);
-    run.set_attempt_count(splits
-                              .next()
-                              .ok_or(Error::ExpectedAttemptCount)?
-                              .parse()?);
+    run.set_attempt_count(splits.next().ok_or(Error::ExpectedAttemptCount)?.parse()?);
     let mut total_time = TimeSpan::zero();
     let mut next_line = lines.next();
     while let Some(line) = next_line {
@@ -50,10 +47,7 @@ pub fn parse<R: BufRead>(source: R) -> Result<Run> {
         }
         let mut splits = line.split('|');
         let world_name = splits.next().ok_or(Error::ExpectedWorldName)?;
-        total_time += splits
-            .next()
-            .ok_or(Error::ExpectedWorldTime)?
-            .parse()?;
+        total_time += splits.next().ok_or(Error::ExpectedWorldTime)?.parse()?;
         next_line = lines.next();
         let mut has_acts = false;
         while let Some(line) = next_line {
diff --git a/src/parser/splitterz.rs b/src/parser/splitterz.rs
@@ -45,10 +45,7 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
     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
-                              .next()
-                              .ok_or(Error::ExpectedAttemptCount)?
-                              .parse()?);
+    run.set_attempt_count(splits.next().ok_or(Error::ExpectedAttemptCount)?.parse()?);
 
     for line in lines {
         let line = line?;
@@ -58,18 +55,12 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
             let mut segment =
                 Segment::new(unescape(splits.next().ok_or(Error::ExpectedSplitName)?));
 
-            let time: TimeSpan = splits
-                .next()
-                .ok_or(Error::ExpectedSplitTime)?
-                .parse()?;
+            let time: TimeSpan = splits.next().ok_or(Error::ExpectedSplitTime)?.parse()?;
             if time != TimeSpan::zero() {
                 segment.set_personal_best_split_time(Time::new().with_real_time(Some(time)));
             }
 
-            let time: TimeSpan = splits
-                .next()
-                .ok_or(Error::ExpectedBestSegment)?
-                .parse()?;
+            let time: TimeSpan = splits.next().ok_or(Error::ExpectedBestSegment)?.parse()?;
             if time != TimeSpan::zero() {
                 segment.set_best_segment_time(Time::new().with_real_time(Some(time)));
             }
diff --git a/src/parser/time_split_tracker.rs b/src/parser/time_split_tracker.rs
@@ -50,10 +50,7 @@ pub fn parse<R: BufRead>(source: R, path_for_loading_other_files: Option<PathBuf
 
     let line = lines.next().ok_or(Error::Empty)??;
     let mut splits = line.split('\t');
-    run.set_attempt_count(splits
-                              .next()
-                              .ok_or(Error::ExpectedAttemptCount)?
-                              .parse()?);
+    run.set_attempt_count(splits.next().ok_or(Error::ExpectedAttemptCount)?.parse()?);
     run.set_offset(splits.next().ok_or(Error::ExpectedOffset)?.parse()?);
     if let (&Some(ref path), Some(file)) = (&path, splits.next()) {
         let path = path.with_file_name(file);
@@ -153,9 +150,7 @@ fn parse_history(run: &mut Run, path: Option<PathBuf>) -> StdResult<(), ()> {
 
             let mut last_split = TimeSpan::zero();
             for (segment, current_split) in
-                run.segments_mut()
-                    .iter_mut()
-                    .zip(split_times.into_iter()) {
+                run.segments_mut().iter_mut().zip(split_times.into_iter()) {
 
                 let mut segment_time = Time::default();
                 if let Some(current_split) = current_split {
diff --git a/src/run.rs b/src/run.rs
diff --git a/src/run_editor/mod.rs b/src/run_editor/mod.rs
diff --git a/src/run_editor/segment_row.rs b/src/run_editor/segment_row.rs
diff --git a/src/timer.rs b/src/timer.rs

Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,10 @@ fn segment_time_or_segment_delta(timer: &Timer,`
`47`	`47`	`if let Some(split_time) = segment.split_time()[method] {`
`48`	`48`	`if segment_time {`
`49`	`49`	`return Some(current_time - split_time);`
`50`		`- } else if let Some(comparison) =`
`51`		`- segment.comparison_timing_method(comparison, method) {`
`52`		`- return split_number_comparison.map(\|s\| {`
`53`		`- (current_time - s) -`
`54`		`- (split_time - comparison)`
`55`		`- });`
	`50`	`+ } else if let Some(comparison) = segment`
	`51`	`+ .comparison_timing_method(comparison, method) {`
	`52`	`+ return split_number_comparison`
	`53`	`+ .map(\|s\| (current_time - s) - (split_time - comparison));`
`56`	`54`	`}`
`57`	`55`	`}`
`58`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,9 +67,10 @@ pub fn get_possible_time_save(timer: &Timer,`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- let mut time = TimeSpan::option_op(segment.comparison(comparison)[method],`
`71`		`- best_segments,`
`72`		`- \|c, b\| c - b - prev_time);`
	`70`	`+ let mut time = TimeSpan::option_op(segment.comparison(comparison)[method], best_segments, \|c,`
	`71`	`+ b\| {`
	`72`	`+ c - b - prev_time`
	`73`	`+ });`
`73`	`74`
`74`	`75`	`if live && segment_index == timer.current_split_index() as usize {`
`75`	`76`	`let segment_delta = analysis::live_segment_delta(timer, segment_index, comparison, method);`