Setup sentence skeleton

Author: tomcumming

src/lib.rs

@@ -67,10 +67,12 @@ pub use grapheme::{Graphemes, GraphemeIndices};
 pub use grapheme::{GraphemeCursor, GraphemeIncomplete};
 pub use tables::UNICODE_VERSION;
 pub use word::{UWordBounds, UWordBoundIndices, UnicodeWords};
+pub use sentence::{USentenceBounds};
 
 mod grapheme;
 mod tables;
 mod word;
+mod sentence;
 
 #[cfg(test)]
 mod test;
@@ -174,6 +176,9 @@ pub trait UnicodeSegmentation {
     /// assert_eq!(&swi1[..], b);
     /// ```
     fn split_word_bound_indices<'a>(&'a self) -> UWordBoundIndices<'a>;
+
+    /// TODO
+    fn split_sentence_bounds<'a>(&'a self) -> USentenceBounds<'a>;
 }
 
 impl UnicodeSegmentation for str {
@@ -201,4 +206,9 @@ impl UnicodeSegmentation for str {
     fn split_word_bound_indices(&self) -> UWordBoundIndices {
         word::new_word_bound_indices(self)
     }
+
+    #[inline]
+    fn split_sentence_bounds(&self) -> USentenceBounds {
+        sentence::new_sentence_bounds(self)
+    }
 }

src/sentence.rs

@@ -0,0 +1,41 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::cmp;
+use core::iter::Filter;
+
+use tables::sentence::SentenceCat;
+
+/// TODO
+#[derive(Clone)]
+pub struct USentenceBounds<'a> {
+    string: &'a str
+    // state?
+}
+
+impl<'a> Iterator for USentenceBounds<'a> {
+    type Item = &'a str;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let slen = self.string.len();
+        (cmp::min(slen, 1), Some(slen))
+    }
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a str> {
+        panic!("todo")
+    }
+}
+
+#[inline]
+pub fn new_sentence_bounds<'b>(s: &'b str) -> USentenceBounds<'b> {
+    USentenceBounds { string: s }
+}

src/test.rs

@@ -141,6 +141,52 @@ fn test_words() {
     }
 }
 
+
+#[test]
+fn test_sentences() {
+    use testdata::TEST_SENTENCE;
+
+    for &(s, w) in TEST_SENTENCE.iter() {
+        macro_rules! assert_ {
+            ($test:expr, $exp:expr, $name:expr) => {
+                // collect into vector for better diagnostics in failure case
+                let testing = $test.collect::<Vec<_>>();
+                let expected = $exp.collect::<Vec<_>>();
+                assert_eq!(testing, expected, "{} test for testcase ({:?}, {:?}) failed.", $name, s, w)
+            }
+        }
+        // test forward iterator
+        assert_!(s.split_sentence_bounds(),
+                w.iter().cloned(),
+                "Forward sentence boundaries");
+
+/*
+        // test reverse iterator
+        assert_!(s.split_sentence_bounds().rev(),
+                w.iter().rev().cloned(),
+                "Reverse sentence boundaries");
+
+        // generate offsets from sentence string lengths
+        let mut indices = vec![0];
+        for i in w.iter().cloned().map(|s| s.len()).scan(0, |t, n| { *t += n; Some(*t) }) {
+            indices.push(i);
+        }
+        indices.pop();
+        let indices = indices;
+
+        // test forward indices iterator
+        assert_!(s.split_sentence_bound_indices().map(|(l,_)| l),
+                 indices.iter().cloned(),
+                 "Forward sentence indices");
+
+        // test backward indices iterator
+        assert_!(s.split_sentence_bound_indices().rev().map(|(l,_)| l),
+                 indices.iter().rev().cloned(),
+                 "Reverse sentence indices");
+*/
+    }
+}
+
 quickcheck! {
     fn quickcheck_forward_reverse_graphemes_extended(s: String) -> bool {
         let a = s.graphemes(true).collect::<Vec<_>>();
@@ -173,4 +219,17 @@ quickcheck! {
         let a = s.split_word_bounds().collect::<String>();
         a == s
     }
+/*
+    fn quickcheck_forward_reverse_sentences(s: String) -> bool {
+        let a = s.split_sentence_bounds().collect::<Vec<_>>();
+        let mut b = s.split_sentence_bounds().rev().collect::<Vec<_>>();
+        b.reverse();
+        a == b
+    }
+
+    fn quickcheck_join_sentences(s: String) -> bool {
+        let a = s.split_sentence_bounds().collect::<String>();
+        a == s
+    }
+*/
 }