avrow-cli: switch to structopt

Author: creativcoder

avrow-cli/Cargo.toml

@@ -7,11 +7,9 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-clap = {version="2.33.1", features=["yaml"] }
-avrow = { path = "../../ravro", features=["all"] }
-argh = "0.1.3"
+avrow = { path = "../../avrow", features=["all"] }
 anyhow = "1.0.32"
-colored = "2.0.0"
+structopt = "0.3.20"
 
 [[bin]]
 name = "av"

avrow-cli/README.md

@@ -3,29 +3,32 @@
 
 Inspired from avro-tools.jar
 
-### Following subcommands are the supported as of now.
+## Install
 
 ```
-Usage: target/debug/av <command> [<args>]
-
-av: command line tool for examining avro datafiles.
-
-Options:
-  --help            display usage information
-
-Commands:
-  getmeta           Get metadata information of the avro datafile.
-  getschema         Prints the writer's schema encoded in the provided datafile.
-  read              Prints data from datafile as human readable value
-  tobytes           Dumps the avro datafile as bytes for debugging purposes
-  fingerprint       Prints fingerprint of the canonical form of writer's schema.
-  canonical         Prints the canonical form of writer's schema encoded in the
-                    provided datafile.
-canonical
+cargo install --path .
 ```
+This will install the binary as `av`.
 
-Usage:
+### Following subcommands are the supported as of now.
 
-```bash
-av read -d ./data.avro 
+```
+avrow-cli 0.1.0
+Command line tool for examining avro datafiles
+
+USAGE:
+    av <SUBCOMMAND>
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+SUBCOMMANDS:
+    bytes          Dumps the avro datafile as bytes for debugging purposes
+    canonical      Prints the canonical form of writer's schema encoded in the avro datafile.
+    fingerprint    Prints fingerprint of the canonical form of writer's schema in the avro datafile.
+    help           Prints this message or the help of the given subcommand(s)
+    metadata       Get metadata information of the avro datafile
+    read           Prints data in the avro datafile in debug format
+    schema         Prints the writer's schema encoded in the avro datafile
 ```

avrow-cli/src/main.rs

@@ -1,42 +1,81 @@
 //! avrow-cli is a command line tool to examine and analyze avro data files.
 //!
-//! Usage: avrow-cli -i <avrodatafile> tojson // This prints the data contained in the <avrodatafile> in a readable format.
+//! Usage: `av -d <avrodatafile> read`
+//!
+//! The above command prints the data contained in the <avrodatafile> in a readable format.
+//!
 
 mod subcommand;
 mod utils;
 
-use argh::FromArgs;
+use std::path::PathBuf;
+use structopt::StructOpt;
+use subcommand::{bytes, canonical, fingerprint, metadata, read, schema};
 use utils::read_datafile;
 
-use subcommand::{Canonical, Fingerprint, GetMeta, GetSchema, ToBytes, ReadData};
-
-#[derive(Debug, FromArgs)]
-/// av: command line tool for examining avro datafiles.
-struct AvrowCli {
-    #[argh(subcommand)]
-    subcommand: SubCommand,
-}
-
-#[derive(FromArgs, PartialEq, Debug)]
-#[argh(subcommand)]
-enum SubCommand {
-    GetMeta(GetMeta),
-    GetSchema(GetSchema),
-    Read(ReadData),
-    ToBytes(ToBytes),
-    Fingerprint(Fingerprint),
-    Canonical(Canonical),
+#[derive(StructOpt, Debug)]
+#[structopt(about = "Command line tool for examining avro datafiles")]
+enum AvrowCli {
+    #[structopt(
+        name = "metadata",
+        about = "Get metadata information of the avro datafile"
+    )]
+    Metadata {
+        #[structopt(short)]
+        datafile: PathBuf,
+    },
+    #[structopt(
+        name = "schema",
+        about = "Prints the writer's schema encoded in the avro datafile"
+    )]
+    Schema {
+        #[structopt(short)]
+        datafile: PathBuf,
+    },
+    #[structopt(
+        about = "Prints fingerprint of the canonical form of writer's schema in the avro datafile."
+    )]
+    Fingerprint {
+        #[structopt(short)]
+        datafile: PathBuf,
+        #[structopt(short)]
+        fingerprint: String,
+    },
+    #[structopt(
+        about = "Prints the canonical form of writer's schema encoded in the avro datafile."
+    )]
+    Canonical {
+        #[structopt(short)]
+        datafile: PathBuf,
+    },
+    #[structopt(about = "Prints data in the avro datafile in debug format")]
+    Read {
+        #[structopt(short)]
+        datafile: PathBuf,
+    },
+    #[structopt(
+        name = "bytes",
+        about = "Dumps the avro datafile as bytes for debugging purposes"
+    )]
+    Bytes {
+        #[structopt(short)]
+        datafile: PathBuf,
+    },
 }
 
 fn main() -> anyhow::Result<()> {
-    let flags: AvrowCli = argh::from_env();
-    match flags.subcommand {
-        SubCommand::GetMeta(cmd) => cmd.getmeta()?,
-        SubCommand::Read(cmd) => cmd.read_data()?,
-        SubCommand::ToBytes(cmd) => cmd.tobytes()?,
-        SubCommand::GetSchema(cmd) => cmd.getschema()?,
-        SubCommand::Fingerprint(cmd) => cmd.fingerprint()?,
-        SubCommand::Canonical(cmd) => cmd.canonical()?
+    use AvrowCli::*;
+    let opt = AvrowCli::from_args();
+    match opt {
+        Metadata { datafile } => metadata(&datafile)?,
+        Schema { datafile } => schema(&datafile)?,
+        Canonical { datafile } => canonical(&datafile)?,
+        Read { datafile } => read(&datafile)?,
+        Bytes { datafile } => bytes(&datafile)?,
+        Fingerprint {
+            datafile,
+            fingerprint: fp,
+        } => fingerprint(&datafile, &fp)?,
     }
 
     Ok(())

avrow-cli/src/subcommand.rs

@@ -1,157 +1,89 @@
 use crate::read_datafile;
 use anyhow::{anyhow, Context};
-use argh::FromArgs;
 use avrow::{Header, Reader};
 use std::io::Read;
 use std::path::PathBuf;
 use std::str;
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Get metadata information of the avro datafile.
-#[argh(subcommand, name = "getmeta")]
-pub struct GetMeta {
-    /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: PathBuf,
-}
-
-impl GetMeta {
-    pub fn getmeta(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let header = Header::from_reader(&mut avro_datafile)?;
-        for (k, v) in header.metadata() {
-            print!("{}\t", k);
-            println!(
-                "{}",
-                str::from_utf8(v).expect("Invalid UTF-8 in avro header")
-            );
-        }
-        Ok(())
+pub fn metadata(datafile: &PathBuf) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let header = Header::from_reader(&mut avro_datafile)?;
+    for (k, v) in header.metadata() {
+        print!("{}\t", k);
+        println!(
+            "{}",
+            str::from_utf8(v).expect("Invalid UTF-8 in avro header")
+        );
     }
+    Ok(())
 }
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Prints data from datafile in debug format.
-#[argh(subcommand, name = "read")]
-pub struct ReadData {
-    /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: PathBuf,
-}
-impl ReadData {
-    pub fn read_data(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let reader = Reader::new(&mut avro_datafile)?;
-        // TODO: remove irrelevant fields
-        for i in reader {
-            println!("{:#?}", i?);
-        }
-
-        Ok(())
+pub fn read(datafile: &PathBuf) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let reader = Reader::new(&mut avro_datafile)?;
+    // TODO: remove irrelevant fields
+    for i in reader {
+        println!("{:?}", i?);
     }
-}
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Dumps the avro datafile as bytes for debugging purposes
-#[argh(subcommand, name = "tobytes")]
-pub struct ToBytes {
-    /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: PathBuf,
+    Ok(())
 }
 
-impl ToBytes {
-    pub fn tobytes(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let mut v = vec![];
+pub fn bytes(datafile: &PathBuf) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let mut v = vec![];
 
-        avro_datafile
-            .read_to_end(&mut v)
-            .with_context(|| "Failed to read data file in memory")?;
+    avro_datafile
+        .read_to_end(&mut v)
+        .with_context(|| "Failed to read datafile")?;
 
-        println!("{:?}", v);
-        Ok(())
-    }
+    println!("{:?}", v);
+    Ok(())
 }
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Prints the writer's schema encoded in the provided datafile.
-#[argh(subcommand, name = "getschema")]
-pub struct GetSchema {
-    /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: PathBuf,
+pub fn schema(datafile: &PathBuf) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let header = Header::from_reader(&mut avro_datafile)?;
+    // TODO print human readable schema
+    println!("{}", header.schema());
+    Ok(())
 }
 
-impl GetSchema{
-    pub fn getschema(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let header = Header::from_reader(&mut avro_datafile)?;
-        // TODO print human readable schema
-        dbg!(header.schema());
-        Ok(())
-    }
-}
-
-#[derive(FromArgs, PartialEq, Debug)]
-/// Prints fingerprint of the canonical form of writer's schema.
-#[argh(subcommand, name = "fingerprint")]
-pub struct Fingerprint {
-    /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: String,
-    /// the fingerprinting algorithm (rabin64 (default), sha256, md5)
-    #[argh(option, short = 'f')]
-    fingerprint: String,
-}
-impl Fingerprint {
-    pub fn fingerprint(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let header = Header::from_reader(&mut avro_datafile)?;
-        match self.fingerprint.as_ref() {
-            "rabin64" => {
-                println!("0x{:x}", header.schema().canonical_form().rabin64());
-            },
-            "sha256" => {
-                let mut fingerprint_str = String::new();
-                let sha256 = header.schema().canonical_form().sha256();
-                for i in sha256 {
-                    let a = format!("{:x}", i);
-                    fingerprint_str.push_str(&a);
-                }
-                
-                println!("{}", fingerprint_str);
+pub fn fingerprint(datafile: &PathBuf, fingerprint: &str) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let header = Header::from_reader(&mut avro_datafile)?;
+    match fingerprint.as_ref() {
+        "rabin64" => {
+            println!("0x{:x}", header.schema().canonical_form().rabin64());
+        }
+        "sha256" => {
+            let mut fingerprint_str = String::new();
+            let sha256 = header.schema().canonical_form().sha256();
+            for i in sha256 {
+                let a = format!("{:x}", i);
+                fingerprint_str.push_str(&a);
             }
-            "md5" => {
-                let mut fingerprint_str = String::new();
-                let md5 = header.schema().canonical_form().md5();
-                for i in md5 {
-                    let a = format!("{:x}", i);
-                    fingerprint_str.push_str(&a);
-                }
-                
-                println!("{}", fingerprint_str);
+
+            println!("{}", fingerprint_str);
+        }
+        "md5" => {
+            let mut fingerprint_str = String::new();
+            let md5 = header.schema().canonical_form().md5();
+            for i in md5 {
+                let a = format!("{:x}", i);
+                fingerprint_str.push_str(&a);
             }
-            other => return Err(anyhow!("invalid or unsupported fingerprint: {}", other))
+
+            println!("{}", fingerprint_str);
         }
-        Ok(())
+        other => return Err(anyhow!("invalid or unsupported fingerprint: {}", other)),
     }
+    Ok(())
 }
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Prints the canonical form of writer's schema encoded in the provided datafile.
-#[argh(subcommand, name = "canonical")]
-pub struct Canonical {
-        /// datafile as input
-    #[argh(option, short = 'd')]
-    datafile: String,
-}
-
-impl Canonical {
-    pub fn canonical(&self) -> Result<(), anyhow::Error> {
-        let mut avro_datafile = read_datafile(&self.datafile)?;
-        let header = Header::from_reader(&mut avro_datafile)?;
-        println!("{}", header.schema().canonical_form());
-        Ok(())
-    }
+pub fn canonical(datafile: &PathBuf) -> Result<(), anyhow::Error> {
+    let mut avro_datafile = read_datafile(datafile)?;
+    let header = Header::from_reader(&mut avro_datafile)?;
+    println!("{}", header.schema().canonical_form());
+    Ok(())
 }