chore: remove unecessary dependencies

* Remove log, stderrlog, structopt
* Add argh

Cargo.toml

@@ -22,7 +22,6 @@ curses = ["easycurses", "pancurses"]
 bitflags = "1.0"
 cassowary = "0.3"
 itertools = "0.8"
-log = "0.4"
 either = "1.5"
 unicode-segmentation = "1.2"
 unicode-width = "0.1"
@@ -33,10 +32,8 @@ easycurses = { version = "0.12.2", optional = true }
 pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
 
 [dev-dependencies]
-stderrlog = "0.4"
 rand = "0.7"
-failure = "0.1"
-structopt = "0.3"
+argh = "0.1"
 
 [[example]]
 name = "canvas"

examples/barchart.rs

@@ -1,19 +1,16 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{BarChart, Block, Borders};
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{BarChart, Block, Borders},
+    Terminal,
+};
 
 struct App<'a> {
     data: Vec<(&'a str, u64)>,
@@ -57,7 +54,7 @@ impl<'a> App<'a> {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/block.rs

@@ -1,20 +1,18 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, BorderType, Borders};
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, BorderType, Borders},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/canvas.rs

@@ -1,21 +1,19 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::Duration;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout, Rect};
-use tui::style::Color;
-use tui::widgets::canvas::{Canvas, Map, MapResolution, Rectangle};
-use tui::widgets::{Block, Borders};
-use tui::Terminal;
-
 use crate::util::event::{Config, Event, Events};
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::Color,
+    widgets::{
+        canvas::{Canvas, Map, MapResolution, Rectangle},
+        Block, Borders,
+    },
+    Terminal,
+};
 
 struct App {
     x: f64,
@@ -74,7 +72,7 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/chart.rs

@@ -5,7 +5,7 @@ use crate::util::{
     event::{Event, Events},
     SinSignal,
 };
-use std::io;
+use std::{error::Error, io};
 use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
 use tui::{
     backend::TermionBackend,
@@ -63,7 +63,7 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/crossterm_demo.rs

@@ -4,18 +4,19 @@ mod demo;
 mod util;
 
 use crate::demo::{ui, App};
+use argh::FromArgs;
 use crossterm::{
     event::{self, Event as CEvent, KeyCode},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
 use std::{
+    error::Error,
     io::{stdout, Write},
     sync::mpsc,
     thread,
     time::Duration,
 };
-use structopt::StructOpt;
 use tui::{backend::CrosstermBackend, Terminal};
 
 enum Event<I> {
@@ -23,17 +24,16 @@ enum Event<I> {
     Tick,
 }
 
-#[derive(Debug, StructOpt)]
+/// Crossterm demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
     enable_raw_mode()?;
 

examples/curses_demo.rs

@@ -2,27 +2,26 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::{Duration, Instant};
-
-use easycurses;
-use structopt::StructOpt;
-use tui::backend::CursesBackend;
-use tui::Terminal;
-
 use crate::demo::{ui, App};
+use argh::FromArgs;
+use easycurses;
+use std::{
+    error::Error,
+    io,
+    time::{Duration, Instant},
+};
+use tui::{backend::CursesBackend, Terminal};
 
-#[derive(Debug, StructOpt)]
+/// Curses demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
     let mut backend = CursesBackend::new().ok_or(io::Error::new(io::ErrorKind::Other, ""))?;
     let curses = backend.get_curses_mut();

examples/custom_widget.rs

@@ -1,20 +1,12 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::buffer::Buffer;
-use tui::layout::Rect;
-use tui::style::Style;
-use tui::widgets::Widget;
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend, buffer::Buffer, layout::Rect, style::Style, widgets::Widget, Terminal,
+};
 
 struct Label<'a> {
     text: &'a str,
@@ -39,7 +31,7 @@ impl<'a> Label<'a> {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/gauge.rs

@@ -1,19 +1,16 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Gauge};
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Gauge},
+    Terminal,
+};
 
 struct App {
     progress1: u16,
@@ -52,7 +49,7 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/layout.rs

@@ -1,20 +1,17 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::widgets::{Block, Borders};
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    widgets::{Block, Borders},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/list.rs

@@ -1,22 +1,19 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Corner, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, List, Text};
-use tui::Terminal;
-
 use crate::util::{
     event::{Event, Events},
     StatefulList,
 };
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Corner, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, List, Text},
+    Terminal,
+};
 
 struct App<'a> {
     items: StatefulList<&'a str>,
@@ -76,7 +73,7 @@ impl<'a> App<'a> {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/paragraph.rs

@@ -1,21 +1,18 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Alignment, Constraint, Direction, Layout};
-use tui::style::{Color, Modifier, Style};
-use tui::widgets::{Block, Borders, Paragraph, Text};
-use tui::Terminal;
-
 use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Alignment, Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Paragraph, Text},
+    Terminal,
+};
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/rustbox_demo.rs

@@ -2,26 +2,25 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::time::{Duration, Instant};
-
-use rustbox::keyboard::Key;
-use structopt::StructOpt;
-use tui::backend::RustboxBackend;
-use tui::Terminal;
-
 use crate::demo::{ui, App};
+use argh::FromArgs;
+use rustbox::keyboard::Key;
+use std::{
+    error::Error,
+    time::{Duration, Instant},
+};
+use tui::{backend::RustboxBackend, Terminal};
 
-#[derive(Debug, StructOpt)]
+/// Rustbox demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
     let backend = RustboxBackend::new()?;
     let mut terminal = Terminal::new(backend)?;

examples/sparkline.rs

@@ -1,20 +1,19 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Sparkline};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
-use crate::util::RandomSignal;
+use crate::util::{
+    event::{Event, Events},
+    RandomSignal,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    widgets::{Block, Borders, Sparkline},
+    Terminal,
+};
 
 struct App {
     signal: RandomSignal,
@@ -50,7 +49,7 @@ impl App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/table.rs

@@ -2,7 +2,7 @@
 mod util;
 
 use crate::util::event::{Event, Events};
-use std::io;
+use std::{error::Error, io};
 use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
 use tui::{
     backend::TermionBackend,
@@ -73,7 +73,7 @@ impl<'a> StatefulTable<'a> {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/tabs.rs

@@ -1,26 +1,25 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, Tabs};
-use tui::Terminal;
-
-use crate::util::event::{Event, Events};
-use crate::util::TabsState;
+use crate::util::{
+    event::{Event, Events},
+    TabsState,
+};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    widgets::{Block, Borders, Tabs},
+    Terminal,
+};
 
 struct App<'a> {
     tabs: TabsState<'a>,
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

examples/termion_demo.rs

@@ -2,33 +2,25 @@ mod demo;
 #[allow(dead_code)]
 mod util;
 
-use std::io;
-use std::time::Duration;
-
-use structopt::StructOpt;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::Terminal;
-
 use crate::{
     demo::{ui, App},
     util::event::{Config, Event, Events},
 };
+use argh::FromArgs;
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{backend::TermionBackend, Terminal};
 
-#[derive(Debug, StructOpt)]
+/// Termion demo
+#[derive(Debug, FromArgs)]
 struct Cli {
-    #[structopt(long = "tick-rate", default_value = "250")]
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
     tick_rate: u64,
-    #[structopt(long = "log")]
-    log: bool,
 }
 
-fn main() -> Result<(), failure::Error> {
-    let cli = Cli::from_args();
-    stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
 
     let events = Events::with_config(Config {
         tick_rate: Duration::from_millis(cli.tick_rate),

examples/user_input.rs

@@ -13,21 +13,22 @@
 #[allow(dead_code)]
 mod util;
 
-use std::io::{self, Write};
-
-use termion::cursor::Goto;
-use termion::event::Key;
-use termion::input::MouseTerminal;
-use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
-use tui::backend::TermionBackend;
-use tui::layout::{Constraint, Direction, Layout};
-use tui::style::{Color, Style};
-use tui::widgets::{Block, Borders, List, Paragraph, Text};
-use tui::Terminal;
-use unicode_width::UnicodeWidthStr;
-
 use crate::util::event::{Event, Events};
+use std::{
+    error::Error,
+    io::{self, Write},
+};
+use termion::{
+    cursor::Goto, event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen,
+};
+use tui::{
+    backend::TermionBackend,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    widgets::{Block, Borders, List, Paragraph, Text},
+    Terminal,
+};
+use unicode_width::UnicodeWidthStr;
 
 enum InputMode {
     Normal,
@@ -54,7 +55,7 @@ impl Default for App {
     }
 }
 
-fn main() -> Result<(), failure::Error> {
+fn main() -> Result<(), Box<dyn Error>> {
     // Terminal initialization
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);

src/backend/rustbox.rs

@@ -1,11 +1,11 @@
-use log::debug;
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
 use std::io;
 
-use super::Backend;
-use crate::buffer::Cell;
-use crate::layout::Rect;
-use crate::style::{Color, Modifier};
-
 pub struct RustboxBackend {
     rustbox: rustbox::RustBox,
 }
@@ -30,9 +30,7 @@ impl Backend for RustboxBackend {
     where
         I: Iterator<Item = (u16, u16, &'a Cell)>,
     {
-        let mut inst = 0;
         for (x, y, cell) in content {
-            inst += 1;
             self.rustbox.print(
                 x as usize,
                 y as usize,
@@ -42,7 +40,6 @@ impl Backend for RustboxBackend {
                 &cell.symbol,
             );
         }
-        debug!("{} instructions outputed", inst);
         Ok(())
     }
     fn hide_cursor(&mut self) -> Result<(), io::Error> {

src/backend/termion.rs

@@ -1,4 +1,3 @@
-use log::debug;
 use std::fmt;
 use std::io;
 use std::io::Write;
@@ -115,7 +114,6 @@ where
             string.push_str(&cell.symbol);
             inst += 1;
         }
-        debug!("{} instructions outputed.", inst);
         write!(
             self.stdout,
             "{}{}{}{}",

src/terminal.rs

@@ -1,4 +1,3 @@
-use log::error;
 use std::io;
 
 use crate::backend::Backend;
@@ -65,7 +64,7 @@ where
         // Attempt to restore the cursor state
         if self.hidden_cursor {
             if let Err(err) = self.show_cursor() {
-                error!("Failed to show the cursor: {}", err);
+                eprintln!("Failed to show the cursor: {}", err);
             }
         }
     }