added: UnreachableRule error + made parser functions return Result<T>

diff --git a/src/error.rs b/src/error.rs
index 8bd0893716905d4ce17e78d33655dca4a92574fb..171b84985ea8ca541d32c84908452a99319a7fa4 100644 (file)
--- a/src/error.rs
+++ b/src/error.rs
@@ -23,6 +23,8 @@ pub enum MetaError {
     UndefinedExpand { val: String, path: String },
     #[error("undefined call to default.meta: {pattern}\n\tin {path}")]
     UndefinedDefault { pattern: String, path: String },
+    #[error("the parser cannot resolve this input: {input}")]
+    UnreachableRule { input: String },
     #[error(transparent)]
     MetaError(#[from] Box<MetaError>),
     #[error(transparent)]

diff --git a/src/parser/array.rs b/src/parser/array.rs
index bb72a231619f96da4c9466b691f568100d0b3084..8358f586da7f629bd753e92c5eb3bde7891e8343 100644 (file)
--- a/src/parser/array.rs
+++ b/src/parser/array.rs
@@ -1,19 +1,20 @@
-use crate::{Rule, Scope};
+use crate::{MetaError, Rule, Scope};
+use eyre::Result;
 use pest::iterators::{Pair, Pairs};
 use std::collections::HashMap;
 
-pub fn parse_array_defs(pairs: Pairs<Rule>) -> HashMap<Scope, Vec<String>> {
+pub fn parse_array_defs(pairs: Pairs<Rule>) -> Result<HashMap<Scope, Vec<String>>> {
     let mut map = HashMap::new();
     for pair in pairs {
         if Rule::assign == pair.as_rule() {
-            let (key, val) = parse_assign_array(pair);
+            let (key, val) = parse_assign_array(pair)?;
             map.insert(key, val);
         }
     }
-    map
+    Ok(map)
 }
 
-fn parse_assign_array(pair: Pair<Rule>) -> (Scope, Vec<String>) {
+fn parse_assign_array(pair: Pair<Rule>) -> Result<(Scope, Vec<String>)> {
     let mut key = "";
     let mut val = Vec::default();
     let mut global = true;
@@ -29,14 +30,19 @@ fn parse_assign_array(pair: Pair<Rule>) -> (Scope, Vec<String>) {
             }
             Rule::key => key = pair.as_str(),
             Rule::value => val = parse_array(pair.into_inner()),
-            _ => unreachable!(),
+            _ => {
+                return Err(MetaError::UnreachableRule {
+                    input: pair.to_string(),
+                }
+                .into())
+            }
         }
     }
 
     if global {
-        (Scope::into_global(key), val)
+        Ok((Scope::into_global(key), val))
     } else {
-        (Scope::into_local(key), val)
+        Ok((Scope::into_local(key), val))
     }
 }
 

diff --git a/src/parser/def_block.rs b/src/parser/def_block.rs
index df5485dea2cf141380046ef353d8e415996dd6af..26333efa0f0d4db5b4299e28a57590140182c791 100644 (file)
--- a/src/parser/def_block.rs
+++ b/src/parser/def_block.rs
@@ -1,19 +1,20 @@
-use crate::{Rule, Scope};
+use crate::{MetaError, Rule, Scope};
+use eyre::Result;
 use pest::iterators::{Pair, Pairs};
 use std::collections::HashMap;
 
-pub fn parse_defs(pairs: Pairs<Rule>) -> HashMap<Scope, String> {
+pub fn parse_defs(pairs: Pairs<Rule>) -> Result<HashMap<Scope, String>> {
     let mut map = HashMap::new();
     for pair in pairs {
         if Rule::assign == pair.as_rule() {
-            let (key, val) = parse_assign(pair);
+            let (key, val) = parse_assign(pair)?;
             map.insert(key, val.to_string());
         }
     }
-    map
+    Ok(map)
 }
 
-fn parse_assign(pair: Pair<Rule>) -> (Scope, &str) {
+fn parse_assign(pair: Pair<Rule>) -> Result<(Scope, &str)> {
     let mut key = "";
     let mut val = "";
     let mut global = true;
@@ -36,7 +37,12 @@ fn parse_assign(pair: Pair<Rule>) -> (Scope, &str) {
                 }
             }
             // nothing else is an acceptable assignment
-            _ => unreachable!(),
+            _ => {
+                return Err(MetaError::UnreachableRule {
+                    input: pair.to_string(),
+                }
+                .into())
+            }
         }
     }
 
@@ -49,8 +55,8 @@ fn parse_assign(pair: Pair<Rule>) -> (Scope, &str) {
     }
 
     if global {
-        (Scope::into_global(key), val)
+        Ok((Scope::into_global(key), val))
     } else {
-        (Scope::into_local(key), val)
+        Ok((Scope::into_local(key), val))
     }
 }