Skip to content

Commit a7ed330

Browse files
ksceriathksceriath
authored
Merge pull request #4 from ksceriath/ref
refactor
2 parents ccd510a + 198ceb9 commit a7ed330

File tree

3 files changed

+182
-180
lines changed

3 files changed

+182
-180
lines changed

‎src/lib.rs

+1-170
Original file line numberDiff line numberDiff line change
@@ -1,172 +1,3 @@
11
pub mod constants;
22
pub mod ds;
3-
mod process;
4-
use constants::Message;
5-
use ds::mismatch::Mismatch;
6-
7-
pub fn compare_jsons(a: &str, b: &str) -> Result<Mismatch, Message> {
8-
let value1 = match serde_json::from_str(a) {
9-
Ok(val1) => val1,
10-
Err(_) => return Err(Message::JSON1),
11-
};
12-
let value2 = match serde_json::from_str(b) {
13-
Ok(val2) => val2,
14-
Err(_) => return Err(Message::JSON2),
15-
};
16-
Ok(process::match_json(&value1, &value2))
17-
}
18-
19-
#[cfg(test)]
20-
mod tests {
21-
use super::ds::{key_node::KeyNode, mismatch::Mismatch};
22-
use super::*;
23-
use maplit::hashmap;
24-
use serde_json::json;
25-
26-
#[test]
27-
fn nested_diff() {
28-
let data1 = r#"{
29-
"a":"b",
30-
"b":{
31-
"c":{
32-
"d":true,
33-
"e":5,
34-
"f":9,
35-
"h":{
36-
"i":true,
37-
"j":false
38-
}
39-
}
40-
}
41-
}"#;
42-
let data2 = r#"{
43-
"a":"b",
44-
"b":{
45-
"c":{
46-
"d":true,
47-
"e":6,
48-
"g":0,
49-
"h":{
50-
"i":false,
51-
"k":false
52-
}
53-
}
54-
}
55-
}"#;
56-
57-
let expected_left = KeyNode::Node(hashmap! {
58-
"b".to_string() => KeyNode::Node(hashmap! {
59-
"c".to_string() => KeyNode::Node(hashmap! {
60-
"f".to_string() => KeyNode::Nil,
61-
"h".to_string() => KeyNode::Node( hashmap! {
62-
"j".to_string() => KeyNode::Nil,
63-
}
64-
),
65-
}
66-
),
67-
}),
68-
});
69-
let expected_right = KeyNode::Node(hashmap! {
70-
"b".to_string() => KeyNode::Node(hashmap! {
71-
"c".to_string() => KeyNode::Node(hashmap! {
72-
"g".to_string() => KeyNode::Nil,
73-
"h".to_string() => KeyNode::Node(hashmap! {
74-
"k".to_string() => KeyNode::Nil,
75-
}
76-
)
77-
}
78-
)
79-
}
80-
)
81-
});
82-
let expected_uneq = KeyNode::Node(hashmap! {
83-
"b".to_string() => KeyNode::Node(hashmap! {
84-
"c".to_string() => KeyNode::Node(hashmap! {
85-
"e".to_string() => KeyNode::Value(json!(5), json!(6)),
86-
"h".to_string() => KeyNode::Node(hashmap! {
87-
"i".to_string() => KeyNode::Value(json!(true), json!(false)),
88-
}
89-
)
90-
}
91-
)
92-
}
93-
)
94-
});
95-
let expected = Mismatch::new(expected_left, expected_right, expected_uneq);
96-
97-
let mismatch = compare_jsons(data1, data2).unwrap();
98-
assert_eq!(mismatch, expected, "Diff was incorrect.");
99-
}
100-
101-
#[test]
102-
fn no_diff() {
103-
let data1 = r#"{
104-
"a":"b",
105-
"b":{
106-
"c":{
107-
"d":true,
108-
"e":5,
109-
"f":9,
110-
"h":{
111-
"i":true,
112-
"j":false
113-
}
114-
}
115-
}
116-
}"#;
117-
let data2 = r#"{
118-
"a":"b",
119-
"b":{
120-
"c":{
121-
"d":true,
122-
"e":5,
123-
"f":9,
124-
"h":{
125-
"i":true,
126-
"j":false
127-
}
128-
}
129-
}
130-
}"#;
131-
132-
assert_eq!(
133-
compare_jsons(data1, data2).unwrap(),
134-
Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
135-
);
136-
}
137-
138-
#[test]
139-
fn no_json() {
140-
let data1 = r#"{}"#;
141-
let data2 = r#"{}"#;
142-
143-
assert_eq!(
144-
compare_jsons(data1, data2).unwrap(),
145-
Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
146-
);
147-
}
148-
149-
#[test]
150-
fn parse_err_source_one() {
151-
let invalid_json1 = r#"{invalid: json}"#;
152-
let valid_json2 = r#"{"a":"b"}"#;
153-
match compare_jsons(invalid_json1, valid_json2) {
154-
Ok(_) => panic!("This shouldn't be an Ok"),
155-
Err(err) => {
156-
assert_eq!(Message::JSON1, err);
157-
}
158-
};
159-
}
160-
161-
#[test]
162-
fn parse_err_source_two() {
163-
let valid_json1 = r#"{"a":"b"}"#;
164-
let invalid_json2 = r#"{invalid: json}"#;
165-
match compare_jsons(valid_json1, invalid_json2) {
166-
Ok(_) => panic!("This shouldn't be an Ok"),
167-
Err(err) => {
168-
assert_eq!(Message::JSON2, err);
169-
}
170-
};
171-
}
172-
}
3+
pub mod process;

‎src/main.rs

+8-6
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,19 @@
1-
use colored::*;
2-
use json_diff::{
3-
compare_jsons,
4-
constants::Message,
5-
ds::{key_node::KeyNode, mismatch::Mismatch},
6-
};
71
use std::{
82
fmt, fs,
93
io::{self, Write},
104
process as proc,
115
str::FromStr,
126
};
7+
8+
use colored::*;
139
use structopt::StructOpt;
1410

11+
use json_diff::{
12+
constants::Message,
13+
ds::{key_node::KeyNode, mismatch::Mismatch},
14+
process::compare_jsons,
15+
};
16+
1517
const HELP: &str = r#"
1618
Example:
1719
json_diff f source1.json source2.json

‎src/process.rs

+173-4
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,25 @@
1-
use crate::ds::key_node::KeyNode;
2-
use crate::ds::mismatch::Mismatch;
3-
use serde_json::Map;
4-
use serde_json::Value;
51
use std::collections::HashMap;
62
use std::collections::HashSet;
73

4+
use serde_json::Map;
5+
use serde_json::Value;
6+
7+
use crate::constants::Message;
8+
use crate::ds::key_node::KeyNode;
9+
use crate::ds::mismatch::Mismatch;
10+
11+
pub fn compare_jsons(a: &str, b: &str) -> Result<Mismatch, Message> {
12+
let value1 = match serde_json::from_str(a) {
13+
Ok(val1) => val1,
14+
Err(_) => return Err(Message::JSON1),
15+
};
16+
let value2 = match serde_json::from_str(b) {
17+
Ok(val2) => val2,
18+
Err(_) => return Err(Message::JSON2),
19+
};
20+
Ok(match_json(&value1, &value2))
21+
}
22+
823
pub fn match_json(value1: &Value, value2: &Value) -> Mismatch {
924
match (value1, value2) {
1025
(Value::Object(a), Value::Object(b)) => {
@@ -102,3 +117,157 @@ fn intersect_maps(
102117
};
103118
(left, right, intersection)
104119
}
120+
121+
#[cfg(test)]
122+
mod tests {
123+
use super::*;
124+
use maplit::hashmap;
125+
use serde_json::json;
126+
127+
#[test]
128+
fn nested_diff() {
129+
let data1 = r#"{
130+
"a":"b",
131+
"b":{
132+
"c":{
133+
"d":true,
134+
"e":5,
135+
"f":9,
136+
"h":{
137+
"i":true,
138+
"j":false
139+
}
140+
}
141+
}
142+
}"#;
143+
let data2 = r#"{
144+
"a":"b",
145+
"b":{
146+
"c":{
147+
"d":true,
148+
"e":6,
149+
"g":0,
150+
"h":{
151+
"i":false,
152+
"k":false
153+
}
154+
}
155+
}
156+
}"#;
157+
158+
let expected_left = KeyNode::Node(hashmap! {
159+
"b".to_string() => KeyNode::Node(hashmap! {
160+
"c".to_string() => KeyNode::Node(hashmap! {
161+
"f".to_string() => KeyNode::Nil,
162+
"h".to_string() => KeyNode::Node( hashmap! {
163+
"j".to_string() => KeyNode::Nil,
164+
}
165+
),
166+
}
167+
),
168+
}),
169+
});
170+
let expected_right = KeyNode::Node(hashmap! {
171+
"b".to_string() => KeyNode::Node(hashmap! {
172+
"c".to_string() => KeyNode::Node(hashmap! {
173+
"g".to_string() => KeyNode::Nil,
174+
"h".to_string() => KeyNode::Node(hashmap! {
175+
"k".to_string() => KeyNode::Nil,
176+
}
177+
)
178+
}
179+
)
180+
}
181+
)
182+
});
183+
let expected_uneq = KeyNode::Node(hashmap! {
184+
"b".to_string() => KeyNode::Node(hashmap! {
185+
"c".to_string() => KeyNode::Node(hashmap! {
186+
"e".to_string() => KeyNode::Value(json!(5), json!(6)),
187+
"h".to_string() => KeyNode::Node(hashmap! {
188+
"i".to_string() => KeyNode::Value(json!(true), json!(false)),
189+
}
190+
)
191+
}
192+
)
193+
}
194+
)
195+
});
196+
let expected = Mismatch::new(expected_left, expected_right, expected_uneq);
197+
198+
let mismatch = compare_jsons(data1, data2).unwrap();
199+
assert_eq!(mismatch, expected, "Diff was incorrect.");
200+
}
201+
202+
#[test]
203+
fn no_diff() {
204+
let data1 = r#"{
205+
"a":"b",
206+
"b":{
207+
"c":{
208+
"d":true,
209+
"e":5,
210+
"f":9,
211+
"h":{
212+
"i":true,
213+
"j":false
214+
}
215+
}
216+
}
217+
}"#;
218+
let data2 = r#"{
219+
"a":"b",
220+
"b":{
221+
"c":{
222+
"d":true,
223+
"e":5,
224+
"f":9,
225+
"h":{
226+
"i":true,
227+
"j":false
228+
}
229+
}
230+
}
231+
}"#;
232+
233+
assert_eq!(
234+
compare_jsons(data1, data2).unwrap(),
235+
Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
236+
);
237+
}
238+
239+
#[test]
240+
fn no_json() {
241+
let data1 = r#"{}"#;
242+
let data2 = r#"{}"#;
243+
244+
assert_eq!(
245+
compare_jsons(data1, data2).unwrap(),
246+
Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
247+
);
248+
}
249+
250+
#[test]
251+
fn parse_err_source_one() {
252+
let invalid_json1 = r#"{invalid: json}"#;
253+
let valid_json2 = r#"{"a":"b"}"#;
254+
match compare_jsons(invalid_json1, valid_json2) {
255+
Ok(_) => panic!("This shouldn't be an Ok"),
256+
Err(err) => {
257+
assert_eq!(Message::JSON1, err);
258+
}
259+
};
260+
}
261+
262+
#[test]
263+
fn parse_err_source_two() {
264+
let valid_json1 = r#"{"a":"b"}"#;
265+
let invalid_json2 = r#"{invalid: json}"#;
266+
match compare_jsons(valid_json1, invalid_json2) {
267+
Ok(_) => panic!("This shouldn't be an Ok"),
268+
Err(err) => {
269+
assert_eq!(Message::JSON2, err);
270+
}
271+
};
272+
}
273+
}

0 commit comments

Comments
 (0)