treediff-4.0.2/.cargo_vcs_info.json 0000644 00000000112 00000000001 0012621 0 ustar {
"git": {
"sha1": "41c9caf8622f860a1cd782f7a450da1786be78e9"
}
}
treediff-4.0.2/CHANGELOG.md 0000644 0000000 0000000 00000034421 00726746425 0013264 0 ustar 0000000 0000000 # Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## v4.0.2 (2021-10-09)
* update changelog
### Commit Statistics
- 1 commit contributed to the release.
- 0 commits where understood as [conventional](https://www.conventionalcommits.org).
- 1 unique issue was worked on
### Commit Details
view details
* **Uncategorized**
- prepare changelog for next release (716c87e)
view details
* **Uncategorized**
- Release treediff v4.0.1 (ebf1d8b)
- Adjusting Changelogs prior to release of treediff v4.0.1 (02db0ae)
- cleanup changelog (20e2e0e)
- rename changelog to capitalized version. (12ad31b)
- Fix broken doc comments. (8f28c92)
- Fix serde_yaml tests - for some reason it inserts newlines to key values (6d524b4)
- fix most of the clippy warnings (223ef3c)
- Remove 'alpha' from next version string (27ec50b)
- optimize imports (a52269e)
- bye bye travis, it was a good time (c44db69)
- Create rust.yml (7bfefb5)
- (cargo-release) start next development iteration 4.0.1-alpha.0 (ab3a679)
view details
* **Uncategorized**
- fix all lints (0ffb242)
- Upgrade serde-yaml to the latest version (3bcb5bb)
- (cargo-release) start next development iteration 3.0.3-alpha.0 (ffc085e)
view details
* **Uncategorized**
- Rust 2018 upgrades (e126c32)
- remove clog; smaller package (176cd69)
view details
* **Uncategorized**
- Make filter_mut() actually return a mutable reference (cbb1b06)
view details
* **Uncategorized**
- Update to latest versions of dependencies (0517e7c)
- Apply latest rustfmt (ace2602)
view details
* **Uncategorized**
- version bump (e0167bd)
- Merge pull request #3 from paulrouget/serde_bump (dbac9ec)
- serde version bump (fe8f02a)
view details
* **Uncategorized**
- Update changelog (323a20f)
- use serde 0.9.8 and Map::Entry (6092375)
view details
* **Uncategorized**
- v2.5.0 (727ed22)
- allow keys to be cloned and displayed (75fae1b)
view details
* **Uncategorized**
- v2.4.0 (960d01c)
- method to obtain mutable borrow to filter (eeb3a2d)
- method to obtain immutable reference to filter. (fc210ea)
view details
* **Uncategorized**
- Update changelog (49cdef0)
- handle possiblity of underflow (07eff4f)
- add AsRef implementation (981c94a)
view details
* **Uncategorized**
- Bump to version 2.2 (3c0dc31)
- Support for yaml-rust (88b632d)
view details
* **Uncategorized**
- fix links (f061028)
view details
* **Uncategorized**
- Mutator/merge support for serde-yaml (5e44fe9)
- prepare merge tests for Yaml (e132c25)
- Add diff support for serde-yaml (8e14a85)
view details
* **Uncategorized**
- Update changelog (ed7c873)
- categories! (4dc2032)
- Say goodbye to git-journal, welcome back clog (67797d3)
view details
* **Uncategorized**
- Bumped version to v2.0 (a579c1c)
- Improved merger API (e6512e2)
- Added doc link to Readme (d84c44f)
view details
* **Uncategorized**
- Changed version to v1.0.0 (958a1f3)
- Added all remaining docs (f17d671)
- Improved crate structure (5d0c76e)
- Added even more docs/structural changes (b463311)
- Improved module layout (367aaf4)
- Added docs for main traits (2d6a8a8)
- Removed unnecessary options in API (a370969)
- Added some more docs (ea88d65)
- Added support for value removal on conflict (1195299)
- Added some crate docs (17fd836)
- Improved project structure (5abc89d)
- Improved suite definitions (96d3b98)
- Added Merge support for serde-json (f932d4a)
- Improved API to support arbitrary modifications when merging (038256d)
- Improved API by using Cow only when needed (773cd1b)
- Added support for deletion handler (a298c50)
- Added test to verify conflict resolver. (46f766a)
- Improved delegate clarity and capability of resolve() (d4eae6a)
- Improved delegate interface consistency (1bcd40a)
- Added groundwork for resolving conflicts (5630e87)
- Added generalized suite for merge tests (d146dba)
- Improved json value tests (fa1bf24)
- Added diff support for serde_json Value (cf1934a)
- Added json value suite (1070cd4)
- Changed structure in preparation for serde (ef34105)
- Added remove_key support for json (0b12455)
- Changed license to MIT/Apache2 (b734959)
- Added handling for merging arrays (3749007)
- Improved object setter code (c141b92)
- Improved mergeable trait to not degenerate information (d448e7c)
- Added key removal and modification for merge (d19b005)
- Added added-key tests and impl (52cb2b6)
- Added a few tests to assert Mergeable.set() (e1d2c14)
- Added merge infrastructure (4347535)
- Improved key ownership (627ba19)
- Added full key support (843d18b)
- Added preliminary key support (70101cc)
- Added handling for scalar/object comparisons (434b533)
- Added implementation for nested object handling (86fbe0a)
- Added key addition and removal (41abd1e)
- Fixed tests (e7905a8)
- Improved type definition (1694109)
- Revert "Added futile attempt to workaround type issue" (420e19c)
- Added futile attempt to workaround type issue (01a4b58)
- Added attempt to use a recursive type (a7eec83)
- Removed std entirely (94b8479)
- Changed diff to get closer to finding differences (6528fa5)
- Improved travis to not run unnecessary tests (048038d)
- Added Value for HashMap (60ef3cf)
- Added json array value (b0304d1)
- Added tests for all json scalars and the json object (0560d81)
- Added first scalar Json value (10b9858)
- Added JsonKey to abstract over usize/String (5ac03ce)
- Added first version of json Value impl (837f56f)
- Added modification of scalar values. (6dee766)
- Added utils module (42e7c3c)
- Improved Delegate to support references (3e31491)
- Improved ChangeType to contain values (9c5904f)
- Added first stub of diff function (01d388b)
- Removed with-std feature (d14deb4)
- Fixed trait type signature to use iterator (ca6ea4e)
- Improved trait signature (569c930)
- Changed trait to just copy everything (9f8203e)
- Revert "Changed trait to support hacky polymorphism" (eb019cc)
- Changed trait to support hacky polymorphism (e544f55)
- Improved definition of trait implementation (4bb8b7d)
- Improved trait lifetime handling (8107a4c)
- Added simplified non-working items() method (e618706)
- Improved trait by simplifying it (c274604)
- Added attempt to create an iterator based items() method (edb547e)
- Improved Value trait (26ff8d4)
- Added first impl of Value Trait for String (1822a45)
- Added git-journal support (15e670a)
- Initial commit (83f2154)
- ,
V::Key: Ord + Clone,
D: Delegate<'a, V::Key, V>,
{
match (l.items(), r.items()) {
// two scalars, equal
(None, None) if l == r => d.unchanged(l),
// two scalars, different
(None, None) => d.modified(l, r),
// two objects, equal
(Some(_), Some(_)) if l == r => d.unchanged(l),
// object and scalar
(Some(_), None) | (None, Some(_)) => d.modified(l, r),
// two objects, different
(Some(li), Some(ri)) => {
let mut sl: BTreeSet> = BTreeSet::new();
sl.extend(li.map(Into::into));
let mut sr: BTreeSet> = BTreeSet::new();
sr.extend(ri.map(Into::into));
for k in sr.intersection(&sl) {
let v1 = sl.get(k).expect("intersection to work");
let v2 = sr.get(k).expect("intersection to work");
d.push(&k.0);
diff(v1.1, v2.1, d);
d.pop();
}
for k in sr.difference(&sl) {
d.added(&k.0, sr.get(k).expect("difference to work").1);
}
for k in sl.difference(&sr) {
d.removed(&k.0, sl.get(k).expect("difference to work").1);
}
}
}
}
struct OrdByKey<'a, K, V: 'a>(pub K, pub &'a V);
impl<'a, K, V> From<(K, &'a V)> for OrdByKey<'a, K, V> {
fn from(src: (K, &'a V)) -> Self {
OrdByKey(src.0, src.1)
}
}
impl<'a, K, V> Eq for OrdByKey<'a, K, V> where K: Eq + PartialOrd {}
impl<'a, K, V> PartialEq for OrdByKey<'a, K, V>
where
K: PartialOrd,
{
fn eq(&self, other: &OrdByKey<'a, K, V>) -> bool {
self.0.eq(&other.0)
}
}
impl<'a, K, V> PartialOrd for OrdByKey<'a, K, V>
where
K: PartialOrd,
{
fn partial_cmp(&self, other: &OrdByKey<'a, K, V>) -> Option {
self.0.partial_cmp(&other.0)
}
}
impl<'a, K, V> Ord for OrdByKey<'a, K, V>
where
K: Ord,
{
fn cmp(&self, other: &Self) -> Ordering {
self.0.cmp(&other.0)
}
}
treediff-4.0.2/src/lib.rs 0000644 0000000 0000000 00000002111 00726746425 0013345 0 ustar 0000000 0000000 //! **See what's different in arbitrary data structures**.
//!
//! The main [`diff`](`diff::diff`) algorithm.
//! we implement here is less than a screen full of lines, yet it enables a vast amount of
//! applications.
//! It can work with all values implementing the `Value` trait.
//!
//! On top of it there is a [merge][`tools::Merger`] implementation, which can be used to aggregate changes
//! into a target value. It works with `Value`s which implement the `Mutable` trait.
//!
//! # Usage
//! Please have a look at the tests for [diff][diff-tests] and [merge][merge-tests].
//!
//! Also note that you will have to choose the features to build the library with in order to
//! get trait implementations for `Value` types of common libraries,
//! i.e. `cargo build --features=with-serde-json`.
//!
//! [diff-tests]: https://github.com/Byron/treediff-rs/blob/master/tests/diff.rs
//! [merge-tests]: https://github.com/Byron/treediff-rs/blob/master/tests/merge.rs
#![deny(missing_docs, unsafe_code)]
mod diff;
pub mod tools;
mod traitdef;
pub mod value;
pub use diff::*;
pub use traitdef::*;
treediff-4.0.2/src/tools/merge.rs 0000644 0000000 0000000 00000012241 00726746425 0015043 0 ustar 0000000 0000000 use crate::traitdef::{Delegate, Mutable};
use std::{borrow::BorrowMut, borrow::Cow, fmt::Display, marker::PhantomData};
/// A `Delegate` which applies differences to a target object.
///
/// It wraps the target object and applies all calls by the `diff`
/// algorithm to it, which changes it in some way.
///
/// Custom resolver functions can be provided to arbitrarily alter
/// the way the merge is performed. This allows you, for example, to
/// keep your own meta-data, or to implement custom conflict resolutions.
///
/// # Examples
/// Please see the [tests][tests] for usage examples.
///
/// [tests]: https://github.com/Byron/treediff-rs/blob/master/tests/merge.rs#L22
pub struct Merger {
cursor: Vec,
inner: V,
filter: BF,
_d: PhantomData,
}
fn appended(keys: &[K], k: Option<&K>) -> Vec
where
K: Clone,
{
let mut keys = Vec::from(keys);
if let Some(k) = k {
keys.push(k.clone());
}
keys
}
/// A filter to manipulate calls to be made to `Value`s implementing the `Mutable` trait in calls
/// made by the `Merger` `Delegate`.
///
/// This allows you to control the exact way merge operations are performed independently of the
/// type implementing the `Value` trait, which usually is not under your control.
pub trait MutableFilter {
/// Called during `Delegate::modified(...)`, returns `None` to cause the Value at the `keys` to
/// be removed, or any Value to be set in its place.
///
/// `old` is the previous value at the given `keys` path, and `new` is the one now at its place.
/// `_target` provides access to the target of the merge operation.
fn resolve_conflict<'a, K: Clone + Display, V: Clone>(
&mut self,
_keys: &[K],
_old: &'a V,
new: &'a V,
_target: &mut V,
) -> Option> {
Some(Cow::Borrowed(new))
}
/// Called during `Delegate::removed(...)`, returns `None` to allow the Value at the `keys` path
/// to be removed, or any Value to be set in its place instead.
///
/// `removed` is the Value which is to be removed.
/// `_target` provides access to the target of the merge operation.
fn resolve_removal<'a, K: Clone + Display, V: Clone>(
&mut self,
_keys: &[K],
_removed: &'a V,
_target: &mut V,
) -> Option> {
None
}
}
/// The default implementation used when when creating a new `Merger` from any `Value` type.
///
/// If you want to choose your own filter, use `Merger::with_filter(...)` instead.
pub struct DefaultMutableFilter;
impl MutableFilter for DefaultMutableFilter {}
impl<'a, K, V, F, BF> Delegate<'a, K, V> for Merger
where
V: Mutable + Clone + 'a,
K: Clone + Display,
F: MutableFilter,
BF: BorrowMut,
{
fn push(&mut self, k: &K) {
self.cursor.push(k.clone());
}
fn pop(&mut self) {
self.cursor.pop();
}
fn removed<'b>(&mut self, k: &'b K, v: &'a V) {
let keys = appended(&self.cursor, Some(k));
match self
.filter
.borrow_mut()
.resolve_removal(&keys, v, &mut self.inner)
{
Some(nv) => self.inner.set(&keys, &nv),
None => self.inner.remove(&keys),
}
}
fn added<'b>(&mut self, k: &'b K, v: &'a V) {
self.inner.set(&appended(&self.cursor, Some(k)), v);
}
fn unchanged<'b>(&mut self, v: &'a V) {
self.inner.set(&self.cursor, v)
}
fn modified<'b>(&mut self, old: &'a V, new: &'a V) {
let keys = appended(&self.cursor, None);
match self
.filter
.borrow_mut()
.resolve_conflict(&keys, old, new, &mut self.inner)
{
Some(v) => self.inner.set(&keys, &v),
None => self.inner.remove(&keys),
}
}
}
impl Merger {
/// Consume the merger and return the contained target Value, which is the result of the
/// merge operation.
pub fn into_inner(self) -> V {
self.inner
}
/// Returns a mutable borrow to the `MutableFilter` instance
pub fn filter_mut(&mut self) -> &mut BF {
&mut self.filter
}
/// Returns a borrow to the `MutableFilter` instance
pub fn filter(&self) -> &BF {
&self.filter
}
}
impl AsRef for Merger {
fn as_ref(&self) -> &V {
&self.inner
}
}
impl<'a, V, BF, F> Merger
where
V: Mutable + 'a + Clone,
F: MutableFilter,
BF: BorrowMut,
{
/// Return a new Merger with the given initial value `v` and the filter `f`
pub fn with_filter(v: V, f: BF) -> Self {
Merger {
inner: v,
cursor: Vec::new(),
filter: f,
_d: PhantomData,
}
}
}
impl<'a, V> From for Merger
where
V: Mutable + 'a + Clone,
{
/// Return a new merger with the given initial value `v`, and the `DefaultMutableFilter`.
fn from(v: V) -> Self {
Merger {
inner: v,
cursor: Vec::new(),
filter: DefaultMutableFilter,
_d: PhantomData,
}
}
}
treediff-4.0.2/src/tools/mod.rs 0000644 0000000 0000000 00000000233 00726746425 0014521 0 ustar 0000000 0000000 //! Various tools to help making the `diff` algorithm useful with minimal effort.
mod merge;
mod record;
pub use self::merge::*;
pub use self::record::*;
treediff-4.0.2/src/tools/record.rs 0000644 0000000 0000000 00000004417 00726746425 0015230 0 ustar 0000000 0000000 use crate::traitdef::Delegate;
/// Identifies a type of change at a given Key path, for use with the `Recorder`.
///
/// The Key path is followed to know what happened with the Value `V` contained in the variants.
#[derive(Debug, PartialEq)]
pub enum ChangeType<'a, K, V: 'a> {
/// The Value was removed
Removed(Vec, &'a V),
/// The Value was added
Added(Vec, &'a V),
/// No change was performed to the Value
Unchanged(Vec, &'a V),
/// The first Value was modified and became the second Value
Modified(Vec, &'a V, &'a V),
}
/// A `Delegate` to record all calls made to it.
///
/// It can be useful if you don't want to implement your own custom delegate, but instead just want
/// to quickly see a flat list of all results of the `diff` run.
///
/// # Examples
/// Please see the [tests][tests] for how to use this type.
///
/// [tests]: https://github.com/Byron/treediff-rs/blob/master/tests/diff.rs#L21
#[derive(Debug, PartialEq)]
pub struct Recorder<'a, K, V: 'a> {
cursor: Vec,
/// A list of all calls the `diff` function made on us.
pub calls: Vec>,
}
impl<'a, K, V> Default for Recorder<'a, K, V> {
fn default() -> Self {
Recorder {
cursor: Vec::new(),
calls: Vec::new(),
}
}
}
fn mk(c: &[K], k: Option<&K>) -> Vec
where
K: Clone,
{
let mut c = Vec::from(c);
match k {
Some(k) => {
c.push(k.clone());
c
}
None => c,
}
}
impl<'a, K, V> Delegate<'a, K, V> for Recorder<'a, K, V>
where
K: Clone,
{
fn push(&mut self, k: &K) {
self.cursor.push(k.clone())
}
fn pop(&mut self) {
self.cursor.pop();
}
fn removed<'b>(&mut self, k: &'b K, v: &'a V) {
self.calls
.push(ChangeType::Removed(mk(&self.cursor, Some(k)), v));
}
fn added<'b>(&mut self, k: &'b K, v: &'a V) {
self.calls
.push(ChangeType::Added(mk(&self.cursor, Some(k)), v));
}
fn unchanged<'b>(&mut self, v: &'a V) {
self.calls
.push(ChangeType::Unchanged(self.cursor.clone(), v));
}
fn modified<'b>(&mut self, v1: &'a V, v2: &'a V) {
self.calls
.push(ChangeType::Modified(mk(&self.cursor, None), v1, v2));
}
}
treediff-4.0.2/src/traitdef.rs 0000644 0000000 0000000 00000004721 00726746425 0014412 0 ustar 0000000 0000000 /// Represents a scalar value or an associative array.
pub trait Value: PartialEq {
/// The Key type used to find Values in a mapping.
type Key;
/// The Value type itself.
type Item;
/// Returns `None` if this is a scalar value, and an iterator yielding (Key, Value) pairs
/// otherwise. It is entirely possible for it to yield no values though.
#[allow(clippy::type_complexity)]
fn items<'a>(&'a self) -> Option + 'a>>;
}
/// The delegate receiving callbacks by the `diff` algorithm, which compares an old to a new value.
///
/// # Type Parameters
/// * `K` is the Key's type
/// * `V` is the Value's type
///
/// Methods will be called if...
pub trait Delegate<'a, K, V> {
/// ... we recurse into the `Value` at the given `Key`.
///
/// Delegates should memoize the current Key path to be able to compute
/// the full Key path when needed.
fn push(&mut self, _k: &K) {}
/// ... we have processed all items and leave the object previously `push`ed.
fn pop(&mut self) {}
/// ... the Value `v` at the given Key `k` should be removed.
///
/// *Note* that the Key is partial, and should be used in conjunction with the recorded Keys
/// received via `push(...)`
fn removed<'b>(&mut self, _k: &'b K, _v: &'a V) {}
/// .. the Value `v` at the given Key `k` should be added.
///
/// *Note* that the Key is partial, and should be used in conjunction with the recorded Keys
/// received via `push(...)`
fn added<'b>(&mut self, _k: &'b K, _v: &'a V) {}
/// The Value `v` was not changed.
fn unchanged(&mut self, _v: &'a V) {}
/// ... the `old` Value was modified, and is now the `new` Value.
fn modified(&mut self, _old: &'a V, _new: &'a V) {}
}
/// A trait to allow changing any `Value`.
pub trait Mutable {
/// The Key type used to find Values in a mapping.
type Key;
/// The Value type itself.
type Item;
/// Set the `new` Value at the path identified by `keys`.
///
/// Intermediate container values (like HashMaps, Arrays) must be created until
/// the last Key in `keys` can be modified or inserted with `new`.
fn set(&mut self, keys: &[Self::Key], new: &Self::Item);
/// Remove the value located at the path identified by `keys`.
///
/// If the value does not exist, just return. Intermediate container values
/// must not be created.
fn remove(&mut self, keys: &[Self::Key]);
}
treediff-4.0.2/src/value/mod.rs 0000644 0000000 0000000 00000000564 00726746425 0014504 0 ustar 0000000 0000000 //! Contains all implementations of the `Value` and `Mutable` traits.
//!
//! Note that these are behind feature flags.
mod shared;
pub use self::shared::*;
#[cfg(feature = "with-rustc-serialize")]
mod rustc_json;
#[cfg(feature = "with-serde-json")]
mod serde_json;
#[cfg(feature = "with-serde-yaml")]
mod serde_yaml;
#[cfg(feature = "with-yaml-rust")]
mod yaml_rust;
treediff-4.0.2/src/value/rustc_json.rs 0000644 0000000 0000000 00000015231 00726746425 0016113 0 ustar 0000000 0000000 use super::Key;
use crate::traitdef::{Mutable, Value};
use rustc_serialize::json::{Json as RustcJson, Object};
use std::{collections::btree_map::Entry::*, mem};
impl Value for RustcJson {
type Key = Key;
type Item = RustcJson;
fn items<'a>(&'a self) -> Option + 'a>> {
match *self {
RustcJson::String(_)
| RustcJson::U64(_)
| RustcJson::I64(_)
| RustcJson::F64(_)
| RustcJson::Boolean(_)
| RustcJson::Null => None,
RustcJson::Array(ref inner) => Some(Box::new(
inner.iter().enumerate().map(|(i, v)| (Key::Index(i), v)),
)),
RustcJson::Object(ref inner) => Some(Box::new(
inner.iter().map(|(s, v)| (Key::String(s.clone()), v)),
)),
}
}
}
impl Mutable for RustcJson {
type Key = Key;
type Item = RustcJson;
fn set(&mut self, keys: &[Self::Key], v: &Self::Item) {
if keys.is_empty() {
*self = v.clone();
} else {
let mut c = self;
let last_key_index = keys.len() - 1;
let object_or_value = |index| {
if index == last_key_index {
v.clone()
} else {
RustcJson::Object(Object::new())
}
};
fn runup_array_or_value<'a>(
array: &'a mut Vec,
target_index: usize,
key_index: usize,
last_key_index: usize,
v: &RustcJson,
) -> &'a mut RustcJson {
for _ in array.len()..target_index {
array.push(RustcJson::Null);
}
let value = if key_index == last_key_index {
v.clone()
} else {
RustcJson::Null
};
if target_index == array.len() {
array.push(value);
} else {
array[target_index] = value;
}
&mut array[target_index]
};
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => match { c } {
&mut RustcJson::Object(ref mut obj) => match obj.entry(k.clone()) {
Vacant(e) => e.insert(object_or_value(i)),
Occupied(e) => {
if i == last_key_index {
*e.into_mut() = v.clone();
return;
} else {
e.into_mut()
}
}
},
c @ &mut RustcJson::String(_)
| c @ &mut RustcJson::F64(_)
| c @ &mut RustcJson::Boolean(_)
| c @ &mut RustcJson::Null
| c @ &mut RustcJson::U64(_)
| c @ &mut RustcJson::Array(_)
| c @ &mut RustcJson::I64(_) => {
drop(mem::replace(
c,
RustcJson::Object({
let mut o = Object::new();
o.insert(k.clone(), object_or_value(i));
o
}),
));
if i == last_key_index {
return;
}
match c {
RustcJson::Object(ref mut obj) => {
obj.get_mut(k).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
Key::Index(idx) => match { c } {
&mut RustcJson::Array(ref mut a) => {
runup_array_or_value(a, idx, i, last_key_index, v)
}
c @ &mut RustcJson::String(_)
| c @ &mut RustcJson::F64(_)
| c @ &mut RustcJson::Boolean(_)
| c @ &mut RustcJson::Null
| c @ &mut RustcJson::U64(_)
| c @ &mut RustcJson::Object(_)
| c @ &mut RustcJson::I64(_) => {
let mut a = Vec::new();
runup_array_or_value(&mut a, idx, i, last_key_index, v);
drop(mem::replace(c, RustcJson::Array(a)));
if i == last_key_index {
return;
}
match c {
RustcJson::Array(ref mut a) => {
a.get_mut(idx).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
}
}
}
}
fn remove(&mut self, keys: &[Self::Key]) {
let mut c = self;
let last_key_index = keys.len().checked_sub(1).expect("at least one key");
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => match { c } {
RustcJson::Object(ref mut obj) => {
if i == last_key_index {
obj.remove(k);
return;
} else {
match obj.get_mut(k) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
Key::Index(idx) => match { c } {
RustcJson::Array(ref mut a) => {
if i == last_key_index {
a.remove(idx);
return;
} else {
match a.get_mut(idx) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
}
}
}
}
treediff-4.0.2/src/value/serde_json.rs 0000644 0000000 0000000 00000014546 00726746425 0016065 0 ustar 0000000 0000000 use super::Key;
use crate::traitdef::{Mutable, Value};
use serde_json::{map, Map, Value as SerdeJson};
use std::mem;
impl Value for SerdeJson {
type Key = Key;
type Item = SerdeJson;
fn items<'a>(&'a self) -> Option + 'a>> {
match *self {
SerdeJson::String(_) | SerdeJson::Number(_) | SerdeJson::Bool(_) | SerdeJson::Null => {
None
}
SerdeJson::Array(ref inner) => Some(Box::new(
inner.iter().enumerate().map(|(i, v)| (Key::Index(i), v)),
)),
SerdeJson::Object(ref inner) => Some(Box::new(
inner.iter().map(|(s, v)| (Key::String(s.clone()), v)),
)),
}
}
}
impl Mutable for SerdeJson {
type Key = Key;
type Item = SerdeJson;
fn set(&mut self, keys: &[Self::Key], v: &Self::Item) {
if keys.is_empty() {
*self = v.clone();
} else {
let mut c = self;
let last_key_index = keys.len() - 1;
let object_or_value = |index| {
if index == last_key_index {
v.clone()
} else {
SerdeJson::Object(Map::new())
}
};
fn runup_array_or_value<'a>(
array: &'a mut Vec,
target_index: usize,
key_index: usize,
last_key_index: usize,
v: &SerdeJson,
) -> &'a mut SerdeJson {
for _ in array.len()..target_index {
array.push(SerdeJson::Null);
}
let value = if key_index == last_key_index {
v.clone()
} else {
SerdeJson::Null
};
if target_index == array.len() {
array.push(value);
} else {
array[target_index] = value;
}
&mut array[target_index]
};
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => match { c } {
&mut SerdeJson::Object(ref mut obj) => match obj.entry(k.clone()) {
map::Entry::Vacant(e) => e.insert(object_or_value(i)),
map::Entry::Occupied(e) => {
if i == last_key_index {
*e.into_mut() = v.clone();
return;
} else {
e.into_mut()
}
}
},
c @ &mut SerdeJson::String(_)
| c @ &mut SerdeJson::Number(_)
| c @ &mut SerdeJson::Bool(_)
| c @ &mut SerdeJson::Null
| c @ &mut SerdeJson::Array(_) => {
drop(mem::replace(
c,
SerdeJson::Object({
let mut o = Map::new();
o.insert(k.clone(), object_or_value(i));
o
}),
));
if i == last_key_index {
return;
}
match c {
SerdeJson::Object(ref mut obj) => {
obj.get_mut(k).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
Key::Index(idx) => match { c } {
&mut SerdeJson::Array(ref mut a) => {
runup_array_or_value(a, idx, i, last_key_index, v)
}
c @ &mut SerdeJson::String(_)
| c @ &mut SerdeJson::Number(_)
| c @ &mut SerdeJson::Bool(_)
| c @ &mut SerdeJson::Null
| c @ &mut SerdeJson::Object(_) => {
let mut a = Vec::new();
runup_array_or_value(&mut a, idx, i, last_key_index, v);
drop(mem::replace(c, SerdeJson::Array(a)));
if i == last_key_index {
return;
}
match c {
SerdeJson::Array(ref mut a) => {
a.get_mut(idx).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
}
}
}
}
fn remove(&mut self, keys: &[Self::Key]) {
let mut c = self;
let last_key_index = keys.len().checked_sub(1).expect("at least one key");
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => match { c } {
SerdeJson::Object(ref mut obj) => {
if i == last_key_index {
obj.remove(k);
return;
} else {
match obj.get_mut(k) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
Key::Index(idx) => match { c } {
SerdeJson::Array(ref mut a) => {
if i == last_key_index {
a.remove(idx);
return;
} else {
match a.get_mut(idx) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
}
}
}
}
treediff-4.0.2/src/value/serde_yaml.rs 0000644 0000000 0000000 00000016272 00726746425 0016054 0 ustar 0000000 0000000 use super::Key;
use crate::traitdef::{Mutable, Value};
use serde_yaml::{self, to_string, Mapping, Value as SerdeYaml};
use std::mem;
fn from_str(s: &str) -> SerdeYaml {
serde_yaml::from_str(s).expect("valid yaml document, we created the key via to_string")
}
impl Value for SerdeYaml {
type Key = Key;
type Item = SerdeYaml;
fn items<'a>(&'a self) -> Option + 'a>> {
match *self {
SerdeYaml::String(_) | SerdeYaml::Number(_) | SerdeYaml::Bool(_) | SerdeYaml::Null => {
None
}
SerdeYaml::Sequence(ref inner) => Some(Box::new(
inner.iter().enumerate().map(|(i, v)| (Key::Index(i), v)),
)),
SerdeYaml::Mapping(ref inner) => Some(Box::new(inner.iter().map(|(k, v)| {
(
Key::String(
to_string(k).expect("yaml value to serialize into yaml correctly")[4..]
.to_owned(),
),
v,
)
}))),
}
}
}
impl Mutable for SerdeYaml {
type Key = Key;
type Item = SerdeYaml;
fn set(&mut self, keys: &[Self::Key], v: &Self::Item) {
if keys.is_empty() {
*self = v.clone();
} else {
let mut c = self;
let last_key_index = keys.len() - 1;
let object_or_value = |index| {
if index == last_key_index {
v.clone()
} else {
SerdeYaml::Mapping(Mapping::new())
}
};
fn runup_array_or_value<'a>(
array: &'a mut Vec,
target_index: usize,
key_index: usize,
last_key_index: usize,
v: &SerdeYaml,
) -> &'a mut SerdeYaml {
for _ in array.len()..target_index {
array.push(SerdeYaml::Null);
}
let value = if key_index == last_key_index {
v.clone()
} else {
SerdeYaml::Null
};
if target_index == array.len() {
array.push(value);
} else {
array[target_index] = value;
}
&mut array[target_index]
};
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => {
let k = from_str(&k);
match { c } {
&mut SerdeYaml::Mapping(ref mut obj) => {
if obj.contains_key(&k) {
let obj = obj.get_mut(&k).expect("map to work");
if i == last_key_index {
*obj = v.clone();
return;
}
obj
} else {
obj.insert(k.clone(), object_or_value(i));
obj.get_mut(&k).expect("map to work")
}
}
c @ &mut SerdeYaml::String(_)
| c @ &mut SerdeYaml::Number(_)
| c @ &mut SerdeYaml::Bool(_)
| c @ &mut SerdeYaml::Null
| c @ &mut SerdeYaml::Sequence(_) => {
drop(mem::replace(
c,
SerdeYaml::Mapping({
let mut o = Mapping::new();
o.insert(k.clone(), object_or_value(i));
o
}),
));
if i == last_key_index {
return;
}
match c {
SerdeYaml::Mapping(ref mut obj) => {
obj.get_mut(&k).expect("previous insertion")
}
_ => unreachable!(),
}
}
}
}
Key::Index(idx) => match { c } {
&mut SerdeYaml::Sequence(ref mut a) => {
runup_array_or_value(a, idx, i, last_key_index, v)
}
c @ &mut SerdeYaml::String(_)
| c @ &mut SerdeYaml::Number(_)
| c @ &mut SerdeYaml::Bool(_)
| c @ &mut SerdeYaml::Null
| c @ &mut SerdeYaml::Mapping(_) => {
let mut a = Vec::new();
runup_array_or_value(&mut a, idx, i, last_key_index, v);
drop(mem::replace(c, SerdeYaml::Sequence(a)));
if i == last_key_index {
return;
}
match c {
SerdeYaml::Sequence(ref mut a) => {
a.get_mut(idx).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
}
}
}
}
fn remove(&mut self, keys: &[Self::Key]) {
let mut c = self;
let last_key_index = keys.len().checked_sub(1).expect("at least one key");
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => {
let k = from_str(&k);
match { c } {
SerdeYaml::Mapping(ref mut obj) => {
if i == last_key_index {
obj.remove(&k);
return;
} else {
match obj.get_mut(&k) {
Some(json) => json,
None => return,
}
}
}
_ => return,
}
}
Key::Index(idx) => match { c } {
SerdeYaml::Sequence(ref mut a) => {
if i == last_key_index {
a.remove(idx);
return;
} else {
match a.get_mut(idx) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
}
}
}
}
treediff-4.0.2/src/value/shared.rs 0000644 0000000 0000000 00000000727 00726746425 0015174 0 ustar 0000000 0000000 use std::fmt;
/// A representation of all key types typical Value types will assume.
#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd)]
pub enum Key {
/// An array index
Index(usize),
/// A string index for mappings
String(String),
}
impl fmt::Display for Key {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Key::String(ref v) => v.fmt(f),
Key::Index(ref v) => v.fmt(f),
}
}
}
treediff-4.0.2/src/value/yaml_rust.rs 0000644 0000000 0000000 00000017023 00726746425 0015742 0 ustar 0000000 0000000 use super::Key;
use crate::traitdef::{Mutable, Value};
use std::mem;
use yaml_rust::{yaml::Hash, Yaml, YamlEmitter, YamlLoader};
fn from_str(s: &str) -> Yaml {
let mut v = YamlLoader::load_from_str(s)
.expect("valid yaml value - we serialized it beforehand after all");
assert_eq!(
v.len(),
1,
"need exactly one document - multi-document keys are just not possible"
);
v.pop().unwrap()
}
fn to_string(v: &Yaml) -> String {
let mut buf = String::new();
YamlEmitter::new(&mut buf)
.dump(v)
.expect("valid yaml value");
buf[4..].to_owned()
}
impl Value for Yaml {
type Key = Key;
type Item = Yaml;
fn items<'a>(&'a self) -> Option + 'a>> {
match *self {
Yaml::String(_)
| Yaml::Integer(_)
| Yaml::Real(_)
| Yaml::Boolean(_)
| Yaml::Null
| Yaml::Alias(_)
| Yaml::BadValue => None,
Yaml::Array(ref inner) => Some(Box::new(
inner.iter().enumerate().map(|(i, v)| (Key::Index(i), v)),
)),
Yaml::Hash(ref inner) => Some(Box::new(
inner.iter().map(|(k, v)| (Key::String(to_string(k)), v)),
)),
}
}
}
impl Mutable for Yaml {
type Key = Key;
type Item = Yaml;
fn set(&mut self, keys: &[Self::Key], v: &Self::Item) {
if keys.is_empty() {
*self = v.clone();
} else {
let mut c = self;
let last_key_index = keys.len() - 1;
let object_or_value = |index| {
if index == last_key_index {
v.clone()
} else {
Yaml::Hash(Hash::new())
}
};
fn runup_array_or_value<'a>(
array: &'a mut Vec,
target_index: usize,
key_index: usize,
last_key_index: usize,
v: &Yaml,
) -> &'a mut Yaml {
for _ in array.len()..target_index {
array.push(Yaml::Null);
}
let value = if key_index == last_key_index {
v.clone()
} else {
Yaml::Null
};
if target_index == array.len() {
array.push(value);
} else {
array[target_index] = value;
}
&mut array[target_index]
};
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => {
let k = from_str(&k);
match { c } {
&mut Yaml::Hash(ref mut obj) => {
if obj.contains_key(&k) {
let obj = obj.get_mut(&k).expect("map to work");
if i == last_key_index {
*obj = v.clone();
return;
}
obj
} else {
obj.insert(k.clone(), object_or_value(i));
obj.get_mut(&k).expect("map to work")
}
}
c @ &mut Yaml::String(_)
| c @ &mut Yaml::Integer(_)
| c @ &mut Yaml::Real(_)
| c @ &mut Yaml::Boolean(_)
| c @ &mut Yaml::Null
| c @ &mut Yaml::Alias(_)
| c @ &mut Yaml::BadValue
| c @ &mut Yaml::Array(_) => {
drop(mem::replace(
c,
Yaml::Hash({
let mut o = Hash::new();
o.insert(k.clone(), object_or_value(i));
o
}),
));
if i == last_key_index {
return;
}
match c {
Yaml::Hash(ref mut obj) => {
obj.get_mut(&k).expect("previous insertion")
}
_ => unreachable!(),
}
}
}
}
Key::Index(idx) => match { c } {
&mut Yaml::Array(ref mut a) => {
runup_array_or_value(a, idx, i, last_key_index, v)
}
c @ &mut Yaml::String(_)
| c @ &mut Yaml::Alias(_)
| c @ &mut Yaml::BadValue
| c @ &mut Yaml::Integer(_)
| c @ &mut Yaml::Real(_)
| c @ &mut Yaml::Boolean(_)
| c @ &mut Yaml::Null
| c @ &mut Yaml::Hash(_) => {
let mut a = Vec::new();
runup_array_or_value(&mut a, idx, i, last_key_index, v);
drop(mem::replace(c, Yaml::Array(a)));
if i == last_key_index {
return;
}
match c {
Yaml::Array(ref mut a) => {
a.get_mut(idx).expect("previous insertion")
}
_ => unreachable!(),
}
}
},
}
}
}
}
fn remove(&mut self, keys: &[Self::Key]) {
let mut c = self;
let last_key_index = keys.len().checked_sub(1).expect("at least one key");
for (i, k) in keys.iter().enumerate() {
c = match *k {
Key::String(ref k) => {
let k = from_str(&k);
match { c } {
Yaml::Hash(ref mut obj) => {
if i == last_key_index {
obj.remove(&k);
return;
} else {
match obj.get_mut(&k) {
Some(json) => json,
None => return,
}
}
}
_ => return,
}
}
Key::Index(idx) => match { c } {
Yaml::Array(ref mut a) => {
if i == last_key_index {
a.remove(idx);
return;
} else {
match a.get_mut(idx) {
Some(json) => json,
None => return,
}
}
}
_ => return,
},
}
}
}
}