Merge pull request #94 from shnmorimoto/add_9-4_9_7

Add 9.5.4 - 9.5.7

Author: yuk1ty

Cargo.lock

@@ -8,6 +8,16 @@ edition = "2018"
 
 [dependencies]
 lib = { path = "../lib" }
+glob = "0.3.0"
+walkdir = "2"
+
+[[bin]]
+name = "main_9_2_1"
+path = "src/main_9_2_1.rs"
+
+[[bin]]
+name = "main_9_2_3"
+path = "src/main_9_2_3.rs"
 
 [[bin]]
 name = "main_9_2_4"
@@ -26,9 +36,17 @@ name = "9_5_3"
 path = "src/9_5_3/main.rs"
 
 [[bin]]
-name = "main_9_2_1"
-path = "src/main_9_2_1.rs"
+name = "9_5_4"
+path = "src/9_5_4/main.rs"
 
 [[bin]]
-name = "main_9_2_3"
-path = "src/main_9_2_3.rs"
+name = "9_5_5"
+path = "src/9_5_5/main.rs"
+
+[[bin]]
+name = "9_5_6"
+path = "src/9_5_6/main.rs"
+
+[[bin]]
+name = "9_5_7"
+path = "src/9_5_7/main.rs"

chapter9/Cargo.toml

@@ -0,0 +1,21 @@
+use lib::path::*;
+use std::path::Path;
+
+fn main() -> Result<(), PathError> {
+    //存在しないパスを指定した場合、エラーを返す
+
+    // パスをそのままクリーンにする
+    let path = Path::new("./chapter9/src/../src/9_5_4/main.rs").clean()?;
+    println!("{:?}", path);
+
+    // パスを絶対パスに整形
+    let abs_path = Path::new("./chapter9/src/9_5_4/main.rs").canonicalize()?;
+    println!("{:?}", abs_path);
+
+    // パスを相対パスに整形
+    let abs_path = Path::new("/usr/local/go/bin/go");
+    let rel_path = abs_path.strip_prefix("/usr/local/go")?;
+    println!("{:?}", rel_path);
+
+    Ok(())
+}

chapter9/src/9_5_4/main.rs

@@ -0,0 +1,21 @@
+use lib::path::{ExtendedPath, PathError};
+use std::path::{Path, PathBuf};
+
+// パス中のenvを展開した上でcleanする
+fn clean2(path: &Path) -> Result<PathBuf, PathError> {
+    let path = path.expand_env()?;
+    let path = path.clean()?;
+    Ok(path)
+}
+
+fn main() -> Result<(), PathError> {
+    //存在しないパスを指定した場合、エラーを返す
+
+    let path = Path::new("${HOME}/.bashrc");
+    println!("{:?}", clean2(path)?);
+
+    let path = Path::new("~/.bashrc");
+    println!("{:?}", clean2(path)?);
+
+    Ok(())
+}

chapter9/src/9_5_5/main.rs

@@ -0,0 +1,12 @@
+use glob::{glob, Pattern, PatternError};
+use std::path::PathBuf;
+
+fn main() -> Result<(), PatternError> {
+    let pattern = Pattern::new("image-*.png")?;
+    println!("{}", pattern.matches("image-100.png"));
+
+    let paths = glob("./*.png")?;
+    let files: Vec<PathBuf> = paths.into_iter().filter_map(Result::ok).collect();
+    println!("{:?}", files);
+    Ok(())
+}

chapter9/src/9_5_6/main.rs

@@ -0,0 +1,43 @@
+use lib::path::PathError;
+use std::{collections::HashSet, env};
+use walkdir::WalkDir;
+
+fn main() -> Result<(), PathError> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() == 1 {
+        println!(
+            "Find images
+
+Usage:
+    {} [path to find]",
+            &args[0]
+        );
+        std::process::exit(0);
+    }
+    let root = &args[1];
+    let image_suffix: HashSet<&'static str> = ["jpg", "jpeg", "png", "webp", "gif", "tiff", "eps"]
+        .iter()
+        .cloned()
+        .collect();
+    // ディレクトリのトラバースのためにwalkdir crateを利用する
+    // ディレクトリ、拡張子が合わないものについては、フィルタして除外する
+    // walkdir crateでは指定のディレクトリをスキップするような機能は存在しない
+    for path in WalkDir::new(root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|f| !f.file_type().is_dir())
+        .filter(|f| {
+            let extention_opt = f
+                .path()
+                .extension()
+                .and_then(|ext| ext.to_str())
+                .map(|ext| ext.to_lowercase());
+            let extention = extention_opt.as_deref().unwrap_or("");
+            image_suffix.contains(extention)
+        })
+    {
+        println!("{}", path.into_path().display());
+    }
+
+    Ok(())
+}

chapter9/src/9_5_7/main.rs

@@ -8,3 +8,5 @@ edition = "2018"
 
 [dependencies]
 crc32fast = "1.2.1"
+regex = "1.5"
+once_cell = "1.7.2"

lib/Cargo.toml

@@ -2,3 +2,4 @@ pub mod binary;
 pub mod env;
 pub mod image;
 pub mod io;
+pub mod path;

lib/src/lib.rs

@@ -0,0 +1,105 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+use std::path::Path;
+use std::path::PathBuf;
+use std::{env, ffi::OsStr};
+
+#[derive(Debug)]
+pub enum PathError {
+    IoError(std::io::Error),
+    StripPrefixError(std::path::StripPrefixError),
+    RegexError(regex::Error),
+    VarError(std::env::VarError),
+}
+
+impl From<std::io::Error> for PathError {
+    fn from(error: std::io::Error) -> Self {
+        PathError::IoError(error)
+    }
+}
+
+impl From<std::path::StripPrefixError> for PathError {
+    fn from(error: std::path::StripPrefixError) -> Self {
+        PathError::StripPrefixError(error)
+    }
+}
+
+impl From<regex::Error> for PathError {
+    fn from(error: regex::Error) -> Self {
+        PathError::RegexError(error)
+    }
+}
+
+impl From<std::env::VarError> for PathError {
+    fn from(error: std::env::VarError) -> Self {
+        PathError::VarError(error)
+    }
+}
+
+static RE_VAR: Lazy<Regex> = Lazy::new(|| Regex::new(r"\$\{(.+)\}").unwrap());
+
+static RE_VAR_WITHOUT_BRACES: Lazy<Regex> = Lazy::new(|| Regex::new(r"\$(.+)").unwrap());
+
+static TILDE: Lazy<&OsStr> = Lazy::new(|| OsStr::new("~"));
+
+/// extend path::Path
+/// add useful functions to path::Path
+///
+/// # Examples
+///
+/// ```
+/// use lib::path::{ExtendedPath, PathError};
+/// use std::path::Path;
+///
+/// fn main() -> Result<(), PathError> {
+///     let path = Path::new("./src/../Cargo.toml");
+///     let cleaned_path = path.clean()?;
+///     println!("cleaned path: {:?}", cleaned_path);
+///
+///     let path = Path::new("~/.cargo");
+///     let expanded_path = path.expand_env()?;
+///     println!("expanded env path: {:?}", expanded_path);
+///     Ok(())
+/// }
+/// ```
+pub trait ExtendedPath {
+    fn clean(&self) -> Result<PathBuf, PathError>;
+    fn expand_env(&self) -> Result<PathBuf, PathError>;
+}
+
+impl ExtendedPath for Path {
+    fn clean(&self) -> Result<PathBuf, PathError> {
+        let abs_path = self.canonicalize()?;
+        if self.is_absolute() {
+            return Ok(abs_path);
+        }
+        let current_dir = env::current_dir()?;
+        abs_path
+            .strip_prefix(current_dir)
+            .map(|path| path.to_path_buf())
+            .map_err(|e| e.into())
+    }
+
+    fn expand_env(&self) -> Result<PathBuf, PathError> {
+        let mut path_buf = PathBuf::new();
+        for path in self.iter() {
+            let path_str = path.to_string_lossy();
+            let caps_opt = RE_VAR
+                .captures(&path_str)
+                .or_else(|| RE_VAR_WITHOUT_BRACES.captures(&path_str));
+            if let Some(caps) = caps_opt {
+                let expanded_var = env::var(&caps[1])?;
+                path_buf.push(expanded_var);
+                continue;
+            }
+            if *TILDE == path {
+                let home_dir = env::var("HOME")?;
+                path_buf.push(home_dir);
+                continue;
+            }
+
+            path_buf.push(path);
+        }
+        Ok(path_buf)
+    }
+}