staticdir 0.3.1

Providing list of directory entries for Iron framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

# staticdir

Serving directory contents for [Iron](https://github.com/iron/iron) web-framework. Documentation can be found [here](http://franza.github.io/staticdir/index.html).

## Purpose

Provides the list of files and directories in a mounted folder. To respond with files use [staticfile](https://github.com/iron/staticfile) along with this one. See examples.

## Example

Start web server at `http://localhost:3000` and mount current directory. List of directory contents will be available as JSON.

```rust
extern crate staticdir;
extern crate iron;

use iron::prelude::*;
use staticdir::{ StaticDir, AsJson };

fn main() {
    Iron::new(StaticDir::new(".", AsJson)).http("localhost:3000").unwrap();
}
```

This code will return you

```JSON
[
  {
    "file_type": "File",
    "file_name": ".gitignore",
    "size": 7,
    "creation_time": null,
    "last_modification_time": 1451939290,
    "last_access_time": 1451939309
  },
  {
    "file_type": "File",
    "file_name": "Cargo.toml",
    "size": 196,
    "creation_time": null,
    "last_modification_time": 1451939547,
    "last_access_time": 1451939547
  },
  {
    "file_type": "Dir",
    "file_name": "src",
    "size": 4096,
    "creation_time": null,
    "last_modification_time": 1451939462,
    "last_access_time": 1451939462
  }
]
```

## Customize behavior

You can customize the response using `ResponseStrategy` trait. Suppose you need an HTML response instead of JSON:

```rust
extern crate staticdir;
extern crate iron;

use iron::prelude::*;
use iron::status::Status;
use staticdir::{ StaticDir, ResponseStrategy };
use std::fs::ReadDir;
use iron::mime::Mime;

struct AsHtml;

fn build_html(dir: ReadDir) -> String {
    let mut html = String::new();
    for entry in dir {
        let entry = entry.unwrap();
        html = format!("{}<li>{}</li>", html, entry.file_name().into_string().unwrap());
    }
    format!("<ul>{}</ul>", html)
}

impl ResponseStrategy for AsHtml {
    fn make_response(&self, dir: ReadDir) -> IronResult<Response> {
        let html = build_html(dir);
        let content_type = "text/html; charset=utf-8".parse::<Mime>().unwrap();
        Ok(Response::with((Status::Ok, html, content_type)))
    }
}

fn main() {
    Iron::new(StaticDir::new(".", AsHtml)).http("localhost:3000").unwrap();
}
```

This will return an HTML page with next contents

```
* Cargo.toml
* src
* .git
```

### Working with iron components

You can use other modules of [iron core bundle](https://github.com/iron/iron#core-extensions) like [staticfile](https://github.com/iron/staticfile) and [mount](https://github.com/iron/mount).
In next example you will receive both directory listing and static files.

```rust
extern crate staticdir;
extern crate iron;
extern crate mount;
extern crate staticfile;

use iron::prelude::*;
use mount::Mount;
use staticdir::{ StaticDir, AsJson };
use staticfile::Static;


fn main() {
    let root = "tests/mount";
    let mut handle_statics = Chain::new(Static::new(root));
    handle_statics.link_after(StaticDir::new(root, AsJson));

    let mut mount = Mount::new();
    mount.mount("/static/", handle_statics);
    let mut server = Iron::new(mount).http("localhost:3000").unwrap();
}
```