merge master

Author: AndyGauge

src/SUMMARY.md

@@ -2,7 +2,6 @@
 
 [Table of Contents](intro.md)
 [About](about.md)
-
 - [Algorithms](algorithms.md)
   - [Generate Random Values](algorithms/randomness.md)
 - [Command Line](cli.md)
@@ -46,6 +45,7 @@
 - [Web Programming](web.md)
   - [Scraping Web Pages](web/scraping.md)
   - [Uniform Resource Location](web/url.md)
+  - [Media Types](web/mime.md)
   - [Clients](web/clients.md)
     - [Making Requests](web/clients/requests.md)
     - [Using APIs](web/clients/apis.md)

src/concurrency/parallel/rayon-thumbnails.md

@@ -16,7 +16,7 @@ extern crate image;
 extern crate rayon;
 
 use std::path::Path;
-use std::fs::{create_dir_all, File};
+use std::fs::create_dir_all;
 
 # use error_chain::ChainedError;
 use glob::{glob_with, MatchOptions};
@@ -71,10 +71,10 @@ where
     PB: AsRef<Path>,
 {
     let img = image::open(original.as_ref())?;
-    let fout = &mut File::create(thumb_dir.as_ref().join(original))?;
+    let file_path = thumb_dir.as_ref().join(original);
 
     Ok(img.resize(longest_edge, longest_edge, FilterType::Nearest)
-        .save(fout, image::JPEG)?)
+        .save(file_path)?)
 }
 #
 # quick_main!(run);

src/development_tools/debugging/config_log/log-custom.md

@@ -8,7 +8,7 @@ Configures log to be output into custom location with [log4rs]. [log4rs] can use
 Firstly creates the log configuration with [`log4rs::append::file::FileAppender`]
 using a custom pattern from [`log4rs::encode::pattern`].
 
-Secondly assigns it to the [`log4rs::config::Config`] which has a root appender that uses the previously created `logfile` appender. Subsequently sets the default [`log::LogLevelFilter`] so that any logs with `Info` level or higher will be sent to the logger.
+Secondly assigns it to the [`log4rs::config::Config`] which has a root appender that uses the previously created `logfile` appender. Subsequently sets the default [`log::LevelFilter`] so that any logs with `Info` level or higher will be sent to the logger.
 
 ```rust,no_run
 # #[macro_use]
@@ -17,7 +17,7 @@ Secondly assigns it to the [`log4rs::config::Config`] which has a root appender
 extern crate log;
 extern crate log4rs;
 
-use log::LogLevelFilter;
+use log::LevelFilter;
 use log4rs::append::file::FileAppender;
 use log4rs::encode::pattern::PatternEncoder;
 use log4rs::config::{Appender, Config, Root};
@@ -39,7 +39,7 @@ fn run() -> Result<()> {
         .appender(Appender::builder().build("logfile", Box::new(logfile)))
         .build(Root::builder()
                    .appender("logfile")
-                   .build(LogLevelFilter::Info))?;
+                   .build(LevelFilter::Info))?;
 
     log4rs::init_config(config)?;
 
@@ -54,4 +54,4 @@ fn run() -> Result<()> {
 [`log4rs::append::file::FileAppender`]: https://docs.rs/log4rs/*/log4rs/append/file/struct.FileAppender.html
 [`log4rs::config::Config`]: https://docs.rs/log4rs/*/log4rs/config/struct.Config.html
 [`log4rs::encode::pattern`]: https://docs.rs/log4rs/*/log4rs/encode/pattern/index.html
-[`log::LogLevelFilter`]: https://doc.rust-lang.org/log/log/enum.LogLevelFilter.html
+[`log::LevelFilter`]: https://docs.rs/log/*/log/enum.LevelFilter.html

src/development_tools/debugging/config_log/log-env-variable.md

@@ -3,46 +3,34 @@
 
 [![log-badge]][log] [![env_logger-badge]][env_logger] [![cat-debugging-badge]][cat-debugging]
 
-Logging is configured with [`LogBuilder`].
+Logging is configured with [`Builder`].
 
-[`LogBuilder::parse`] parses `MY_APP_LOG`
+[`Builder::parse`] parses `MY_APP_LOG`
 environmental variable contents in the form of [`RUST_LOG`] syntax.
-Then [`LogBuilder::init`] initializes the logger.
+Then [`Builder::init`] initializes the logger.
 All these steps are normally done internally by [`env_logger::init`].
 
 ```rust
-# #[macro_use]
-# extern crate error_chain;
 #[macro_use]
 extern crate log;
 extern crate env_logger;
 
 use std::env;
-use env_logger::LogBuilder;
-
-# error_chain! {
-#     foreign_links {
-#         EnvLogger(log::SetLoggerError);
-#     }
-# }
-#
-fn run() -> Result<()> {
-    LogBuilder::new()
+use env_logger::Builder;
+
+fn main() {
+    Builder::new()
         .parse(&env::var("MY_APP_LOG").unwrap_or_default())
-        .init()?;
+        .init();
 
     info!("informational message");
     warn!("warning message");
     error!("this is an error {}", "message");
-
-    Ok(())
 }
-#
-# quick_main!(run);
 ```
 
 [`env_logger::init`]: https://doc.rust-lang.org/log/env_logger/fn.init.html
-[`LogBuilder`]: https://doc.rust-lang.org/log/env_logger/struct.Builder.html
-[`LogBuilder::init`]: https://doc.rust-lang.org/log/env_logger/struct.LogBuilder.html#method.init
-[`LogBuilder::parse`]: https://doc.rust-lang.org/log/env_logger/struct.LogBuilder.html#method.parse
+[`Builder`]: https://docs.rs/env_logger/*/env_logger/struct.Builder.html
+[`Builder::init`]: https://docs.rs/env_logger/*/env_logger/struct.Builder.html#method.init
+[`Builder::parse`]: https://docs.rs/env_logger/*/env_logger/struct.Builder.html#method.parsese
 [`RUST_LOG`]: https://doc.rust-lang.org/log/env_logger/#enabling-logging

src/development_tools/debugging/config_log/log-mod.md

@@ -7,8 +7,6 @@ Creates two modules `foo` and nested `foo::bar` with logging directives
 controlled separately with [`RUST_LOG`] environmental variable.
 
 ```rust
-# #[macro_use]
-# extern crate error_chain;
 #[macro_use]
 extern crate log;
 extern crate env_logger;
@@ -29,24 +27,14 @@ mod foo {
         bar::run();
     }
 }
-#
-# error_chain! {
-#     foreign_links {
-#         SetLogger(log::SetLoggerError);
-#     }
-# }
 
-fn run() -> Result<()> {
-    env_logger::init()?;
+fn main() {
+    env_logger::init();
     warn!("[root] warn");
     info!("[root] info");
     debug!("[root] debug");
     foo::run();
-
-    Ok(())
 }
-#
-# quick_main!(run);
 ```
 
 [`env_logger`][env_logger] output is controlled by [`RUST_LOG`] environmental
@@ -57,7 +45,7 @@ Running the `test` application as follows:
 RUST_LOG="warn,test::foo=info,test::foo::bar=debug" ./test
 ```
 
-Sets the default [`log::LogLevel`] to `warn`, module's `foo` and module's `foo::bar`
+Sets the default [`log::Level`] to `warn`, module's `foo` and module's `foo::bar`
 respectively to `info` and `debug`. The output is:
 
 ```bash
@@ -69,5 +57,5 @@ INFO:test::foo::bar: [bar] info
 DEBUG:test::foo::bar: [bar] debug
 ```
 
-[`log::LogLevel`]: https://doc.rust-lang.org/log/log/enum.LogLevel.html
+[`log::Level`]: https://docs.rs/log/*/log/enum.Level.html
 [`RUST_LOG`]: https://doc.rust-lang.org/log/env_logger/#enabling-logging

src/development_tools/debugging/config_log/log-timestamp.md

@@ -3,49 +3,40 @@
 
 [![log-badge]][log] [![env_logger-badge]][env_logger] [![chrono-badge]][chrono] [![cat-debugging-badge]][cat-debugging]
 
-Creates a custom logger configuration with [`LogBuilder`].
+Creates a custom logger configuration with [`Builder`].
 Each log entry calls [`Local::now`] to get the current [`DateTime`] in local timezone and uses [`DateTime::format`] with [`strftime::specifiers`] to format a timestamp used in the final log.
 
-The example calls [`LogBuilder::format`] to set a closure which formats each
-message text with timestamp, [`LogRecord::level`] and body ([`LogRecord::args`]).
+The example calls [`Builder::format`] to set a closure which formats each
+message text with timestamp, [`Record::level`] and body ([`Record::args`]).
 
 ```rust
-# #[macro_use]
-# extern crate error_chain;
 #[macro_use]
 extern crate log;
-extern crate env_logger;
 extern crate chrono;
+extern crate env_logger;
 
 use std::env;
-use env_logger::LogBuilder;
+use std::io::Write;
 use chrono::Local;
-
-#
-# error_chain! {
-#     foreign_links {
-#         SetLogger(log::SetLoggerError);
-#     }
-# }
-
-fn run() -> Result<()> {
-    LogBuilder::new()
-        .format(|record| {
-                    format!("{} [{}] - {}",
-                            Local::now().format("%Y-%m-%dT%H:%M:%S"),
-                            record.level(),
-                            record.args())
-                })
+use env_logger::Builder;
+
+fn main() {
+    Builder::new()
+        .format(|buf, record| {
+            write!(buf,
+                "{} [{}] - {}",
+                Local::now().format("%Y-%m-%dT%H:%M:%S"),
+                record.level(),
+                record.args()
+            )
+        })
         .parse(&env::var("MY_APP_LOG").unwrap_or_default())
-        .init()?;
+        .init();
 
     warn!("warn");
     info!("info");
     debug!("debug");
-    Ok(())
 }
-#
-# quick_main!(run);
 ```
 Calling `MY_APP_LOG="info" cargo run` will result in similar output:
 ```
@@ -56,8 +47,8 @@ Calling `MY_APP_LOG="info" cargo run` will result in similar output:
 [`DateTime::format`]: https://docs.rs/chrono/*/chrono/datetime/struct.DateTime.html#method.format
 [`DateTime`]: https://docs.rs/chrono/*/chrono/datetime/struct.DateTime.html
 [`Local::now`]: https://docs.rs/chrono/*/chrono/offset/local/struct.Local.html#method.now
-[`LogBuilder`]: https://doc.rust-lang.org/log/env_logger/struct.Builder.html
-[`LogBuilder::format`]: https://doc.rust-lang.org/log/env_logger/struct.LogBuilder.html#method.format
-[`LogRecord::args`]: https://doc.rust-lang.org/log/log/struct.LogRecord.html#method.args
-[`LogRecord::level`]: https://doc.rust-lang.org/log/log/struct.LogRecord.html#method.level
+[`Builder`]: https://docs.rs/env_logger/*/env_logger/struct.Builder.html
+[`Builder::format`]: https://docs.rs/env_logger/*/env_logger/struct.Builder.html#method.format
+[`Record::args`]: https://docs.rs/log/*/log/struct.Record.html#method.args
+[`Record::level`]: https://docs.rs/log/*/log/struct.Record.html#method.level
 [`strftime::specifiers`]: https://docs.rs/chrono/*/chrono/format/strftime/index.html#specifiers

src/development_tools/debugging/log/log-custom-logger.md

@@ -13,20 +13,24 @@ the [`log::Log`] trait and has to be installed via [`log::set_logger`].
 #[macro_use]
 extern crate log;
 
-use log::{LogRecord, LogLevel, LogMetadata, LogLevelFilter};
+use log::{Record, Level, Metadata, LevelFilter};
+
+static CONSOLE_LOGGER: ConsoleLogger = ConsoleLogger;
 
 struct ConsoleLogger;
 
 impl log::Log for ConsoleLogger {
-    fn enabled(&self, metadata: &LogMetadata) -> bool {
-        metadata.level() <= LogLevel::Info
+  fn enabled(&self, metadata: &Metadata) -> bool {
+     metadata.level() <= Level::Info
     }
 
-    fn log(&self, record: &LogRecord) {
+    fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
             println!("Rust says: {} - {}", record.level(), record.args());
         }
     }
+
+    fn flush(&self) {}
 }
 #
 # error_chain! {
@@ -36,10 +40,8 @@ impl log::Log for ConsoleLogger {
 # }
 
 fn run() -> Result<()> {
-    log::set_logger(|max_log_level| {
-                        max_log_level.set(LogLevelFilter::Info);
-                        Box::new(ConsoleLogger)
-                    })?;
+    log::set_logger(&CONSOLE_LOGGER)?;
+    log::set_max_level(LevelFilter::Info);
 
     info!("hello log");
     warn!("warning");

src/development_tools/debugging/log/log-debug.md

@@ -10,30 +10,16 @@ logging via an environment variable.
 #[macro_use]
 extern crate log;
 extern crate env_logger;
-#
-# #[macro_use]
-# extern crate error_chain;
-#
-# error_chain! {
-#     foreign_links {
-#         SetLogger(log::SetLoggerError);
-#     }
-# }
 
 fn execute_query(query: &str) {
     debug!("Executing query: {}", query);
-
 }
 
-fn run() -> Result<()> {
-    env_logger::init()?;
+fn main {
+    env_logger::init();
 
     execute_query("DROP TABLE students");
-
-    Ok(())
 }
-#
-# quick_main!(run);
 ```
 
 If you run this code, you'll notice that no output is printed. By default, the

src/development_tools/debugging/log/log-error.md

@@ -7,35 +7,22 @@
 #[macro_use]
 extern crate log;
 extern crate env_logger;
-#
-# #[macro_use]
-# extern crate error_chain;
-#
-# error_chain! {
-#     foreign_links {
-#         SetLogger(log::SetLoggerError);
-#     }
-# }
 
 fn execute_query(_query: &str) -> Result<()> {
     // Do the thing, or maybe not
 
     bail!("I'm afraid I can't do that")
 }
 
-fn run() -> Result<()> {
-    env_logger::init()?;
+fn main() {
+    env_logger::init();
 
     let response = execute_query("DROP TABLE students");
     if let Err(err) = response {
         // Log the error message and continue
         error!("Failed to execute query: {}", err);
     }
-
-    Ok(())
 }
-#
-# quick_main!(run);
 ```
 
 Run this code with `cargo run` and you should see the following line: