rustup

README.md

@@ -41,7 +41,7 @@ Don't like tuples? That's fine. Use a struct instead:
 
 ```rust
 extern crate csv;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 
 #[derive(RustcDecodable)]
 struct Record {

examples/nfl_plays.rs

@@ -1,5 +1,5 @@
 extern crate csv;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 
 #[allow(dead_code)]
 #[derive(RustcDecodable)]

examples/rational_numbers.rs

@@ -5,7 +5,7 @@
 
 extern crate csv;
 extern crate regex;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 
 use std::str;
 

examples/simple_missing.rs

@@ -1,5 +1,5 @@
 extern crate csv;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 
 #[derive(RustcDecodable)]
 struct Record {

examples/simple_struct.rs

@@ -1,5 +1,5 @@
 extern crate csv;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 
 #[derive(RustcDecodable)]
 struct Record {

src/bytestr.rs

@@ -132,31 +132,31 @@ impl ops::Deref for ByteString {
 impl ops::Index<ops::RangeFull> for ByteString {
  type Output = [u8];
 
- fn index<'a>(&'a self, _: &ops::RangeFull) -> &'a [u8] {
+ fn index<'a>(&'a self, _: ops::RangeFull) -> &'a [u8] {
  &**self
  }
 }
 
 impl ops::Index<ops::RangeFrom<usize>> for ByteString {
  type Output = [u8];
 
- fn index<'a>(&'a self, index: &ops::RangeFrom<usize>) -> &'a [u8] {
+ fn index<'a>(&'a self, index: ops::RangeFrom<usize>) -> &'a [u8] {
  &(&**self)[index.start..]
  }
 }
 
 impl ops::Index<ops::RangeTo<usize>> for ByteString {
  type Output = [u8];
 
- fn index<'a>(&'a self, index: &ops::RangeTo<usize>) -> &'a [u8] {
+ fn index<'a>(&'a self, index: ops::RangeTo<usize>) -> &'a [u8] {
  &(&**self)[..index.end]
  }
 }
 
 impl ops::Index<ops::Range<usize>> for ByteString {
  type Output = [u8];
 
- fn index<'a>(&'a self, index: &ops::Range<usize>) -> &'a [u8] {
+ fn index<'a>(&'a self, index: ops::Range<usize>) -> &'a [u8] {
  &(&**self)[index.start..index.end]
  }
 }

src/encoder.rs

@@ -69,7 +69,7 @@ impl serialize::Encoder for Encoded {
  }
  fn emit_char(&mut self, v: char) -> Result<()> {
  let mut bytes = [0u8; 4];
- let n = v.encode_utf8(bytes.as_mut_slice()).unwrap_or(0);
+ let n = v.encode_utf8(&mut bytes).unwrap_or(0);
  self.push_bytes(&bytes[..n])
  }
  fn emit_str(&mut self, v: &str) -> Result<()> {

src/lib.rs

@@ -179,10 +179,10 @@
 #![deny(missing_docs)]
 
 #![cfg_attr(test, feature(test))]
-#![feature(core, io, std_misc, unicode)]
+#![feature(convert, core, io, into_cow, std_misc, unicode)]
 
 extern crate byteorder;
-extern crate "rustc-serialize" as rustc_serialize;
+extern crate rustc_serialize;
 #[cfg(test)] extern crate test;
 
 use std::error::Error as StdError;

src/reader.rs

@@ -1,7 +1,7 @@
 use std::borrow::IntoCow;
 use std::fs;
 use std::io::{self, BufRead};
-use std::path::AsPath;
+use std::path::Path;
 
 use rustc_serialize::Decodable;
 
@@ -166,7 +166,7 @@ impl<R: io::Read> Reader<R> {
 
 impl Reader<fs::File> {
  /// Creates a new CSV reader for the data at the file path given.
- pub fn from_file<P: AsPath>(path: P) -> Result<Reader<fs::File>> {
+ pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Reader<fs::File>> {
  Ok(Reader::from_reader(try!(fs::File::open(path))))
  }
 }
@@ -205,7 +205,7 @@ impl<R: io::Read> Reader<R> {
  /// currently, the *names* of the struct members are irrelevant.)
  ///
  /// ```rust
- /// extern crate "rustc-serialize" as rustc_serialize;
+ /// extern crate rustc_serialize;
  /// # extern crate csv;
  /// # fn main() {
  ///
@@ -231,7 +231,7 @@ impl<R: io::Read> Reader<R> {
  /// valid data in every record (whether it be empty or malformed).
  ///
  /// ```rust
- /// extern crate "rustc-serialize" as rustc_serialize;
+ /// extern crate rustc_serialize;
  /// # extern crate csv;
  /// # fn main() {
  ///
@@ -264,7 +264,7 @@ impl<R: io::Read> Reader<R> {
  /// "tail" of another tuple/struct/`Vec` to capture all remaining fields:
  ///
  /// ```rust
- /// extern crate "rustc-serialize" as rustc_serialize;
+ /// extern crate rustc_serialize;
  /// # extern crate csv;
  /// # fn main() {
  ///

src/tests.rs

@@ -5,14 +5,15 @@ use {
  RecordTerminator, QuoteStyle,
 };
 
-fn assert_svec_eq<S: Str, T: Str>(got: Vec<Vec<S>>, expected: Vec<Vec<T>>) {
+fn assert_svec_eq<S, T>(got: Vec<Vec<S>>, expected: Vec<Vec<T>>)
+ where S: AsRef<str>, T: AsRef<str> {
  let got: Vec<Vec<&str>> =
  got.iter().map(|row| {
- row.iter().map(|f| f.as_slice()).collect()
+ row.iter().map(|f| f.as_ref()).collect()
  }).collect();
  let expected: Vec<Vec<&str>> =
  expected.iter().map(|row| {
- row.iter().map(|f| f.as_slice()).collect()
+ row.iter().map(|f| f.as_ref()).collect()
  }).collect();
 
  println!("got len: {}, expected len: {}", got.len(), expected.len());

src/writer.rs

@@ -2,7 +2,7 @@ use std::borrow::IntoCow;
 use std::error::FromError;
 use std::fs;
 use std::io::{self, Write};
-use std::path::AsPath;
+use std::path::Path;
 use std::str;
 
 use rustc_serialize::Encodable;
@@ -83,7 +83,7 @@ impl Writer<fs::File> {
  ///
  /// The file is created if it does not already exist and is truncated
  /// otherwise.
- pub fn from_file<P: AsPath>(path: P) -> Result<Writer<fs::File>> {
+ pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Writer<fs::File>> {
  Ok(Writer::from_writer(try!(fs::File::create(path))))
  }
 }
@@ -163,7 +163,7 @@ impl<W: io::Write> Writer<W> {
  /// edit distances computed.
  ///
  /// ```rust
- /// extern crate "rustc-serialize" as rustc_serialize;
+ /// extern crate rustc_serialize;
  /// # extern crate csv;
  /// # fn main() {
  ///