expanded.txt

#![feature(prelude_import)]
#![allow(dead_code)]
#[prelude_import]
use std::prelude::rust_2018::*;
#[macro_use]
extern crate std;
use server::Server;
use website_handler::WebsiteHandler;
use std::env;
mod http {
    pub use method::Method;
    pub use query_string::{QueryString, Value as QueryStringValue};
    pub use request::ParseError;
    pub use request::Request;
    pub use response::Response;
    pub use status_code::StatusCode;
    pub mod method {
        use std::str::FromStr;
        pub enum Method {
            GET,
            DELETE,
            POST,
            PUT,
            HEAD,
            CONNECT,
            OPTIONS,
            TRACE,
            PATCH,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Method {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match (&*self,) {
                    (&Method::GET,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "GET");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::DELETE,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "DELETE");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::POST,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "POST");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::PUT,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "PUT");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::HEAD,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "HEAD");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::CONNECT,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "CONNECT");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::OPTIONS,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "OPTIONS");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::TRACE,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "TRACE");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Method::PATCH,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "PATCH");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                }
            }
        }
        impl FromStr for Method {
            type Err = MethodError;
            fn from_str(s: &str) -> Result<Self, Self::Err> {
                match s {
                    "GET" => Ok(Self::GET),
                    "DELETE" => Ok(Self::DELETE),
                    "POST" => Ok(Self::POST),
                    "PUT" => Ok(Self::PUT),
                    "HEAD" => Ok(Self::HEAD),
                    "CONNECT" => Ok(Self::CONNECT),
                    "OPTIONS" => Ok(Self::OPTIONS),
                    "TRACE" => Ok(Self::TRACE),
                    "PATCH" => Ok(Self::PATCH),
                    _ => Err(MethodError),
                }
            }
        }
        pub struct MethodError;
    }
    pub mod query_string {
        use ::std::collections::HashMap;
        pub struct QueryString<'buf_lifetime> {
            data: HashMap<&'buf_lifetime str, Value<'buf_lifetime>>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl<'buf_lifetime> ::core::fmt::Debug for QueryString<'buf_lifetime> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match *self {
                    QueryString {
                        data: ref __self_0_0,
                    } => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_struct(f, "QueryString");
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "data",
                            &&(*__self_0_0),
                        );
                        ::core::fmt::DebugStruct::finish(debug_trait_builder)
                    }
                }
            }
        }
        pub enum Value<'buf_lifetime> {
            Single(&'buf_lifetime str),
            Multiple(Vec<&'buf_lifetime str>),
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl<'buf_lifetime> ::core::fmt::Debug for Value<'buf_lifetime> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match (&*self,) {
                    (&Value::Single(ref __self_0),) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "Single");
                        let _ = ::core::fmt::DebugTuple::field(debug_trait_builder, &&(*__self_0));
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&Value::Multiple(ref __self_0),) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "Multiple");
                        let _ = ::core::fmt::DebugTuple::field(debug_trait_builder, &&(*__self_0));
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                }
            }
        }
        impl<'buf_lifetime> QueryString<'buf_lifetime> {
            pub fn get(&self, key: &str) -> Option<&Value> {
                self.data.get(key)
            }
        }
        impl<'buf_lifetime> From<&'buf_lifetime str> for QueryString<'buf_lifetime> {
            fn from(s: &'buf_lifetime str) -> Self {
                let mut data = HashMap::new();
                for sub_str in s.split('&') {
                    let mut key = sub_str;
                    let mut val = "";
                    if let Some(i) = sub_str.find('=') {
                        key = &sub_str[..i];
                        val = &sub_str[i + 1..];
                    }
                    data.entry(key)
                        .and_modify(|existing: &mut Value| match existing {
                            Value::Single(prev_val) => {
                                *existing = Value::Multiple(<[_]>::into_vec(box [prev_val, val]));
                            }
                            Value::Multiple(vec) => vec.push(val),
                        })
                        .or_insert(Value::Single(val));
                }
                QueryString { data }
            }
        }
    }
    pub mod request {
        use super::method::{Method, MethodError};
        use super::QueryString;
        use std::convert::TryFrom;
        use std::error::Error;
        use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
        use std::str;
        use std::str::Utf8Error;
        pub struct Request<'buf_lifetime> {
            path: &'buf_lifetime str,
            query_string: Option<QueryString<'buf_lifetime>>,
            method: Method,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl<'buf_lifetime> ::core::fmt::Debug for Request<'buf_lifetime> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match *self {
                    Request {
                        path: ref __self_0_0,
                        query_string: ref __self_0_1,
                        method: ref __self_0_2,
                    } => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_struct(f, "Request");
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "path",
                            &&(*__self_0_0),
                        );
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "query_string",
                            &&(*__self_0_1),
                        );
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "method",
                            &&(*__self_0_2),
                        );
                        ::core::fmt::DebugStruct::finish(debug_trait_builder)
                    }
                }
            }
        }
        impl<'buf_lifetime> Request<'buf_lifetime> {
            pub fn path(&self) -> &str {
                &self.path
            }
            pub fn method(&self) -> &Method {
                &self.method
            }
            pub fn query_string(&self) -> Option<&QueryString> {
                self.query_string.as_ref()
            }
        }
        impl<'buf_lifetime> TryFrom<&'buf_lifetime [u8]> for Request<'buf_lifetime> {
            type Error = ParseError;
            fn try_from(buf: &'buf_lifetime [u8]) -> Result<Request<'buf_lifetime>, Self::Error> {
                let request = str::from_utf8(buf)?;
                let (method, request) = get_next_word(request).ok_or(ParseError::InvalidRequest)?;
                let (mut path, request) =
                    get_next_word(request).ok_or(ParseError::InvalidRequest)?;
                let (protocol, _) = get_next_word(request).ok_or(ParseError::InvalidRequest)?;
                if protocol != "HTTP/1.1" {
                    return Err(ParseError::InvalidProtocol);
                }
                let method: Method = method.parse()?;
                let mut query_string = None;
                if let Some(i) = path.find('?') {
                    query_string = Some(QueryString::from(&path[i + 1..]));
                    path = &path[..i];
                }
                Ok(Self {
                    path,
                    query_string,
                    method,
                })
            }
        }
        fn get_next_word<'a>(request: &'a str) -> Option<(&'a str, &'a str)> {
            for (i, c) in request.chars().enumerate() {
                if c == ' ' || c == '\r' {
                    return Some((&request[..i], &request[i + 1..]));
                }
            }
            None
        }
        impl From<Utf8Error> for ParseError {
            fn from(_: Utf8Error) -> Self {
                Self::InvalidEncoding
            }
        }
        impl From<MethodError> for ParseError {
            fn from(_: MethodError) -> Self {
                Self::InvalidMethod
            }
        }
        pub enum ParseError {
            InvalidRequest,
            InvalidEncoding,
            InvalidProtocol,
            InvalidMethod,
        }
        impl Error for ParseError {}
        impl Display for ParseError {
            fn fmt(&self, f: &mut Formatter) -> FmtResult {
                f.write_fmt(::core::fmt::Arguments::new_v1(
                    &[""],
                    &match (&self.message(),) {
                        (arg0,) => [::core::fmt::ArgumentV1::new(
                            arg0,
                            ::core::fmt::Display::fmt,
                        )],
                    },
                ))
            }
        }
        impl Debug for ParseError {
            fn fmt(&self, f: &mut Formatter) -> FmtResult {
                f.write_fmt(::core::fmt::Arguments::new_v1(
                    &[""],
                    &match (&self.message(),) {
                        (arg0,) => [::core::fmt::ArgumentV1::new(
                            arg0,
                            ::core::fmt::Display::fmt,
                        )],
                    },
                ))
            }
        }
        impl ParseError {
            fn message(&self) -> &str {
                match self {
                    Self::InvalidRequest => "Invalid Request",
                    Self::InvalidEncoding => "Invalid Encoding",
                    Self::InvalidProtocol => "Invalid Protocol",
                    Self::InvalidMethod => "Invalid Method",
                }
            }
        }
    }
    pub mod response {
        use std::net::TcpStream;
        use std::io::{Write, Result as IoResult};
        use std::fmt::{Display, Formatter, Result as FmtResult};
        use super::StatusCode;
        pub struct Response {
            status_code: StatusCode,
            body: Option<String>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for Response {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match *self {
                    Response {
                        status_code: ref __self_0_0,
                        body: ref __self_0_1,
                    } => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_struct(f, "Response");
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "status_code",
                            &&(*__self_0_0),
                        );
                        let _ = ::core::fmt::DebugStruct::field(
                            debug_trait_builder,
                            "body",
                            &&(*__self_0_1),
                        );
                        ::core::fmt::DebugStruct::finish(debug_trait_builder)
                    }
                }
            }
        }
        impl Response {
            pub fn new(status_code: StatusCode, body: Option<String>) -> Self {
                Response { status_code, body }
            }
            pub fn send(&self, stream: &mut impl Write) -> IoResult<()> {
                let body = match &self.body {
                    Some(b) => b,
                    None => "",
                };
                stream.write_fmt(::core::fmt::Arguments::new_v1(
                    &["HTTP/1.1 ", " ", "\r\n\r\n"],
                    &match (&self.status_code, &self.status_code.reason_phrase(), &body) {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ))
            }
        }
        impl Display for Response {
            fn fmt(&self, f: &mut Formatter) -> FmtResult {
                let body = match &self.body {
                    Some(b) => b,
                    None => "",
                };
                f.write_fmt(::core::fmt::Arguments::new_v1(
                    &["HTTP/1.1 ", " ", "\r\n\r\n"],
                    &match (&self.status_code, &self.status_code.reason_phrase(), &body) {
                        (arg0, arg1, arg2) => [
                            ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
                            ::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
                        ],
                    },
                ))
            }
        }
    }
    pub mod status_code {
        use std::fmt::{Display, Formatter, Result as FmtResult};
        pub enum StatusCode {
            Ok = 200,
            BadRequest = 400,
            NotFound = 404,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::marker::Copy for StatusCode {}
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::clone::Clone for StatusCode {
            #[inline]
            fn clone(&self) -> StatusCode {
                {
                    *self
                }
            }
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::core::fmt::Debug for StatusCode {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                match (&*self,) {
                    (&StatusCode::Ok,) => {
                        let debug_trait_builder = &mut ::core::fmt::Formatter::debug_tuple(f, "Ok");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&StatusCode::BadRequest,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "BadRequest");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                    (&StatusCode::NotFound,) => {
                        let debug_trait_builder =
                            &mut ::core::fmt::Formatter::debug_tuple(f, "NotFound");
                        ::core::fmt::DebugTuple::finish(debug_trait_builder)
                    }
                }
            }
        }
        impl StatusCode {
            pub fn reason_phrase(&self) -> &str {
                match self {
                    Self::Ok => "Ok",
                    Self::BadRequest => "Bad Request",
                    Self::NotFound => "Not Found",
                }
            }
        }
        impl Display for StatusCode {
            fn fmt(&self, f: &mut Formatter) -> FmtResult {
                f.write_fmt(::core::fmt::Arguments::new_v1(
                    &[""],
                    &match (&(*self as u16),) {
                        (arg0,) => [::core::fmt::ArgumentV1::new(
                            arg0,
                            ::core::fmt::Display::fmt,
                        )],
                    },
                ))
            }
        }
    }
}
mod server {
    use crate::http::{Request, Response, StatusCode, ParseError};
    use std::convert::TryFrom;
    use std::io::{Read, Write};
    use std::net::TcpListener;
    pub struct Server {
        addr: String,
    }
    pub trait Handler {
        fn handle_request(&mut self, request: &Request) -> Response;
        fn handle_bad_request(&mut self, e: &ParseError) -> Response {
            {
                ::std::io::_print(::core::fmt::Arguments::new_v1(
                    &["Failed to parse request: ", "\n"],
                    &match (&e,) {
                        (arg0,) => [::core::fmt::ArgumentV1::new(
                            arg0,
                            ::core::fmt::Display::fmt,
                        )],
                    },
                ));
            };
            Response::new(StatusCode::BadRequest, None)
        }
    }
    impl Server {
        pub fn new(addr: String) -> Self {
            Server { addr }
        }
        pub fn run(self, mut handler: impl Handler) {
            {
                ::std::io::_print(::core::fmt::Arguments::new_v1(
                    &["Listening on ", "\n"],
                    &match (&self.addr,) {
                        (arg0,) => [::core::fmt::ArgumentV1::new(
                            arg0,
                            ::core::fmt::Display::fmt,
                        )],
                    },
                ));
            };
            let listener = TcpListener::bind(&self.addr).unwrap();
            loop {
                match listener.accept() {
                    Ok((mut stream, addr)) => {
                        {
                            ::std::io::_print(::core::fmt::Arguments::new_v1(
                                &["Listening on address ", "\n"],
                                &match (&addr,) {
                                    (arg0,) => [::core::fmt::ArgumentV1::new(
                                        arg0,
                                        ::core::fmt::Display::fmt,
                                    )],
                                },
                            ));
                        };
                        let mut buffer = [0; 1024];
                        match stream.read(&mut buffer) {
                            Ok(_) => {
                                {
                                    ::std::io::_print(::core::fmt::Arguments::new_v1(
                                        &["Receive a request: ", "\n"],
                                        &match (&String::from_utf8_lossy(&buffer),) {
                                            (arg0,) => [::core::fmt::ArgumentV1::new(
                                                arg0,
                                                ::core::fmt::Display::fmt,
                                            )],
                                        },
                                    ));
                                };
                                let response = match Request::try_from(&buffer[..]) {
                                    Ok(request) => handler.handle_request(&request),
                                    Err(e) => handler.handle_bad_request(&e),
                                };
                                if let Err(e) = response.send(&mut stream) {
                                    {
                                        ::std::io::_print(::core::fmt::Arguments::new_v1(
                                            &["Failed to send response: ", "\n"],
                                            &match (&e,) {
                                                (arg0,) => [::core::fmt::ArgumentV1::new(
                                                    arg0,
                                                    ::core::fmt::Display::fmt,
                                                )],
                                            },
                                        ));
                                    };
                                }
                            }
                            Err(e) => {
                                ::std::io::_print(::core::fmt::Arguments::new_v1(
                                    &["Failed to read from connection: ", "\n"],
                                    &match (&e,) {
                                        (arg0,) => [::core::fmt::ArgumentV1::new(
                                            arg0,
                                            ::core::fmt::Display::fmt,
                                        )],
                                    },
                                ));
                            }
                        }
                    }
                    Err(e) => {
                        {
                            ::std::io::_print(::core::fmt::Arguments::new_v1(
                                &["Failed to establish a connection: ", "\n"],
                                &match (&e,) {
                                    (arg0,) => [::core::fmt::ArgumentV1::new(
                                        arg0,
                                        ::core::fmt::Display::fmt,
                                    )],
                                },
                            ));
                        };
                    }
                }
            }
        }
    }
}
mod website_handler {
    use super::server::Handler;
    use super::http::{Request, Response, StatusCode, Method};
    pub struct WebsiteHandler {
        public_path: String,
    }
    impl WebsiteHandler {
        pub fn new(public_path: String) -> Self {
            Self { public_path }
        }
    }
    impl Handler for WebsiteHandler {
        fn handle_request(&mut self, request: &Request) -> Response {
            match request.method() {
                Method::GET => match request.path() {
                    "/" => Response::new(StatusCode::Ok, Some("<h1>Welcome</h1>.".to_string())),
                    "/hello" => Response::new(StatusCode::Ok, Some("<h1>Hello!</h1>.".to_string())),
                    _ => Response::new(StatusCode::NotFound, None),
                },
                _ => Response::new(StatusCode::NotFound, None),
            }
        }
    }
}
fn main() {
    let default_path = "/Users/fedecaccia/code/courses/rust/udemy/http_server";
    let public_path = env::var("PUBLIC_PATH").unwrap();
    let server = Server::new("127.0.0.1:8080".to_string());
    server.run(WebsiteHandler::new(public_path));
}