Move to stable

README.md

@@ -23,8 +23,6 @@ to compile anywhere, and this is as good a way as any to try and learn it.
 Build Instructions
 ------------------
 
-NOTE: This currently requires the most current nightly build.
-
 To simply build all available utilities:
 ```
 make

src/fmt/fmt.rs

@@ -1,5 +1,4 @@
 #![crate_name = "uu_fmt"]
-#![feature(str_char, unicode)]
 
 /*
  * This file is part of `fmt` from the uutils coreutils package.
@@ -11,7 +10,6 @@
  */
 
 extern crate getopts;
-extern crate rustc_unicode;
 extern crate unicode_width;
 
 #[macro_use]

src/fmt/parasplit.rs

@@ -10,7 +10,6 @@
 use std::iter::Peekable;
 use std::io::{BufRead, Lines};
 use std::slice::Iter;
-use std::str::CharRange;
 use unicode_width::UnicodeWidthChar;
 use FileOrStdReader;
 use FmtOptions;
@@ -100,11 +99,13 @@ impl<'a> FileLines<'a> {
 
         if !exact {
             // we do it this way rather than byte indexing to support unicode whitespace chars
-            let mut i = 0;
-            while (i < line.len()) && line.char_at(i).is_whitespace() {
-                i = match line.char_range_at(i) { CharRange { next: nxi, .. } => nxi };
-                if line[i..].starts_with(pfx) {
-                    return (true, i);
+            for (i, char) in line.char_indices() {
+                if char.is_whitespace() {
+                    if line[i..].starts_with(pfx) {
+                        return (true, i);
+                    }
+                } else {
+                    break;
                 }
             }
         }
@@ -544,8 +545,9 @@ impl<'a> Iterator for WordSplit<'a> {
         let is_start_of_sentence = self.prev_punct && (before_tab.is_some() || word_start_relative > 1);
 
         // now record whether this word ends in punctuation
-        self.prev_punct = match self.string.char_range_at_reverse(self.position) {
-            CharRange { ch, .. } => WordSplit::is_punctuation(ch)
+        self.prev_punct = match self.string[..self.position].chars().rev().next() {
+            Some(ch) => WordSplit::is_punctuation(ch),
+            _ => panic!("fatal: expected word not to be empty")
         };
 
         let (word, word_start_relative, before_tab, after_tab) =

src/tr/tr.rs

@@ -1,5 +1,4 @@
 #![crate_name = "uu_tr"]
-#![feature(io)]
 
 /*
  * This file is part of the uutils coreutils package.
@@ -21,7 +20,7 @@ extern crate uucore;
 
 use bit_set::BitSet;
 use getopts::Options;
-use std::io::{stdin, stdout, BufReader, Read, Write};
+use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
 use vec_map::VecMap;
 
 use expand::ExpandSet;
@@ -49,25 +48,22 @@ fn delete(set: ExpandSet, complement: bool) {
         }
     };
 
-    for c in BufReader::new(stdin()).chars() {
-        match c {
-            Ok(c) if is_allowed(c) => buf.push(c),
-            Ok(_) => (),
-            Err(err) => panic!("{}", err),
-        };
-        if buf.len() >= BUFFER_LEN {
-            safe_unwrap!(stdout.write_all(&buf[..].as_bytes()));
-        }
-    }
-    if !buf.is_empty() {
-        safe_unwrap!(stdout.write_all(&buf[..].as_bytes()));
-        pipe_flush!();
+    let mut reader = BufReader::new(stdin());
+
+    while let Ok(length) = reader.read_to_string(&mut buf) {
+        if length == 0 { break }
+
+        let filtered = buf.chars()
+                          .filter(|c| { is_allowed(*c) })
+                          .collect::<String>();
+        safe_unwrap!(stdout.write_all(filtered.as_bytes()));
+        buf.clear();
     }
 }
 
 fn tr<'a>(set1: ExpandSet<'a>, mut set2: ExpandSet<'a>) {
     let mut map = VecMap::new();
-    let mut stdout = stdout();
+    let stdout = stdout();
     let mut buf = String::with_capacity(BUFFER_LEN + 4);
 
     let mut s2_prev = '_';
@@ -77,27 +73,25 @@ fn tr<'a>(set1: ExpandSet<'a>, mut set2: ExpandSet<'a>) {
         map.insert(i as usize, s2_prev);
     }
 
-    for c in BufReader::new(stdin()).chars() {
-        match c {
-            Ok(inc) => {
-                let trc = match map.get(&(inc as usize)) {
+    let mut reader = BufReader::new(stdin());
+    let mut writer = BufWriter::new(stdout);
+
+    while let Ok(length) = reader.read_to_string(&mut buf) {
+        if length == 0 { break }
+
+        {
+            let mut chars = buf.chars();
+
+            while let Some(char) = chars.next() {
+                let trc = match map.get(&(char as usize)) {
                     Some(t) => *t,
-                    None => inc,
+                    None => char,
                 };
-                buf.push(trc);
-                if buf.len() >= BUFFER_LEN {
-                    safe_unwrap!(stdout.write_all(&buf[..].as_bytes()));
-                    buf.truncate(0);
-                }
-            }
-            Err(err) => {
-                panic!("{}", err);
+                safe_unwrap!(writer.write_all(format!("{}", trc).as_ref()));
             }
         }
-    }
-    if !buf.is_empty() {
-        safe_unwrap!(stdout.write_all(&buf[..].as_bytes()));
-        pipe_flush!();
+
+        buf.clear();
     }
 }