---

yaml
---
r: 148917
b: refs/heads/try2
c: fc1d655
h: refs/heads/master
i:
  148915: 8df1dcf
v: v3

Author: adrientetar

[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: 6aad3bf944da209d1852c51144ba584de400a10c
+refs/heads/try2: fc1d655ed29a6ead06dfccece1b585e2c4212e16
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -49,26 +49,25 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid serialize sync
+TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid sync
 HOST_CRATES := syntax rustc rustdoc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt
-DEPS_extra := std serialize sync term
+DEPS_extra := std term sync
 DEPS_green := std
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std extra term serialize
-DEPS_rustc := syntax native:rustllvm flate arena serialize sync
-DEPS_rustdoc := rustc native:sundown serialize sync
+DEPS_syntax := std extra term
+DEPS_rustc := syntax native:rustllvm flate arena sync
+DEPS_rustdoc := rustc native:sundown sync
 DEPS_flate := std native:miniz
 DEPS_arena := std extra
 DEPS_glob := std
-DEPS_serialize := std
 DEPS_term := std
 DEPS_semver := std
-DEPS_uuid := std serialize
+DEPS_uuid := std extra
 DEPS_sync := std
 
 TOOL_DEPS_compiletest := extra green rustuv

branches/try2/src/doc/index.md

@@ -41,10 +41,9 @@ li {list-style-type: none; }
 * [The `flate` compression library](flate/index.html)
 * [The `glob` file path matching library](glob/index.html)
 * [The `semver` version collation library](semver/index.html)
-* [The `serialize` value encoding/decoding library](serialize/index.html)
-* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 * [The `term` terminal-handling library](term/index.html)
-* [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
+* [The UUID library](uuid/index.html)
+* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 
 # Tooling
 

branches/try2/src/etc/snapshot.py

@@ -195,7 +195,30 @@ def in_tar_name(fn):
 
     return file1
 
-def determine_curr_snapshot_info(triple):
+def curr_snapshot_rev():
+  i = 0
+  found_snap = False
+  date = None
+  rev = None
+
+  f = open(snapshotfile)
+  for line in f.readlines():
+    i += 1
+    parsed = parse_line(i, line)
+    if (not parsed): continue
+
+    if parsed["type"] == "snapshot":
+      date = parsed["date"]
+      rev = parsed["rev"]
+      found_snap = True
+      break
+
+  if not found_snap:
+    raise Exception("no snapshot entries in file")
+
+  return (date, rev)
+
+def determine_curr_snapshot(triple):
   i = 0
   platform = get_platform(triple)
 
@@ -228,7 +251,4 @@ def determine_curr_snapshot_info(triple):
     raise Exception("no snapshot file found for platform %s, rev %s" %
                     (platform, rev))
 
-  return (date, rev, platform, hsh)
-
-def determine_curr_snapshot(triple):
-  return full_snapshot_name(*determine_curr_snapshot_info(triple))
+  return full_snapshot_name(date, rev, platform, hsh)

branches/try2/src/etc/tidy.py

@@ -57,12 +57,13 @@ def do_license_check(name, contents):
             match = re.match(r'^.*//\s*SNAP\s+(\w+)', line)
             if match:
                 hsh = match.group(1)
-                a, b, c, phash = snapshot.determine_curr_snapshot_info()
-                if not phash.startswith(hsh):
-                    report_err("Snapshot out of date: " + line)
+                date, rev = snapshot.curr_snapshot_rev()
+                if not hsh.startswith(rev):
+                    report_err("snapshot out of date (" + date 
+                      + "): " + line)
             else:
                 if "SNAP" in line:
-                    report_warn("Unmatched SNAP line: " + line)
+                    report_warn("unmatched SNAP line: " + line)
 
         if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):

branches/try2/src/libextra/dlist.rs

@@ -30,8 +30,6 @@ use std::iter;
 
 use container::Deque;
 
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
 /// A doubly-linked list.
 pub struct DList<T> {
     priv length: uint,
@@ -630,31 +628,6 @@ impl<A: Clone> Clone for DList<A> {
     }
 }
 
-impl<
-    S: Encoder,
-    T: Encodable<S>
-> Encodable<S> for DList<T> {
-    fn encode(&self, s: &mut S) {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                s.emit_seq_elt(i, |s| e.encode(s));
-            }
-        })
-    }
-}
-
-impl<D:Decoder,T:Decodable<D>> Decodable<D> for DList<T> {
-    fn decode(d: &mut D) -> DList<T> {
-        let mut list = DList::new();
-        d.read_seq(|d, len| {
-            for i in range(0u, len) {
-                list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
-            }
-        });
-        list
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use container::Deque;

branches/try2/src/libserialize/ebml.rs renamed to branches/try2/src/libextra/ebml.rs

@@ -83,19 +83,15 @@ pub enum EbmlEncoderTag {
 
 pub mod reader {
     use std::char;
+    use super::*;
+
+    use serialize;
 
     use std::cast::transmute;
     use std::int;
     use std::option::{None, Option, Some};
     use std::io::extensions::u64_from_be_bytes;
 
-    use serialize;
-
-    use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey,
-        EsEnumVid, EsU64, EsU32, EsU16, EsU8, EsInt, EsI64, EsI32, EsI16, EsI8,
-        EsBool, EsF64, EsF32, EsChar, EsStr, EsMapVal, EsEnumBody, EsUint,
-        EsOpaque, EsLabel, EbmlEncoderTag, Doc, TaggedDoc };
-
     // ebml reading
 
     pub struct Res {
@@ -592,20 +588,15 @@ pub mod reader {
 }
 
 pub mod writer {
+    use super::*;
+
     use std::cast;
     use std::clone::Clone;
     use std::io;
     use std::io::{Writer, Seek};
     use std::io::MemWriter;
     use std::io::extensions::u64_to_be_bytes;
 
-    use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey,
-        EsEnumVid, EsU64, EsU32, EsU16, EsU8, EsInt, EsI64, EsI32, EsI16, EsI8,
-        EsBool, EsF64, EsF32, EsChar, EsStr, EsMapVal, EsEnumBody, EsUint,
-        EsOpaque, EsLabel, EbmlEncoderTag };
-
-    use serialize;
-
     // ebml writing
     pub struct Encoder<'a> {
         // FIXME(#5665): this should take a trait object. Note that if you
@@ -784,7 +775,7 @@ pub mod writer {
         }
     }
 
-    impl<'a> serialize::Encoder for Encoder<'a> {
+    impl<'a> ::serialize::Encoder for Encoder<'a> {
         fn emit_nil(&mut self) {}
 
         fn emit_uint(&mut self, v: uint) {
@@ -961,7 +952,8 @@ pub mod writer {
 mod tests {
     use ebml::reader;
     use ebml::writer;
-    use {Encodable, Decodable};
+    use serialize::Encodable;
+    use serialize;
 
     use std::io::MemWriter;
     use std::option::{None, Option, Some};
@@ -1025,7 +1017,7 @@ mod tests {
             }
             let ebml_doc = reader::Doc(wr.get_ref());
             let mut deser = reader::Decoder(ebml_doc);
-            let v1 = Decodable::decode(&mut deser);
+            let v1 = serialize::Decodable::decode(&mut deser);
             debug!("v1 == {:?}", v1);
             assert_eq!(v, v1);
         }
@@ -1039,7 +1031,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     use ebml::reader;
-    use extra::test::BenchHarness;
+    use test::BenchHarness;
 
     #[bench]
     pub fn vuint_at_A_aligned(bh: &mut BenchHarness) {

branches/try2/src/libextra/json.rs

@@ -51,18 +51,17 @@ A simple JSON document encoding a person, his/her age, address and phone numbers
 
 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 `serialize::Encodable` trait.
-To be able to decode a piece of data, it must implement the `serialize::Decodable` trait.
+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
-extern mod serialize;
 use extra::json;
 use std::io;
-use serialize::Encodable;
+use extra::serialize::Encodable;
 
  #[deriving(Encodable)]
  pub struct TestStruct   {
@@ -126,8 +125,7 @@ fn main() {
 To decode a json string using `Decodable` trait :
 
 ```rust
-extern mod serialize;
-use serialize::Decodable;
+use extra::serialize::Decodable;
 
 #[deriving(Decodable)]
 pub struct MyStruct  {
@@ -152,9 +150,8 @@ Create a struct called TestStruct1 and serialize and deserialize it to and from
 using the serialization API, using the derived serialization code.
 
 ```rust
-extern mod serialize;
 use extra::json;
-use serialize::{Encodable, Decodable};
+use extra::serialize::{Encodable, Decodable};
 
  #[deriving(Decodable, Encodable)] //generate Decodable, Encodable impl.
  pub struct TestStruct1  {
@@ -184,10 +181,9 @@ This example use the ToJson impl to unserialize the json string.
 Example of `ToJson` trait implementation for TestStruct1.
 
 ```rust
-extern mod serialize;
 use extra::json;
 use extra::json::ToJson;
-use serialize::{Encodable, Decodable};
+use extra::serialize::{Encodable, Decodable};
 use extra::treemap::TreeMap;
 
 #[deriving(Decodable, Encodable)] // generate Decodable, Encodable impl.
@@ -316,7 +312,7 @@ impl<'a> Encoder<'a> {
     }
 
     /// Encode the specified struct into a json [u8]
-    pub fn buffer_encode<T:serialize::Encodable<Encoder<'a>>>(to_encode_object: &T) -> ~[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();
         {
@@ -327,7 +323,7 @@ impl<'a> Encoder<'a> {
     }
 
     /// Encode the specified struct into a json str
-    pub fn str_encode<T:serialize::Encodable<Encoder<'a>>>(to_encode_object: &T) -> ~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).unwrap()
     }
@@ -688,7 +684,7 @@ impl<E: serialize::Encoder> serialize::Encodable<E> for Json {
     }
 }
 
-impl Json {
+impl Json{
     /// Encodes a json value into a io::writer.  Uses a single line.
     pub fn to_writer(&self, wr: &mut io::Writer) -> io::IoResult<()> {
         let mut encoder = Encoder::new(wr);

branches/try2/src/libextra/lib.rs

@@ -35,17 +35,6 @@ Rust extras are part of the standard Rust distribution.
 #[deny(missing_doc)];
 
 extern mod sync;
-#[cfg(not(stage0))]
-extern mod serialize;
-
-#[cfg(stage0)]
-pub mod serialize {
-    #[allow(missing_doc)];
-    // Temp re-export until after a snapshot
-    extern mod serialize = "serialize";
-    pub use self::serialize::{Encoder, Decoder, Encodable, Decodable,
-                                   EncoderHelpers, DecoderHelpers};
-}
 
 #[cfg(stage0)]
 macro_rules! if_ok (
@@ -73,6 +62,7 @@ pub mod lru_cache;
 // And ... other stuff
 
 pub mod url;
+pub mod ebml;
 pub mod getopts;
 pub mod json;
 pub mod tempfile;
@@ -95,6 +85,7 @@ mod unicode;
 // Compiler support modules
 
 pub mod test;
+pub mod serialize;
 
 // A curious inner-module that's not exported that contains the binding
 // 'extra' so that macro-expanded references to extra::serialize and such

branches/try2/src/libextra/ringbuf.rs

@@ -19,8 +19,6 @@ use std::iter::{Rev, RandomAccessIterator};
 
 use container::Deque;
 
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
 static INITIAL_CAPACITY: uint = 8u; // 2^3
 static MINIMUM_CAPACITY: uint = 2u;
 
@@ -404,31 +402,6 @@ impl<A> Extendable<A> for RingBuf<A> {
     }
 }
 
-impl<
-    S: Encoder,
-    T: Encodable<S>
-> Encodable<S> for RingBuf<T> {
-    fn encode(&self, s: &mut S) {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                s.emit_seq_elt(i, |s| e.encode(s));
-            }
-        })
-    }
-}
-
-impl<D:Decoder,T:Decodable<D>> Decodable<D> for RingBuf<T> {
-    fn decode(d: &mut D) -> RingBuf<T> {
-        let mut deque = RingBuf::new();
-        d.read_seq(|d, len| {
-            for i in range(0u, len) {
-                deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
-            }
-        });
-        deque
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use container::Deque;