Rename some Buffer's methods

- Buffer::write_str => Buffer::push_str
- Buffer::write_char => Buffer::push

sailfish/src/runtime/buffer.rs

@@ -101,7 +101,7 @@ impl Buffer {
     }
 
     #[inline]
-    pub fn write_str(&mut self, data: &str) {
+    pub fn push_str(&mut self, data: &str) {
         let size = data.len();
         if size > self.capacity - self.len {
             self.reserve(size);
@@ -114,9 +114,9 @@ impl Buffer {
     }
 
     #[inline]
-    pub fn write_char(&mut self, data: char) {
+    pub fn push(&mut self, data: char) {
         let mut buf = [0u8; 4];
-        self.write_str(data.encode_utf8(&mut buf));
+        self.push_str(data.encode_utf8(&mut buf));
     }
 
     unsafe fn realloc(&mut self, cap: usize) {
@@ -143,7 +143,7 @@ impl Drop for Buffer {
 impl fmt::Write for Buffer {
     #[inline]
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        Buffer::write_str(self, s);
+        Buffer::push_str(self, s);
         Ok(())
     }
 }
@@ -176,7 +176,7 @@ impl Add<&str> for Buffer {
 
     #[inline]
     fn add(mut self, other: &str) -> Buffer {
-        self.write_str(other);
+        self.push_str(other);
         self
     }
 }
@@ -184,7 +184,7 @@ impl Add<&str> for Buffer {
 impl AddAssign<&str> for Buffer {
     #[inline]
     fn add_assign(&mut self, other: &str) {
-        self.write_str(other)
+        self.push_str(other)
     }
 }
 
@@ -206,12 +206,12 @@ mod tests {
         assert_eq!(buffer.len, 0);
         assert_eq!(buffer.capacity, 0);
 
-        buffer.write_str("apple");
+        buffer.push_str("apple");
         assert!(!buffer.data.is_null());
         assert_eq!(buffer.len, 5);
         assert_eq!(buffer.capacity, 5);
 
-        buffer.write_str("pie");
+        buffer.push_str("pie");
         assert!(!buffer.data.is_null());
         assert_eq!(buffer.len, 8);
         assert_eq!(buffer.capacity, 10);
@@ -223,7 +223,7 @@ mod tests {
         let s = String::new();
         let mut buf = Buffer::from(s);
         assert_eq!(buf.as_str(), "");
-        buf.write_str("abc");
+        buf.push_str("abc");
         assert_eq!(buf.as_str(), "abc");
 
         // into non-empty string

sailfish/src/runtime/escape/mod.rs

@@ -51,7 +51,7 @@ pub fn escape_with<F: FnMut(&str)>(mut writer: F, feed: &str) {
 
 #[doc(hidden)]
 pub fn escape_to_buf(feed: &str, buf: &mut Buffer) {
-    escape_with(|e| buf.write_str(e), feed);
+    escape_with(|e| buf.push_str(e), feed);
 }
 
 /// write the escaped contents into `String`
@@ -152,9 +152,9 @@ mod tests {
 
             unsafe {
                 escape_to_buf(&*s, &mut buf1);
-                fallback::escape(&mut |s| buf2.write_str(s), s.as_bytes());
+                fallback::escape(&mut |s| buf2.push_str(s), s.as_bytes());
                 naive::escape(
-                    &mut |s| buf3.write_str(s),
+                    &mut |s| buf3.push_str(s),
                     s.as_ptr(),
                     s.as_ptr(),
                     s.as_ptr().add(s.len()),

sailfish/src/runtime/macros.rs

@@ -18,7 +18,7 @@ macro_rules! render_escaped {
 #[doc(hidden)]
 macro_rules! render_text {
     ($ctx:ident, $value:expr) => {
-        $ctx.buf.write_str($value)
+        $ctx.buf.push_str($value)
     };
 }
 

sailfish/src/runtime/render.rs

@@ -12,7 +12,7 @@ pub trait Render {
     fn render_escaped(&self, b: &mut Buffer) -> fmt::Result {
         let mut tmp = Buffer::new();
         self.render(&mut tmp)?;
-        b.write_str(tmp.as_str());
+        b.push_str(tmp.as_str());
         Ok(())
     }
 }
@@ -30,7 +30,7 @@ pub trait Render {
 // 
 //         impl<'a> fmt::Write for Wrapper<'a> {
 //             #[inline]
-//             fn write_str(&mut self, s: &str) -> fmt::Result {
+//             fn push_str(&mut self, s: &str) -> fmt::Result {
 //                 escape::escape_to_buf(s, self.0);
 //                 Ok(())
 //             }
@@ -43,7 +43,7 @@ pub trait Render {
 impl Render for str {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
-        b.write_str(self);
+        b.push_str(self);
         Ok(())
     }
 
@@ -57,7 +57,7 @@ impl Render for str {
 impl<'a> Render for &'a str {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
-        b.write_str(self);
+        b.push_str(self);
         Ok(())
     }
 
@@ -72,7 +72,7 @@ impl<'a> Render for &'a str {
 impl Render for String {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
-        b.write_str(self);
+        b.push_str(self);
         Ok(())
     }
 
@@ -87,18 +87,18 @@ impl Render for String {
 impl Render for char {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
-        b.write_char(*self);
+        b.push(*self);
         Ok(())
     }
 
     #[inline]
     fn render_escaped(&self, b: &mut Buffer) -> fmt::Result {
         match *self {
-            '\"' => b.write_str("&quot;"),
-            '&' => b.write_str("&amp;"),
-            '<' => b.write_str("&lt;"),
-            '>' => b.write_str("&gt;"),
-            _ => b.write_char(*self),
+            '\"' => b.push_str("&quot;"),
+            '&' => b.push_str("&amp;"),
+            '<' => b.push_str("&lt;"),
+            '>' => b.push_str("&gt;"),
+            _ => b.push(*self),
         }
         Ok(())
     }
@@ -108,7 +108,7 @@ impl<'a> Render for &'a Path {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
         // TODO: speed up on Windows using OsStrExt
-        b.write_str(&*self.to_string_lossy());
+        b.push_str(&*self.to_string_lossy());
         Ok(())
     }
 
@@ -122,7 +122,7 @@ impl<'a> Render for &'a Path {
 impl Render for PathBuf {
     #[inline]
     fn render(&self, b: &mut Buffer) -> fmt::Result {
-        b.write_str(&*self.to_string_lossy());
+        b.push_str(&*self.to_string_lossy());
         Ok(())
     }
 
@@ -167,7 +167,7 @@ impl Render for bool {
         } else {
             "false"
         };
-        b.write_str(s);
+        b.push_str(s);
         Ok(())
     }
 
@@ -185,13 +185,13 @@ macro_rules! render_int {
                 fn render(&self, b: &mut Buffer) -> fmt::Result {
                     let mut buffer = itoa::Buffer::new();
                     let s = buffer.format(*self);
-                    b.write_str(s);
+                    b.push_str(s);
                     Ok(())
                 }
 
                 #[inline]
                 fn render_escaped(&self, b: &mut Buffer) -> fmt::Result {
-                    // write_str without escape
+                    // push_str without escape
                     self.render(b)
                 }
             }
@@ -209,7 +209,7 @@ macro_rules! render_float {
                 fn render(&self, b: &mut Buffer) -> fmt::Result {
                     let mut buffer = ryu::Buffer::new();
                     let s = buffer.format(*self);
-                    b.write_str(s);
+                    b.push_str(s);
                     Ok(())
                 }