Merge pull request #471 from svenstaro/show-hidden

Show hidden

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 <!-- next-header -->
 
 ## [Unreleased] - ReleaseDate
+- Add option `-H`/`--hidden` to show hidden files
 - Start instantly in case an explicit index is chosen
 - Fix DoS issue when deliberately sending unconforming URL paths
 - Add footer [#456](https://github.com/svenstaro/miniserve/pull/456) (thanks @levaitamas)

src/args.rs

@@ -69,6 +69,10 @@ struct CliArgs {
     #[structopt(short = "P", long = "no-symlinks")]
     no_symlinks: bool,
 
+    /// Show hidden files
+    #[structopt(short = "H", long = "hidden")]
+    hidden: bool,
+
     /// Default color scheme
     #[structopt(
         short = "c",
@@ -242,6 +246,7 @@ pub fn parse_args() -> crate::MiniserveConfig {
         auth: args.auth,
         path_explicitly_chosen,
         no_symlinks: args.no_symlinks,
+        show_hidden: args.hidden,
         random_route,
         favicon_route,
         css_route,

src/listing.rs

@@ -148,6 +148,7 @@ pub fn directory_listing(
     dir: &actix_files::Directory,
     req: &HttpRequest,
     skip_symlinks: bool,
+    show_hidden: bool,
     file_upload: bool,
     random_route: Option<String>,
     favicon_route: String,
@@ -248,7 +249,7 @@ pub fn directory_listing(
     let mut entries: Vec<Entry> = Vec::new();
 
     for entry in dir.path.read_dir()? {
-        if dir.is_visible(&entry) {
+        if dir.is_visible(&entry) || show_hidden {
             let entry = entry?;
             let p = match entry.path().strip_prefix(&dir.path) {
                 Ok(p) => base.join(p),

src/main.rs

@@ -48,6 +48,9 @@ pub struct MiniserveConfig {
     /// Enable symlink resolution
     pub no_symlinks: bool,
 
+    /// Show hidden files
+    pub show_hidden: bool,
+
     /// Enable random route generation
     pub random_route: Option<String>,
 
@@ -311,6 +314,7 @@ fn configure_app(app: &mut web::ServiceConfig, conf: &MiniserveConfig) {
     let serve_path = {
         let path = &conf.path;
         let no_symlinks = conf.no_symlinks;
+        let show_hidden = conf.show_hidden;
         let random_route = conf.random_route.clone();
         let favicon_route = conf.favicon_route.clone();
         let css_route = conf.css_route.clone();
@@ -336,31 +340,39 @@ fn configure_app(app: &mut web::ServiceConfig, conf: &MiniserveConfig) {
             )
         } else {
             let u_r = upload_route.clone();
-            Some(
-                actix_files::Files::new(&full_route, path)
+            let files;
+            if show_hidden {
+                files = actix_files::Files::new(&full_route, path)
                     .show_files_listing()
-                    .files_listing_renderer(move |dir, req| {
-                        listing::directory_listing(
-                            dir,
-                            req,
-                            no_symlinks,
-                            file_upload,
-                            random_route.clone(),
-                            favicon_route.clone(),
-                            css_route.clone(),
-                            &default_color_scheme,
-                            &default_color_scheme_dark,
-                            show_qrcode,
-                            u_r.clone(),
-                            tar_enabled,
-                            zip_enabled,
-                            dirs_first,
-                            hide_version_footer,
-                            title.clone(),
-                        )
-                    })
-                    .default_handler(web::to(error_404)),
-            )
+                    .use_hidden_files();
+            } else {
+                files = actix_files::Files::new(&full_route, path).show_files_listing();
+            }
+
+            let files = files
+                .files_listing_renderer(move |dir, req| {
+                    listing::directory_listing(
+                        dir,
+                        req,
+                        no_symlinks,
+                        show_hidden,
+                        file_upload,
+                        random_route.clone(),
+                        favicon_route.clone(),
+                        css_route.clone(),
+                        &default_color_scheme,
+                        &default_color_scheme_dark,
+                        show_qrcode,
+                        u_r.clone(),
+                        tar_enabled,
+                        zip_enabled,
+                        dirs_first,
+                        hide_version_footer,
+                        title.clone(),
+                    )
+                })
+                .default_handler(web::to(error_404));
+            Some(files)
         }
     };
 

tests/fixtures/mod.rs

@@ -18,10 +18,18 @@ pub static FILES: &[&str] = &[
     "⎙.mp4",
 ];
 
+/// Hidden files for testing purpose
+#[allow(dead_code)]
+pub static HIDDEN_FILES: &[&str] = &[".hidden_file1", ".hidden_file2"];
+
 /// Directory names for testing purpose
 #[allow(dead_code)]
 pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/"];
 
+/// Hidden directories for testing purpose
+#[allow(dead_code)]
+pub static HIDDEN_DIRECTORIES: &[&str] = &[".hidden_dir1/", ".hidden_dir2/"];
+
 /// Name of a deeply nested file
 #[allow(dead_code)]
 pub static DEEPLY_NESTED_FILE: &str = "very/deeply/nested/test.rs";
@@ -32,20 +40,26 @@ pub static DEEPLY_NESTED_FILE: &str = "very/deeply/nested/test.rs";
 #[allow(dead_code)]
 pub fn tmpdir() -> TempDir {
     let tmpdir = assert_fs::TempDir::new().expect("Couldn't create a temp dir for tests");
-    for &file in FILES {
+    let mut files = FILES.to_vec();
+    files.extend_from_slice(HIDDEN_FILES);
+    for file in &files {
         tmpdir
             .child(file)
             .write_str("Test Hello Yes")
             .expect("Couldn't write to file");
     }
-    for &directory in DIRECTORIES {
-        for &file in FILES {
+
+    let mut directories = DIRECTORIES.to_vec();
+    directories.extend_from_slice(HIDDEN_DIRECTORIES);
+    for directory in directories {
+        for file in &files {
             tmpdir
                 .child(format!("{}{}", directory, file))
                 .write_str(&format!("This is {}{}", directory, file))
                 .expect("Couldn't write to file");
         }
     }
+
     tmpdir
         .child(&DEEPLY_NESTED_FILE)
         .write_str("File in a deeply nested directory.")

tests/serve_request.rs

@@ -2,7 +2,8 @@ mod fixtures;
 
 use assert_cmd::prelude::*;
 use assert_fs::fixture::TempDir;
-use fixtures::{port, tmpdir, Error, DIRECTORIES, FILES};
+use fixtures::{port, tmpdir, Error, DIRECTORIES, FILES, HIDDEN_DIRECTORIES, HIDDEN_FILES};
+use http::StatusCode;
 use regex::Regex;
 use rstest::rstest;
 use select::document::Document;
@@ -76,6 +77,82 @@ fn serves_requests_with_non_default_port(tmpdir: TempDir, port: u16) -> Result<(
     Ok(())
 }
 
+#[rstest]
+fn serves_requests_hidden_files(tmpdir: TempDir, port: u16) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("miniserve")?
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .arg("--hidden")
+        .stdout(Stdio::null())
+        .spawn()?;
+
+    sleep(Duration::from_secs(1));
+
+    let body = reqwest::blocking::get(format!("http://localhost:{}", port).as_str())?
+        .error_for_status()?;
+    let parsed = Document::from_read(body)?;
+
+    for &file in FILES.into_iter().chain(HIDDEN_FILES) {
+        let f = parsed.find(|x: &Node| x.text() == file).next().unwrap();
+        assert_eq!(
+            format!("/{}", file),
+            percent_encoding::percent_decode_str(f.attr("href").unwrap()).decode_utf8_lossy(),
+        );
+    }
+
+    for &directory in DIRECTORIES.into_iter().chain(HIDDEN_DIRECTORIES) {
+        assert!(parsed
+            .find(|x: &Node| x.text() == directory)
+            .next()
+            .is_some());
+        let dir_body =
+            reqwest::blocking::get(format!("http://localhost:{}/{}", port, directory).as_str())?
+                .error_for_status()?;
+        let dir_body_parsed = Document::from_read(dir_body)?;
+        for &file in FILES.into_iter().chain(HIDDEN_FILES) {
+            assert!(dir_body_parsed
+                .find(|x: &Node| x.text() == file)
+                .next()
+                .is_some());
+        }
+    }
+
+    child.kill()?;
+
+    Ok(())
+}
+
+#[rstest]
+fn serves_requests_no_hidden_files_without_flag(tmpdir: TempDir, port: u16) -> Result<(), Error> {
+    let mut child = Command::cargo_bin("miniserve")?
+        .arg(tmpdir.path())
+        .arg("-p")
+        .arg(port.to_string())
+        .stdout(Stdio::null())
+        .spawn()?;
+
+    sleep(Duration::from_secs(1));
+
+    let body = reqwest::blocking::get(format!("http://localhost:{}", port).as_str())?
+        .error_for_status()?;
+    let parsed = Document::from_read(body)?;
+
+    for &hidden_item in HIDDEN_FILES.into_iter().chain(HIDDEN_DIRECTORIES) {
+        assert!(parsed
+            .find(|x: &Node| x.text() == hidden_item)
+            .next()
+            .is_none());
+        let resp =
+            reqwest::blocking::get(format!("http://localhost:{}/{}", port, hidden_item).as_str())?;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    child.kill()?;
+
+    Ok(())
+}
+
 #[rstest]
 fn serves_requests_with_randomly_assigned_port(tmpdir: TempDir) -> Result<(), Error> {
     let mut child = Command::cargo_bin("miniserve")?