Skip to content

Commit 2c4a1b5

Browse files
lilyballlilyball
committed
Rename extra::json::*::init() constructors to *::new()
1 parent 408dc5a commit 2c4a1b5

File tree

7 files changed

+57
-57
lines changed

7 files changed

+57
-57
lines changed

‎src/libextra/json.rs

+48-48
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ pub struct Encoder<'self> {
9191
impl<'self> Encoder<'self> {
9292
/// Creates a new JSON encoder whose output will be written to the writer
9393
/// specified.
94-
pub fn init<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
94+
pub fn new<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
9595
Encoder { wr: wr }
9696
}
9797
}
@@ -247,7 +247,7 @@ pub struct PrettyEncoder<'self> {
247247

248248
impl<'self> PrettyEncoder<'self> {
249249
/// Creates a new encoder whose output will be written to the specified writer
250-
pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> {
250+
pub fn new<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> {
251251
PrettyEncoder {
252252
wr: wr,
253253
indent: 0,
@@ -449,14 +449,14 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
449449
impl Json{
450450
/// Encodes a json value into a io::writer. Uses a single line.
451451
pub fn to_writer(&self, wr: &mut io::Writer) {
452-
let mut encoder = Encoder::init(wr);
452+
let mut encoder = Encoder::new(wr);
453453
self.encode(&mut encoder)
454454
}
455455

456456
/// Encodes a json value into a io::writer.
457457
/// Pretty-prints in a more readable format.
458458
pub fn to_pretty_writer(&self, wr: &mut io::Writer) {
459-
let mut encoder = PrettyEncoder::init(wr);
459+
let mut encoder = PrettyEncoder::new(wr);
460460
self.encode(&mut encoder)
461461
}
462462

@@ -477,7 +477,7 @@ pub struct Parser<T> {
477477

478478
impl<T: Iterator<char>> Parser<T> {
479479
/// Decode a json value from an Iterator<char>
480-
pub fn init(rdr: T) -> Parser<T> {
480+
pub fn new(rdr: T) -> Parser<T> {
481481
let mut p = Parser {
482482
rdr: rdr,
483483
ch: '\x00',
@@ -848,13 +848,13 @@ impl<T : Iterator<char>> Parser<T> {
848848
/// Decodes a json value from an `&mut io::Reader`
849849
pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, Error> {
850850
let s = str::from_utf8_owned(rdr.read_to_end());
851-
let mut parser = Parser::init(s.chars());
851+
let mut parser = Parser::new(s.chars());
852852
parser.parse()
853853
}
854854

855855
/// Decodes a json value from a string
856856
pub fn from_str(s: &str) -> Result<Json, Error> {
857-
let mut parser = Parser::init(s.chars());
857+
let mut parser = Parser::new(s.chars());
858858
parser.parse()
859859
}
860860

@@ -865,7 +865,7 @@ pub struct Decoder {
865865

866866
impl Decoder {
867867
/// Creates a new decoder instance for decoding the specified JSON value.
868-
pub fn init(json: Json) -> Decoder {
868+
pub fn new(json: Json) -> Decoder {
869869
Decoder {
870870
stack: ~[json]
871871
}
@@ -1522,14 +1522,14 @@ mod tests {
15221522
let animal = Dog;
15231523
assert_eq!(
15241524
with_str_writer(|wr| {
1525-
let mut encoder = Encoder::init(wr);
1525+
let mut encoder = Encoder::new(wr);
15261526
animal.encode(&mut encoder);
15271527
}),
15281528
~"\"Dog\""
15291529
);
15301530
assert_eq!(
15311531
with_str_writer(|wr| {
1532-
let mut encoder = PrettyEncoder::init(wr);
1532+
let mut encoder = PrettyEncoder::new(wr);
15331533
animal.encode(&mut encoder);
15341534
}),
15351535
~"\"Dog\""
@@ -1538,14 +1538,14 @@ mod tests {
15381538
let animal = Frog(~"Henry", 349);
15391539
assert_eq!(
15401540
with_str_writer(|wr| {
1541-
let mut encoder = Encoder::init(wr);
1541+
let mut encoder = Encoder::new(wr);
15421542
animal.encode(&mut encoder);
15431543
}),
15441544
~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
15451545
);
15461546
assert_eq!(
15471547
with_str_writer(|wr| {
1548-
let mut encoder = PrettyEncoder::init(wr);
1548+
let mut encoder = PrettyEncoder::new(wr);
15491549
animal.encode(&mut encoder);
15501550
}),
15511551
~"\
@@ -1561,14 +1561,14 @@ mod tests {
15611561
fn test_write_some() {
15621562
let value = Some(~"jodhpurs");
15631563
let s = with_str_writer(|wr| {
1564-
let mut encoder = Encoder::init(wr);
1564+
let mut encoder = Encoder::new(wr);
15651565
value.encode(&mut encoder);
15661566
});
15671567
assert_eq!(s, ~"\"jodhpurs\"");
15681568

15691569
let value = Some(~"jodhpurs");
15701570
let s = with_str_writer(|wr| {
1571-
let mut encoder = PrettyEncoder::init(wr);
1571+
let mut encoder = PrettyEncoder::new(wr);
15721572
value.encode(&mut encoder);
15731573
});
15741574
assert_eq!(s, ~"\"jodhpurs\"");
@@ -1578,13 +1578,13 @@ mod tests {
15781578
fn test_write_none() {
15791579
let value: Option<~str> = None;
15801580
let s = with_str_writer(|wr| {
1581-
let mut encoder = Encoder::init(wr);
1581+
let mut encoder = Encoder::new(wr);
15821582
value.encode(&mut encoder);
15831583
});
15841584
assert_eq!(s, ~"null");
15851585
15861586
let s = with_str_writer(|wr| {
1587-
let mut encoder = Encoder::init(wr);
1587+
let mut encoder = Encoder::new(wr);
15881588
value.encode(&mut encoder);
15891589
});
15901590
assert_eq!(s, ~"null");
@@ -1633,15 +1633,15 @@ mod tests {
16331633
16341634
#[test]
16351635
fn test_decode_identifiers() {
1636-
let mut decoder = Decoder::init(from_str("null").unwrap());
1636+
let mut decoder = Decoder::new(from_str("null").unwrap());
16371637
let v: () = Decodable::decode(&mut decoder);
16381638
assert_eq!(v, ());
16391639
1640-
let mut decoder = Decoder::init(from_str("true").unwrap());
1640+
let mut decoder = Decoder::new(from_str("true").unwrap());
16411641
let v: bool = Decodable::decode(&mut decoder);
16421642
assert_eq!(v, true);
16431643
1644-
let mut decoder = Decoder::init(from_str("false").unwrap());
1644+
let mut decoder = Decoder::new(from_str("false").unwrap());
16451645
let v: bool = Decodable::decode(&mut decoder);
16461646
assert_eq!(v, false);
16471647
}
@@ -1676,31 +1676,31 @@ mod tests {
16761676
16771677
#[test]
16781678
fn test_decode_numbers() {
1679-
let mut decoder = Decoder::init(from_str("3").unwrap());
1679+
let mut decoder = Decoder::new(from_str("3").unwrap());
16801680
let v: f64 = Decodable::decode(&mut decoder);
16811681
assert_eq!(v, 3.0);
16821682
1683-
let mut decoder = Decoder::init(from_str("3.1").unwrap());
1683+
let mut decoder = Decoder::new(from_str("3.1").unwrap());
16841684
let v: f64 = Decodable::decode(&mut decoder);
16851685
assert_eq!(v, 3.1);
16861686
1687-
let mut decoder = Decoder::init(from_str("-1.2").unwrap());
1687+
let mut decoder = Decoder::new(from_str("-1.2").unwrap());
16881688
let v: f64 = Decodable::decode(&mut decoder);
16891689
assert_eq!(v, -1.2);
16901690
1691-
let mut decoder = Decoder::init(from_str("0.4").unwrap());
1691+
let mut decoder = Decoder::new(from_str("0.4").unwrap());
16921692
let v: f64 = Decodable::decode(&mut decoder);
16931693
assert_eq!(v, 0.4);
16941694
1695-
let mut decoder = Decoder::init(from_str("0.4e5").unwrap());
1695+
let mut decoder = Decoder::new(from_str("0.4e5").unwrap());
16961696
let v: f64 = Decodable::decode(&mut decoder);
16971697
assert_eq!(v, 0.4e5);
16981698
1699-
let mut decoder = Decoder::init(from_str("0.4e15").unwrap());
1699+
let mut decoder = Decoder::new(from_str("0.4e15").unwrap());
17001700
let v: f64 = Decodable::decode(&mut decoder);
17011701
assert_eq!(v, 0.4e15);
17021702
1703-
let mut decoder = Decoder::init(from_str("0.4e-01").unwrap());
1703+
let mut decoder = Decoder::new(from_str("0.4e-01").unwrap());
17041704
let v: f64 = Decodable::decode(&mut decoder);
17051705
assert_eq!(v, 0.4e-01);
17061706
}
@@ -1728,39 +1728,39 @@ mod tests {
17281728

17291729
#[test]
17301730
fn test_decode_str() {
1731-
let mut decoder = Decoder::init(from_str("\"\"").unwrap());
1731+
let mut decoder = Decoder::new(from_str("\"\"").unwrap());
17321732
let v: ~str = Decodable::decode(&mut decoder);
17331733
assert_eq!(v, ~"");
17341734

1735-
let mut decoder = Decoder::init(from_str("\"foo\"").unwrap());
1735+
let mut decoder = Decoder::new(from_str("\"foo\"").unwrap());
17361736
let v: ~str = Decodable::decode(&mut decoder);
17371737
assert_eq!(v, ~"foo");
17381738
1739-
let mut decoder = Decoder::init(from_str("\"\\\"\"").unwrap());
1739+
let mut decoder = Decoder::new(from_str("\"\\\"\"").unwrap());
17401740
let v: ~str = Decodable::decode(&mut decoder);
17411741
assert_eq!(v, ~"\"");
17421742

1743-
let mut decoder = Decoder::init(from_str("\"\\b\"").unwrap());
1743+
let mut decoder = Decoder::new(from_str("\"\\b\"").unwrap());
17441744
let v: ~str = Decodable::decode(&mut decoder);
17451745
assert_eq!(v, ~"\x08");
17461746

1747-
let mut decoder = Decoder::init(from_str("\"\\n\"").unwrap());
1747+
let mut decoder = Decoder::new(from_str("\"\\n\"").unwrap());
17481748
let v: ~str = Decodable::decode(&mut decoder);
17491749
assert_eq!(v, ~"\n");
17501750

1751-
let mut decoder = Decoder::init(from_str("\"\\r\"").unwrap());
1751+
let mut decoder = Decoder::new(from_str("\"\\r\"").unwrap());
17521752
let v: ~str = Decodable::decode(&mut decoder);
17531753
assert_eq!(v, ~"\r");
17541754

1755-
let mut decoder = Decoder::init(from_str("\"\\t\"").unwrap());
1755+
let mut decoder = Decoder::new(from_str("\"\\t\"").unwrap());
17561756
let v: ~str = Decodable::decode(&mut decoder);
17571757
assert_eq!(v, ~"\t");
17581758

1759-
let mut decoder = Decoder::init(from_str("\"\\u12ab\"").unwrap());
1759+
let mut decoder = Decoder::new(from_str("\"\\u12ab\"").unwrap());
17601760
let v: ~str = Decodable::decode(&mut decoder);
17611761
assert_eq!(v, ~"\u12ab");
17621762

1763-
let mut decoder = Decoder::init(from_str("\"\\uAB12\"").unwrap());
1763+
let mut decoder = Decoder::new(from_str("\"\\uAB12\"").unwrap());
17641764
let v: ~str = Decodable::decode(&mut decoder);
17651765
assert_eq!(v, ~"\uAB12");
17661766
}
@@ -1793,27 +1793,27 @@ mod tests {
17931793

17941794
#[test]
17951795
fn test_decode_list() {
1796-
let mut decoder = Decoder::init(from_str("[]").unwrap());
1796+
let mut decoder = Decoder::new(from_str("[]").unwrap());
17971797
let v: ~[()] = Decodable::decode(&mut decoder);
17981798
assert_eq!(v, ~[]);
17991799

1800-
let mut decoder = Decoder::init(from_str("[null]").unwrap());
1800+
let mut decoder = Decoder::new(from_str("[null]").unwrap());
18011801
let v: ~[()] = Decodable::decode(&mut decoder);
18021802
assert_eq!(v, ~[()]);
18031803

1804-
let mut decoder = Decoder::init(from_str("[true]").unwrap());
1804+
let mut decoder = Decoder::new(from_str("[true]").unwrap());
18051805
let v: ~[bool] = Decodable::decode(&mut decoder);
18061806
assert_eq!(v, ~[true]);
18071807

1808-
let mut decoder = Decoder::init(from_str("[true]").unwrap());
1808+
let mut decoder = Decoder::new(from_str("[true]").unwrap());
18091809
let v: ~[bool] = Decodable::decode(&mut decoder);
18101810
assert_eq!(v, ~[true]);
18111811

1812-
let mut decoder = Decoder::init(from_str("[3, 1]").unwrap());
1812+
let mut decoder = Decoder::new(from_str("[3, 1]").unwrap());
18131813
let v: ~[int] = Decodable::decode(&mut decoder);
18141814
assert_eq!(v, ~[3, 1]);
18151815

1816-
let mut decoder = Decoder::init(from_str("[[3], [1, 2]]").unwrap());
1816+
let mut decoder = Decoder::new(from_str("[[3], [1, 2]]").unwrap());
18171817
let v: ~[~[uint]] = Decodable::decode(&mut decoder);
18181818
assert_eq!(v, ~[~[3], ~[1, 2]]);
18191819
}
@@ -1915,7 +1915,7 @@ mod tests {
19151915
{ \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
19161916
]
19171917
}";
1918-
let mut decoder = Decoder::init(from_str(s).unwrap());
1918+
let mut decoder = Decoder::new(from_str(s).unwrap());
19191919
let v: Outer = Decodable::decode(&mut decoder);
19201920
assert_eq!(
19211921
v,
@@ -1929,31 +1929,31 @@ mod tests {
19291929
19301930
#[test]
19311931
fn test_decode_option() {
1932-
let mut decoder = Decoder::init(from_str("null").unwrap());
1932+
let mut decoder = Decoder::new(from_str("null").unwrap());
19331933
let value: Option<~str> = Decodable::decode(&mut decoder);
19341934
assert_eq!(value, None);
19351935
1936-
let mut decoder = Decoder::init(from_str("\"jodhpurs\"").unwrap());
1936+
let mut decoder = Decoder::new(from_str("\"jodhpurs\"").unwrap());
19371937
let value: Option<~str> = Decodable::decode(&mut decoder);
19381938
assert_eq!(value, Some(~"jodhpurs"));
19391939
}
19401940
19411941
#[test]
19421942
fn test_decode_enum() {
1943-
let mut decoder = Decoder::init(from_str("\"Dog\"").unwrap());
1943+
let mut decoder = Decoder::new(from_str("\"Dog\"").unwrap());
19441944
let value: Animal = Decodable::decode(&mut decoder);
19451945
assert_eq!(value, Dog);
19461946

19471947
let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
1948-
let mut decoder = Decoder::init(from_str(s).unwrap());
1948+
let mut decoder = Decoder::new(from_str(s).unwrap());
19491949
let value: Animal = Decodable::decode(&mut decoder);
19501950
assert_eq!(value, Frog(~"Henry", 349));
19511951
}
19521952
19531953
#[test]
19541954
fn test_decode_map() {
19551955
let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
1956-
let mut decoder = Decoder::init(from_str(s).unwrap());
1956+
let mut decoder = Decoder::new(from_str(s).unwrap());
19571957
let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
19581958
19591959
assert_eq!(map.pop(&~"a"), Some(Dog));
@@ -1990,7 +1990,7 @@ mod tests {
19901990
match from_str(to_parse) {
19911991
Err(e) => Some(e.to_str()),
19921992
Ok(json) => {
1993-
let _: T = Decodable::decode(&mut Decoder::init(json));
1993+
let _: T = Decodable::decode(&mut Decoder::new(json));
19941994
None
19951995
}
19961996
}

‎src/libextra/test.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -947,7 +947,7 @@ impl MetricMap {
947947
assert!(p.exists());
948948
let mut f = File::open(p);
949949
let value = json::from_reader(&mut f as &mut io::Reader).unwrap();
950-
let mut decoder = json::Decoder::init(value);
950+
let mut decoder = json::Decoder::new(value);
951951
MetricMap(Decodable::decode(&mut decoder))
952952
}
953953

‎src/libextra/workcache.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,7 @@ impl Database {
191191
Err(e) => fail!("Couldn't parse workcache database (from file {}): {}",
192192
self.db_filename.display(), e.to_str()),
193193
Ok(r) => {
194-
let mut decoder = json::Decoder::init(r);
194+
let mut decoder = json::Decoder::new(r);
195195
self.db_cache = Decodable::decode(&mut decoder);
196196
}
197197
}
@@ -258,7 +258,7 @@ enum Work<'self, T> {
258258

259259
fn json_encode<'self, T:Encodable<json::Encoder<'self>>>(t: &T) -> ~str {
260260
let mut writer = MemWriter::new();
261-
let mut encoder = json::Encoder::init(&mut writer as &mut io::Writer);
261+
let mut encoder = json::Encoder::new(&mut writer as &mut io::Writer);
262262
t.encode(&mut encoder);
263263
str::from_utf8_owned(writer.inner())
264264
}
@@ -267,7 +267,7 @@ fn json_encode<'self, T:Encodable<json::Encoder<'self>>>(t: &T) -> ~str {
267267
fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
268268
debug!("json decoding: {}", s);
269269
let j = json::from_str(s).unwrap();
270-
let mut decoder = json::Decoder::init(j);
270+
let mut decoder = json::Decoder::new(j);
271271
Decodable::decode(&mut decoder)
272272
}
273273

‎src/librustdoc/lib.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
283283
}
284284
let crate = match obj.pop(&~"crate") {
285285
Some(json) => {
286-
let mut d = json::Decoder::init(json);
286+
let mut d = json::Decoder::new(json);
287287
Decodable::decode(&mut d)
288288
}
289289
None => return Err(~"malformed json"),
@@ -314,7 +314,7 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) {
314314
let crate_json_str = {
315315
let mut w = MemWriter::new();
316316
{
317-
let mut encoder = json::Encoder::init(&mut w as &mut io::Writer);
317+
let mut encoder = json::Encoder::new(&mut w as &mut io::Writer);
318318
crate.encode(&mut encoder);
319319
}
320320
str::from_utf8_owned(w.inner())

‎src/libsyntax/parse/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -344,7 +344,7 @@ mod test {
344344
#[cfg(test)]
345345
fn to_json_str<'a, E: Encodable<extra::json::Encoder<'a>>>(val: &E) -> ~str {
346346
let mut writer = MemWriter::new();
347-
let mut encoder = extra::json::Encoder::init(&mut writer as &mut io::Writer);
347+
let mut encoder = extra::json::Encoder::new(&mut writer as &mut io::Writer);
348348
val.encode(&mut encoder);
349349
str::from_utf8_owned(writer.inner())
350350
}

0 commit comments

Comments
 (0)