array_tool 1.0.3

Helper methods for processing collections
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

extern crate array_tool;

#[test]
fn it_squeezes_characters() {
  use array_tool::string::Squeeze;

  assert_eq!("yellow moon".squeeze(""), "yelow mon");
  assert_eq!("  now   is  the".squeeze(" "), " now is the");
  assert_eq!("ééé".squeeze(""), "é");
  assert_eq!("  ///  aa".squeeze("/"), "  /  aa");

  let string: String = format!("yellow moon");
  assert_eq!(string.squeeze(""), "yelow mon");

  assert_eq!("".squeeze(""), "");
}

#[test]
fn it_iterates_over_every_grapheme_character() {
  use array_tool::string::ToGraphemeBytesIter;

  let temp = "a s—d féZ";
  let mut giter = temp.grapheme_bytes_iter();

  assert_eq!(giter.next().unwrap(), "a".as_bytes());
  assert_eq!(giter.next().unwrap(), " ".as_bytes());
  assert_eq!(giter.next().unwrap(), "s".as_bytes());
  assert_eq!(giter.next().unwrap(), "—".as_bytes());
  assert_eq!(giter.next().unwrap(), "d".as_bytes());
  assert_eq!(giter.next().unwrap(), " ".as_bytes());
  assert_eq!(giter.next().unwrap(), "f".as_bytes());
  assert_eq!(giter.next().unwrap(), "é".as_bytes());
  assert_eq!(giter.next().unwrap(), "Z".as_bytes());
  assert_eq!(giter.next(), None);

  let somestring2 = format!("{}", "a s—d féZ");
  let mut giter2 = somestring2.grapheme_bytes_iter();

  assert_eq!(giter2.next().unwrap(), "a".as_bytes());
  assert_eq!(giter2.next().unwrap(), " ".as_bytes());
  assert_eq!(giter2.next().unwrap(), "s".as_bytes());
  assert_eq!(giter2.next().unwrap(), "—".as_bytes());
  assert_eq!(giter2.next().unwrap(), "d".as_bytes());
  assert_eq!(giter2.next().unwrap(), " ".as_bytes());
  assert_eq!(giter2.next().unwrap(), "f".as_bytes());
  assert_eq!(giter2.next().unwrap(), "é".as_bytes());
  assert_eq!(giter2.next().unwrap(), "Z".as_bytes());
  assert_eq!(giter2.next(), None);

  assert_eq!("".grapheme_bytes_iter().next(), None);
}

#[test]
fn it_justifies_one_line_in_for_string() {
  use array_tool::string::Justify;

  assert_eq!("asd asdf asd".justify_line(14), "asd  asdf  asd");
  assert_eq!("asd asdf asd".justify_line(16), "asd   asdf   asd");
  assert_eq!("asd as df asd".justify_line(16), "asd  as  df  asd");
  assert_eq!("asd as df asd".justify_line(18), "asd   as   df  asd");
  assert_eq!("  asd as df asd  ".justify_line(16), "asd  as  df  asd");
  assert_eq!("asdasdfasd".justify_line(16), "asdasdfasd");
  assert_eq!("asdasdfasd".justify_line(6), "asdasdfasd");
  assert_eq!("é é".justify_line(5), "é   é");
  assert_eq!("a s—d féZ".justify_line(12), "a   s—d  féZ");

  assert_eq!("".justify_line(14), "");
}

#[test]
fn it_substitutes_character_at_each_indexed_point() {
  use array_tool::string::SubstMarks;

  assert_eq!("asdf asdf asdf".subst_marks(vec![0,5,8], "Z"), "Zsdf ZsdZ asdf");
  assert_eq!("asdf asdf asdf".subst_marks(vec![8,5,0], "Z"), "Zsdf ZsdZ asdf");
  assert_eq!("asdf asdf asdf".subst_marks(vec![0,5,8], "\n"), "\nsdf \nsd\n asdf");
  assert_eq!("ééé".subst_marks(vec![1], "Z"), "éZé");
  assert_eq!("ééé".subst_marks(vec![1,2], "Z"), "éZZ");
  assert_eq!("ZZZ".subst_marks(vec![0,2], "é" ), "éZé");
  assert_eq!("ééé".subst_marks(vec![0], "Z"), "Zéé");

  assert_eq!("".subst_marks(vec![0], "Z"), "");
}

#[test]
fn it_seeks_end_of_whitespace_after_offset() {
  use array_tool::string::AfterWhitespace;

  assert_eq!("asdf           asdf asdf".seek_end_of_whitespace(6), Some(9));
  assert_eq!("asdf".seek_end_of_whitespace(3), Some(0));
  assert_eq!("asdf           ".seek_end_of_whitespace(6), None);
  assert_eq!("asdf".seek_end_of_whitespace(6), None);

  assert_eq!("".seek_end_of_whitespace(6), None);
}

#[test]
fn it_word_wraps_for_string() {
  use array_tool::string::WordWrap;

  assert_eq!(
    "01234 67 9 BC EFG IJ".word_wrap(6),
    "01234\n67 9\nBC EFG\nIJ"
  );

  assert_eq!(
    "0123456789ABC EFG IJ".word_wrap(6),
    "0123456789ABC\nEFG IJ"
  );
  assert_eq!(
    "1234\n 1234 6789 1234".word_wrap(10),
    "1234\n 1234 6789\n1234"
  );
  assert_eq!(
    "1234\n 1234 67 90 1234".word_wrap(10),
    "1234\n 1234 67\n90 1234"
  );
  assert_eq!(
    "1234\n 1234 67 90A 1234".word_wrap(10),
    "1234\n 1234 67\n90A 1234"
  );
  assert_eq!("1  \n34 ".word_wrap(3), "1  \n34 ");
  assert_eq!("1   34".word_wrap(3),   "1  \n34");
  assert_eq!("\n \n \n \n".word_wrap(1), "\n \n \n \n" );

  // White space to new line shouldn't add new lines.  Use seek ahead.
  assert_eq!("\nAA\nA \nA   \n".word_wrap(1), "\nAA\nA \nA   \n" );
  assert_eq!("\n \n \n \n     ".word_wrap(1), "\n \n \n \n     " );
}