---

yaml
---
r: 148446
b: refs/heads/try2
c: 6b18ef5
h: refs/heads/master
v: v3

Author: omasanori

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: bf89b68a3702e10b18e84ef37c3aa19f13418731
+refs/heads/try2: 6b18ef535808f41c9292da0bd4ed366dac649656
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/guide-testing.md

@@ -33,7 +33,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 # Unit testing in Rust
 
 Rust has built in support for simple unit testing. Functions can be
-marked as unit tests using the `test` attribute.
+marked as unit tests using the 'test' attribute.
 
 ~~~
 #[test]
@@ -44,13 +44,13 @@ fn return_none_if_empty() {
 
 A test function's signature must have no arguments and no return
 value. To run the tests in a crate, it must be compiled with the
-`--test` flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
+'--test' flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
 the resulting executable will run all the tests in the crate. A test
 is considered successful if its function returns; if the task running
 the test fails, through a call to `fail!`, a failed `check` or
 `assert`, or some other (`assert_eq`, ...) means, then the test fails.
 
-When compiling a crate with the `--test` flag `--cfg test` is also
+When compiling a crate with the '--test' flag '--cfg test' is also
 implied, so that tests can be conditionally compiled.
 
 ~~~
@@ -64,17 +64,17 @@ mod tests {
 ~~~
 
 Additionally `#[test]` items behave as if they also have the
-`#[cfg(test)]` attribute, and will not be compiled when the `--test` flag
+`#[cfg(test)]` attribute, and will not be compiled when the --test flag
 is not used.
 
-Tests that should not be run can be annotated with the `ignore`
+Tests that should not be run can be annotated with the 'ignore'
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
 by configuration so, for example, to ignore a test on windows you can
 write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
-`should_fail` attribute. The test will be run, and if it causes its
+'should_fail' attribute. The test will be run, and if it causes its
 task to fail then the test will be counted as successful; otherwise it
 will be counted as a failure. For example:
 
@@ -87,11 +87,11 @@ fn test_out_of_bounds_failure() {
 }
 ~~~
 
-A test runner built with the `--test` flag supports a limited set of
+A test runner built with the '--test' flag supports a limited set of
 arguments to control which tests are run: the first free argument
 passed to a test runner specifies a filter used to narrow down the set
-of tests being run; the `--ignored` flag tells the test runner to run
-only tests with the `ignore` attribute.
+of tests being run; the '--ignored' flag tells the test runner to run
+only tests with the 'ignore' attribute.
 
 ## Parallelism
 

branches/try2/src/compiletest/runtest.rs

@@ -237,15 +237,9 @@ actual:\n\
 
     fn make_typecheck_args(config: &config, props: &TestProps, testfile: &Path) -> ProcArgs {
         let aux_dir = aux_output_dir_name(config, testfile);
-        let target = if props.force_host {
-            config.host.as_slice()
-        } else {
-            config.target.as_slice()
-        };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
-                         ~"--target=" + target,
                          ~"-L", config.build_base.as_str().unwrap().to_owned(),
                          ~"-L",
                          aux_dir.as_str().unwrap().to_owned()];

branches/try2/src/libextra/base64.rs

@@ -237,9 +237,8 @@ impl<'a> FromBase64 for &'a str {
         }
 
         for (idx, byte) in it {
-            match byte as char {
-                '='|'\r'|'\n' => continue,
-                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
+            if (byte as char) != '=' {
+                return Err(InvalidBase64Character(self.char_at(idx), idx));
             }
         }
 
@@ -311,8 +310,6 @@ mod test {
     fn test_from_base64_newlines() {
         assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
                    "foobar".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
-                   "foob".as_bytes().to_owned());
     }
 
     #[test]

branches/try2/src/libextra/json.rs

@@ -14,211 +14,7 @@
 #[forbid(non_camel_case_types)];
 #[allow(missing_doc)];
 
-/*!
-JSON parsing and serialization
-
-# What is JSON?
-
-JSON (JavaScript Object Notation) is a way to write data in Javascript.
-Like XML it allows one to encode structured data in a text format that can be read by humans easily.
-Its native compatibility with JavaScript and its simple syntax make it used widely.
-
-Json data are encoded in a form of "key":"value".
-Data types that can be encoded are JavaScript types :
-boolean (`true` or `false`), number (`f64`), string, array, object, null.
-An object is a series of string keys mapping to values, in `"key": value` format.
-Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
-A simple JSON document encoding a person, his/her age, address and phone numbers could look like:
-
-```
-{
-    "FirstName": "John",
-    "LastName": "Doe",
-    "Age": 43,
-    "Address": {
-        "Street": "Downing Street 10",
-        "City": "London",
-        "Country": "Great Britain"
-    },
-    "PhoneNumbers": [
-        "+44 1234567",
-        "+44 2345678"
-    ]
-}
-```
-
-# Rust Type-based Encoding and Decoding
-
-Rust provides a mechanism for low boilerplate encoding & decoding
-of values to and from JSON via the serialization API.
-To be able to encode a piece of data, it must implement the `extra::serialize::Encodable` trait.
-To be able to decode a piece of data, it must implement the `extra::serialize::Decodable` trait.
-The Rust compiler provides an annotation to automatically generate
-the code for these traits: `#[deriving(Decodable, Encodable)]`
-
-To encode using Encodable :
-
-```rust
-use extra::json;
-use std::io;
-use extra::serialize::Encodable;
-
- #[deriving(Encodable)]
- pub struct TestStruct   {
-    data_str: ~str,
- }
-
-fn main() {
-    let to_encode_object = TestStruct{data_str:~"example of string to encode"};
-    let mut m = io::MemWriter::new();
-    {
-        let mut encoder = json::Encoder::new(&mut m as &mut std::io::Writer);
-        to_encode_object.encode(&mut encoder);
-    }
-}
-```
-
-Two wrapper functions are provided to encode a Encodable object
-into a string (~str) or buffer (~[u8]): `str_encode(&m)` and `buffer_encode(&m)`.
-
-```rust
-use extra::json;
-let to_encode_object = ~"example of string to encode";
-let encoded_str: ~str = json::Encoder::str_encode(&to_encode_object);
-```
-
-JSON API provide an enum `json::Json` and a trait `ToJson` to encode object.
-The trait `ToJson` encode object into a container `json::Json` and the API provide writer
-to encode them into a stream or a string ...
-
-When using `ToJson` the `Encodable` trait implementation is not mandatory.
-
-A basic `ToJson` example using a TreeMap of attribute name / attribute value:
-
-
-```rust
-use extra::json;
-use extra::json::ToJson;
-use extra::treemap::TreeMap;
-
-pub struct MyStruct  {
-    attr1: u8,
-    attr2: ~str,
-}
-
-impl ToJson for MyStruct {
-    fn to_json( &self ) -> json::Json {
-        let mut d = ~TreeMap::new();
-        d.insert(~"attr1", self.attr1.to_json());
-        d.insert(~"attr2", self.attr2.to_json());
-        json::Object(d)
-    }
-}
-
-fn main() {
-    let test2: MyStruct = MyStruct {attr1: 1, attr2:~"test"};
-    let tjson: json::Json = test2.to_json();
-    let json_str: ~str = tjson.to_str();
-}
-```
-
-To decode a json string using `Decodable` trait :
-
-```rust
-use extra::serialize::Decodable;
-
-#[deriving(Decodable)]
-pub struct MyStruct  {
-     attr1: u8,
-     attr2: ~str,
-}
-
-fn main() {
-    let json_str_to_decode: ~str =
-            ~"{\"attr1\":1,\"attr2\":\"toto\"}";
-    let json_object = extra::json::from_str(json_str_to_decode);
-    let mut decoder = extra::json::Decoder::new(json_object.unwrap());
-    let decoded_object: MyStruct = Decodable::decode(&mut decoder); // create the final object
-}
-```
-
-# Examples of use
-
-## Using Autoserialization
-
-Create a struct called TestStruct1 and serialize and deserialize it to and from JSON
-using the serialization API, using the derived serialization code.
-
-```rust
-use extra::json;
-use extra::serialize::{Encodable, Decodable};
-
- #[deriving(Decodable, Encodable)] //generate Decodable, Encodable impl.
- pub struct TestStruct1  {
-    data_int: u8,
-    data_str: ~str,
-    data_vector: ~[u8],
- }
-
-// To serialize use the `json::str_encode` to encode an object in a string.
-// It calls the generated `Encodable` impl.
-fn main() {
-    let to_encode_object = TestStruct1
-         {data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
-    let encoded_str: ~str = json::Encoder::str_encode(&to_encode_object);
-
-    // To unserialize use the `extra::json::from_str` and `extra::json::Decoder`
-
-    let json_object = extra::json::from_str(encoded_str);
-    let mut decoder = json::Decoder::new(json_object.unwrap());
-    let decoded1: TestStruct1 = Decodable::decode(&mut decoder); // create the final object
-}
-```
-
-## Using `ToJson`
-
-This example use the ToJson impl to unserialize the json string.
-Example of `ToJson` trait implementation for TestStruct1.
-
-```rust
-use extra::json;
-use extra::json::ToJson;
-use extra::serialize::{Encodable, Decodable};
-use extra::treemap::TreeMap;
-
-#[deriving(Decodable, Encodable)] // generate Decodable, Encodable impl.
-pub struct TestStruct1  {
-    data_int: u8,
-    data_str: ~str,
-    data_vector: ~[u8],
-}
-
-impl ToJson for TestStruct1 {
-    fn to_json( &self ) -> json::Json {
-        let mut d = ~TreeMap::new();
-        d.insert(~"data_int", self.data_int.to_json());
-        d.insert(~"data_str", self.data_str.to_json());
-        d.insert(~"data_vector", self.data_vector.to_json());
-        json::Object(d)
-    }
-}
-
-fn main() {
-    // Seralization using our impl of to_json
-
-    let test2: TestStruct1 = TestStruct1 {data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
-    let tjson: json::Json = test2.to_json();
-    let json_str: ~str = tjson.to_str();
-
-    // Unserialize like before.
-
-    let mut decoder = json::Decoder::new(json::from_str(json_str).unwrap());
-    // create the final object
-    let decoded2: TestStruct1 = Decodable::decode(&mut decoder);
-}
-```
-
-*/
+//! json parsing and serialization
 
 use std::char;
 use std::cast::transmute;
@@ -297,23 +93,6 @@ impl<'a> Encoder<'a> {
     pub fn new<'a>(wr: &'a mut io::Writer) -> Encoder<'a> {
         Encoder { wr: wr }
     }
-
-    /// Encode the specified struct into a json [u8]
-    pub fn buffer_encode<T:Encodable<Encoder<'a>>>(to_encode_object: &T) -> ~[u8]  {
-       //Serialize the object in a string using a writer
-        let mut m = MemWriter::new();
-        {
-            let mut encoder = Encoder::new(&mut m as &mut io::Writer);
-            to_encode_object.encode(&mut encoder);
-        }
-        m.unwrap()
-    }
-
-    /// Encode the specified struct into a json str
-    pub fn str_encode<T:Encodable<Encoder<'a>>>(to_encode_object: &T) -> ~str  {
-        let buff:~[u8] = Encoder::buffer_encode(to_encode_object);
-        str::from_utf8_owned(buff)
-    }
 }
 
 impl<'a> serialize::Encoder for Encoder<'a> {
@@ -909,7 +688,7 @@ impl<T : Iterator<char>> Parser<T> {
             }
         }
 
-        let exp: f64 = num::pow(10u as f64, exp);
+        let exp: f64 = num::pow_with_uint(10u, exp);
         if neg_exp {
             res /= exp;
         } else {