• actori-http 1.0.1/src/h1/encoder.rs
    103
    		 
                    }
    104
    		 
                    #[allow(clippy::write_with_newline)]
    105
    		 
                    write!(dst.writer(), "{}\r\n", len)?;
  • beatrice 0.3.2/src/event.rs
    34
    		 
        /// Returns `ErrorKind::WriteZero` when `buf` is not big enough to hold the event data.
    35
    		 
        #[allow(clippy::write_with_newline)]
    36
    		 
        pub fn write_to(&self, mut buf: &mut [u8]) -> Result<usize, std::io::Error> {
    51
    		 
        #[allow(clippy::write_with_newline)]
    52
    		 
        pub fn push_to(&self, buf: &mut Vec<u8>) {
  • eternal 0.3.2/src/http/h1/encoder.rs
    103
    		 
                    }
    104
    		 
                    #[allow(clippy::write_with_newline)]
    105
    		 
                    write!(dst.writer(), "{}\r\n", len)?;
  • gst-plugin-closedcaption 0.9.3/src/mcc_enc/imp.rs
    66
    		 
    impl MccEnc {
    67
    		 
        #[allow(clippy::write_with_newline)]
    68
    		 
        fn generate_headers(&self, _state: &State, buffer: &mut Vec<u8>) -> Result<(), gst::FlowError> {
  • hreq-h1 0.3.10/src/http11.rs
    18
    		 
    /// Write an http/1.1 request to a buffer.
    19
    		 
    #[allow(clippy::write_with_newline)]
    20
    		 
    pub fn write_http1x_req(req: &http::Request<()>, buf: &mut [u8]) -> Result<usize, io::Error> {
    91
    		 
    /// Write an http/1.x response to a buffer.
    92
    		 
    #[allow(clippy::write_with_newline)]
    93
    		 
    pub fn write_http1x_res(res: &http::Response<()>, buf: &mut [u8]) -> Result<usize, io::Error> {
  • klogger 0.0.16/src/lib.rs
    208
    		 
            use core::fmt::Write;
    209
    		 
            #[allow(clippy::write_with_newline)]
    210
    		 
            write!(self, "\r\n").expect("Newline");
  • marktwin 0.4.2/src/emitter.rs
    88
    		 
    fn newline<W: Write, N: traits::Newline>(writer: &mut W, _node: &N) -> io::Result<()> {
    89
    		 
      #[allow(clippy::write_with_newline)]
    90
    		 
      write!(writer, "<br />\n")?;
  • minimal-yaml 0.1.5/src/lib.rs
    69
    		 
                                Yaml::Sequence(..) | Yaml::Mapping(..) => {
    70
    		 
                                    #[allow(clippy::write_with_newline)]
    71
    		 
                                    write!(f, "\n")?;
    111
    		 
                                    print_yaml(&entry.value, indent, f, PrintStyle::Block)?;
    112
    		 
                                    #[allow(clippy::write_with_newline)]
    113
    		 
                                    write!(f, "\n")?;
    115
    		 
                                Yaml::Sequence(..) | Yaml::Mapping(..) => {
    116
    		 
                                    #[allow(clippy::write_with_newline)]
    117
    		 
                                    write!(f, "\n")?;
  • mockito 0.31.1/src/lib.rs
    1358
    		 
        #[allow(deprecated)]
    1359
    		 
        #[allow(clippy::write_with_newline)]
    1360
    		 
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  • quartz_nbt 0.2.6/src/tag.rs
    268
    		 
        #[allow(clippy::write_with_newline)]
    269
    		 
        fn to_formatted_snbt(&self, indent: &mut String, f: &mut Formatter<'_>) -> fmt::Result {
    822
    		 
        #[allow(clippy::write_with_newline)]
    823
    		 
        fn to_formatted_snbt(&self, indent: &mut String, f: &mut Formatter<'_>) -> fmt::Result {
    1251
    		 
        #[allow(clippy::write_with_newline)]
    1252
    		 
        fn to_formatted_snbt(&self, indent: &mut String, f: &mut Formatter<'_>) -> fmt::Result {
  • requiem-http 1.0.1/src/h1/encoder.rs
    103
    		 
                    }
    104
    		 
                    #[allow(clippy::write_with_newline)]
    105
    		 
                    write!(dst.writer(), "{}\r\n", len)?;
  • risq 0.4.1/src/p2p/tor.rs
    231
    		 
    #[allow(clippy::write_with_newline)]
    232
    		 
    fn send_command(writer: &mut impl Write, command: String) -> Result<(), io::Error> {
  • rustos 0.4.3/examples/post03.rs
    177
    		 
        for i in 0..20 {
    178
    		 
            #[allow(clippy::write_with_newline)]
    179
    		 
            write!(writer, "The numbers are {} and {}\n", 42 + i, 1.0 / 3.0).unwrap();
  • scrappy-http 0.0.1/src/h1/encoder.rs
    103
    		 
                    }
    104
    		 
                    #[allow(clippy::write_with_newline)]
    105
    		 
                    write!(dst.writer(), "{}\r\n", len)?;
  • servlin 0.1.1/src/event.rs
    34
    		 
        /// Returns `ErrorKind::WriteZero` when `buf` is not big enough to hold the event data.
    35
    		 
        #[allow(clippy::write_with_newline)]
    36
    		 
        pub fn write_to(&self, mut buf: &mut [u8]) -> Result<usize, std::io::Error> {
    51
    		 
        #[allow(clippy::write_with_newline)]
    52
    		 
        pub fn push_to(&self, buf: &mut Vec<u8>) {
  • ureq 2.6.2/src/test/mod.rs
    42
    		 
    #[allow(clippy::write_with_newline)]
    43
    		 
    pub(crate) fn make_response(
  • ureq 2.6.2/src/unit.rs
    400
    		 
    /// Send request line + headers (all up until the body).
    401
    		 
    #[allow(clippy::write_with_newline)]
    402
    		 
    fn send_prelude(unit: &Unit, stream: &mut Stream) -> io::Result<()> {
  • yenc 0.2.2/src/encode.rs
    139
    		 
        /// must be specified. The input_filename ends up as the filename in the yenc header.
    140
    		 
        #[allow(clippy::write_with_newline)]
    141
    		 
        pub fn encode_stream<R, W>(
  • yooper 0.1.1/src/ssdp/packet/encoder.rs
    15
    		 
        #[allow(clippy::write_with_newline)]
    16
    		 
        fn encode(&mut self, p: Packet, dst: &mut BytesMut) -> Result<(), Self::Error> {
  • async-resol-vbus 0.1.0/src/lib.rs
    83
    		 
    #![allow(clippy::trivially_copy_pass_by_ref)]
    84
    		 
    #![allow(clippy::write_with_newline)]
  • blockfrost 0.2.0/src/error.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
  • bpaf 0.7.7/src/info.rs
    3
    		 
    #![allow(clippy::write_with_newline)]
    4
    		 
    use std::marker::PhantomData;
  • bpaf 0.7.7/src/meta_help.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
    2
    		 
    #![allow(clippy::match_like_matches_macro)]
  • clap_complete_fig 4.1.0/src/fig.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
  • cpp_build 0.5.7/src/lib.rs
    7
    		 
    #![allow(clippy::write_with_newline)]
  • cursion 0.1.0/src/lib.rs
    1
    		 
    //! Cursion is a pure Rust, cursor optimization library to avoid flickering in terminal like Curses.
    2
    		 
    #![allow(clippy::write_with_newline, clippy::write_literal)]
    3
    		 
    #![warn(missing_docs)]
  • exa 0.10.1/build.rs
    22
    		 
    fn main() -> io::Result<()> {
    23
    		 
        #![allow(clippy::write_with_newline)]
  • fancy-prompt 0.2.1/src/main.rs
    12
    		 
    #![allow(clippy::single_match)]
    13
    		 
    #![allow(clippy::write_with_newline)]
  • hbbft 0.1.1/tests/net/mod.rs
    9
    		 
    // We need to allow writes with newlines, resulting from `net_trace!` calls.
    10
    		 
    #![allow(clippy::write_with_newline)]
    11
    		 
    // Almost all of our types are fairly readable, but trigger the type complexity checks, probably
  • http_io 0.2.18/src/protocol.rs
    3
    		 
    // We do write! + '\r\n' and don't want to hide the line ending in a writeln!
    4
    		 
    #![allow(clippy::write_with_newline)]
  • implib 0.3.1/src/ar/write.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
  • lunatic-redis 0.1.3/tests/support/mod.rs
    217
    		 
    {
    218
    		 
        #![allow(clippy::write_with_newline)]
    219
    		 
        match *value {
  • mco-redis-rs 0.21.6/tests/support/mod.rs
    283
    		 
    {
    284
    		 
        #![allow(clippy::write_with_newline)]
    285
    		 
        match *value {
  • ocypod 0.8.0/tests/support/mod.rs
    253
    		 
    {
    254
    		 
        #![allow(clippy::write_with_newline)]
    255
    		 
        match *value {
  • ojcmp 0.4.0/benches/n_random.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
  • osm-geo-mapper 0.8.0/src/features.rs
    1
    		 
    #![allow(clippy::write_with_newline)]
  • owoof 0.2.0/src/sql.rs
    10
    		 
    //! in [`crate::driver`] instead.
    11
    		 
    #![allow(clippy::write_with_newline)]
  • phetch 1.2.0/src/lib.rs
    33
    		 
    #![allow(clippy::while_let_on_iterator)]
    34
    		 
    #![allow(clippy::write_with_newline)]
  • redis 0.22.3/tests/support/mod.rs
    313
    		 
    {
    314
    		 
        #![allow(clippy::write_with_newline)]
    315
    		 
        match *value {
  • redis-sk 0.17.1/tests/support/mod.rs
    337
    		 
    {
    338
    		 
        #![allow(clippy::write_with_newline)]
    339
    		 
        match *value {
  • resol-vbus 0.2.1/src/lib.rs
    135
    		 
    #![allow(clippy::trivially_copy_pass_by_ref)]
    136
    		 
    #![allow(clippy::write_with_newline)]
  • rfc822-like 0.2.1/src/ser/mod.rs
    625
    		 
        // so we need to ignore this nitpicky lint.
    626
    		 
        #![allow(clippy::write_with_newline)]
  • sip-codec 0.1.0/src/lib.rs
    1
    		 
    #![forbid(unsafe_code)]
    2
    		 
    #![allow(clippy::write_with_newline)]
    3
    		 
    #[macro_use]
  • sudoku 0.7.0/src/lib.rs
    10
    		 
            wrong_self_convention,
    11
    		 
            write_with_newline,
    12
    		 
        )
  • svf 0.3.0/src/display.rs
    4
    		 
    #![allow(clippy::write_with_newline)]
  • trezm-redis 0.15.2-alpha.0/tests/support/mod.rs
    236
    		 
    {
    237
    		 
        #![allow(clippy::write_with_newline)]
    238
    		 
        match *value {
  • vkcargo 0.45.1/src/cargo/lib.rs
    18
    		 
    #![allow(clippy::wrong_self_convention)] // perhaps `Rc` should be special-cased in Clippy?
    19
    		 
    #![allow(clippy::write_with_newline)] // too pedantic
    20
    		 
    #![allow(clippy::inefficient_to_string)] // this causes suggestions that result in `(*s).to_string()`
  • websocket 0.26.5/src/lib.rs
    3
    		 
    #![allow(
    4
    		 
    	clippy::write_with_newline,
    5
    		 
    	clippy::type_complexity,