Merge pull request #210 from andreevlex/feature/spelling-check-06-05

spelling check

src/error.rs

@@ -542,7 +542,7 @@ impl From<UrlParseError> for UrlGenerationError {
 /// Helper type that can wrap any error and generate custom response.
 ///
 /// In following example any `io::Error` will be converted into "BAD REQUEST"
-/// response as opposite to *INNTERNAL SERVER ERROR* which is defined by
+/// response as opposite to *INTERNAL SERVER ERROR* which is defined by
 /// default.
 ///
 /// ```rust

src/extractor.rs

@@ -715,7 +715,7 @@ mod tests {
     }
 
     #[test]
-    fn test_extract_path_signle() {
+    fn test_extract_path_single() {
         let mut resource = ResourceHandler::<()>::default();
         resource.name("index");
         let mut routes = Vec::new();

src/header/shared/charset.rs

@@ -7,7 +7,7 @@ use self::Charset::*;
 
 /// A Mime charset.
 ///
-/// The string representation is normalised to upper case.
+/// The string representation is normalized to upper case.
 ///
 /// See [http://www.iana.org/assignments/character-sets/character-sets.xhtml][url].
 ///

src/httprequest.rs

@@ -199,7 +199,7 @@ impl<S> HttpRequest<S> {
         &self.as_ref().extensions
     }
 
-    /// Mutable refernece to a the request's extensions
+    /// Mutable reference to a the request's extensions
     #[inline]
     pub fn extensions_mut(&mut self) -> &mut Extensions {
         &mut self.as_mut().extensions

src/lib.rs

@@ -44,7 +44,7 @@
 //! * [HttpRequest](struct.HttpRequest.html) and
 //!   [HttpResponse](struct.HttpResponse.html): These structs
 //!   represent HTTP requests and responses and expose various methods
-//!   for inspecting, creating and otherwise utilising them.
+//!   for inspecting, creating and otherwise utilizing them.
 //!
 //! ## Features
 //!

src/middleware/errhandlers.rs

@@ -12,7 +12,7 @@ type ErrorHandler<S> = Fn(&mut HttpRequest<S>, HttpResponse) -> Result<Response>
 ///
 /// You can use `ErrorHandlers::handler()` method  to register a custom error
 /// handler for specific status code. You can modify existing response or
-/// create completly new one.
+/// create completely new one.
 ///
 /// ## Example
 ///

src/route.rs

@@ -104,7 +104,7 @@ impl<S: 'static> Route<S> {
         self.handler = InnerHandler::async(handler);
     }
 
-    /// Set handler function, use request extractor for paramters.
+    /// Set handler function, use request extractor for parameters.
     ///
     /// ```rust
     /// # extern crate bytes;
@@ -140,7 +140,7 @@ impl<S: 'static> Route<S> {
         cfg
     }
 
-    /// Set handler function, use request extractor for both paramters.
+    /// Set handler function, use request extractor for both parameters.
     ///
     /// ```rust
     /// # extern crate bytes;
@@ -189,7 +189,7 @@ impl<S: 'static> Route<S> {
         (cfg1, cfg2)
     }
 
-    /// Set handler function, use request extractor for all paramters.
+    /// Set handler function, use request extractor for all parameters.
     pub fn with3<T1, T2, T3, F, R>(
         &mut self, handler: F,
     ) -> (

src/router.rs

@@ -150,7 +150,7 @@ enum PatternType {
 pub enum ResourceType {
     /// Normal resource
     Normal,
-    /// Resource for applicaiton default handler
+    /// Resource for application default handler
     Default,
     /// External resource
     External,
@@ -158,7 +158,7 @@ pub enum ResourceType {
     Unset,
 }
 
-/// Reslource type describes an entry in resources table
+/// Resource type describes an entry in resources table
 #[derive(Clone)]
 pub struct Resource {
     tp: PatternType,
@@ -268,7 +268,7 @@ impl Resource {
         }
     }
 
-    /// Build reousrce path.
+    /// Build resource path.
     pub fn resource_path<U, I>(
         &self, router: &Router, elements: U,
     ) -> Result<String, UrlGenerationError>

src/test.rs

@@ -88,7 +88,7 @@ impl TestServer {
     /// Create test server builder with specific state factory
     ///
     /// This method can be used for constructing application state.
-    /// Also it can be used for external dependecy initialization,
+    /// Also it can be used for external dependency initialization,
     /// like creating sync actors for diesel integration.
     pub fn build_with_state<F, S>(state: F) -> TestServerBuilder<S>
     where

src/ws/client.rs

@@ -258,7 +258,7 @@ struct Inner {
 
 /// Future that implementes client websocket handshake process.
 ///
-/// It resolves to a pair of `ClientReadr` and `ClientWriter` that
+/// It resolves to a pair of `ClientReader` and `ClientWriter` that
 /// can be used for reading and writing websocket frames.
 pub struct ClientHandshake {
     request: Option<SendRequest>,

tools/wsload/src/wsclient.rs

@@ -259,7 +259,7 @@ impl StreamHandler<ws::Message, ws::ProtocolError> for ChatClient {
                         ctx.stop();
                     }
                 } else {
-                    println!("not eaqual");
+                    println!("not equal");
                 }
             }
             _ => (),