difftreelog
feat preserve object field order
in: trunk
5 files changed
crates/nixlike/Cargo.tomldiffbeforeafterboth--- a/crates/nixlike/Cargo.toml
+++ b/crates/nixlike/Cargo.toml
@@ -8,6 +8,7 @@
[dependencies]
anyhow = "1.0.44"
dprint-core = "0.46.2"
+linked-hash-map = "0.5.4"
peg = "0.7.0"
serde = "1.0.130"
serde_json = "1.0.68"
crates/nixlike/src/de_impl.rsdiffbeforeafterboth--- a/crates/nixlike/src/de_impl.rs
+++ b/crates/nixlike/src/de_impl.rs
@@ -1,8 +1,6 @@
-use std::{
- collections::BTreeMap,
- convert::{TryFrom, TryInto},
-};
+use std::convert::{TryFrom, TryInto};
+use linked_hash_map::LinkedHashMap;
use serde::{
de::{self, MapAccess, SeqAccess},
Deserializer,
@@ -11,11 +9,11 @@
use crate::{Error, Value};
struct ObjectAccess {
- iter: std::collections::btree_map::IntoIter<String, Value>,
+ iter: linked_hash_map::IntoIter<String, Value>,
value: Option<Value>,
}
impl ObjectAccess {
- fn new(v: BTreeMap<String, Value>) -> Self {
+ fn new(v: LinkedHashMap<String, Value>) -> Self {
Self {
iter: v.into_iter(),
value: None,
@@ -103,7 +101,7 @@
_ => Err(Error::Expected("array")),
}
}
- fn parse_object(self) -> Result<BTreeMap<String, Value>, Error> {
+ fn parse_object(self) -> Result<LinkedHashMap<String, Value>, Error> {
match self {
Value::Object(s) => Ok(s),
_ => Err(Error::Expected("object")),
crates/nixlike/src/lib.rsdiffbeforeafterboth--- a/crates/nixlike/src/lib.rs
+++ b/crates/nixlike/src/lib.rs
@@ -1,5 +1,4 @@
-use std::collections::BTreeMap;
-
+use linked_hash_map::LinkedHashMap;
use peg::str::LineCol;
use se_impl::MySerialize;
use serde::{Deserialize, Serialize};
@@ -29,7 +28,7 @@
Number(i64),
String(String),
Boolean(bool),
- Object(BTreeMap<String, Value>),
+ Object(LinkedHashMap<String, Value>),
Array(Vec<Value>),
Null,
}
@@ -49,11 +48,11 @@
/ "false" {false} } / expected!("<boolean>")
rule indent() -> String
= quiet! { s:$(['a'..='z' | 'A'..='Z' | '0'..='9' | '_' | '-']+) { s.to_owned() } } / expected!("<identifier>")
- rule object() -> BTreeMap<String, Value>
+ rule object() -> LinkedHashMap<String, Value>
= "{" _
e:(k:indent()++(_ "." _) _ "=" _ v:value() _ ";" _ {(k, v)})*
"}" {?
- let mut out = BTreeMap::new();
+ let mut out = LinkedHashMap::new();
for (k, v) in e {
let mut map = &mut out;
for v in k.iter().take(k.len() - 1) {
crates/nixlike/src/se_impl.rsdiffbeforeafterboth1use std::{collections::BTreeMap, convert::TryInto};23use serde::{4 ser::{5 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,6 SerializeTupleStruct, SerializeTupleVariant,7 },8 Serializer,9};1011use crate::{Error, Value};1213impl ser::Error for Error {14 fn custom<T>(msg: T) -> Self15 where16 T: std::fmt::Display,17 {18 Self::Custom(format!("{}", msg))19 }20}2122pub struct MySerializeSeq(Vec<Value>);2324impl SerializeSeq for MySerializeSeq {25 type Ok = Value;2627 type Error = Error;2829 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>30 where31 T: serde::Serialize,32 {33 self.0.push(value.serialize(MySerialize)?);34 Ok(())35 }3637 fn end(self) -> Result<Self::Ok, Self::Error> {38 Ok(Value::Array(self.0))39 }40}41impl SerializeTuple for MySerializeSeq {42 type Ok = Value;4344 type Error = Error;4546 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>47 where48 T: serde::Serialize,49 {50 self.0.push(value.serialize(MySerialize)?);51 Ok(())52 }5354 fn end(self) -> Result<Self::Ok, Self::Error> {55 Ok(Value::Array(self.0))56 }57}58impl SerializeTupleStruct for MySerializeSeq {59 type Ok = Value;6061 type Error = Error;6263 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>64 where65 T: serde::Serialize,66 {67 self.0.push(value.serialize(MySerialize)?);68 Ok(())69 }7071 fn end(self) -> Result<Self::Ok, Self::Error> {72 Ok(Value::Array(self.0))73 }74}7576pub struct MySerializeSeqVariant(String, MySerializeSeq);7778impl SerializeTupleVariant for MySerializeSeqVariant {79 type Ok = Value;8081 type Error = Error;8283 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>84 where85 T: serde::Serialize,86 {87 self.1.serialize_field(value)88 }8990 fn end(self) -> Result<Self::Ok, Self::Error> {91 Ok(Value::Object(92 vec![(self.0, Value::Array(self.1 .0))]93 .into_iter()94 .collect(),95 ))96 }97}9899pub struct MySerializeMap(BTreeMap<String, Value>, Option<String>);100101impl SerializeMap for MySerializeMap {102 type Ok = Value;103104 type Error = Error;105106 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>107 where108 T: serde::Serialize,109 {110 let _ = self111 .1112 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());113 Ok(())114 }115116 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>117 where118 T: serde::Serialize,119 {120 self.0121 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);122 Ok(())123 }124125 fn end(self) -> Result<Self::Ok, Self::Error> {126 Ok(Value::Object(self.0))127 }128}129130pub struct MySerializeStruct(BTreeMap<String, Value>);131132impl SerializeStruct for MySerializeStruct {133 type Ok = Value;134135 type Error = Error;136137 fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>138 where139 T: serde::Serialize,140 {141 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);142 Ok(())143 }144145 fn end(self) -> Result<Self::Ok, Self::Error> {146 Ok(Value::Object(self.0))147 }148}149150pub struct MySerializeStructVariant(String, BTreeMap<String, Value>);151152impl SerializeStructVariant for MySerializeStructVariant {153 type Ok = Value;154155 type Error = Error;156157 fn serialize_field<T: ?Sized>(158 &mut self,159 key: &'static str,160 value: &T,161 ) -> Result<(), Self::Error>162 where163 T: serde::Serialize,164 {165 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);166 Ok(())167 }168169 fn end(self) -> Result<Self::Ok, Self::Error> {170 Ok(Value::Object(171 vec![(self.0, Value::Object(self.1))].into_iter().collect(),172 ))173 }174}175176pub struct MySerialize;177178impl Serializer for MySerialize {179 type Ok = Value;180181 type Error = Error;182183 type SerializeSeq = MySerializeSeq;184185 type SerializeTuple = MySerializeSeq;186187 type SerializeTupleStruct = MySerializeSeq;188189 type SerializeTupleVariant = MySerializeSeqVariant;190191 type SerializeMap = MySerializeMap;192193 type SerializeStruct = MySerializeStruct;194195 type SerializeStructVariant = MySerializeStructVariant;196197 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {198 Ok(Value::Boolean(v))199 }200201 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {202 Ok(Value::Number(v as i64))203 }204205 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {206 Ok(Value::Number(v as i64))207 }208209 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {210 Ok(Value::Number(v as i64))211 }212213 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {214 Ok(Value::Number(v as i64))215 }216217 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {218 Ok(Value::Number(v as i64))219 }220221 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {222 Ok(Value::Number(v as i64))223 }224225 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {226 Ok(Value::Number(v as i64))227 }228229 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {230 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))231 }232233 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {234 todo!()235 }236237 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {238 todo!()239 }240241 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {242 Ok(Value::String(v.to_string()))243 }244245 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {246 Ok(Value::String(v.to_owned()))247 }248249 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {250 todo!()251 }252253 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {254 Ok(Value::Null)255 }256257 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>258 where259 T: serde::Serialize,260 {261 value.serialize(self)262 }263264 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {265 Ok(Value::Null)266 }267268 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {269 self.serialize_unit()270 }271272 fn serialize_unit_variant(273 self,274 _name: &'static str,275 _variant_index: u32,276 variant: &'static str,277 ) -> Result<Self::Ok, Self::Error> {278 Ok(Value::String(variant.to_string()))279 }280281 fn serialize_newtype_struct<T: ?Sized>(282 self,283 _name: &'static str,284 value: &T,285 ) -> Result<Self::Ok, Self::Error>286 where287 T: serde::Serialize,288 {289 value.serialize(self)290 }291292 fn serialize_newtype_variant<T: ?Sized>(293 self,294 _name: &'static str,295 _variant_index: u32,296 variant: &'static str,297 value: &T,298 ) -> Result<Self::Ok, Self::Error>299 where300 T: serde::Serialize,301 {302 Ok(Value::Object(303 vec![(variant.to_string(), value.serialize(self)?)]304 .into_iter()305 .collect(),306 ))307 }308309 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {310 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))311 }312313 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {314 Ok(MySerializeSeq(Vec::with_capacity(len)))315 }316317 fn serialize_tuple_struct(318 self,319 _name: &'static str,320 len: usize,321 ) -> Result<Self::SerializeTupleStruct, Self::Error> {322 Ok(MySerializeSeq(Vec::with_capacity(len)))323 }324325 fn serialize_tuple_variant(326 self,327 _name: &'static str,328 _variant_index: u32,329 variant: &'static str,330 len: usize,331 ) -> Result<Self::SerializeTupleVariant, Self::Error> {332 Ok(MySerializeSeqVariant(333 variant.to_owned(),334 MySerializeSeq(Vec::with_capacity(len)),335 ))336 }337338 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {339 Ok(MySerializeMap(BTreeMap::new(), None))340 }341342 fn serialize_struct(343 self,344 _name: &'static str,345 _len: usize,346 ) -> Result<Self::SerializeStruct, Self::Error> {347 Ok(MySerializeStruct(BTreeMap::new()))348 }349350 fn serialize_struct_variant(351 self,352 _name: &'static str,353 _variant_index: u32,354 variant: &'static str,355 _len: usize,356 ) -> Result<Self::SerializeStructVariant, Self::Error> {357 Ok(MySerializeStructVariant(358 variant.to_owned(),359 BTreeMap::new(),360 ))361 }362}1use std::convert::TryInto;23use linked_hash_map::LinkedHashMap;4use serde::{5 ser::{6 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,7 SerializeTupleStruct, SerializeTupleVariant,8 },9 Serializer,10};1112use crate::{Error, Value};1314impl ser::Error for Error {15 fn custom<T>(msg: T) -> Self16 where17 T: std::fmt::Display,18 {19 Self::Custom(format!("{}", msg))20 }21}2223pub struct MySerializeSeq(Vec<Value>);2425impl SerializeSeq for MySerializeSeq {26 type Ok = Value;2728 type Error = Error;2930 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>31 where32 T: serde::Serialize,33 {34 self.0.push(value.serialize(MySerialize)?);35 Ok(())36 }3738 fn end(self) -> Result<Self::Ok, Self::Error> {39 Ok(Value::Array(self.0))40 }41}42impl SerializeTuple for MySerializeSeq {43 type Ok = Value;4445 type Error = Error;4647 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>48 where49 T: serde::Serialize,50 {51 self.0.push(value.serialize(MySerialize)?);52 Ok(())53 }5455 fn end(self) -> Result<Self::Ok, Self::Error> {56 Ok(Value::Array(self.0))57 }58}59impl SerializeTupleStruct for MySerializeSeq {60 type Ok = Value;6162 type Error = Error;6364 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>65 where66 T: serde::Serialize,67 {68 self.0.push(value.serialize(MySerialize)?);69 Ok(())70 }7172 fn end(self) -> Result<Self::Ok, Self::Error> {73 Ok(Value::Array(self.0))74 }75}7677pub struct MySerializeSeqVariant(String, MySerializeSeq);7879impl SerializeTupleVariant for MySerializeSeqVariant {80 type Ok = Value;8182 type Error = Error;8384 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>85 where86 T: serde::Serialize,87 {88 self.1.serialize_field(value)89 }9091 fn end(self) -> Result<Self::Ok, Self::Error> {92 Ok(Value::Object(93 vec![(self.0, Value::Array(self.1 .0))]94 .into_iter()95 .collect(),96 ))97 }98}99100pub struct MySerializeMap(LinkedHashMap<String, Value>, Option<String>);101102impl SerializeMap for MySerializeMap {103 type Ok = Value;104105 type Error = Error;106107 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>108 where109 T: serde::Serialize,110 {111 let _ = self112 .1113 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());114 Ok(())115 }116117 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>118 where119 T: serde::Serialize,120 {121 self.0122 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);123 Ok(())124 }125126 fn end(self) -> Result<Self::Ok, Self::Error> {127 Ok(Value::Object(self.0))128 }129}130131pub struct MySerializeStruct(LinkedHashMap<String, Value>);132133impl SerializeStruct for MySerializeStruct {134 type Ok = Value;135136 type Error = Error;137138 fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>139 where140 T: serde::Serialize,141 {142 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);143 Ok(())144 }145146 fn end(self) -> Result<Self::Ok, Self::Error> {147 Ok(Value::Object(self.0))148 }149}150151pub struct MySerializeStructVariant(String, LinkedHashMap<String, Value>);152153impl SerializeStructVariant for MySerializeStructVariant {154 type Ok = Value;155156 type Error = Error;157158 fn serialize_field<T: ?Sized>(159 &mut self,160 key: &'static str,161 value: &T,162 ) -> Result<(), Self::Error>163 where164 T: serde::Serialize,165 {166 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);167 Ok(())168 }169170 fn end(self) -> Result<Self::Ok, Self::Error> {171 Ok(Value::Object(172 vec![(self.0, Value::Object(self.1))].into_iter().collect(),173 ))174 }175}176177pub struct MySerialize;178179impl Serializer for MySerialize {180 type Ok = Value;181182 type Error = Error;183184 type SerializeSeq = MySerializeSeq;185186 type SerializeTuple = MySerializeSeq;187188 type SerializeTupleStruct = MySerializeSeq;189190 type SerializeTupleVariant = MySerializeSeqVariant;191192 type SerializeMap = MySerializeMap;193194 type SerializeStruct = MySerializeStruct;195196 type SerializeStructVariant = MySerializeStructVariant;197198 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {199 Ok(Value::Boolean(v))200 }201202 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {203 Ok(Value::Number(v as i64))204 }205206 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {207 Ok(Value::Number(v as i64))208 }209210 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {211 Ok(Value::Number(v as i64))212 }213214 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {215 Ok(Value::Number(v as i64))216 }217218 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {219 Ok(Value::Number(v as i64))220 }221222 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {223 Ok(Value::Number(v as i64))224 }225226 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {227 Ok(Value::Number(v as i64))228 }229230 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {231 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))232 }233234 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {235 todo!()236 }237238 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {239 todo!()240 }241242 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {243 Ok(Value::String(v.to_string()))244 }245246 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {247 Ok(Value::String(v.to_owned()))248 }249250 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {251 todo!()252 }253254 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {255 Ok(Value::Null)256 }257258 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>259 where260 T: serde::Serialize,261 {262 value.serialize(self)263 }264265 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {266 Ok(Value::Null)267 }268269 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {270 self.serialize_unit()271 }272273 fn serialize_unit_variant(274 self,275 _name: &'static str,276 _variant_index: u32,277 variant: &'static str,278 ) -> Result<Self::Ok, Self::Error> {279 Ok(Value::String(variant.to_string()))280 }281282 fn serialize_newtype_struct<T: ?Sized>(283 self,284 _name: &'static str,285 value: &T,286 ) -> Result<Self::Ok, Self::Error>287 where288 T: serde::Serialize,289 {290 value.serialize(self)291 }292293 fn serialize_newtype_variant<T: ?Sized>(294 self,295 _name: &'static str,296 _variant_index: u32,297 variant: &'static str,298 value: &T,299 ) -> Result<Self::Ok, Self::Error>300 where301 T: serde::Serialize,302 {303 Ok(Value::Object(304 vec![(variant.to_string(), value.serialize(self)?)]305 .into_iter()306 .collect(),307 ))308 }309310 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {311 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))312 }313314 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {315 Ok(MySerializeSeq(Vec::with_capacity(len)))316 }317318 fn serialize_tuple_struct(319 self,320 _name: &'static str,321 len: usize,322 ) -> Result<Self::SerializeTupleStruct, Self::Error> {323 Ok(MySerializeSeq(Vec::with_capacity(len)))324 }325326 fn serialize_tuple_variant(327 self,328 _name: &'static str,329 _variant_index: u32,330 variant: &'static str,331 len: usize,332 ) -> Result<Self::SerializeTupleVariant, Self::Error> {333 Ok(MySerializeSeqVariant(334 variant.to_owned(),335 MySerializeSeq(Vec::with_capacity(len)),336 ))337 }338339 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {340 Ok(MySerializeMap(LinkedHashMap::new(), None))341 }342343 fn serialize_struct(344 self,345 _name: &'static str,346 _len: usize,347 ) -> Result<Self::SerializeStruct, Self::Error> {348 Ok(MySerializeStruct(LinkedHashMap::new()))349 }350351 fn serialize_struct_variant(352 self,353 _name: &'static str,354 _variant_index: u32,355 variant: &'static str,356 _len: usize,357 ) -> Result<Self::SerializeStructVariant, Self::Error> {358 Ok(MySerializeStructVariant(359 variant.to_owned(),360 LinkedHashMap::new(),361 ))362 }363}crates/nixlike/src/to_string.rsdiffbeforeafterboth--- a/crates/nixlike/src/to_string.rs
+++ b/crates/nixlike/src/to_string.rs
@@ -41,7 +41,7 @@
out.push_signal(Signal::StartIndent);
out.push_condition(conditions::if_true_or(
"array start",
- is_multiple_lines.clone(),
+ is_multiple_lines,
Signal::NewLine.into(),
Signal::SpaceOrNewLine.into(),
));
@@ -49,7 +49,7 @@
write_nix_buf(item, out);
out.push_condition(conditions::if_true_or(
"element separator",
- is_multiple_lines.clone(),
+ is_multiple_lines,
Signal::NewLine.into(),
Signal::SpaceOrNewLine.into(),
));
@@ -73,7 +73,7 @@
out.push_signal(Signal::StartIndent);
out.push_condition(conditions::if_true_or(
"object start",
- is_multiple_lines.clone(),
+ is_multiple_lines,
Signal::NewLine.into(),
Signal::SpaceOrNewLine.into(),
));
@@ -81,7 +81,7 @@
write_nix_obj_key_buf(k, v, out);
out.push_condition(conditions::if_true_or(
"element separator",
- is_multiple_lines.clone(),
+ is_multiple_lines,
Signal::NewLine.into(),
Signal::SpaceOrNewLine.into(),
));