Split lib from core application, added examples

Cargo.toml

@@ -8,11 +8,11 @@ homepage = "https://github.com/ltgr/asciiframe"
 authors = ["Luke"]
 license = "MIT"
 edition = "2018"
-exclude = ["ci/benchmarks/*"]
+exclude = ["ci/*", "examples/*"]
 
 [[bin]]
 name = "asc"
-path = "src/main.rs"
+path = "src/bin/asc/main.rs"
 
 [dependencies]
 clap = { version = "3.0.14", features = ["derive", "cargo"] }

examples/.gitignore

@@ -0,0 +1,2 @@
+target/
+Cargo.lock

examples/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "asc-examples"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+asciiframe = "0.1.4"

examples/src/main.rs

@@ -0,0 +1,12 @@
+use std::path::Path;
+
+fn main() -> asciiframe::Result<()> {
+	let strategy = asciiframe::Strategy::Ascii;
+	let fin = Path::new("test.mov");
+	let fout = Path::new("test.sh");
+
+	asciiframe::render_to_stdout(&fin, strategy)?;
+	asciiframe::render_to_file(&fin, &fout, strategy)?;
+
+	Ok(())
+}

src/bin/asc/main.rs

@@ -0,0 +1,39 @@
+#![forbid(unsafe_code)]
+#![warn(warnings, rust_2018_idioms)]
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+use clap::Parser;
+use std::process;
+
+mod cli;
+mod validators;
+
+fn run(strategy: asciiframe::Strategy) -> asciiframe::Result<()> {
+	let opts = cli::Opts::parse();
+
+	if let Some(p) = opts.output {
+		asciiframe::render_to_file(&opts.file, &p, strategy)?;
+	} else {
+		asciiframe::render_to_stdout(&opts.file, strategy)?;
+	}
+
+	Ok(())
+}
+
+pub fn main() {
+	// TODO: implement colors opt
+	let strategy = asciiframe::Strategy::Ascii;
+
+	let result = run(strategy);
+
+	match result {
+		Err(error) => {
+			let stderr = std::io::stderr();
+			asciiframe::default_error_handler(&mut stderr.lock(), &error);
+			process::exit(1);
+		}
+		Ok(()) => {
+			process::exit(0);
+		}
+	}
+}

src/validators.rs → src/bin/asc/validators.rs

@@ -2,7 +2,7 @@
 use ::std::fs::{metadata, File};
 use ::std::path::Path;
 
-use crate::error::{Error, Result};
+use asciiframe::{Error, Result};
 
 pub fn path_is_readable_file<P: AsRef<Path> + ?Sized>(p: &P) -> Result<()> {
 	let path = p.as_ref();

src/converter.rs

@@ -9,6 +9,9 @@ pub enum Strategy {
 	ColorAscii,
 }
 
+/// # Errors
+///
+/// Will return `Err` if grabbing RGB values from `frame` fail
 pub fn convert_frame(frame: &Mat, strategy: Strategy) -> Result<String> {
 	let mut res = String::default();
 
@@ -50,6 +53,6 @@ fn to_ascii(r: u8, g: u8, b: u8, strategy: Strategy) -> char {
 	CHARS[(10.0 * brightness / 255.0) as usize]
 }
 
-fn to_color_ascii(r: u8, g: u8, b: u8) -> String {
+fn to_color_ascii(_r: u8, _g: u8, _b: u8) -> String {
 	String::from("hello world")
 }

src/error.rs

@@ -1,6 +1,8 @@
+use ansi_term::Colour::Red;
 use std::fmt::Display;
 
 #[derive(Debug)]
+
 pub enum Error {
 	Io(::std::io::Error),
 	Opencv(::opencv::Error),
@@ -44,3 +46,13 @@ impl From<String> for Error {
 impl std::error::Error for Error {}
 
 pub type Result<T> = std::result::Result<T, Error>;
+
+pub fn default_error_handler(handle: &mut dyn std::io::Write, error: &Error) {
+	writeln!(
+		handle,
+		"{} {}\n\nFor more information go to docs.rs/asciiframe",
+		Red.paint("error:"),
+		error
+	)
+	.unwrap();
+}

src/lib.rs

@@ -0,0 +1,11 @@
+#![forbid(unsafe_code)]
+#![warn(warnings, rust_2018_idioms)]
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+mod converter;
+mod error;
+mod renderer;
+
+pub use converter::*;
+pub use error::*;
+pub use renderer::*;

src/renderer.rs

@@ -14,17 +14,13 @@ use terminal_size::{terminal_size, Height, Width};
 use crate::converter;
 use crate::error::{Error, Result};
 
-pub fn render(filename: &Path, output: Option<&Path>, strategy: converter::Strategy) -> Result<()> {
-	if let Some(p) = output {
-		render_to_file(filename, p, strategy)?;
-	} else {
-		render_to_stdout(filename, strategy)?;
-	}
-
-	Ok(())
-}
-
-fn render_to_file(fin: &Path, fout: &Path, strategy: converter::Strategy) -> Result<()> {
+/// # Errors
+///
+/// Will return `Err` if video capture from file fails OR
+/// accessing frame count fails OR
+/// reading frame data fails OR
+/// writing ascii data to a file fails
+pub fn render_to_file(fin: &Path, fout: &Path, strategy: converter::Strategy) -> Result<()> {
 	let mut capture = videoio::VideoCapture::from_file(fin.to_str().unwrap(), 0)?;
 	let frame_count: u64 = capture.get(videoio::CAP_PROP_FRAME_COUNT)? as u64;
 	let pb = ProgressBar::new(frame_count);
@@ -64,8 +60,14 @@ fn render_to_file(fin: &Path, fout: &Path, strategy: converter::Strategy) -> Res
 	Ok(())
 }
 
-fn render_to_stdout(filename: &Path, strategy: converter::Strategy) -> Result<()> {
-	let mut capture = videoio::VideoCapture::from_file(filename.to_str().unwrap(), 0)?;
+/// # Errors
+///
+/// Will return `Err` if video capture from file fails OR
+/// accessing frame count fails OR
+/// reading frame data fails OR
+/// writing ascii to stdout fails
+pub fn render_to_stdout(fin: &Path, strategy: converter::Strategy) -> Result<()> {
+	let mut capture = videoio::VideoCapture::from_file(fin.to_str().unwrap(), 0)?;
 	let frame_count: u64 = capture.get(videoio::CAP_PROP_FRAME_COUNT)? as u64;
 	let time_d: f32 = (1.0 / capture.get(videoio::CAP_PROP_FPS)?) as f32;
 	let stdout = io::stdout();