Merge branch 'main' of https://github.com/keltia/leftpad-rs into main

Author: keltia

Cargo.toml

@@ -1,13 +1,14 @@
 [package]
 name = "leftpad-rs"
-version = "1.0.1"
+version = "1.1.0"
 edition = "2018"
 authors = ["Ollivier Robert <roberto@keltia.net>"]
 keywords = ["leftpad", "joke"]
 repository = "https://github.com/keltia/leftpad-rs"
 license = "MIT"
 readme = "README.md"
 description = "Rust implementation of the Go Leftpad package."
+documentation = "https://docs.rs/leftpad-rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

README.md

@@ -1,6 +1,7 @@
 # Leftpad
 
 [![CircleCI](https://circleci.com/gh/keltia/leftpad-rs/tree/main.svg?style=shield)](https://circleci.com/gh/keltia/leftpad-rs/tree/main)
+[![dependency status](https://deps.rs/repo/github/keltia/leftpad-rs/status.svg)](https://deps.rs/repo/github/keltia/leftpad-rs)
 [![](https://img.shields.io/crates/v/leftpad-rs.svg)](https://crates.io/crates/leftpad-rs)
 [![Docs](https://docs.rs/leftpad-rs/badge.svg)](https://docs.rs/leftpad-rs)
 

examples/small.rs

@@ -0,0 +1,8 @@
+use leftpad_rs::{pad, pad_char};
+
+fn main() {
+    let s = "foo";
+
+    println!("{}", pad(s, 5));
+    println!("{:?}", pad_char(s, 5, 'b'));
+}

src/lib.rs

@@ -5,99 +5,93 @@
 //!
 //! Examples:
 //! ```
-//!   use crate::leftpad_rs::*;
+//!   use leftpad_rs::{pad,pad_char};
 //!
 //!   let r = pad("foo", 5);  // -> "  foo"
 //!
 //!   let s = pad_char("foo", 6, 'X');    // -> "XXXfoo"
 //! ```
 
 /// This module implements `pad` and `pad_char`.
-pub mod leftpad_rs {
-
-    /// Left-pads the string with spaces.
-    pub fn pad(s: &str, n: usize) -> String {
-        format!("{:>width$}", s, width = n)
-    }
+/// Left-pads the string with spaces.
+pub fn pad(s: &str, n: usize) -> String {
+    format!("{:>width$}", s, width = n)
+}
 
-    /// Left-pads the string with the supplied character.
-    pub fn pad_char(s: &str, n: usize, c: char) -> Result<String, &str> {
-        let l = s.len();
+/// Left-pads the string with the supplied character.
+pub fn pad_char(s: &str, n: usize, c: char) -> Result<String, &str> {
+    let l = s.len();
 
-        if n <= 0 {
-            return Err("invalid size");
-        }
-        if n <= l {
-            return Ok(s.to_string());
-        }
-        let f = c.to_string().repeat(n - l);
-        Ok(format!("{}{}", f, s))
+    if n == 0 {
+        return Err("invalid size");
     }
-
-    /// Useful alias
-    pub fn pad_with(s: &str, n: usize, c: char) -> Result<String, &str> {
-        pad_char(s, n, c)
+    if n <= l {
+        return Ok(s.to_string());
     }
-    
-    #[cfg(test)]
-    mod tests {
-        use super::*;
+    let f = c.to_string().repeat(n - l);
+    Ok(format!("{}{}", f, s))
+}
 
-        use rstest::rstest;
+/// Useful alias
+pub fn pad_with(s: &str, n: usize, c: char) -> Result<String, &str> {
+    pad_char(s, n, c)
+}
 
-        #[rstest]
-        #[case(2, "foo")]
-        #[case(3, "foo")]
-        #[case(4, " foo")]
-        #[case(5, "  foo")]
-        fn test_pad(#[case] n: usize, #[case] want: &str) {
-            assert_eq!(want, pad("foo", n));
-        }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-        #[test]
-        fn test_nopad() {
-            assert_ne!(pad("foo", 6), "foobar")
-        }
+    use rstest::rstest;
 
-        #[rstest]
-        #[case(2, "foo")]
-        #[case(3, "foo")]
-        #[case(4, "Xfoo")]
-        #[case(5, "XXfoo")]
-        fn test_pad_char(#[case] n: usize, #[case] want: &str) {
-            assert_eq!(Ok(want.to_string()), pad_char("foo", n, 'X'));
-        }
+    #[rstest]
+    #[case(2, "foo")]
+    #[case(3, "foo")]
+    #[case(4, " foo")]
+    #[case(5, "  foo")]
+    fn test_pad(#[case] n: usize, #[case] want: &str) {
+        assert_eq!(want, pad("foo", n));
+    }
 
-        #[test]
-        fn test_pad_char_0() {
-            assert_eq!(Err("invalid size"), pad_char("foo", 0, 'X'))
-        }
+    #[test]
+    fn test_nopad() {
+        assert_ne!(pad("foo", 6), "foobar")
+    }
 
-        #[test]
-        fn test_nopad_char() {
-            assert_ne!(Ok("foobar".to_string()), pad_char("foo", 6, 'X'))
-        }
+    #[rstest]
+    #[case(2, "foo")]
+    #[case(3, "foo")]
+    #[case(4, "Xfoo")]
+    #[case(5, "XXfoo")]
+    fn test_pad_char(#[case] n: usize, #[case] want: &str) {
+        assert_eq!(Ok(want.to_string()), pad_char("foo", n, 'X'));
+    }
 
-        #[rstest]
-        #[case(2, "foo")]
-        #[case(3, "foo")]
-        #[case(4, "Xfoo")]
-        #[case(5, "XXfoo")]
-        fn test_pad_with(#[case] n: usize, #[case] want: &str) {
-            assert_eq!(Ok(want.to_string()), pad_with("foo", n, 'X'));
-        }
+    #[test]
+    fn test_pad_char_0() {
+        assert_eq!(Err("invalid size"), pad_char("foo", 0, 'X'))
+    }
 
-        #[test]
-        fn test_pad_with_0() {
-            assert_eq!(Err("invalid size"), pad_with("foo", 0, 'X'))
-        }
+    #[test]
+    fn test_nopad_char() {
+        assert_ne!(Ok("foobar".to_string()), pad_char("foo", 6, 'X'))
+    }
 
-        #[test]
-        fn test_nopad_with() {
-            assert_ne!(Ok("foobar".to_string()), pad_with("foo", 6, 'X'))
-        }
+    #[rstest]
+    #[case(2, "foo")]
+    #[case(3, "foo")]
+    #[case(4, "Xfoo")]
+    #[case(5, "XXfoo")]
+    fn test_pad_with(#[case] n: usize, #[case] want: &str) {
+        assert_eq!(Ok(want.to_string()), pad_with("foo", n, 'X'));
+    }
 
+    #[test]
+    fn test_pad_with_0() {
+        assert_eq!(Err("invalid size"), pad_with("foo", 0, 'X'))
     }
-}
 
-pub use crate::leftpad_rs::*;
+    #[test]
+    fn test_nopad_with() {
+        assert_ne!(Ok("foobar".to_string()), pad_with("foo", 6, 'X'))
+    }
+}