Add COLNAMES option to give names to the columns

The COLNAMES option should contain the row number giving the name to the
columns. This name will be used in place of the lettered column name
used by excel in the SQL Table.

Author: roblabla

src/options.rs

@@ -9,13 +9,15 @@ pub enum UsingOption {
     File(String),
     Worksheet(String),
     Range(String),
+    ColNames(String),
 }
 
 pub fn parse_option(input: &str) -> IResult<&str, UsingOption> {
     parse_with_spaces(alt((
         parse_filename_option,
         parse_worksheet_option,
         parse_range_option,
+        parse_colnames_option,
         ))).parse(input)
 }
 
@@ -49,6 +51,16 @@ fn parse_range_option(input: &str) -> IResult<&str, UsingOption> {
         |t: (&str, &str)| UsingOption::Range(t.1.to_string()))(input)
 }
 
+fn parse_colnames_option(input: &str) -> IResult<&str, UsingOption> {
+    let option = tag_no_case("COLNAMES");
+
+    let value = preceded(
+        tag("'"), terminated(digit0, tag("'")));
+
+    map(separated_pair(option, multispace1, value),
+        |t: (&str, &str)| UsingOption::ColNames(t.1.to_string()))(input)
+}
+
 fn parse_with_spaces<'a, T>(parser: impl Parser<&'a str, T, nom::error::Error<&'a str>>)
     -> impl Parser<&'a str, T, nom::error::Error<&'a str>> {
     preceded(multispace0, terminated(parser, multispace0))

src/spreadsheet/manager.rs

@@ -5,11 +5,13 @@ use crate::spreadsheet::{
 };
 use calamine::{open_workbook_auto, DataType, Range, Reader, Sheets};
 use std::path::Path;
+use std::str::FromStr;
 
 pub struct DataManager {
     sheets: Sheets,
     worksheet: String,
     range: Option<CellRange>,
+    colnames_row: Option<u32>,
 }
 
 pub enum DataManagerError {
@@ -47,9 +49,17 @@ impl DataManager {
     pub fn get_columns(&mut self) -> Vec<String> {
         let range = self.get_effective_range();
         if range.get_size().1 > 0 {
+            let row_workspace_sheet = self.colnames_row
+                .and_then(|v| Some((v, self.sheets.worksheet_range(self.worksheet.as_str()))))
+                .and_then(|(row, sheet)| Some((row, sheet?.ok()?)));
             (range.start().unwrap().1..=range.end().unwrap().1)
                 .into_iter()
-                .map(|n| CellIndex::new(n + 1, 1).get_x_as_string())
+                .map(|n| {
+                    row_workspace_sheet
+                        .as_ref()
+                        .and_then(|(row, sheet)| sheet.get_value((*row, n)).map(|v| v.to_string()))
+                        .unwrap_or_else(|| CellIndex::new(n + 1, 1).get_x_as_string())
+                })
                 .collect()
         } else {
             Vec::new()
@@ -68,6 +78,7 @@ pub struct DataManagerBuilder {
     file: Option<String>,
     worksheet: Option<String>,
     range: Option<CellRange>,
+    colnames_row: Option<u32>,
 }
 
 impl DataManagerBuilder {
@@ -89,6 +100,9 @@ impl DataManagerBuilder {
                 UsingOption::Range(range) => {
                     builder = builder.range(CellRange::try_parse(range.as_str()).unwrap());
                 }
+                UsingOption::ColNames(colnames) => {
+                    builder = builder.colnames_row(u32::from_str(colnames.as_str()).unwrap());
+                },
             }
         }
 
@@ -110,6 +124,11 @@ impl DataManagerBuilder {
         self
     }
 
+    pub fn colnames_row(mut self, row: u32) -> Self {
+        self.colnames_row = Some(row);
+        self
+    }
+
     pub fn open(self) -> Result<DataManager, DataManagerError> {
         if let Some(file) = self.file {
             if let Some(worksheet) = self.worksheet {
@@ -118,6 +137,7 @@ impl DataManagerBuilder {
                         sheets,
                         worksheet,
                         range: self.range,
+                        colnames_row: self.colnames_row,
                     }),
                     Err(err) => Err(DataManagerError::Calamine(err)),
                 }