Start implementing consistent command and subcommand.

src/cli/args/genomics.rs

@@ -23,9 +23,9 @@ pub(crate) enum ContigSubcommand {
 }
 
 #[derive(Subcommand)]
-pub(crate) enum MafSubcommand {
-    #[command(about = "Convert MAF to other formats", name = "convert")]
-    MafConvert(MafConvertArgs),
+pub(crate) enum GenomicSubcommand {
+    #[command(about = "Convert genomic files to other formats", name = "convert")]
+    Genomic(GenomicConvertArgs),
 }
 
 
@@ -78,11 +78,11 @@ pub(crate) struct ContigSummaryArgs {
 }
 
 #[derive(Args)]
-pub(crate) struct MafConvertArgs {
+pub(crate) struct GenomicConvertArgs {
     #[command(flatten)]
     pub(crate) io: IOArgs,
-    #[arg(long, help = "Source of reference names")]
-    pub(crate) reference_path: PathBuf,
+    #[arg(long, help = "Path to the source of reference names")]
+    pub(crate) reference: PathBuf,
     #[arg(long, help = "Source of names is a bed file")]
     pub(crate) from_bed: bool,
     #[arg(

src/cli/args/mod.rs

@@ -7,7 +7,7 @@ use clap::Args;
 use clap::Parser;
 use clap::Subcommand;
 use genomics::ContigSubcommand;
-use genomics::MafSubcommand;
+use genomics::GenomicSubcommand;
 use genomics::SeqReadSubcommand;
 
 use super::args::sequence::SequenceSubcommand;
@@ -41,8 +41,8 @@ pub(crate) enum MainSubcommand {
     RawRead(SeqReadSubcommand),
     #[command(subcommand, about = "Contiguous sequence analyses", name = "contig")]
     Contig(ContigSubcommand),
-    #[command(subcommand, about = "Multiple alignment format analyses", name = "maf")]
-    Maf(MafSubcommand),
+    #[command(subcommand, about = "Genomic specific analyses", name = "genomic")]
+    Genomic(GenomicSubcommand),
     #[command(subcommand, about = "Alignment analyses", name = "align")]
     Alignment(AlignmentSubcommand),
     #[command(

src/cli/commands.rs

@@ -14,7 +14,7 @@ use super::align::concat::ConcatParser;
 use super::align::trim::AlignTrimParser;
 use super::align::unalign::UnalignParser;
 use super::args::align::{AlignmentSubcommand, PartitionSubcommand};
-use super::args::genomics::{ContigSubcommand, MafSubcommand, SeqReadSubcommand};
+use super::args::genomics::{ContigSubcommand, GenomicSubcommand, SeqReadSubcommand};
 use super::args::sequence::SequenceSubcommand;
 use super::args::MainSubcommand;
 use super::contig::summarize::ContigCliParser;
@@ -26,7 +26,7 @@ pub(crate) fn match_cli_subcommand(subcommand: &MainSubcommand) {
     match subcommand {
         MainSubcommand::RawRead(subcommand) => match_raw_read_subcommand(subcommand),
         MainSubcommand::Contig(subcommand) => match_contig_subcommand(subcommand),
-        MainSubcommand::Maf(subcommand) => match_maf_subcommand(subcommand),
+        MainSubcommand::Genomic(subcommand) => match_genomic_subcommand(subcommand),
         MainSubcommand::Alignment(subcommand) => match_alignment_subcommand(subcommand),
         MainSubcommand::Partition(subcommand) => match_partition_subcommand(subcommand),
         MainSubcommand::Sequence(subcommand) => match_sequence_subcommand(subcommand),
@@ -45,9 +45,9 @@ fn match_raw_read_subcommand(subcommand: &SeqReadSubcommand) {
     };
 }
 
-fn match_maf_subcommand(subcommand: &MafSubcommand) {
+fn match_genomic_subcommand(subcommand: &GenomicSubcommand) {
     match subcommand {
-        MafSubcommand::MafConvert(maf_args) => {
+        GenomicSubcommand::Genomic(maf_args) => {
             MafConvertParser::new(maf_args).convert();
         }
     };

src/cli/maf/convert.rs

@@ -1,21 +1,21 @@
 use std::path::Path;
 
 use crate::{
-    cli::{args::genomics::MafConvertArgs, InputCli, OutputCli},
+    cli::{args::genomics::GenomicConvertArgs, InputCli, OutputCli},
     core::maf::convert::MafConverter,
     helper::{finder::MafFileFinder, utils},
 };
 
 pub(in crate::cli) struct MafConvertParser<'a> {
-    args: &'a MafConvertArgs,
+    args: &'a GenomicConvertArgs,
 }
 
 impl InputCli for MafConvertParser<'_> {}
 
 impl OutputCli for MafConvertParser<'_> {}
 
 impl<'a> MafConvertParser<'a> {
-    pub(in crate::cli) fn new(args: &'a MafConvertArgs) -> Self {
+    pub(in crate::cli) fn new(args: &'a GenomicConvertArgs) -> Self {
         Self { args }
     }
 
@@ -38,7 +38,7 @@ impl<'a> MafConvertParser<'a> {
         self.check_output_dir_exist(&self.args.output, self.args.io.force);
         let convert = MafConverter::new(
             &files,
-            &self.args.reference_path,
+            &self.args.reference,
             self.args.from_bed,
             &self.args.output,
             &output_fmt,

src/core/maf/convert.rs

@@ -56,6 +56,11 @@ impl<'a> MafConverter<'a> {
     pub fn convert(&self) {
         if self.name_from_bed {
             self.parse_maf_from_bed();
+        } else {
+            unreachable!(
+                "Name source is not supported. \
+            Use BED file instead and set the flag --from-bed"
+            );
         }
         self.print_output_info();
     }