Update for 0.7.0

Expose HTTPVersion, etc

Author: cyderize

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "websocket"
-version = "0.6.1"
+version = "0.7.0"
 authors = ["cyderize <[email protected]>"]
 
 description = "A WebSocket (RFC6455) library for Rust."

README.md

@@ -10,7 +10,7 @@ Rust-WebSocket attempts to provide a framework for WebSocket connections (both c
 To add a library release version from [crates.io](https://crates.io/crates/websocket) to a Cargo project, add this to the 'dependencies' section of your Cargo.toml:
 
 ```INI
-websocket = "~0.6.1"
+websocket = "~0.7.0"
 ```
 
 To add the library's Git repository to a Cargo project, add this to your Cargo.toml:

src/lib.rs

@@ -13,7 +13,7 @@
 //! ```no_run
 //! use std::io::TcpListener;
 //! use std::io::{Listener, Acceptor};
-//! use websocket::WebSocketClient;
+//! use websocket::{WebSocketClient, WebSocketClientMode};
 //! use websocket::handshake::WebSocketResponse;
 //! 
 //! let listener = TcpListener::bind("127.0.0.1:1234");
@@ -25,8 +25,7 @@
 //! 			// Spawn a new task for each connection to run in parallel
 //! 			spawn(proc() {
 //! 				// Get a WebSocketClient from this stream
-//! 				// The mask argument is false as messages sent by the server are always unmasked
-//! 				let mut client = WebSocketClient::new(stream, false); 
+//! 				let mut client = WebSocketClient::new(stream, WebSocketClientMode::RemoteClient); 
 //! 				
 //! 				// Read the handshake from the client
 //! 				let request = client.receive_handshake_request().unwrap();
@@ -60,7 +59,7 @@ extern crate url;
 extern crate sha1;
 extern crate serialize;
 
-pub use self::ws::client::WebSocketClient;
+pub use self::ws::client::{WebSocketClient, WebSocketClientMode};
 
 /// Structs for manipulation of HTTP headers. Used in conjunction with 
 /// WebSocketRequest and WebSocketResponse.
@@ -74,6 +73,7 @@ pub mod headers {
 pub mod handshake {
 	pub use ws::handshake::request::WebSocketRequest;
 	pub use ws::handshake::response::WebSocketResponse;
+	pub use ws::handshake::version::HttpVersion;
 }
 
 /// Structs for WebSocket messages and the transmission of messages

src/ws/client.rs

@@ -12,7 +12,7 @@ use std::clone::Clone;
 /// 
 /// ```no_run
 /// use std::io::TcpStream;
-/// use websocket::WebSocketClient;
+/// use websocket::{WebSocketClient, WebSocketClientMode};
 /// use websocket::handshake::WebSocketRequest;
 /// 
 /// let request = WebSocketRequest::new("ws://127.0.0.1:1234", ["myProtocol"].as_slice()).unwrap();
@@ -21,7 +21,7 @@ use std::clone::Clone;
 /// // We can get the hostname from the request
 /// let stream = TcpStream::connect(request.host().unwrap().as_slice()).unwrap();
 ///
-/// let mut client = WebSocketClient::new(stream, true);
+/// let mut client = WebSocketClient::new(stream, WebSocketClientMode::RemoteServer);
 /// let _ = client.send_handshake_request(&request);
 /// let response = client.receive_handshake_response().unwrap();
 /// 
@@ -47,10 +47,13 @@ impl<S: Stream + Clone> WebSocketClient<S> {
 	/// endpoint (and therefore, the server is the local endpoint), set mask to false.
 	/// 
 	/// Nothing is sent to or read from the stream during the conversion.
-	pub fn new(stream: S, mask: bool) -> WebSocketClient<S> {
+	pub fn new(stream: S, mode: WebSocketClientMode) -> WebSocketClient<S> {
 		WebSocketClient {
 			stream: stream,
-			mask: mask,
+			mask: match mode {
+				WebSocketClientMode::RemoteClient => { false }
+				WebSocketClientMode::RemoteServer => { true }
+			},
 		}
 	}
 
@@ -104,4 +107,9 @@ impl<S: Stream + Clone> Clone for WebSocketClient<S> {
 			mask: self.mask,
 		}
 	}
+}
+
+pub enum WebSocketClientMode {
+	RemoteClient,
+	RemoteServer,
 }

src/ws/handshake/version.rs

@@ -1,18 +1,40 @@
+#[phase(plugin)]
+extern crate regex_macros;
+extern crate regex;
+
 use std::fmt::{Show, Formatter, Result};
 use std::option::Option;
 
+/// Represents an HTTP version.
 pub struct HttpVersion {
+	/// The major HTTP version.
 	pub version_major: u8,
+	/// The minor HTTP version if present.
 	pub version_minor: Option<u8>,
 }
 
 impl HttpVersion {
+	/// Create a new HttpVersion from major and minor version numbers.
 	pub fn new(version_major: u8, version_minor: Option<u8>) -> HttpVersion {
 		HttpVersion {
 			version_major: version_major,
 			version_minor: version_minor,
 		}
 	}
+	
+	/// Create a new HttpVersion from a string. Panics if unable to parse the string.
+	pub fn parse(version: &str) -> HttpVersion {
+		let re = regex!(r"(\d+)(?:\.(\d+))?");
+		let captures = re.captures(version).unwrap();
+		
+		let version_major: Option<u8> = from_str(captures.at(1));
+		let version_minor: Option<u8> = from_str(captures.at(2));
+		
+		HttpVersion {
+			version_major: version_major.unwrap(),
+			version_minor: version_minor,
+		}
+	}
 }
 
 impl Show for HttpVersion {

src/ws/message/receive.rs

@@ -13,12 +13,12 @@ use std::clone::Clone;
 ///
 /// ```no_run
 /// use websocket::message::WebSocketMessage;
-/// # use websocket::WebSocketClient;
+/// # use websocket::{WebSocketClient, WebSocketClientMode};
 /// # use std::io::TcpStream;
 /// # #[allow(unused_must_use)]
 /// # fn foo() {
 /// # let stream = TcpStream::connect("127.0.0.1:1234").unwrap();
-/// # let mut client = WebSocketClient::new(stream, true);
+/// # let mut client = WebSocketClient::new(stream, WebSocketClientMode::RemoteServer);
 /// 
 /// let receiver = client.receiver();
 /// 

src/ws/message/send.rs

@@ -13,12 +13,12 @@ use std::clone::Clone;
 /// 
 /// ```no_run
 /// use websocket::message::WebSocketMessage;
-/// # use websocket::WebSocketClient;
+/// # use websocket::{WebSocketClient, WebSocketClientMode};
 /// # use std::io::TcpStream;
 /// # #[allow(unused_must_use)]
 /// # fn foo() {
 /// # let stream = TcpStream::connect("127.0.0.1:1234").unwrap();
-/// # let mut client = WebSocketClient::new(stream, true);
+/// # let mut client = WebSocketClient::new(stream, WebSocketClientMode::RemoteServer);
 /// 
 /// let mut sender = client.sender(); // Get a sender
 /// let data = "My fancy message".to_string();
@@ -100,12 +100,12 @@ impl<S: Stream + Clone> WebSocketSender<S> {
 /// 
 /// ```no_run
 /// use websocket::message::WebSocketMessage;
-/// # use websocket::WebSocketClient;
+/// # use websocket::{WebSocketClient, WebSocketClientMode};
 /// # use std::io::TcpStream;
 /// # #[allow(unused_must_use)]
 /// # fn foo() {
 /// # let stream = TcpStream::connect("127.0.0.1:1234").unwrap();
-/// # let mut client = WebSocketClient::new(stream, true);
+/// # let mut client = WebSocketClient::new(stream, WebSocketClientMode::RemoteServer);
 /// # let mut sender = client.sender();
 /// // Get a WebSocketFragmentSerializer
 /// let mut fragment = sender.fragment();