clojure-reader 0.6.1

A Clojure reader
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

extern crate alloc;

use alloc::collections::BTreeMap;

use clojure_reader::edn::{self, Edn};

#[test]
fn get() {
	let e = edn::read_string("{:foo 4 :bar 2}").unwrap();

	assert_eq!(e.get(&Edn::Key("foo")), Some(&Edn::Int(4)));
	assert_eq!(e.get(&Edn::Str("foo")), None);
	assert_eq!(e.get(&Edn::Symbol(":foo")), None);
	assert_eq!(e.nth(0), None);
}

#[test]
fn nth() {
	let e = edn::read_string("[1 2 3 42 3 2 1]").unwrap();

	assert_eq!(e.nth(3), Some(&Edn::Int(42)));
	assert_eq!(e.nth(42), None);
	assert_eq!(e.get(&Edn::Str(":foo")), None);

	let e = edn::read_string("(1 2 3 42 3 2 1)").unwrap();

	assert_eq!(e.nth(3), Some(&Edn::Int(42)));
	assert_eq!(e.nth(42), None);
}

#[test]
fn default_map_namespace_syntax() {
	// see https://github.com/Grinkers/clojure-reader/issues/2
	let variations = [
		"{:thingy #:foo{:bar \"baz\"} :more \"stuff\"}",
		"{:thingy #:foo {:bar \"baz\"} :more \"stuff\"}",
		"{:more \"stuff\" :thingy #:foo{:bar \"baz\"}}",
	];
	for v in variations {
		let cfg = edn::read_string(&v).unwrap();

		let Edn::Map(cfg) = cfg else { panic!() };
		assert_eq!(
			cfg.get(&Edn::Key("thingy")),
			Some(&Edn::Tagged(
				":foo",
				Box::new(Edn::Map(BTreeMap::from([(Edn::Key("bar"), Edn::Str("baz"))])))
			))
		);
		assert_eq!(cfg.get(&Edn::Key("more")), Some(&Edn::Str("stuff")));
	}

	// without keyword `:` symbol.
	// the tag is parsed/preserved, but we don't support custom readers
	let variations = [
		"{:thingy #foo{:bar \"baz\"} :more \"stuff\"}",
		"{:thingy #foo {:bar \"baz\"} :more \"stuff\"}",
		"{:more \"stuff\" :thingy #foo{:bar \"baz\"}}",
	];
	for v in variations {
		let cfg = edn::read_string(&v).unwrap();

		let Edn::Map(cfg) = cfg else { panic!() };
		assert_eq!(
			cfg.get(&Edn::Key("thingy")),
			Some(&Edn::Tagged(
				"foo",
				Box::new(Edn::Map(BTreeMap::from([(Edn::Key("bar"), Edn::Str("baz"))])))
			))
		);
		assert_eq!(cfg.get(&Edn::Key("more")), Some(&Edn::Str("stuff")));
	}
}

#[test]
fn namespace_syntax_edge_cases() {
	let edn_data = edn::read_string(r#"#:thingy {:f#猫o "bar" :baz/bar "qux" 42 24}"#).unwrap();

	assert_eq!(edn_data.get(&Edn::Key("thingy/f#猫o")), Some(&Edn::Str("bar")));
	assert_eq!(edn_data.get(&Edn::Key("baz/bar")), Some(&Edn::Str("qux")));
	assert_eq!(edn_data.get(&Edn::Key("foo")), None);
	assert_eq!(edn_data.get(&Edn::Key("baz")), None);
	assert_eq!(edn_data.get(&Edn::Key(":baz/bar")), None);
	assert_eq!(edn_data.get(&Edn::Key("thingy/")), None);
	assert_eq!(edn_data.get(&Edn::Key("thingy")), None);
	assert_eq!(edn_data.get(&Edn::Key("thingything")), None);

	let edn_data = edn::read_string(r#"#thingy {:f#猫o "bar" :baz/bar "qux" 42 24}"#).unwrap();
	assert_eq!(edn_data.get(&Edn::Key("thingy/f#猫o")), None);
	assert_eq!(edn_data.get(&Edn::Key("baz/bar")), None);

	let edn_data = edn::read_string(r#"#:thingy {:foo 1}"#).unwrap();
	assert_eq!(edn_data.get(&Edn::Key("thingy/foo")), Some(&Edn::Int(1)));
	assert_eq!(edn_data.get(&Edn::Key("thingyfoo")), None);
}

#[test]
fn get_contains() {
	let edn_data = edn::read_string(r#"{:f#猫o "bar" :baz/bar "qux" 42 24}"#).unwrap();
	assert_eq!(edn_data.get(&Edn::Key("f#猫o")), Some(&Edn::Str("bar")));
	assert_eq!(edn_data.contains(&Edn::Key("f#猫o")), true);
	assert_eq!(edn_data.get(&Edn::Key("foo")), None);
	assert_eq!(edn_data.contains(&Edn::Key("foo")), false);

	let edn_data = edn::read_string(r#"#{:f#猫o "bar" :baz/bar "qux" 42 24}"#).unwrap();
	assert_eq!(edn_data.contains(&Edn::Key("f#猫o")), true);
	assert_eq!(edn_data.contains(&Edn::Int(42)), true);
	assert_eq!(edn_data.contains(&Edn::Key("foo")), false);

	let edn_data = edn::read_string(r#"[:f#猫o "bar" :baz/bar "qux" 42 24]"#).unwrap();
	assert_eq!(edn_data.contains(&Edn::Key("f#猫o")), true);
	assert_eq!(edn_data.contains(&Edn::Int(42)), true);
	assert_eq!(edn_data.contains(&Edn::Key("foo")), false);

	let edn_data = edn::read_string(r#"(:f#猫o "bar" :baz/bar "qux" 42 24)"#).unwrap();
	assert_eq!(edn_data.contains(&Edn::Key("f#猫o")), true);
	assert_eq!(edn_data.contains(&Edn::Int(42)), true);
	assert_eq!(edn_data.contains(&Edn::Key("foo")), false);

	let edn_data = edn::read_string(r#"42"#).unwrap();
	assert_eq!(edn_data.contains(&Edn::Key("f#猫o")), false);
	assert_eq!(edn_data.contains(&Edn::Int(42)), false);
	assert_eq!(edn_data.contains(&Edn::Key("foo")), false);
}