diff --git a/src/codegen/branchify.rs b/src/codegen/branchify.rs index 0daf281..8d85241 100644 --- a/src/codegen/branchify.rs +++ b/src/codegen/branchify.rs @@ -3,7 +3,7 @@ use std::str::Chars; use std::io::IoResult; -struct ParseBranch { +pub struct ParseBranch { matches: ~[u8], result: Option<~str>, children: ~[ParseBranch], diff --git a/src/codegen/main.rs b/src/codegen/main.rs index d43e13e..8faeb00 100644 --- a/src/codegen/main.rs +++ b/src/codegen/main.rs @@ -21,9 +21,9 @@ fn main() { 3 => { let output_dir = Path::new(args[2].as_slice()); - match args[1] { - ~"read_method.rs" => read_method::generate(&output_dir).unwrap(), - ~"status.rs" => status::generate(&output_dir).unwrap(), + match args[1].as_slice() { + "read_method.rs" => read_method::generate(&output_dir).unwrap(), + "status.rs" => status::generate(&output_dir).unwrap(), s => { println!("unknown thing-to-generate '{}'", s); os::set_exit_status(1); diff --git a/src/codegen/status.rs b/src/codegen/status.rs index f9e0690..b231044 100644 --- a/src/codegen/status.rs +++ b/src/codegen/status.rs @@ -9,7 +9,7 @@ use collections::hashmap::HashSet; use std::ascii::StrAsciiExt; -use std::vec; +use std::slice; use std::io::IoResult; use super::get_writer; @@ -52,7 +52,7 @@ impl Status { /// "ImATeaPot" fn camel_case(msg: &str) -> ~str { let msg = msg.replace("-", " ").replace("'", ""); - let mut result: ~[Ascii] = vec::with_capacity(msg.len()); + let mut result: ~[Ascii] = slice::with_capacity(msg.len()); let mut capitalise = true; for c in msg.chars() { let c = match capitalise { diff --git a/src/examples/server/apache_fake/main.rs b/src/examples/server/apache_fake/main.rs index f1cc1d7..f4dad3a 100644 --- a/src/examples/server/apache_fake/main.rs +++ b/src/examples/server/apache_fake/main.rs @@ -4,10 +4,11 @@ #[crate_id = "apache_fake"]; -extern crate extra; extern crate time; extern crate http; +use std::vec::Vec; + use std::io::net::ip::{SocketAddr, Ipv4Addr}; use std::io::Writer; @@ -44,13 +45,13 @@ impl Server for ApacheFakeServer { weak: false, opaque_tag: ~"501b29-b1-4a285ed47404a" }); w.headers.accept_ranges = Some(headers::accept_ranges::RangeUnits( - ~[headers::accept_ranges::Bytes])); + vec!(headers::accept_ranges::Bytes))); w.headers.content_length = Some(177); w.headers.vary = Some(~"Accept-Encoding"); w.headers.content_type = Some(headers::content_type::MediaType { type_: ~"text", subtype: ~"html", - parameters: ~[] + parameters: Vec::new() }); w.headers.extensions.insert(~"X-Pad", ~"avoid browser bug"); diff --git a/src/examples/server/hello_world/main.rs b/src/examples/server/hello_world/main.rs index fd9aefe..3cdb66a 100644 --- a/src/examples/server/hello_world/main.rs +++ b/src/examples/server/hello_world/main.rs @@ -2,7 +2,6 @@ #[crate_id = "hello_world"]; -extern crate extra; extern crate time; extern crate http; @@ -26,7 +25,7 @@ impl Server for HelloWorldServer { w.headers.content_type = Some(MediaType { type_: ~"text", subtype: ~"plain", - parameters: ~[(~"charset", ~"UTF-8")] + parameters: vec!((~"charset", ~"UTF-8")) }); w.headers.server = Some(~"Example"); diff --git a/src/examples/server/info/main.rs b/src/examples/server/info/main.rs index 7fe400a..d1b42be 100644 --- a/src/examples/server/info/main.rs +++ b/src/examples/server/info/main.rs @@ -3,7 +3,6 @@ #[crate_id = "info"]; -extern crate extra; extern crate time; extern crate http; @@ -27,7 +26,7 @@ impl Server for InfoServer { w.headers.content_type = Some(MediaType { type_: ~"text", subtype: ~"html", - parameters: ~[(~"charset", ~"UTF-8")] + parameters: vec!((~"charset", ~"UTF-8")) }); w.headers.server = Some(~"Rust Thingummy/0.0-pre"); w.write(bytes!("Rust HTTP server")).unwrap(); diff --git a/src/examples/server/request_uri/main.rs b/src/examples/server/request_uri/main.rs index 5cca89e..4963a47 100644 --- a/src/examples/server/request_uri/main.rs +++ b/src/examples/server/request_uri/main.rs @@ -6,10 +6,11 @@ #[crate_id = "request_uri"]; -extern crate extra; extern crate time; extern crate http; +use std::vec::Vec; + use std::io::net::ip::{SocketAddr, Ipv4Addr}; use std::io::Writer; @@ -47,7 +48,7 @@ impl Server for RequestUriServer { (&Options, &Star) => { // Querying server capabilities. That's nice and simple. I can handle these methods: // (TODO: let user code override this, providing a default method.) - w.headers.allow = Some(~[Get, Head, Post, Put, Delete, Trace, Options, Connect, Patch]); + w.headers.allow = Some(vec!(Get, Head, Post, Put, Delete, Trace, Options, Connect, Patch)); w.headers.content_length = Some(0); return; }, @@ -62,7 +63,7 @@ impl Server for RequestUriServer { w.headers.content_type = Some(MediaType { type_: ~"text", subtype: ~"html", - parameters: ~[] + parameters: Vec::new() }); w.write(bytes!("Rust HTTP server")).unwrap(); diff --git a/src/http/buffer.rs b/src/http/buffer.rs index 5971440..039b19b 100644 --- a/src/http/buffer.rs +++ b/src/http/buffer.rs @@ -2,7 +2,8 @@ use std::io::{IoResult, Stream}; use std::cmp::min; -use std::vec; +use std::vec::Vec; +use std::slice; use std::num::ToStrRadix; // 64KB chunks (moderately arbitrary) @@ -12,12 +13,12 @@ static WRITE_BUF_SIZE: uint = 0x10000; pub struct BufferedStream { wrapped: T, - read_buffer: ~[u8], + read_buffer: Vec, // The current position in the buffer read_pos: uint, // The last valid position in the reader read_max: uint, - write_buffer: ~[u8], + write_buffer: Vec, write_len: uint, writing_chunked_body: bool, @@ -25,9 +26,9 @@ pub struct BufferedStream { impl BufferedStream { pub fn new(stream: T) -> BufferedStream { - let mut read_buffer = vec::with_capacity(READ_BUF_SIZE); + let mut read_buffer = Vec::with_capacity(READ_BUF_SIZE); unsafe { read_buffer.set_len(READ_BUF_SIZE); } - let mut write_buffer = vec::with_capacity(WRITE_BUF_SIZE); + let mut write_buffer = Vec::with_capacity(WRITE_BUF_SIZE); unsafe { write_buffer.set_len(WRITE_BUF_SIZE); } BufferedStream { wrapped: stream, @@ -52,14 +53,14 @@ impl BufferedStream { (0, _) => fail!("poke called when buffer is full"), (_, _) => self.read_pos -= 1, } - self.read_buffer[self.read_pos] = byte; + self.read_buffer.as_mut_slice()[self.read_pos] = byte; } #[inline] fn fill_buffer(&mut self) -> IoResult<()> { assert_eq!(self.read_pos, self.read_max); self.read_pos = 0; - match self.wrapped.read(self.read_buffer) { + match self.wrapped.read(self.read_buffer.as_mut_slice()) { Ok(i) => { self.read_max = i; Ok(()) @@ -80,7 +81,7 @@ impl BufferedStream { try!(self.fill_buffer()); } self.read_pos += 1; - Ok(self.read_buffer[self.read_pos - 1]) + Ok(self.read_buffer.as_slice()[self.read_pos - 1]) } } @@ -110,7 +111,7 @@ impl Reader for BufferedStream { try!(self.fill_buffer()); } let size = min(self.read_max - self.read_pos, buf.len()); - vec::bytes::copy_memory(buf, self.read_buffer.slice_from(self.read_pos).slice_to(size)); + slice::bytes::copy_memory(buf, self.read_buffer.slice_from(self.read_pos).slice_to(size)); self.read_pos += size; Ok(size) } @@ -135,17 +136,20 @@ impl Writer for BufferedStream { try!(self.wrapped.write(bytes!("\r\n"))); } } else { - unsafe { self.write_buffer.mut_slice_from(self.write_len).copy_memory(buf); } + unsafe { + let len = self.write_buffer.len(); + self.write_buffer.mut_slice(self.write_len, len).copy_memory(buf); + } self.write_len += buf.len(); if self.write_len == self.write_buffer.len() { if self.writing_chunked_body { let s = format!("{}\r\n", self.write_len.to_str_radix(16)); try!(self.wrapped.write(s.as_bytes())); - try!(self.wrapped.write(self.write_buffer)); + try!(self.wrapped.write(self.write_buffer.as_slice())); try!(self.wrapped.write(bytes!("\r\n"))); } else { - try!(self.wrapped.write(self.write_buffer)); + try!(self.wrapped.write(self.write_buffer.as_slice())); } self.write_len = 0; } diff --git a/src/http/client/request.rs b/src/http/client/request.rs index d8fcf06..97a67ee 100644 --- a/src/http/client/request.rs +++ b/src/http/client/request.rs @@ -35,9 +35,8 @@ let response = match request.read_response() { ``` */ - -use extra::url::Url; -use extra::url; +use url; +use url::Url; use method::Method; use std::io::{IoError, IoResult}; use std::io::net::get_host_addresses; diff --git a/src/http/headers/accept_ranges.rs b/src/http/headers/accept_ranges.rs index c14c6f6..a784e65 100644 --- a/src/http/headers/accept_ranges.rs +++ b/src/http/headers/accept_ranges.rs @@ -1,5 +1,6 @@ //! The Accept-Ranges request header, defined in RFC 2616, Section 14.5. +use std::vec::Vec; use std::io::IoResult; use std::ascii::StrAsciiExt; @@ -13,7 +14,7 @@ pub enum RangeUnit { #[deriving(Clone,Eq)] // RFC 2616: acceptable-ranges = 1#range-unit | "none" pub enum AcceptableRanges { - RangeUnits(~[RangeUnit]), + RangeUnits(Vec), NoAcceptableRanges, } @@ -23,7 +24,7 @@ static BYTES: &'static [u8] = bytes!("bytes"); impl super::HeaderConvertible for AcceptableRanges { fn from_stream(reader: &mut super::HeaderValueByteIterator) -> Option { - let mut range_units = ~[]; + let mut range_units = Vec::new(); loop { match reader.read_token() { Some(token) => { diff --git a/src/http/headers/connection.rs b/src/http/headers/connection.rs index 3ae63cc..1d775ea 100644 --- a/src/http/headers/connection.rs +++ b/src/http/headers/connection.rs @@ -10,7 +10,7 @@ use headers::serialization_utils::normalise_header_name; /// A value for the Connection header. Note that should it be a ``Token``, the string is in /// normalised header case (e.g. "Keep-Alive"). -#[deriving(Clone, DeepClone, Eq)] +#[deriving(Clone, Eq)] pub enum Connection { Token(~str), Close, @@ -58,24 +58,25 @@ impl super::HeaderConvertible for Connection { #[test] fn test_connection() { + use std::vec::Vec; use headers::test_utils::{assert_conversion_correct, assert_interpretation_correct, assert_invalid}; - assert_conversion_correct("close", ~[Close]); - assert_conversion_correct("Foo", ~[Token(~"Foo")]); - assert_conversion_correct("Foo, Keep-Alive", ~[Token(~"Foo"), Token(~"Keep-Alive")]); - assert_conversion_correct("Foo, close", ~[Token(~"Foo"), Close]); - assert_conversion_correct("close, Bar", ~[Close, Token(~"Bar")]); + assert_conversion_correct("close", vec!(Close)); + assert_conversion_correct("Foo", vec!(Token(~"Foo"))); + assert_conversion_correct("Foo, Keep-Alive", vec!(Token(~"Foo"), Token(~"Keep-Alive"))); + assert_conversion_correct("Foo, close", vec!(Token(~"Foo"), Close)); + assert_conversion_correct("close, Bar", vec!(Close, Token(~"Bar"))); - assert_interpretation_correct("close", ~[Close]); - assert_interpretation_correct("foo", ~[Token(~"Foo")]); - assert_interpretation_correct("close \r\n , keep-ALIVE", ~[Close, Token(~"Keep-Alive")]); - assert_interpretation_correct("foo,close", ~[Token(~"Foo"), Close]); - assert_interpretation_correct("close, bar", ~[Close, Token(~"Bar")]); + assert_interpretation_correct("close", vec!(Close)); + assert_interpretation_correct("foo", vec!(Token(~"Foo"))); + assert_interpretation_correct("close \r\n , keep-ALIVE", vec!(Close, Token(~"Keep-Alive"))); + assert_interpretation_correct("foo,close", vec!(Token(~"Foo"), Close)); + assert_interpretation_correct("close, bar", vec!(Close, Token(~"Bar"))); assert_interpretation_correct("CLOSE", Close); - assert_invalid::<~[Connection]>("foo bar"); - assert_invalid::<~[Connection]>("foo bar"); - assert_invalid::<~[Connection]>("foo, bar baz"); - assert_invalid::<~[Connection]>("foo, , baz"); + assert_invalid::>("foo bar"); + assert_invalid::>("foo bar"); + assert_invalid::>("foo, bar baz"); + assert_invalid::>("foo, , baz"); } diff --git a/src/http/headers/content_type.rs b/src/http/headers/content_type.rs index 6ea8404..6dbdf7b 100644 --- a/src/http/headers/content_type.rs +++ b/src/http/headers/content_type.rs @@ -1,5 +1,6 @@ //! The Content-Type entity header, defined in RFC 2616, Section 14.17. use headers::serialization_utils::{push_parameters, WriterUtil}; +use std::vec::Vec; use std::io::IoResult; use std::fmt; @@ -7,10 +8,10 @@ use std::fmt; pub struct MediaType { type_: ~str, subtype: ~str, - parameters: ~[(~str, ~str)], + parameters: Vec<(~str, ~str)>, } -pub fn MediaType(type_: ~str, subtype: ~str, parameters: ~[(~str, ~str)]) -> MediaType { +pub fn MediaType(type_: ~str, subtype: ~str, parameters: Vec<(~str, ~str)>) -> MediaType { MediaType { type_: type_, subtype: subtype, @@ -28,7 +29,7 @@ impl fmt::Show for MediaType { //s.push_parameters(self.parameters); //s let s = format!("{}/{}", self.type_, self.subtype); - f.buf.write(push_parameters(s, self.parameters).as_bytes()) + f.buf.write(push_parameters(s, self.parameters.as_slice()).as_bytes()) } } @@ -63,7 +64,7 @@ impl super::HeaderConvertible for MediaType { try!(writer.write_token(self.type_)); try!(writer.write(['/' as u8])); try!(writer.write_token(self.subtype)); - writer.write_parameters(self.parameters) + writer.write_parameters(self.parameters.as_slice()) } fn http_value(&self) -> ~str { @@ -75,13 +76,13 @@ impl super::HeaderConvertible for MediaType { fn test_content_type() { use headers::test_utils::{assert_conversion_correct, assert_interpretation_correct, assert_invalid}; - assert_conversion_correct("type/subtype", MediaType(~"type", ~"subtype", ~[])); + assert_conversion_correct("type/subtype", MediaType(~"type", ~"subtype", Vec::new())); assert_conversion_correct("type/subtype;key=value", - MediaType(~"type", ~"subtype", ~[(~"key", ~"value")])); + MediaType(~"type", ~"subtype", vec!((~"key", ~"value")))); assert_conversion_correct("type/subtype;key=value;q=0.1", - MediaType(~"type", ~"subtype", ~[(~"key", ~"value"), (~"q", ~"0.1")])); + MediaType(~"type", ~"subtype", vec!((~"key", ~"value"), (~"q", ~"0.1")))); assert_interpretation_correct("type/subtype ; key = value ; q = 0.1", - MediaType(~"type", ~"subtype", ~[(~"key", ~"value"), (~"q", ~"0.1")])); + MediaType(~"type", ~"subtype", vec!((~"key", ~"value"), (~"q", ~"0.1")))); assert_invalid::(""); assert_invalid::("/"); diff --git a/src/http/headers/mod.rs b/src/http/headers/mod.rs index 0dff909..e0160a0 100644 --- a/src/http/headers/mod.rs +++ b/src/http/headers/mod.rs @@ -4,9 +4,10 @@ //! known HTTP headers are type checked, rather than being dealt with as strings all the time. Only //! unknown headers are stored in a map in the traditional way. +use url::Url; +use std::vec::Vec; use std::io::IoResult; use time::{Tm, strptime}; -use extra::url::Url; use rfc2616::{is_token_item, is_separator, CR, LF, SP, HT, COLON}; use method::Method; @@ -62,7 +63,7 @@ pub mod transfer_encoding; pub type DeltaSeconds = u64; -#[deriving(Clone, DeepClone, Eq)] +#[deriving(Clone, Eq)] pub enum ConsumeCommaLWSResult { CommaConsumed, EndOfValue, @@ -151,7 +152,7 @@ pub struct HeaderValueByteIterator<'a, R> { next_byte: Option, at_start: bool, - state: HeaderValueByteIteratorState, + priv state: HeaderValueByteIteratorState, } impl<'a, R: Reader> HeaderValueByteIterator<'a, R> { @@ -332,8 +333,8 @@ impl<'a, R: Reader> HeaderValueByteIterator<'a, R> { /// /// The return value ``None`` is reserved for syntax errors in parameters that exist; a mere /// absense of parameters will lead to returning an empty vector instead. - fn read_parameters(&mut self) -> Option<~[(~str, ~str)]> { - let mut result = ~[]; + fn read_parameters(&mut self) -> Option> { + let mut result = Vec::new(); loop { match self.next() { //This catches the LWS after the last ';', and can probably be replaced with @@ -552,13 +553,13 @@ pub trait HeaderConvertible: Eq + Clone { } /// A header with multiple comma-separated values. Implement this and a HeaderConvertible -/// implementation for ~[T] is yours for free—just make sure your reading does not consume the +/// implementation for Vec is yours for free—just make sure your reading does not consume the /// comma. pub trait CommaListHeaderConvertible: HeaderConvertible {} -impl HeaderConvertible for ~[T] { - fn from_stream(reader: &mut HeaderValueByteIterator) -> Option<~[T]> { - let mut result = ~[]; +impl HeaderConvertible for Vec { + fn from_stream(reader: &mut HeaderValueByteIterator) -> Option> { + let mut result = Vec::new(); loop { match HeaderConvertible::from_stream(reader) { Some(h) => result.push(h), @@ -871,8 +872,8 @@ macro_rules! headers_mod { $attr; #[allow(unused_imports)]; + use std::vec::Vec; use std::io::IoResult; - use extra; use time; use collections::treemap::{TreeMap, Entries}; use headers; @@ -1013,11 +1014,11 @@ headers_mod! { // RFC 2616, Section 4.5: General Header Fields 0, "Cache-Control", "Cache-Control", CacheControl, cache_control, ~str; - 1, "Connection", "Connection", Connection, connection, ~[headers::connection::Connection]; + 1, "Connection", "Connection", Connection, connection, Vec; 2, "Date", "Date", Date, date, time::Tm; 3, "Pragma", "Pragma", Pragma, pragma, ~str; 4, "Trailer", "Trailer", Trailer, trailer, ~str; - 5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, ~[headers::transfer_encoding::TransferCoding]; + 5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, Vec; 6, "Upgrade", "Upgrade", Upgrade, upgrade, ~str; 7, "Via", "Via", Via, via, ~str; 8, "Warning", "Warning", Warning, warning, ~str; @@ -1044,7 +1045,7 @@ headers_mod! { 27, "User-Agent", "User-Agent", UserAgent, user_agent, ~str; // RFC 2616, Section 7.1: Entity Header Fields - 28, "Allow", "Allow", Allow, allow, ~[::method::Method]; + 28, "Allow", "Allow", Allow, allow, Vec<::method::Method>; 29, "Content-Encoding", "Content-Encoding", ContentEncoding, content_encoding, ~str; 30, "Content-Language", "Content-Language", ContentLanguage, content_language, ~str; 31, "Content-Length", "Content-Length", ContentLength, content_length, uint; @@ -1064,11 +1065,11 @@ headers_mod! { // RFC 2616, Section 4.5: General Header Fields 0, "Cache-Control", "Cache-Control", CacheControl, cache_control, ~str; - 1, "Connection", "Connection", Connection, connection, ~[headers::connection::Connection]; + 1, "Connection", "Connection", Connection, connection, Vec; 2, "Date", "Date", Date, date, time::Tm; 3, "Pragma", "Pragma", Pragma, pragma, ~str; 4, "Trailer", "Trailer", Trailer, trailer, ~str; - 5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, ~[headers::transfer_encoding::TransferCoding]; + 5, "Transfer-Encoding", "Transfer-Encoding", TransferEncoding, transfer_encoding, Vec; 6, "Upgrade", "Upgrade", Upgrade, upgrade, ~str; 7, "Via", "Via", Via, via, ~str; 8, "Warning", "Warning", Warning, warning, ~str; @@ -1078,7 +1079,7 @@ headers_mod! { 10, "Accept-Ranges", "Accept-Ranges", AcceptRanges, accept_ranges, headers::accept_ranges::AcceptableRanges; 11, "Age", "Age", Age, age, ~str; 12, "ETag", "Etag", ETag, etag, headers::etag::EntityTag; - 13, "Location", "Location", Location, location, extra::url::Url; + 13, "Location", "Location", Location, location, ::url::Url; 14, "Proxy-Authenticate", "Proxy-Authenticate", ProxyAuthenticate, proxy_authenticate, ~str; 15, "Retry-After", "Retry-After", RetryAfter, retry_after, ~str; 16, "Server", "Server", Server, server, ~str; @@ -1086,7 +1087,7 @@ headers_mod! { 18, "WWW-Authenticate", "Www-Authenticate", WwwAuthenticate, www_authenticate, ~str; // RFC 2616, Section 7.1: Entity Header Fields - 19, "Allow", "Allow", Allow, allow, ~[::method::Method]; + 19, "Allow", "Allow", Allow, allow, Vec<::method::Method>; 20, "Content-Encoding", "Content-Encoding", ContentEncoding, content_encoding, ~str; 21, "Content-Language", "Content-Language", ContentLanguage, content_language, ~str; 22, "Content-Length", "Content-Length", ContentLength, content_length, uint; diff --git a/src/http/headers/serialization_utils.rs b/src/http/headers/serialization_utils.rs index 95195bc..7c37181 100644 --- a/src/http/headers/serialization_utils.rs +++ b/src/http/headers/serialization_utils.rs @@ -1,6 +1,7 @@ //! Utility functions for assisting with conversion of headers from and to the HTTP text form. -use std::vec; +use std::vec::Vec; +use std::slice; use std::ascii::Ascii; use std::io::IoResult; use rfc2616::is_token; @@ -22,7 +23,7 @@ use rfc2616::is_token; /// assert_eq!(normalise_header_name("FOO-BAR"), "Foo-Bar"); /// ~~~ pub fn normalise_header_name(name: &str) -> ~str { - let mut result: ~[Ascii] = vec::with_capacity(name.len()); + let mut result: ~[Ascii] = slice::with_capacity(name.len()); let mut capitalise = true; for c in name.chars() { let c = match capitalise { @@ -45,7 +46,7 @@ pub fn normalise_header_name(name: &str) -> ~str { /// ~~~ .{rust} /// assert_eq!(comma_split(" en;q=0.8, en_AU, text/html"), ["en;q=0.8", "en_AU", "text/html"]) /// ~~~ -pub fn comma_split(value: &str) -> ~[~str] { +pub fn comma_split(value: &str) -> Vec<~str> { value.split(',').map(|w| w.trim_left().to_owned()).collect() } @@ -236,17 +237,17 @@ mod test { #[test] fn test_comma_split() { // Simple 0-element case - assert_eq!(comma_split(""), ~[~""]); + assert_eq!(comma_split(""), vec!(~"")); // Simple 1-element case - assert_eq!(comma_split("foo"), ~[~"foo"]); + assert_eq!(comma_split("foo"), vec!(~"foo")); // Simple 2-element case - assert_eq!(comma_split("foo,bar"), ~[~"foo", ~"bar"]); + assert_eq!(comma_split("foo,bar"), vec!(~"foo", ~"bar")); // Simple >2-element case - assert_eq!(comma_split("foo,bar,baz,quux"), ~[~"foo", ~"bar", ~"baz", ~"quux"]); + assert_eq!(comma_split("foo,bar,baz,quux"), vec!(~"foo", ~"bar", ~"baz", ~"quux")); // Doesn't handle quoted-string intelligently - assert_eq!(comma_split("\"foo,bar\",baz"), ~[~"\"foo", ~"bar\"", ~"baz"]); + assert_eq!(comma_split("\"foo,bar\",baz"), vec!(~"\"foo", ~"bar\"", ~"baz")); // Doesn't do right trimming, but does left - assert_eq!(comma_split(" foo;q=0.8 , bar/* "), ~[~"foo;q=0.8 ", ~"bar/* "]); + assert_eq!(comma_split(" foo;q=0.8 , bar/* "), vec!(~"foo;q=0.8 ", ~"bar/* ")); } #[test] diff --git a/src/http/headers/transfer_encoding.rs b/src/http/headers/transfer_encoding.rs index 9afd27d..7bb3668 100644 --- a/src/http/headers/transfer_encoding.rs +++ b/src/http/headers/transfer_encoding.rs @@ -2,6 +2,7 @@ //! //! Transfer-Encoding = "Transfer-Encoding" ":" 1#transfer-coding +use std::vec::Vec; use std::ascii::StrAsciiExt; use std::io::IoResult; use headers::serialization_utils::{WriterUtil, push_parameters}; @@ -13,7 +14,7 @@ use headers::serialization_utils::{WriterUtil, push_parameters}; #[deriving(Clone,Eq)] pub enum TransferCoding { Chunked, - TransferExtension(~str, ~[(~str, ~str)]), + TransferExtension(~str, Vec<(~str, ~str)>), } impl super::CommaListHeaderConvertible for TransferCoding {} @@ -42,7 +43,7 @@ impl super::HeaderConvertible for TransferCoding { Chunked => writer.write(bytes!("chunked")), TransferExtension(ref token, ref parameters) => { try!(writer.write_token(*token)); - writer.write_parameters(*parameters) + writer.write_parameters(parameters.as_slice()) } } } @@ -52,7 +53,7 @@ impl super::HeaderConvertible for TransferCoding { Chunked => ~"chunked", TransferExtension(ref token, ref parameters) => { let out = token.to_owned(); - push_parameters(out, *parameters) + push_parameters(out, parameters.as_slice()) } } } diff --git a/src/http/lib.rs b/src/http/lib.rs index 6f7f77d..5e4a5a8 100644 --- a/src/http/lib.rs +++ b/src/http/lib.rs @@ -11,9 +11,11 @@ //#[deny(missing_doc)]; #[feature(macro_rules)]; +#[feature(phase)]; #[macro_escape]; -extern crate extra; +#[phase(syntax, link)] extern crate log; +extern crate url; extern crate time; extern crate collections; diff --git a/src/http/memstream.rs b/src/http/memstream.rs index 27f3577..f14b507 100644 --- a/src/http/memstream.rs +++ b/src/http/memstream.rs @@ -93,19 +93,19 @@ mod test { #[test] fn test_mem_reader_fake_stream() { let mut reader = MemReaderFakeStream::new(~[0, 1, 2, 3, 4, 5, 6, 7]); - let mut buf = []; + let mut buf = ~[]; assert_eq!(reader.read(buf), Ok(0)); assert_eq!(reader.tell(), Ok(0)); - let mut buf = [0]; + let mut buf = ~[0]; assert_eq!(reader.read(buf), Ok(1)); assert_eq!(reader.tell(), Ok(1)); - assert_eq!(buf, [0]); - let mut buf = [0, ..4]; + assert_eq!(buf, ~[0]); + let mut buf = ~[0, 0, 0, 0]; assert_eq!(reader.read(buf), Ok(4)); assert_eq!(reader.tell(), Ok(5)); - assert_eq!(buf, [1, 2, 3, 4]); + assert_eq!(buf, ~[1, 2, 3, 4]); assert_eq!(reader.read(buf), Ok(3)); - assert_eq!(buf.slice(0, 3), [5, 6, 7]); + assert_eq!(buf.slice(0, 3), &[5, 6, 7]); assert_eq!(reader.read(buf).ok(), None); } } diff --git a/src/http/server/mod.rs b/src/http/server/mod.rs index 0304ef1..410d71c 100644 --- a/src/http/server/mod.rs +++ b/src/http/server/mod.rs @@ -1,6 +1,3 @@ -extern crate extra; - -use std::comm::Chan; use std::io::{Listener, Acceptor}; use std::io::net::ip::SocketAddr; use time::precise_time_ns; @@ -37,9 +34,9 @@ pub trait Server: Send + Clone { Ok(acceptor) => acceptor, }; debug!("listening"); - let (perf_po, perf_ch) = Chan::new(); + let (perf_sender, perf_receiver) = channel(); spawn(proc() { - perf_dumper(perf_po); + perf_dumper(perf_receiver); }); loop { let time_start = precise_time_ns(); @@ -55,7 +52,7 @@ pub trait Server: Send + Clone { }, Ok(socket) => socket, }; - let child_perf_ch = perf_ch.clone(); + let child_perf_sender = perf_sender.clone(); let child_self = self.clone(); spawn(proc() { let mut time_start = time_start; @@ -103,7 +100,7 @@ pub trait Server: Send + Clone { Ok(_) => (), } let time_finished = precise_time_ns(); - child_perf_ch.send((time_start, time_spawned, time_request_made, time_response_made, time_finished)); + child_perf_sender.send((time_start, time_spawned, time_request_made, time_response_made, time_finished)); // Subsequent requests on this connection have no spawn time time_start = time_finished; @@ -128,7 +125,7 @@ pub struct Config { static PERF_DUMP_FREQUENCY : u64 = 10_000; /// Simple function to dump out perf stats every `PERF_DUMP_FREQUENCY` requests -fn perf_dumper(perf_po: Port<(u64, u64, u64, u64, u64)>) { +fn perf_dumper(perf_receiver: Receiver<(u64, u64, u64, u64, u64)>) { // Total durations let mut td_spawn = 0u64; let mut td_request = 0u64; @@ -137,7 +134,7 @@ fn perf_dumper(perf_po: Port<(u64, u64, u64, u64, u64)>) { let mut td_total = 0u64; let mut i = 0u64; loop { - let data = perf_po.recv(); + let data = perf_receiver.recv(); let (start, spawned, request_made, response_made, finished) = data; td_spawn += spawned - start; td_request += request_made - spawned; diff --git a/src/http/server/request.rs b/src/http/server/request.rs index 65028aa..8f14b22 100644 --- a/src/http/server/request.rs +++ b/src/http/server/request.rs @@ -1,4 +1,4 @@ -use extra::url::Url; +use url::Url; use method::{Method, Options}; use status; use std::from_str::FromStr; @@ -6,6 +6,7 @@ use std::io::{Stream, IoResult}; use std::io::net::ip::SocketAddr; use std::io::net::tcp::TcpStream; use std::str; +use std::fmt; use rfc2616::{CR, LF, SP}; use headers; use buffer::BufferedStream; @@ -282,6 +283,17 @@ impl FromStr for RequestUri { } } +impl fmt::Show for RequestUri { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + Star => f.buf.write("*".as_bytes()), + AbsoluteUri(ref url) => write!(f.buf, "{}", url), + AbsolutePath(ref str) => f.buf.write(str.as_bytes()), + Authority(ref str) => f.buf.write(str.as_bytes()), + } + } +} + impl Request { /// Get a response from an open socket. @@ -360,7 +372,7 @@ impl Request { // Read body if its length is specified match request.headers.content_length { Some(length) => { - match buffer.read_bytes(length) { + match buffer.read_exact(length) { Ok(body) => match str::from_utf8(body) { Some(body_str) => request.body = body_str.to_owned(), None => return (request, Err(status::BadRequest)) diff --git a/src/http/server/response.rs b/src/http/server/response.rs index 51385e5..4ca9ee7 100644 --- a/src/http/server/response.rs +++ b/src/http/server/response.rs @@ -84,7 +84,7 @@ impl<'a> ResponseWriter<'a> { // apply. In such a case, chunked MUST come last. This way prevents it from being extensible // thus, which is suboptimal. if self.headers.content_length == None { - self.headers.transfer_encoding = Some(~[Chunked]); + self.headers.transfer_encoding = Some(vec!(Chunked)); } else { self.headers.transfer_encoding = None; }