Support for complex deprecated definition and any type.

Author: jerbly

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.2.1
+
+- Support for complex deprecated definition and any type.
+
 # 0.2.0
 
 - Added a namespace tree view sidebar.
@@ -29,11 +33,10 @@
 
 - Number type attributes now run an `avg` query when a dataset is clicked
 - Template type attributes:
-    - Now render with the `.<key>` suffix in the name
-    - The dictionary, discovered from Honeycomb, is displayed in a `keys` section with query links
+  - Now render with the `.<key>` suffix in the name
+  - The dictionary, discovered from Honeycomb, is displayed in a `keys` section with query links
 - Added a favicon
 
-
 # 0.1.5
 
 - Uses `cargo-dist` for build and release.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "honey-explore"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Jeremy Blythe <jeremyblythe@gmail.com>"]
 repository = "https://github.com/jerbly/honey-explore"

Cargo.toml

@@ -154,7 +154,7 @@ async fn main() -> anyhow::Result<()> {
     {
         Ok(hclient) => hclient,
         Err(e) => {
-            eprintln!("Failed to get honeycomb client: {}", e);
+            eprintln!("Failed to get honeycomb client: {e}");
             None
         }
     };
@@ -197,10 +197,10 @@ async fn main() -> anyhow::Result<()> {
     // run it
     let listener = tokio::net::TcpListener::bind(args.addr).await?;
     let local_addr = listener.local_addr()?;
-    println!("listening on {}", local_addr);
+    println!("listening on {local_addr}");
     // open a browser
-    if let Err(e) = open::that(format!("http://{}", local_addr)) {
-        eprintln!("Failed to open browser: {}", e);
+    if let Err(e) = open::that(format!("http://{local_addr}")) {
+        eprintln!("Failed to open browser: {e}");
     }
     axum::serve(listener, app).await?;
     Ok(())
@@ -310,7 +310,7 @@ async fn honeycomb_exists_handler(
                         }
                         Simple(PrimitiveType::TemplateOfInt)
                         | Simple(PrimitiveType::TemplateOfDouble) => {
-                            let column_with_suffix = format!("{}.{}", column, suffix);
+                            let column_with_suffix = format!("{column}.{suffix}");
                             if let Ok(avg) =
                                 hc.get_avg_query_url(&dataset, &column_with_suffix).await
                             {
@@ -323,7 +323,7 @@ async fn honeycomb_exists_handler(
                         | Simple(PrimitiveType::TemplateOfArrayOfInt)
                         | Simple(PrimitiveType::TemplateOfArrayOfDouble)
                         | Simple(PrimitiveType::TemplateOfArrayOfBoolean) => {
-                            let column_with_suffix = format!("{}.{}", column, suffix);
+                            let column_with_suffix = format!("{column}.{suffix}");
                             if let Ok(exists) = hc
                                 .get_exists_query_url(&dataset, &column_with_suffix, false)
                                 .await
@@ -440,7 +440,7 @@ fn get_links(names: &Vec<String>) -> Vec<String> {
         if prev.is_empty() {
             prev = name.clone();
         } else {
-            prev = format!("{}.{}", prev, name);
+            prev = format!("{prev}.{name}");
         }
         links.push(prev.clone());
     }

src/main.rs

@@ -17,8 +17,8 @@ pub enum MemberValue {
 impl Display for MemberValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            MemberValue::StringType(s) => write!(f, "{}", s),
-            MemberValue::IntegerType(i) => write!(f, "{}", i),
+            MemberValue::StringType(s) => write!(f, "{s}"),
+            MemberValue::IntegerType(i) => write!(f, "{i}"),
         }
     }
 }
@@ -62,6 +62,7 @@ impl Display for ComplexType {
 #[derive(Debug, Deserialize, Clone)]
 #[serde(untagged)]
 pub enum PrimitiveType {
+    Any,
     String,
     Int,
     Double,
@@ -83,6 +84,7 @@ pub enum PrimitiveType {
 impl Display for PrimitiveType {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
+            PrimitiveType::Any => write!(f, "any"),
             PrimitiveType::String => write!(f, "string"),
             PrimitiveType::Int => write!(f, "int"),
             PrimitiveType::Double => write!(f, "double"),
@@ -110,6 +112,7 @@ where
     let s: serde_yaml::Value = serde::Deserialize::deserialize(deserializer)?;
     match s {
         serde_yaml::Value::String(s) => match s.as_str() {
+            "any" => Ok(PrimitiveType::Any),
             "string" => Ok(PrimitiveType::String),
             "int" => Ok(PrimitiveType::Int),
             "double" => Ok(PrimitiveType::Double),
@@ -143,8 +146,8 @@ pub enum Type {
 impl Display for Type {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Type::Simple(s) => write!(f, "{}", s),
-            Type::Complex(c) => write!(f, "{}", c),
+            Type::Simple(s) => write!(f, "{s}"),
+            Type::Complex(c) => write!(f, "{c}"),
         }
     }
 }
@@ -156,6 +159,7 @@ pub enum ValueType {
     Bool(bool),
     Integer(i64),
     Float(f64),
+    Any(String),
     ArrayString(Vec<String>),
     ArrayBool(Vec<bool>),
     ArrayInteger(Vec<i64>),
@@ -165,14 +169,15 @@ pub enum ValueType {
 impl Display for ValueType {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ValueType::String(s) => write!(f, "{}", s),
-            ValueType::Bool(b) => write!(f, "{}", b),
-            ValueType::Integer(i) => write!(f, "{}", i),
-            ValueType::Float(fl) => write!(f, "{}", fl),
-            ValueType::ArrayString(s) => write!(f, "{:?}", s),
-            ValueType::ArrayBool(b) => write!(f, "{:?}", b),
-            ValueType::ArrayInteger(i) => write!(f, "{:?}", i),
-            ValueType::ArrayFloat(fl) => write!(f, "{:?}", fl),
+            ValueType::String(s) => write!(f, "{s}"),
+            ValueType::Bool(b) => write!(f, "{b}"),
+            ValueType::Integer(i) => write!(f, "{i}"),
+            ValueType::Float(fl) => write!(f, "{fl}"),
+            ValueType::Any(s) => write!(f, "{s}"),
+            ValueType::ArrayString(s) => write!(f, "{s:?}"),
+            ValueType::ArrayBool(b) => write!(f, "{b:?}"),
+            ValueType::ArrayInteger(i) => write!(f, "{i:?}"),
+            ValueType::ArrayFloat(fl) => write!(f, "{fl:?}"),
         }
     }
 }
@@ -191,13 +196,30 @@ pub struct Attribute {
     pub brief: Option<String>,
     pub note: Option<String>,
     pub examples: Option<Examples>,
-    pub deprecated: Option<String>,
+    pub deprecated: Option<Deprecated>,
     pub used_by: Option<Vec<String>>,
     pub registry_name: Option<String>,
     pub defined_in: Option<String>,
     pub template_suffixes: Option<BTreeMap<String, Vec<String>>>,
 }
 
+#[derive(Debug, Deserialize, Clone)]
+pub struct Deprecated {
+    pub reason: String,
+}
+
+impl Display for Deprecated {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Deprecated: {}", self.reason)
+    }
+}
+
+impl AsRef<str> for Deprecated {
+    fn as_ref(&self) -> &str {
+        &self.reason
+    }
+}
+
 impl Attribute {
     pub fn is_template_type(&self) -> bool {
         matches!(
@@ -246,7 +268,10 @@ impl SemanticConventions {
                 let entry = entry?;
                 // print the trailing part of the path after the root_dir
                 let defined_in = entry.strip_prefix(root_dir)?.to_str().unwrap_or("");
-
+                // ignore registry_manifest files
+                if defined_in.contains("registry_manifest") {
+                    continue;
+                }
                 sc.read_file(&entry, registry_name, defined_in)?;
             }
         }
@@ -259,7 +284,7 @@ impl SemanticConventions {
         registry_name: &str,
         defined_in: &str,
     ) -> anyhow::Result<()> {
-        // println!("reading file: {:?}", path);
+        //println!("reading file: {:?}", path);
         let groups: Groups = serde_yaml::from_reader(&File::open(path)?)?;
         for group in groups.groups {
             if let Some(attributes) = group.attributes {