Merge pull request #3 from emig/update-1.9.0

feat: update to rust 1.9.0

Author: skade

Cargo.lock

@@ -12,6 +12,11 @@ name = "sl"
 
 name = "sl"
 
+[dependencies]
+
+getopts = "0.2.14"
+libc = "0.2"
+
 [dependencies.ncurses]
 
 git = "https://github.com/jeaye/ncurses-rs.git"

Cargo.toml

@@ -3,119 +3,119 @@ extern crate libc;
 extern crate ncurses;
 extern crate getopts;
 
-use getopts::{optflag,getopts};
-use std::os;
+use getopts::Options;
+use std::env;
 
-use sl::{Train};
+use sl::Train;
 use sl::d51::SL;
 use sl::c51::C51;
 use sl::logo::Logo;
 
-trait Render : Train + Copy {
-  fn render(&self, x: i32) {
-    let mut len = 0 as i32;
-    let y = ncurses::LINES / 2;
-    let body_iter = self.body().iter();
-    let wheelset_iter = self.wheelset(x as uint).iter();
-    let iter = body_iter.chain(wheelset_iter);
-    let (_, hint) = iter.size_hint();
-    let height = match hint {
-      Some(s) => s,
-      None => panic!("this really shouldn't happen")
-    };
-    let offset = (height / 2) as i32;
-    for (index, line) in iter.rev().enumerate() {
-      if line.len() as i32 > len {
-        len = line.len() as i32;
-      }
-      self.render_line((y + offset) - index as i32, x, *line);
-    }
-    if let Some(tender) = self.tender() {
-      let mut new_len = 0 as i32;
-      for (index, line) in tender.iter().rev().enumerate() {
-        if len + line.len() as i32 > new_len {
-          new_len = len + line.len() as i32;
+trait Render: Train + Copy {
+    fn render(&self, x: i32) {
+        let mut len = 0 as i32;
+        let y = ncurses::LINES / 2;
+        let body_iter = self.body().iter();
+        let wheelset_iter = self.wheelset(x as usize).iter();
+        let iter = body_iter.chain(wheelset_iter);
+        let (_, hint) = iter.size_hint();
+        let height = match hint {
+            Some(s) => s,
+            None => panic!("this really shouldn't happen"),
+        };
+        let offset = (height / 2) as i32;
+        for (index, line) in iter.rev().enumerate() {
+            if line.len() as i32 > len {
+                len = line.len() as i32;
+            }
+            self.render_line((y + offset) - index as i32, x, *line);
         }
-        self.render_line((y + offset) - index as i32, x + len, *line);
-      }
-      len = new_len;
-    }
-    if let Some(wagon) = self.wagon() {
-      for _ in range(0,self.wagons()) {
-        let mut new_len = 0 as i32;
-        for (index, line) in wagon.iter().rev().enumerate() {
-          if len + line.len() as i32 > new_len {
-            new_len = len + line.len() as i32;
-          }
-          self.render_line((y + offset) - index as i32, x + len, *line);
+        if let Some(tender) = self.tender() {
+            let mut new_len = 0 as i32;
+            for (index, line) in tender.iter().rev().enumerate() {
+                if len + line.len() as i32 > new_len {
+                    new_len = len + line.len() as i32;
+                }
+                self.render_line((y + offset) - index as i32, x + len, *line);
+            }
+            len = new_len;
+        }
+        if let Some(wagon) = self.wagon() {
+            for _ in 0..self.wagons() {
+                let mut new_len = 0 as i32;
+                for (index, line) in wagon.iter().rev().enumerate() {
+                    if len + line.len() as i32 > new_len {
+                        new_len = len + line.len() as i32;
+                    }
+                    self.render_line((y + offset) - index as i32, x + len, *line);
+                }
+                len = new_len;
+            }
         }
-        len = new_len;
-      }
     }
-  }
 
-  fn render_line(&self, y: i32, x: i32, line: &str) {
-    let paint_len = (ncurses::COLS - x) as uint;
-    if paint_len < line.len() {
-      ncurses::mvaddstr(y, x, &line[0..paint_len]);
-    } else if x < 0 {
-      if -x < line.len() as i32 {
-        ncurses::mvaddstr(y, 0, &line[-x as uint..line.len()]);
-      }
-    } else {
-      ncurses::mvaddstr(y, x, line);
+    fn render_line(&self, y: i32, x: i32, line: &str) {
+        let paint_len = (ncurses::COLS - x) as usize;
+        if paint_len < line.len() {
+            ncurses::mvaddstr(y, x, &line[0..paint_len]);
+        } else if x < 0 {
+            if -x < line.len() as i32 {
+                ncurses::mvaddstr(y, 0, &line[-x as usize..line.len()]);
+            }
+        } else {
+            ncurses::mvaddstr(y, x, line);
+        }
     }
-  }
 }
 
-impl Render for SL { }
-impl Render for C51 { }
-impl Render for Logo { }
+impl Render for SL {}
+impl Render for C51 {}
+impl Render for Logo {}
 
 fn main() {
-  use libc::funcs::posix01::signal::signal;
-  use libc::funcs::posix88::unistd::usleep;
-  use libc::SIGINT;
-  use libc::consts::os::posix01::SIG_IGN;
-
-  let args: Vec<String> = os::args();
+    use libc::signal;
+    use libc::usleep;
+    use libc::SIGINT;
+    use libc::SIG_IGN;
 
-  let opts = [
-    optflag("l", "", "logo"),
-    optflag("c", "", "C51"),
-    optflag("a", "", "reserved for future use"),
-    optflag("f", "", "reserved for future use"),
-  ];
+    let args: Vec<String> = env::args().collect();
 
-  let matches = match getopts(args.tail(), &opts) {
-    Ok(m) => { m }
-    Err(f) => { panic!(f.to_string()) }
-  };
-
-  let train: Box<Render> = if matches.opt_present("l") {
-                             Box::new(Logo)
-                           } else if matches.opt_present("c") {
-                             Box::new(C51)
-                           } else {
-                             Box::new(SL)
-                           };
+    let mut opts = Options::new();
+    opts.optflag("l", "", "logo");
+    opts.optflag("c", "", "C51");
+    opts.optflag("a", "", "reserved for future use");
+    opts.optflag("f", "", "reserved for future use");
 
+    let matches = match opts.parse(&args[1..]) {
+        Ok(m) => m,
+        Err(f) => panic!(f.to_string()),
+    };
 
-  ncurses::initscr();
-  unsafe { signal(SIGINT, SIG_IGN); }
+    ncurses::initscr();
+    unsafe {
+        signal(SIGINT, SIG_IGN);
+    }
 
-  ncurses::noecho();
-  ncurses::curs_set(ncurses::CURSOR_VISIBILITY::CURSOR_INVISIBLE);
-  ncurses::nodelay(ncurses::stdscr, true);
-  ncurses::leaveok(ncurses::stdscr, true);
-  ncurses::scrollok(ncurses::stdscr, false);
+    ncurses::noecho();
+    ncurses::curs_set(ncurses::CURSOR_VISIBILITY::CURSOR_INVISIBLE);
+    ncurses::nodelay(ncurses::stdscr, true);
+    ncurses::leaveok(ncurses::stdscr, true);
+    ncurses::scrollok(ncurses::stdscr, false);
 
-  for x in range(-85, ncurses::COLS).rev() {
-    ncurses::clear();
-    train.render(x);
-    ncurses::getch();
-    ncurses::refresh();
-    unsafe { usleep(40000); }
-  }
-  ncurses::endwin();
+    for x in (-85..ncurses::COLS).rev() {
+        ncurses::clear();
+        if matches.opt_present("l") {
+            Logo.render(x)
+        } else if matches.opt_present("c") {
+            C51.render(x)
+        } else {
+            SL.render(x)
+        };
+        ncurses::getch();
+        ncurses::refresh();
+        unsafe {
+            usleep(40000);
+        }
+    }
+    ncurses::endwin();
 }

src/bin/sl.rs

@@ -1,19 +1,19 @@
 use super::Train;
 use super::data::{C51WHL, C51BODY, COAL};
 
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct C51;
 
 impl Train for C51 {
-  fn body(&self) -> &'static [&'static str] {
-    &C51BODY
-  }
+    fn body(&self) -> &'static [&'static str] {
+        &C51BODY
+    }
 
-  fn wheelset(&self, x: uint) -> &'static [&'static str] {
-    &C51WHL[x % 6]
-  }
+    fn wheelset(&self, x: usize) -> &'static [&'static str] {
+        &C51WHL[(x % 6)]
+    }
 
-  fn tender(&self) -> Option<&'static [&'static str]> {
-    Some(COAL.as_slice())
-  }
+    fn tender(&self) -> Option<&'static [&'static str]> {
+        Some(&COAL)
+    }
 }

src/c51.rs

@@ -1,20 +1,19 @@
 use super::Train;
 use super::data::{D51BODY, D51WHL, COAL};
 
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct SL;
 
 impl Train for SL {
-  fn body(&self) -> &'static [&'static str] {
-    &D51BODY
-  }
+    fn body(&self) -> &'static [&'static str] {
+        &D51BODY
+    }
 
-  fn wheelset(&self, x: uint) -> &'static [&'static str] {
-    &D51WHL[x % 6]
-  }
+    fn wheelset(&self, x: usize) -> &'static [&'static str] {
+        &D51WHL[(x % 6)]
+    }
 
-  fn tender(&self) -> Option<&'static [&'static str]> {
-    Some(COAL.as_slice())
-  }
+    fn tender(&self) -> Option<&'static [&'static str]> {
+        Some(&COAL)
+    }
 }
-