goish 0.20.6

Goish Rust — write Rust using Go idioms. Ports Go's standard library and syntax so Go programmers can write Rust code that reads and feels like Go.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// http::Response (client side) + http::ResponseWriter (server side).

use crate::errors::{error, nil};
use crate::net::http::body::Body;
use crate::net::http::request::Header;
use crate::types::{byte, int, int64, string};

/// `http.Response` — a client's view of a server's response.
///
///   (resp, err) := http.Get(url)
///   resp.StatusCode
///   resp.Header.Get("Content-Type")
///   resp.Body                     (io.ReadCloser)
pub struct Response {
    pub Status: string,       // "200 OK"
    pub StatusCode: int,      // 200
    pub Proto: string,        // "HTTP/1.1"
    pub Header: Header,
    pub Body: Body,
    pub ContentLength: int64,
    pub Request: Option<Box<crate::net::http::Request>>,
}

impl Response {
    pub(crate) fn empty(code: int) -> Response {
        Response {
            Status: format!("{} {}", code, crate::net::http::StatusText(code)).into(),
            StatusCode: code,
            Proto: "HTTP/1.1".into(),
            Header: Header::new(),
            Body: Body::empty(),
            ContentLength: 0,
            Request: None,
        }
    }
}

/// `http.ResponseWriter` — what a handler writes its response through.
///
///   fn handler(mut w: http::ResponseWriter, r: http::Request) {
///       w.Header().Set("Content-Type", "text/plain");
///       w.WriteHeader(200);
///       fmt::Fprintf!(&mut w, "hello %s", r.URL.Path);
///   }
pub struct ResponseWriter {
    pub(crate) header: Header,
    pub(crate) status: int,
    pub(crate) body: Vec<byte>,
    pub(crate) wrote_header: bool,
}

impl ResponseWriter {
    pub(crate) fn new() -> Self {
        ResponseWriter {
            header: Header::new(),
            status: 200,
            body: Vec::new(),
            wrote_header: false,
        }
    }

    /// `w.Header()` — return a mutable handle to the response headers.
    /// Mutations must happen BEFORE the first `Write` / `WriteHeader`.
    #[allow(non_snake_case)]
    pub fn Header(&mut self) -> &mut Header {
        &mut self.header
    }

    /// `w.WriteHeader(code)` — send the status line. If not called,
    /// the first `Write` implicitly sends 200.
    #[allow(non_snake_case)]
    pub fn WriteHeader(&mut self, code: int) {
        if !self.wrote_header {
            self.status = code;
            self.wrote_header = true;
        }
    }

    /// `w.Write(bytes)` — append to the response body. Implicitly sends
    /// status 200 on first call if `WriteHeader` wasn't used.
    #[allow(non_snake_case)]
    pub fn Write(&mut self, p: &[byte]) -> (int, error) {
        if !self.wrote_header { self.wrote_header = true; }
        self.body.extend_from_slice(p);
        (p.len() as int, nil)
    }
}

// Blanket `std::io::Write` so `fmt::Fprintf!(&mut w, ...)` works on
// a ResponseWriter exactly like it does on a `bytes::Buffer`.
impl std::io::Write for ResponseWriter {
    fn write(&mut self, p: &[u8]) -> std::io::Result<usize> {
        if !self.wrote_header { self.wrote_header = true; }
        self.body.extend_from_slice(p);
        Ok(p.len())
    }
    fn flush(&mut self) -> std::io::Result<()> { Ok(()) }
}