From 2c4a1b55e65c9f513cd71f0f824e94aa6f588df0 Mon Sep 17 00:00:00 2001 From: Kevin Ballard Date: Tue, 3 Dec 2013 19:18:35 -0800 Subject: [PATCH] Rename extra::json::*::init() constructors to *::new() --- src/libextra/json.rs | 96 ++++++++++++++++----------------- src/libextra/test.rs | 2 +- src/libextra/workcache.rs | 6 +-- src/librustdoc/lib.rs | 4 +- src/libsyntax/parse/mod.rs | 2 +- src/test/run-pass/issue-4016.rs | 2 +- src/test/run-pass/issue-4036.rs | 2 +- 7 files changed, 57 insertions(+), 57 deletions(-) diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 30288a08c79..46a04abebe5 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -91,7 +91,7 @@ pub struct Encoder<'self> { impl<'self> Encoder<'self> { /// Creates a new JSON encoder whose output will be written to the writer /// specified. - pub fn init<'a>(wr: &'a mut io::Writer) -> Encoder<'a> { + pub fn new<'a>(wr: &'a mut io::Writer) -> Encoder<'a> { Encoder { wr: wr } } } @@ -247,7 +247,7 @@ pub struct PrettyEncoder<'self> { impl<'self> PrettyEncoder<'self> { /// Creates a new encoder whose output will be written to the specified writer - pub fn init<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> { + pub fn new<'a>(wr: &'a mut io::Writer) -> PrettyEncoder<'a> { PrettyEncoder { wr: wr, indent: 0, @@ -449,14 +449,14 @@ impl serialize::Encodable for Json { impl Json{ /// Encodes a json value into a io::writer. Uses a single line. pub fn to_writer(&self, wr: &mut io::Writer) { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); self.encode(&mut encoder) } /// Encodes a json value into a io::writer. /// Pretty-prints in a more readable format. pub fn to_pretty_writer(&self, wr: &mut io::Writer) { - let mut encoder = PrettyEncoder::init(wr); + let mut encoder = PrettyEncoder::new(wr); self.encode(&mut encoder) } @@ -477,7 +477,7 @@ pub struct Parser { impl> Parser { /// Decode a json value from an Iterator - pub fn init(rdr: T) -> Parser { + pub fn new(rdr: T) -> Parser { let mut p = Parser { rdr: rdr, ch: '\x00', @@ -848,13 +848,13 @@ impl> Parser { /// Decodes a json value from an `&mut io::Reader` pub fn from_reader(rdr: &mut io::Reader) -> Result { let s = str::from_utf8_owned(rdr.read_to_end()); - let mut parser = Parser::init(s.chars()); + let mut parser = Parser::new(s.chars()); parser.parse() } /// Decodes a json value from a string pub fn from_str(s: &str) -> Result { - let mut parser = Parser::init(s.chars()); + let mut parser = Parser::new(s.chars()); parser.parse() } @@ -865,7 +865,7 @@ pub struct Decoder { impl Decoder { /// Creates a new decoder instance for decoding the specified JSON value. - pub fn init(json: Json) -> Decoder { + pub fn new(json: Json) -> Decoder { Decoder { stack: ~[json] } @@ -1522,14 +1522,14 @@ mod tests { let animal = Dog; assert_eq!( with_str_writer(|wr| { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); animal.encode(&mut encoder); }), ~"\"Dog\"" ); assert_eq!( with_str_writer(|wr| { - let mut encoder = PrettyEncoder::init(wr); + let mut encoder = PrettyEncoder::new(wr); animal.encode(&mut encoder); }), ~"\"Dog\"" @@ -1538,14 +1538,14 @@ mod tests { let animal = Frog(~"Henry", 349); assert_eq!( with_str_writer(|wr| { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); animal.encode(&mut encoder); }), ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}" ); assert_eq!( with_str_writer(|wr| { - let mut encoder = PrettyEncoder::init(wr); + let mut encoder = PrettyEncoder::new(wr); animal.encode(&mut encoder); }), ~"\ @@ -1561,14 +1561,14 @@ mod tests { fn test_write_some() { let value = Some(~"jodhpurs"); let s = with_str_writer(|wr| { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); value.encode(&mut encoder); }); assert_eq!(s, ~"\"jodhpurs\""); let value = Some(~"jodhpurs"); let s = with_str_writer(|wr| { - let mut encoder = PrettyEncoder::init(wr); + let mut encoder = PrettyEncoder::new(wr); value.encode(&mut encoder); }); assert_eq!(s, ~"\"jodhpurs\""); @@ -1578,13 +1578,13 @@ mod tests { fn test_write_none() { let value: Option<~str> = None; let s = with_str_writer(|wr| { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); value.encode(&mut encoder); }); assert_eq!(s, ~"null"); let s = with_str_writer(|wr| { - let mut encoder = Encoder::init(wr); + let mut encoder = Encoder::new(wr); value.encode(&mut encoder); }); assert_eq!(s, ~"null"); @@ -1633,15 +1633,15 @@ mod tests { #[test] fn test_decode_identifiers() { - let mut decoder = Decoder::init(from_str("null").unwrap()); + let mut decoder = Decoder::new(from_str("null").unwrap()); let v: () = Decodable::decode(&mut decoder); assert_eq!(v, ()); - let mut decoder = Decoder::init(from_str("true").unwrap()); + let mut decoder = Decoder::new(from_str("true").unwrap()); let v: bool = Decodable::decode(&mut decoder); assert_eq!(v, true); - let mut decoder = Decoder::init(from_str("false").unwrap()); + let mut decoder = Decoder::new(from_str("false").unwrap()); let v: bool = Decodable::decode(&mut decoder); assert_eq!(v, false); } @@ -1676,31 +1676,31 @@ mod tests { #[test] fn test_decode_numbers() { - let mut decoder = Decoder::init(from_str("3").unwrap()); + let mut decoder = Decoder::new(from_str("3").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 3.0); - let mut decoder = Decoder::init(from_str("3.1").unwrap()); + let mut decoder = Decoder::new(from_str("3.1").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 3.1); - let mut decoder = Decoder::init(from_str("-1.2").unwrap()); + let mut decoder = Decoder::new(from_str("-1.2").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, -1.2); - let mut decoder = Decoder::init(from_str("0.4").unwrap()); + let mut decoder = Decoder::new(from_str("0.4").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 0.4); - let mut decoder = Decoder::init(from_str("0.4e5").unwrap()); + let mut decoder = Decoder::new(from_str("0.4e5").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 0.4e5); - let mut decoder = Decoder::init(from_str("0.4e15").unwrap()); + let mut decoder = Decoder::new(from_str("0.4e15").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 0.4e15); - let mut decoder = Decoder::init(from_str("0.4e-01").unwrap()); + let mut decoder = Decoder::new(from_str("0.4e-01").unwrap()); let v: f64 = Decodable::decode(&mut decoder); assert_eq!(v, 0.4e-01); } @@ -1728,39 +1728,39 @@ mod tests { #[test] fn test_decode_str() { - let mut decoder = Decoder::init(from_str("\"\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~""); - let mut decoder = Decoder::init(from_str("\"foo\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"foo\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"foo"); - let mut decoder = Decoder::init(from_str("\"\\\"\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\\"\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\""); - let mut decoder = Decoder::init(from_str("\"\\b\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\b\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\x08"); - let mut decoder = Decoder::init(from_str("\"\\n\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\n\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\n"); - let mut decoder = Decoder::init(from_str("\"\\r\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\r\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\r"); - let mut decoder = Decoder::init(from_str("\"\\t\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\t\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\t"); - let mut decoder = Decoder::init(from_str("\"\\u12ab\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\u12ab\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\u12ab"); - let mut decoder = Decoder::init(from_str("\"\\uAB12\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"\\uAB12\"").unwrap()); let v: ~str = Decodable::decode(&mut decoder); assert_eq!(v, ~"\uAB12"); } @@ -1793,27 +1793,27 @@ mod tests { #[test] fn test_decode_list() { - let mut decoder = Decoder::init(from_str("[]").unwrap()); + let mut decoder = Decoder::new(from_str("[]").unwrap()); let v: ~[()] = Decodable::decode(&mut decoder); assert_eq!(v, ~[]); - let mut decoder = Decoder::init(from_str("[null]").unwrap()); + let mut decoder = Decoder::new(from_str("[null]").unwrap()); let v: ~[()] = Decodable::decode(&mut decoder); assert_eq!(v, ~[()]); - let mut decoder = Decoder::init(from_str("[true]").unwrap()); + let mut decoder = Decoder::new(from_str("[true]").unwrap()); let v: ~[bool] = Decodable::decode(&mut decoder); assert_eq!(v, ~[true]); - let mut decoder = Decoder::init(from_str("[true]").unwrap()); + let mut decoder = Decoder::new(from_str("[true]").unwrap()); let v: ~[bool] = Decodable::decode(&mut decoder); assert_eq!(v, ~[true]); - let mut decoder = Decoder::init(from_str("[3, 1]").unwrap()); + let mut decoder = Decoder::new(from_str("[3, 1]").unwrap()); let v: ~[int] = Decodable::decode(&mut decoder); assert_eq!(v, ~[3, 1]); - let mut decoder = Decoder::init(from_str("[[3], [1, 2]]").unwrap()); + let mut decoder = Decoder::new(from_str("[[3], [1, 2]]").unwrap()); let v: ~[~[uint]] = Decodable::decode(&mut decoder); assert_eq!(v, ~[~[3], ~[1, 2]]); } @@ -1915,7 +1915,7 @@ mod tests { { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } ] }"; - let mut decoder = Decoder::init(from_str(s).unwrap()); + let mut decoder = Decoder::new(from_str(s).unwrap()); let v: Outer = Decodable::decode(&mut decoder); assert_eq!( v, @@ -1929,23 +1929,23 @@ mod tests { #[test] fn test_decode_option() { - let mut decoder = Decoder::init(from_str("null").unwrap()); + let mut decoder = Decoder::new(from_str("null").unwrap()); let value: Option<~str> = Decodable::decode(&mut decoder); assert_eq!(value, None); - let mut decoder = Decoder::init(from_str("\"jodhpurs\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"jodhpurs\"").unwrap()); let value: Option<~str> = Decodable::decode(&mut decoder); assert_eq!(value, Some(~"jodhpurs")); } #[test] fn test_decode_enum() { - let mut decoder = Decoder::init(from_str("\"Dog\"").unwrap()); + let mut decoder = Decoder::new(from_str("\"Dog\"").unwrap()); let value: Animal = Decodable::decode(&mut decoder); assert_eq!(value, Dog); let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; - let mut decoder = Decoder::init(from_str(s).unwrap()); + let mut decoder = Decoder::new(from_str(s).unwrap()); let value: Animal = Decodable::decode(&mut decoder); assert_eq!(value, Frog(~"Henry", 349)); } @@ -1953,7 +1953,7 @@ mod tests { #[test] fn test_decode_map() { let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}"; - let mut decoder = Decoder::init(from_str(s).unwrap()); + let mut decoder = Decoder::new(from_str(s).unwrap()); let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder); assert_eq!(map.pop(&~"a"), Some(Dog)); @@ -1990,7 +1990,7 @@ mod tests { match from_str(to_parse) { Err(e) => Some(e.to_str()), Ok(json) => { - let _: T = Decodable::decode(&mut Decoder::init(json)); + let _: T = Decodable::decode(&mut Decoder::new(json)); None } } diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 7d6fd81c614..818cc49511f 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -947,7 +947,7 @@ impl MetricMap { assert!(p.exists()); let mut f = File::open(p); let value = json::from_reader(&mut f as &mut io::Reader).unwrap(); - let mut decoder = json::Decoder::init(value); + let mut decoder = json::Decoder::new(value); MetricMap(Decodable::decode(&mut decoder)) } diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index d906896ff60..0afc8c08d4c 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -191,7 +191,7 @@ impl Database { Err(e) => fail!("Couldn't parse workcache database (from file {}): {}", self.db_filename.display(), e.to_str()), Ok(r) => { - let mut decoder = json::Decoder::init(r); + let mut decoder = json::Decoder::new(r); self.db_cache = Decodable::decode(&mut decoder); } } @@ -258,7 +258,7 @@ enum Work<'self, T> { fn json_encode<'self, T:Encodable>>(t: &T) -> ~str { let mut writer = MemWriter::new(); - let mut encoder = json::Encoder::init(&mut writer as &mut io::Writer); + let mut encoder = json::Encoder::new(&mut writer as &mut io::Writer); t.encode(&mut encoder); str::from_utf8_owned(writer.inner()) } @@ -267,7 +267,7 @@ fn json_encode<'self, T:Encodable>>(t: &T) -> ~str { fn json_decode>(s: &str) -> T { debug!("json decoding: {}", s); let j = json::from_str(s).unwrap(); - let mut decoder = json::Decoder::init(j); + let mut decoder = json::Decoder::new(j); Decodable::decode(&mut decoder) } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 9944497190c..8d6fd5cd9dc 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -283,7 +283,7 @@ fn json_input(input: &str) -> Result { } let crate = match obj.pop(&~"crate") { Some(json) => { - let mut d = json::Decoder::init(json); + let mut d = json::Decoder::new(json); Decodable::decode(&mut d) } None => return Err(~"malformed json"), @@ -314,7 +314,7 @@ fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) { let crate_json_str = { let mut w = MemWriter::new(); { - let mut encoder = json::Encoder::init(&mut w as &mut io::Writer); + let mut encoder = json::Encoder::new(&mut w as &mut io::Writer); crate.encode(&mut encoder); } str::from_utf8_owned(w.inner()) diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 83825cca631..612151f83e4 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -344,7 +344,7 @@ mod test { #[cfg(test)] fn to_json_str<'a, E: Encodable>>(val: &E) -> ~str { let mut writer = MemWriter::new(); - let mut encoder = extra::json::Encoder::init(&mut writer as &mut io::Writer); + let mut encoder = extra::json::Encoder::new(&mut writer as &mut io::Writer); val.encode(&mut encoder); str::from_utf8_owned(writer.inner()) } diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs index 578d210a6fc..c1f40d302c8 100644 --- a/src/test/run-pass/issue-4016.rs +++ b/src/test/run-pass/issue-4016.rs @@ -18,7 +18,7 @@ trait JD : Decodable { } fn exec() { let doc = json::from_str("").unwrap(); - let mut decoder = json::Decoder::init(doc); + let mut decoder = json::Decoder::new(doc); let _v: T = Decodable::decode(&mut decoder); fail!() } diff --git a/src/test/run-pass/issue-4036.rs b/src/test/run-pass/issue-4036.rs index bd3ca844263..5665bff571e 100644 --- a/src/test/run-pass/issue-4036.rs +++ b/src/test/run-pass/issue-4036.rs @@ -17,6 +17,6 @@ use self::extra::serialize; pub fn main() { let json = json::from_str("[1]").unwrap(); - let mut decoder = json::Decoder::init(json); + let mut decoder = json::Decoder::new(json); let _x: ~[int] = serialize::Decodable::decode(&mut decoder); }