Add 'Header', TryFrom<YaccKind> for Value and it's inverse.

Author: ratmice

cfgrammar/src/lib/header.rs

@@ -1,9 +1,19 @@
-use crate::{yacc::ParserError, Location, Span};
+use crate::{
+     markmap::MarkMap,
+    yacc::{ParserError, YaccKind, YaccOriginalActionKind},
+    Location, Span,
+};
 use lazy_static::lazy_static;
 use regex::{Regex, RegexBuilder};
 use std::collections::{hash_map::Entry, HashMap};
 use std::{error::Error, fmt};
 
+/// An error regarding the `%grmtools` header section.
+///
+/// It could be any of:
+///
+/// * An error during parsing the section.
+/// * An error resulting from a value in the section having an invalid value.
 #[derive(Debug, Clone)]
 pub struct HeaderError {
     pub kind: HeaderErrorKind,
@@ -32,6 +42,7 @@ pub enum HeaderErrorKind {
     ExpectedToken(char),
     DuplicateEntry,
     InvalidEntry(&'static str),
+    ConversionError(&'static str, &'static str),
 }
 
 impl fmt::Display for HeaderErrorKind {
@@ -42,6 +53,9 @@ impl fmt::Display for HeaderErrorKind {
             HeaderErrorKind::ExpectedToken(c) => &format!("Expected token: '{}", c),
             HeaderErrorKind::InvalidEntry(s) => &format!("Invalid entry: '{}'", s),
             HeaderErrorKind::DuplicateEntry => "Duplicate Entry",
+            HeaderErrorKind::ConversionError(t, err_str) => {
+                &format!("Converting header value to type '{}': {}", t, err_str)
+            }
         };
         write!(f, "{}", s)
     }
@@ -64,6 +78,7 @@ impl fmt::Display for HeaderErrorKind {
 /// }
 /// ```
 #[derive(Debug, Eq, PartialEq)]
+#[doc(hidden)]
 pub struct Namespaced {
     pub namespace: Option<(String, Location)>,
     pub member: (String, Location),
@@ -91,7 +106,12 @@ pub struct GrmtoolsSectionParser<'input> {
     required: bool,
 }
 
+/// The value contained within a `Header`
+///
+/// To be useful across diverse crates this types fields are limited to types derived from `core::` types.
+/// like booleans, numeric types, and string values.
 #[derive(Debug, Eq, PartialEq)]
+#[doc(hidden)]
 pub enum Value {
     Flag(bool, Location),
     Setting(Setting),
@@ -345,6 +365,155 @@ impl<'input> GrmtoolsSectionParser<'input> {
     }
 }
 
+/// A data structure representation of the %grmtools section.
+pub type Header = MarkMap<String, (Location, Value)>;
+
+impl TryFrom<YaccKind> for Value {
+    type Error = HeaderError;
+    fn try_from(kind: YaccKind) -> Result<Value, HeaderError> {
+        let from_loc = Location::Other("From<YaccKind>".to_string());
+        Ok(match kind {
+            YaccKind::Grmtools => Value::Setting(Setting::Unitary(Namespaced {
+                namespace: Some(("yacckind".to_string(), from_loc.clone())),
+                member: ("grmtools".to_string(), from_loc),
+            })),
+            YaccKind::Eco => Value::Setting(Setting::Unitary(Namespaced {
+                namespace: Some(("yacckind".to_string(), from_loc.clone())),
+                member: ("eco".to_string(), from_loc),
+            })),
+            YaccKind::Original(action_kind) => Value::Setting(Setting::Constructor {
+                ctor: Namespaced {
+                    namespace: Some(("yacckind".to_string(), from_loc.clone())),
+                    member: ("original".to_string(), from_loc.clone()),
+                },
+                arg: match action_kind {
+                    YaccOriginalActionKind::NoAction => Namespaced {
+                        namespace: Some(("yaccoriginalactionkind".to_string(), from_loc.clone())),
+                        member: ("noaction".to_string(), from_loc),
+                    },
+                    YaccOriginalActionKind::UserAction => Namespaced {
+                        namespace: Some(("yaccoriginalactionkind".to_string(), from_loc.clone())),
+                        member: ("useraction".to_string(), from_loc),
+                    },
+                    YaccOriginalActionKind::GenericParseTree => Namespaced {
+                        namespace: Some(("yaccoriginalactionkind".to_string(), from_loc.clone())),
+                        member: ("genericparsetree".to_string(), from_loc),
+                    },
+                },
+            }),
+        })
+    }
+}
+
+impl TryFrom<&Value> for YaccKind {
+    type Error = HeaderError;
+    fn try_from(value: &Value) -> Result<YaccKind, HeaderError> {
+        let mut err_locs = Vec::new();
+        match value {
+            Value::Flag(_, loc) => Err(HeaderError {
+                kind: HeaderErrorKind::ConversionError(
+                    "From<YaccKind>",
+                    "Cannot convert boolean to YaccKind",
+                ),
+                locations: vec![loc.clone()],
+            }),
+            Value::Setting(Setting::Num(_, loc)) => Err(HeaderError {
+                kind: HeaderErrorKind::ConversionError(
+                    "From<YaccKind>",
+                    "Cannot convert number to YaccKind",
+                ),
+                locations: vec![loc.clone()],
+            }),
+            Value::Setting(Setting::Unitary(Namespaced {
+                namespace,
+                member: (yk_value, yk_value_loc),
+            })) => {
+                if let Some((ns, ns_loc)) = namespace {
+                    if ns != "yacckind" {
+                        err_locs.push(ns_loc.clone());
+                    }
+                }
+                let yacckinds = [
+                    ("grmtools".to_string(), YaccKind::Grmtools),
+                    ("eco".to_string(), YaccKind::Eco),
+                ];
+                let yk_found = yacckinds
+                    .iter()
+                    .find_map(|(yk_str, yk)| (yk_str == yk_value).then_some(yk));
+                if let Some(yk) = yk_found {
+                    if err_locs.is_empty() {
+                        Ok(*yk)
+                    } else {
+                        Err(HeaderError {
+                            kind: HeaderErrorKind::InvalidEntry("yacckind"),
+                            locations: err_locs,
+                        })
+                    }
+                } else {
+                    err_locs.push(yk_value_loc.clone());
+                    Err(HeaderError {
+                        kind: HeaderErrorKind::InvalidEntry("yacckind"),
+                        locations: err_locs,
+                    })
+                }
+            }
+            Value::Setting(Setting::Constructor {
+                ctor:
+                    Namespaced {
+                        namespace: yk_namespace,
+                        member: (yk_str, yk_loc),
+                    },
+                arg:
+                    Namespaced {
+                        namespace: ak_namespace,
+                        member: (ak_str, ak_loc),
+                    },
+            }) => {
+                if let Some((yk_ns, yk_ns_loc)) = yk_namespace {
+                    if yk_ns != "yacckind" {
+                        err_locs.push(yk_ns_loc.clone());
+                    }
+                }
+
+                if yk_str != "original" {
+                    err_locs.push(yk_loc.clone());
+                }
+
+                if let Some((ak_ns, ak_ns_loc)) = ak_namespace {
+                    if ak_ns != "yaccoriginalactionkind" {
+                        err_locs.push(ak_ns_loc.clone());
+                    }
+                }
+                let actionkinds = [
+                    ("noaction", YaccOriginalActionKind::NoAction),
+                    ("useraction", YaccOriginalActionKind::UserAction),
+                    ("genericparsetree", YaccOriginalActionKind::GenericParseTree),
+                ];
+                let yk_found = actionkinds.iter().find_map(|(actionkind_str, actionkind)| {
+                    (ak_str == actionkind_str).then_some(YaccKind::Original(*actionkind))
+                });
+
+                if let Some(yk) = yk_found {
+                    if err_locs.is_empty() {
+                        Ok(yk)
+                    } else {
+                        Err(HeaderError {
+                            kind: HeaderErrorKind::InvalidEntry("yacckind"),
+                            locations: err_locs,
+                        })
+                    }
+                } else {
+                    err_locs.push(ak_loc.clone());
+                    Err(HeaderError {
+                        kind: HeaderErrorKind::InvalidEntry("yacckind"),
+                        locations: err_locs,
+                    })
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

cfgrammar/src/lib/mod.rs

@@ -56,7 +56,6 @@ use bincode::{Decode, Encode};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-#[doc(hidden)]
 pub mod header;
 mod idxnewtype;
 pub mod markmap;