Centralize field names for consistent JSON and text output

The great field name unification of 2025. JSON said "operstate",
text said "STATE" - now they both agree on "state" (lowercase for
JSON, UPPERCASE for text, as nature intended).

Added src/fields.rs as the single source of truth for all field
names across all subcommands. Text output uses to_text_key() to
convert to UPPERCASE, JSON uses the constants directly.

Breaking changes to JSON output (text output unchanged):
- net: operstate -> state, mac_address -> mac, speed_mbps -> speed
- pci: subsystem_vendor_id -> subsys_vendor, subsystem_device_id -> subsys_device

Shorter names win. Consistency wins. Everyone wins.

Author: walruscraft

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kv"
-version = "0.4.2"
+version = "0.5.0"
 edition = "2024"
 rust-version = "1.85"
 description = "kv (kernel view): a portable system inspector for Linux"

src/block.rs

@@ -8,6 +8,7 @@
 //! either as subdirectories of /sys/block/<disk>/ or as separate entries.
 
 use crate::cli::GlobalOptions;
+use crate::fields::{block as f, to_text_key};
 use crate::filter::{opt_str, Filterable};
 use crate::io;
 use crate::json::{begin_kv_output, JsonWriter};
@@ -181,40 +182,40 @@ impl BlockDevice {
     pub fn print_text(&self, verbose: bool, human: bool) {
         let mut parts = Vec::new();
 
-        parts.push(format!("NAME={}", self.name));
-        parts.push(format!("TYPE={}", self.dev_type.as_str()));
-        parts.push(format!("MAJMIN={}:{}", self.major, self.minor));
+        parts.push(format!("{}={}", to_text_key(f::NAME), self.name));
+        parts.push(format!("{}={}", to_text_key(f::TYPE), self.dev_type.as_str()));
+        parts.push(format!("{}={}:{}", to_text_key(f::MAJMIN), self.major, self.minor));
 
         if human {
             let size = io::format_sectors_human(self.size_sectors, self.sector_size);
-            parts.push(format!("SIZE={}", size));
+            parts.push(format!("{}={}", to_text_key(f::SIZE), size));
         } else {
-            parts.push(format!("SIZE_SECTORS={}", self.size_sectors));
+            parts.push(format!("{}={}", to_text_key(f::SIZE_SECTORS), self.size_sectors));
         }
 
         if let Some(ref parent) = self.parent {
-            parts.push(format!("PARENT={}", parent));
+            parts.push(format!("{}={}", to_text_key(f::PARENT), parent));
         }
 
         if let Some(ref mp) = self.mountpoint {
-            parts.push(format!("MOUNTPOINT=\"{}\"", mp));
+            parts.push(format!("{}=\"{}\"", to_text_key(f::MOUNTPOINT), mp));
         }
 
         if verbose {
             if !human {
-                parts.push(format!("SECTOR_SIZE={}", self.sector_size));
+                parts.push(format!("{}={}", to_text_key(f::SECTOR_SIZE), self.sector_size));
             }
-            parts.push(format!("REMOVABLE={}", if self.removable { 1 } else { 0 }));
-            parts.push(format!("RO={}", if self.ro { 1 } else { 0 }));
+            parts.push(format!("{}={}", to_text_key(f::REMOVABLE), if self.removable { 1 } else { 0 }));
+            parts.push(format!("{}={}", to_text_key(f::RO), if self.ro { 1 } else { 0 }));
 
             if let Some(ref model) = self.model {
-                parts.push(format!("MODEL=\"{}\"", model.trim()));
+                parts.push(format!("{}=\"{}\"", to_text_key(f::MODEL), model.trim()));
             }
             if let Some(rot) = self.rotational {
-                parts.push(format!("ROTATIONAL={}", if rot { 1 } else { 0 }));
+                parts.push(format!("{}={}", to_text_key(f::ROTATIONAL), if rot { 1 } else { 0 }));
             }
             if let Some(ref sched) = self.scheduler {
-                parts.push(format!("SCHEDULER={}", sched));
+                parts.push(format!("{}={}", to_text_key(f::SCHEDULER), sched));
             }
         }
 
@@ -352,32 +353,32 @@ fn print_json(devices: &[BlockDevice], pretty: bool, verbose: bool, human: bool)
 fn write_device_json(w: &mut JsonWriter, dev: &BlockDevice, verbose: bool, human: bool) {
     w.array_object_begin();
 
-    w.field_str("name", &dev.name);
-    w.field_str("type", dev.dev_type.as_str());
-    w.field_u64("major", dev.major as u64);
-    w.field_u64("minor", dev.minor as u64);
+    w.field_str(f::NAME, &dev.name);
+    w.field_str(f::TYPE, dev.dev_type.as_str());
+    w.field_u64(f::MAJOR, dev.major as u64);
+    w.field_u64(f::MINOR, dev.minor as u64);
 
     if human {
         let size = io::format_sectors_human(dev.size_sectors, dev.sector_size);
-        w.field_str("size", &size);
+        w.field_str(f::SIZE, &size);
     } else {
-        w.field_u64("size_sectors", dev.size_sectors);
+        w.field_u64(f::SIZE_SECTORS, dev.size_sectors);
     }
 
-    w.field_str_opt("parent", dev.parent.as_deref());
-    w.field_str_opt("mountpoint", dev.mountpoint.as_deref());
+    w.field_str_opt(f::PARENT, dev.parent.as_deref());
+    w.field_str_opt(f::MOUNTPOINT, dev.mountpoint.as_deref());
 
     if verbose {
         if !human {
-            w.field_u64("sector_size", dev.sector_size as u64);
+            w.field_u64(f::SECTOR_SIZE, dev.sector_size as u64);
         }
-        w.field_bool("removable", dev.removable);
-        w.field_bool("ro", dev.ro);
-        w.field_str_opt("model", dev.model.as_deref());
+        w.field_bool(f::REMOVABLE, dev.removable);
+        w.field_bool(f::RO, dev.ro);
+        w.field_str_opt(f::MODEL, dev.model.as_deref());
         if let Some(rot) = dev.rotational {
-            w.field_bool("rotational", rot);
+            w.field_bool(f::ROTATIONAL, rot);
         }
-        w.field_str_opt("scheduler", dev.scheduler.as_deref());
+        w.field_str_opt(f::SCHEDULER, dev.scheduler.as_deref());
     }
 
     w.array_object_end();

src/cpu.rs

@@ -10,6 +10,7 @@
 //! but some fields may be missing on some platforms. That's life in embedded.
 
 use crate::cli::GlobalOptions;
+use crate::fields::{cpu as f, to_text_key};
 use crate::io;
 use crate::json::{begin_kv_output, JsonWriter};
 use std::collections::HashSet;
@@ -168,51 +169,51 @@ impl CpuInfo {
     pub fn print_text(&self, verbose: bool) {
         let mut parts = Vec::new();
 
-        parts.push(format!("LOGICAL_CPUS={}", self.logical_cpus));
+        parts.push(format!("{}={}", to_text_key(f::LOGICAL_CPUS), self.logical_cpus));
 
         if let Some(ref name) = self.model_name {
             // Quote model name since it often has spaces
-            parts.push(format!("MODEL_NAME=\"{}\"", name));
+            parts.push(format!("{}=\"{}\"", to_text_key(f::MODEL_NAME), name));
         }
 
         if let Some(ref vendor) = self.vendor_id {
-            parts.push(format!("VENDOR_ID={}", vendor));
+            parts.push(format!("{}={}", to_text_key(f::VENDOR_ID), vendor));
         }
 
         if let Some(sockets) = self.sockets {
-            parts.push(format!("SOCKETS={}", sockets));
+            parts.push(format!("{}={}", to_text_key(f::SOCKETS), sockets));
         }
 
         if let Some(cores) = self.cores_per_socket {
-            parts.push(format!("CORES_PER_SOCKET={}", cores));
+            parts.push(format!("{}={}", to_text_key(f::CORES_PER_SOCKET), cores));
         }
 
         // RISC-V specific fields (always show if present, very informative)
         if let Some(ref isa) = self.isa {
-            parts.push(format!("ISA={}", isa));
+            parts.push(format!("{}={}", to_text_key(f::ISA), isa));
         }
         if let Some(ref mmu) = self.mmu {
-            parts.push(format!("MMU={}", mmu));
+            parts.push(format!("{}={}", to_text_key(f::MMU), mmu));
         }
 
         if verbose {
             if let Some(family) = self.cpu_family {
-                parts.push(format!("CPU_FAMILY={}", family));
+                parts.push(format!("{}={}", to_text_key(f::CPU_FAMILY), family));
             }
             if let Some(model) = self.model {
-                parts.push(format!("MODEL={}", model));
+                parts.push(format!("{}={}", to_text_key(f::MODEL), model));
             }
             if let Some(stepping) = self.stepping {
-                parts.push(format!("STEPPING={}", stepping));
+                parts.push(format!("{}={}", to_text_key(f::STEPPING), stepping));
             }
             if let Some(mhz) = self.cpu_mhz {
-                parts.push(format!("CPU_MHZ={:.2}", mhz));
+                parts.push(format!("{}={:.2}", to_text_key(f::CPU_MHZ), mhz));
             }
             if let Some(ref cache) = self.cache_size {
-                parts.push(format!("CACHE_SIZE=\"{}\"", cache));
+                parts.push(format!("{}=\"{}\"", to_text_key(f::CACHE_SIZE), cache));
             }
             if let Some(ref arch) = self.architecture {
-                parts.push(format!("ARCHITECTURE={}", arch));
+                parts.push(format!("{}={}", to_text_key(f::ARCHITECTURE), arch));
             }
         }
 
@@ -225,26 +226,26 @@ impl CpuInfo {
 
         w.field_object("data");
 
-        w.field_u64("logical_cpus", self.logical_cpus as u64);
-        w.field_str_opt("model_name", self.model_name.as_deref());
-        w.field_str_opt("vendor_id", self.vendor_id.as_deref());
-        w.field_u64_opt("sockets", self.sockets.map(|v| v as u64));
-        w.field_u64_opt("cores_per_socket", self.cores_per_socket.map(|v| v as u64));
+        w.field_u64(f::LOGICAL_CPUS, self.logical_cpus as u64);
+        w.field_str_opt(f::MODEL_NAME, self.model_name.as_deref());
+        w.field_str_opt(f::VENDOR_ID, self.vendor_id.as_deref());
+        w.field_u64_opt(f::SOCKETS, self.sockets.map(|v| v as u64));
+        w.field_u64_opt(f::CORES_PER_SOCKET, self.cores_per_socket.map(|v| v as u64));
         // RISC-V specific
-        w.field_str_opt("isa", self.isa.as_deref());
-        w.field_str_opt("mmu", self.mmu.as_deref());
+        w.field_str_opt(f::ISA, self.isa.as_deref());
+        w.field_str_opt(f::MMU, self.mmu.as_deref());
 
         if verbose {
-            w.field_u64_opt("cpu_family", self.cpu_family.map(|v| v as u64));
-            w.field_u64_opt("model", self.model.map(|v| v as u64));
-            w.field_u64_opt("stepping", self.stepping.map(|v| v as u64));
+            w.field_u64_opt(f::CPU_FAMILY, self.cpu_family.map(|v| v as u64));
+            w.field_u64_opt(f::MODEL, self.model.map(|v| v as u64));
+            w.field_u64_opt(f::STEPPING, self.stepping.map(|v| v as u64));
             // For MHz we'll use string to preserve precision
             if let Some(mhz) = self.cpu_mhz {
-                w.field_str("cpu_mhz", &format!("{:.2}", mhz));
+                w.field_str(f::CPU_MHZ, &format!("{:.2}", mhz));
             }
-            w.field_str_opt("cache_size", self.cache_size.as_deref());
-            w.field_str_opt("architecture", self.architecture.as_deref());
-            w.field_str_opt("flags", self.flags.as_deref());
+            w.field_str_opt(f::CACHE_SIZE, self.cache_size.as_deref());
+            w.field_str_opt(f::ARCHITECTURE, self.architecture.as_deref());
+            w.field_str_opt(f::FLAGS, self.flags.as_deref());
         }
 
         w.end_field_object();
@@ -332,24 +333,24 @@ pub fn collect(_verbose: bool) -> Option<CpuInfo> {
 pub fn write_json(w: &mut JsonWriter, info: &CpuInfo, verbose: bool) {
     w.field_object("cpu");
 
-    w.field_u64("logical_cpus", info.logical_cpus as u64);
-    w.field_str_opt("model_name", info.model_name.as_deref());
-    w.field_str_opt("vendor_id", info.vendor_id.as_deref());
-    w.field_u64_opt("sockets", info.sockets.map(|v| v as u64));
-    w.field_u64_opt("cores_per_socket", info.cores_per_socket.map(|v| v as u64));
+    w.field_u64(f::LOGICAL_CPUS, info.logical_cpus as u64);
+    w.field_str_opt(f::MODEL_NAME, info.model_name.as_deref());
+    w.field_str_opt(f::VENDOR_ID, info.vendor_id.as_deref());
+    w.field_u64_opt(f::SOCKETS, info.sockets.map(|v| v as u64));
+    w.field_u64_opt(f::CORES_PER_SOCKET, info.cores_per_socket.map(|v| v as u64));
     // RISC-V specific
-    w.field_str_opt("isa", info.isa.as_deref());
-    w.field_str_opt("mmu", info.mmu.as_deref());
+    w.field_str_opt(f::ISA, info.isa.as_deref());
+    w.field_str_opt(f::MMU, info.mmu.as_deref());
 
     if verbose {
-        w.field_u64_opt("cpu_family", info.cpu_family.map(|v| v as u64));
-        w.field_u64_opt("model", info.model.map(|v| v as u64));
-        w.field_u64_opt("stepping", info.stepping.map(|v| v as u64));
+        w.field_u64_opt(f::CPU_FAMILY, info.cpu_family.map(|v| v as u64));
+        w.field_u64_opt(f::MODEL, info.model.map(|v| v as u64));
+        w.field_u64_opt(f::STEPPING, info.stepping.map(|v| v as u64));
         if let Some(mhz) = info.cpu_mhz {
-            w.field_str("cpu_mhz", &format!("{:.2}", mhz));
+            w.field_str(f::CPU_MHZ, &format!("{:.2}", mhz));
         }
-        w.field_str_opt("cache_size", info.cache_size.as_deref());
-        w.field_str_opt("architecture", info.architecture.as_deref());
+        w.field_str_opt(f::CACHE_SIZE, info.cache_size.as_deref());
+        w.field_str_opt(f::ARCHITECTURE, info.architecture.as_deref());
     }
 
     w.end_field_object();