Add CLI arguments. Fix run switching byte-to-numeric

asilano · asilano · commit 5be38787c8cb · 2023-11-24T23:21:16.000Z
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -19,7 +19,7 @@
           "kind": "bin"
         }
       },
-      "args": [],
+      "args": ["[package]\nname = \"qr-generator\"\nversion = \"0.1.0\"\nedition = \"2021\""],
       "cwd": "${workspaceFolder}"
     },
     {
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,4 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+clap = { version = "4.4.8", features = ["derive"] }
 qr-generator = { version = "0.1.0", path = "qr-generator" }
diff --git a/qr-generator/src/encoder.rs b/qr-generator/src/encoder.rs
@@ -23,7 +23,18 @@ struct DistToNextType {
     alpha_numeric: Option<usize>,
     kanji: Option<usize>,
     byte: Option<usize>,
-    end: usize
+    end: usize,
+}
+impl DistToNextType {
+    fn run_length(&self) -> usize {
+        [self.numeric, self.alpha_numeric, self.kanji, self.byte, Some(self.end)].iter().filter_map(|d| {
+            if let Some(num) = d {
+                if *num == 0 { None } else { *d }
+            } else {
+                None
+            }
+        }).min().unwrap()
+    }
 }
 
 pub struct Encoder<'a> {
@@ -73,9 +84,9 @@ impl<'a> Encoder<'a> {
             .peekable();
         while input_iter.peek().is_some() {
             let (next_encoding, mut bit_run, char_count) = match current_encoding {
-                EncodingModes::Numeric => Self::encode_numeric_run(&mut input_iter),
-                EncodingModes::AlphaNumeric => self.encode_alphanumeric_run(&mut input_iter),
-                EncodingModes::Byte => self.encode_byte_run(&mut input_iter),
+                EncodingModes::Numeric => Self::encode_numeric_run(&mut input_iter, dynamic_mode)?,
+                EncodingModes::AlphaNumeric => self.encode_alphanumeric_run(&mut input_iter, dynamic_mode)?,
+                EncodingModes::Byte => self.encode_byte_run(&mut input_iter, dynamic_mode)?,
                 _ => unreachable!(),
             };
             self.output_data
@@ -210,7 +221,8 @@ impl<'a> Encoder<'a> {
 
     fn encode_numeric_run<'b, Input>(
         input: &mut Peekable<Input>,
-    ) -> (EncodingModes, BitVec<u8, Msb0>, usize)
+        dynamic: bool
+    ) -> Result<(EncodingModes, BitVec<u8, Msb0>, usize), EncodingError>
     where
         Input: Iterator<Item = (char, &'b DistToNextType)>,
     {
@@ -238,18 +250,22 @@ impl<'a> Encoder<'a> {
         }
 
         let next_mode = if let Some(&(c, _)) = input.peek() {
+            if !dynamic {
+                return Err(EncodingError::new("Need to change mode, but not dynamic"));
+            }
             Self::char_type(c)
         } else {
             // Doesn't matter
             EncodingModes::Numeric
         };
-        (next_mode, encoded_numbers, char_count)
+        Ok((next_mode, encoded_numbers, char_count))
     }
 
     fn encode_alphanumeric_run<'b, Input>(
         &self,
         input: &mut Peekable<Input>,
-    ) -> (EncodingModes, BitVec<u8, Msb0>, usize)
+        dynamic: bool
+    ) -> Result<(EncodingModes, BitVec<u8, Msb0>, usize), EncodingError>
     where
         Input: Iterator<Item = (char, &'b DistToNextType)>,
     {
@@ -259,11 +275,12 @@ impl<'a> Encoder<'a> {
                 (10..=26) => 15,
                 (27..) => 17,
             };
+            let should_switch_down = c.is_ascii_digit()
+                && distances.alpha_numeric.unwrap_or(usize::MAX)
+                    .min(distances.byte.unwrap_or(usize::MAX))
+                    .min(distances.end) >= min_dist_to_non_num;
             Self::is_qr_alphanumeric(c)
-                && (!c.is_ascii_digit()
-                    || distances.alpha_numeric.unwrap_or(usize::MAX)
-                        .min(distances.byte.unwrap_or(usize::MAX)
-                        .min(distances.end)) < min_dist_to_non_num)
+                && (!should_switch_down || !dynamic)
         });
         let mut char_count = 0usize;
         let mut encoded_alphanums = bitvec![u8, Msb0;];
@@ -287,44 +304,55 @@ impl<'a> Encoder<'a> {
         }
 
         let next_mode = if let Some(&(c, _)) = input.peek() {
+            if !dynamic {
+                return Err(EncodingError::new("Need to change mode, but not dynamic"))
+            }
             Self::char_type(c)
         } else {
             // Doesn't matter
             EncodingModes::Numeric
         };
-        (next_mode, encoded_alphanums, char_count)
+        Ok((next_mode, encoded_alphanums, char_count))
     }
 
     fn encode_byte_run<'b, Input>(
         &self,
         input: &mut Peekable<Input>,
-    ) -> (EncodingModes, BitVec<u8, Msb0>, usize)
+        dynamic: bool
+    ) -> Result<(EncodingModes, BitVec<u8, Msb0>, usize), EncodingError>
     where
         Input: Iterator<Item = (char, &'b DistToNextType)>,
     {
-        let bytes = input.peeking_take_while(|&(c, distances)| {
-            let min_dist_alphanum_to_byte = match self.size_estimate {
-                (0..=9) => 11,
-                (10..=26) => 15,
-                (27..) => 16,
-            };
-            let min_dist_num_to_byte = match self.size_estimate {
-                (0..=9) => 6,
-                (10..=26) => 8,
-                (27..) => 9,
-            };
-            let min_dist_num_to_alphanum = match self.size_estimate {
-                (0..=9) => 6,
-                (10..=26) => 7,
-                (27..) => 8,
-            };
-
-            let change_to_alphanum = Self::is_qr_alphanumeric(c)
-                && distances.byte.unwrap_or(usize::MAX).min(distances.end) >= min_dist_alphanum_to_byte;
-            let change_to_numeric = c.is_ascii_digit()
+        let min_dist_alphanum_to_byte = match self.size_estimate {
+            (0..=9) => 11,
+            (10..=26) => 15,
+            (27..) => 16,
+        };
+        let min_dist_num_to_byte = match self.size_estimate {
+            (0..=9) => 6,
+            (10..=26) => 8,
+            (27..) => 9,
+        };
+        let min_dist_num_to_alphanum = match self.size_estimate {
+            (0..=9) => 6,
+            (10..=26) => 7,
+            (27..) => 8,
+        };
+        let change_to_alphanum = |c, distances: &DistToNextType| -> bool {
+            Self::is_qr_alphanumeric(c)
+                && distances.byte.unwrap_or(usize::MAX).min(distances.end) >= min_dist_alphanum_to_byte
+        };
+        let change_to_numeric = |c: char, distances: &DistToNextType| -> bool {
+            // TODO: needs to depend on run length as well!
+            c.is_ascii_digit()
                 && (distances.byte.unwrap_or(usize::MAX).min(distances.end) >= min_dist_num_to_byte
-                    || distances.alpha_numeric.unwrap_or(usize::MAX).min(distances.end) >= min_dist_num_to_alphanum);
-            !(change_to_alphanum || change_to_numeric)
+                    || distances.alpha_numeric.unwrap_or(usize::MAX).min(distances.run_length()).min(distances.end) >= min_dist_num_to_alphanum)
+        };
+
+        let bytes = input.peeking_take_while(|&(c, distances)| {
+            let should_change_to_alphanum = change_to_alphanum(c, distances);
+            let should_change_to_numeric = change_to_numeric(c, distances);
+            !(should_change_to_alphanum || should_change_to_numeric) || !dynamic
         });
 
         let mut byte_count = 0usize;
@@ -342,13 +370,22 @@ impl<'a> Encoder<'a> {
             }
         }
 
-        let next_mode = if let Some(&(c, _)) = input.peek() {
-            Self::char_type(c)
+        let next_mode = if let Some(&(c, distances)) = input.peek() {
+            if !dynamic {
+                return Err(EncodingError::new("Need to change mode, but not dynamic"))
+            }
+            if change_to_alphanum(c, distances) {
+                EncodingModes::AlphaNumeric
+            } else if change_to_numeric(c, distances) {
+                EncodingModes::Numeric
+            } else {
+                unreachable!()
+            }
         } else {
             // Doesn't matter
             EncodingModes::Byte
         };
-        (next_mode, encoded_bytes, byte_count)
+        Ok((next_mode, encoded_bytes, byte_count))
     }
 
     fn sequence_preamble(&self, encoding: EncodingModes, char_count: usize) -> BitVec<u8, Msb0> {
diff --git a/src/cli.rs b/src/cli.rs
@@ -0,0 +1,66 @@
+pub use clap::{Parser, ValueEnum};
+use qr_generator::{EncodingModes, CorrectionLevels};
+
+macro_rules! bidir_from {
+  ( $owned:ident, $foreign:ident; $( $variant:ident ),+ ) => {
+    impl From<$foreign> for $owned {
+      fn from(other: $foreign) -> $owned {
+          match other {
+            $(
+              $foreign::$variant => $owned::$variant
+            ),+
+           }
+      }
+    }
+    impl From<$owned> for $foreign {
+      fn from(other: $owned) -> $foreign {
+          match other {
+            $(
+              $owned::$variant => $foreign::$variant
+            ),+
+           }
+      }
+    }
+  };
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+pub enum CliEncoding {
+  #[value(alias("n"), help("(abbrev: n) Data must consist only of digits 0-9. Most compact"))]
+  Numeric,
+  #[value(alias("a"), help("(abbrev: a) Data must consist only of 0-9, A-Z (uppercase), $%*+-./:, and <space>"))]
+  AlphaNumeric,
+  #[value(alias("b"), help("(abbrev: b) Data will be encoded as bytes. Least compact"))]
+  Byte,
+  #[value(skip)] //, alias("k"), help("(abbrev: k) Data will be encoded as Kanji from Shift-JIS"))]
+  Kanji,
+  #[value(alias("d"), help("(abbrev: d) Default. Data encoding will change as necessary to obtain the smallest possible code"))]
+  Dynamic
+}
+bidir_from!(CliEncoding, EncodingModes; Numeric, AlphaNumeric, Byte, Dynamic, Kanji);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+pub enum CliCorrectionLevels {
+    #[value(alias("d"), help("(abbrev: d) Only valid for M1 Micro QR Codes"))]
+    DetectionOnly,
+    L,
+    M,
+    Q,
+    H,
+}
+bidir_from!(CliCorrectionLevels, CorrectionLevels; DetectionOnly, L, M, Q, H);
+
+#[derive(Parser)]
+#[command(author, about, long_about = None)]
+pub struct Cli {
+  // qr_type: SomeTypeHere,
+  /// What encoding to use for the data
+  #[arg(long, short, value_enum, default_value = "dynamic")]
+  pub encoding: CliEncoding,
+  #[arg(long, short='l', value_enum, default_value = "q")]
+  pub correction_level: CliCorrectionLevels,
+  #[arg(long, short, help = "The 'size' of the QR Code. If omitted, the smallest size that fits will be used")]
+  pub version: Option<u32>,
+  #[arg()]
+  pub data: String
+}
diff --git a/src/main.rs b/src/main.rs
@@ -1,15 +1,20 @@
 use qr_generator::{QRGenerator, QRSymbolTypes, EncodingModes, CorrectionLevels};
 use std::process;
 
+mod cli;
+use cli::{Cli, Parser};
+
 fn main() {
+    let cli = Cli::parse();
+
     let options = qr_generator::Options {
-        // mode: Some(EncodingModes::Numeric),
-        // version: Some(30),
-        correction_level: Some(CorrectionLevels::H),
+        mode: Some(EncodingModes::from(cli.encoding)),
+        version: cli.version,
+        correction_level: Some(CorrectionLevels::from(cli.correction_level)),
         ..Default::default()
     };
     let mut generator = QRGenerator { options };
-    let ret = generator.make_qr_code("Sing, O goddess, the anger of Achilles son of Peleus, that brought countless ills upon the Achaeans.".to_string());
+    let ret = generator.make_qr_code(cli.data);
     if let Err(err) = ret {
         println!("save_qr_image failed with {}", err);
         process::exit(1);

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`"kind": "bin"`
`20`	`20`	`}`
`21`	`21`	`},`
`22`		`- "args": [],`
	`22`	`+ "args": ["[package]\nname = \"qr-generator\"\nversion = \"0.1.0\"\nedition = \"2021\""],`
`23`	`23`	`"cwd": "${workspaceFolder}"`
`24`	`24`	`},`
`25`	`25`	`{`