4b874deae1
* Pre: Fix error in parser macros. * Pre: Make test unwrapping more verbose. * Pre: Make lookup refs be (lookup-ref a v) in the entity position. This has the advantage of being explicit in all situations and unambiguous at parse-time. This choice agrees with the Clojure implementation but not with Datomic. Datomic treats [a v] as a lookup ref, is ambiguous at parse-time, and is disambiguated in ways I do not understand at transaction time. We mooted making lookup refs [[a v]] and outlawing nested value vectors in transactions, but after implementing that approach I decided it was better to handle lookup refs at parse time and therefore outlawing nested value vectors is not necessary. * Handle lookup refs in the entity and value columns. Fixes #183. * Pre 0a: Use a stack instead of into_iter. * Pre 0b: Dedent. * Pre 0c: Handle `e` after `v`. This allows to use the original `e` while handling `v`. * Explode value lists for :db.cardinality/many attributes. Fixes #284. * Parse and accept map notation. Fixes #180. * Pre: Modernize add() and retract() into one add_or_retract(). * Pre: Add is_collection and is_atom to edn::Value. * Pre: Differentiate atoms from lookup-refs in value position. Initially, I expected to accept arbitrary edn::Value instances in the value position, and to differentiate in the transactor. However, the implementation quickly became a two-stage parser, since we always wanted to parse the resulting value position into some other known thing using the tx-parser. To save calls into the parser and to allow the parser to move forward with a smaller API surface, I push as much of this parsing as possible into the initial parse. * Pre: Modernize entities(). * Pre: Quote edn::Value::Text in Display. * Review comment: Add and use edn::Value::into_atom. * Review comment: Use skip(eof()) throughout. * Review comment: VecDeque instead of Vec. * Review comment: Part 0: Rename TempId to TempIdHandle. * Review comment: Part 1: Differentiate internal and external tempids. This breaks an abstraction boundary by pushing the Internal/External split up to the Entity level in tx/ and tx-parser/. This just makes it easier to explode Entity map notation instances into Entity instances, taking an existing External tempid :db/id or generating a new Internal tempid as appropriate. To do this without breaking the abstraction boundary would require adding flexibility to the transaction processor: we'd need to be able to turn Entity instances into some internal enum and handle the two cases independently. It wouldn't be too hard, but this reduces the combinatorial type explosion.
63 lines
2.3 KiB
Rust
63 lines
2.3 KiB
Rust
// Copyright 2016 Mozilla
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
// this file except in compliance with the License. You may obtain a copy of the
|
|
// License at http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software distributed
|
|
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations under the License.
|
|
|
|
extern crate edn;
|
|
extern crate combine;
|
|
extern crate mentat_tx;
|
|
extern crate mentat_tx_parser;
|
|
|
|
use edn::parse;
|
|
use edn::symbols::NamespacedKeyword;
|
|
use edn::types::Value;
|
|
use mentat_tx::entities::{
|
|
AtomOrLookupRefOrVectorOrMapNotation,
|
|
Entid,
|
|
EntidOrLookupRefOrTempId,
|
|
Entity,
|
|
OpType,
|
|
TempId,
|
|
};
|
|
use mentat_tx_parser::Tx;
|
|
|
|
#[test]
|
|
fn test_entities() {
|
|
let input = r#"
|
|
[[:db/add 101 :test/a "v"]
|
|
[:db/add "tempid" :test/a "v"]
|
|
[:db/retract 102 :test/b "w"]]"#;
|
|
|
|
let edn = parse::value(input).unwrap().without_spans();
|
|
let input = [edn];
|
|
|
|
let result = Tx::parse(&input[..]);
|
|
assert_eq!(result.unwrap(),
|
|
vec![
|
|
Entity::AddOrRetract {
|
|
op: OpType::Add,
|
|
e: EntidOrLookupRefOrTempId::Entid(Entid::Entid(101)),
|
|
a: Entid::Ident(NamespacedKeyword::new("test", "a")),
|
|
v: AtomOrLookupRefOrVectorOrMapNotation::Atom(Value::Text("v".into())),
|
|
},
|
|
Entity::AddOrRetract {
|
|
op: OpType::Add,
|
|
e: EntidOrLookupRefOrTempId::TempId(TempId::External("tempid".into())),
|
|
a: Entid::Ident(NamespacedKeyword::new("test", "a")),
|
|
v: AtomOrLookupRefOrVectorOrMapNotation::Atom(Value::Text("v".into())),
|
|
},
|
|
Entity::AddOrRetract {
|
|
op: OpType::Retract,
|
|
e: EntidOrLookupRefOrTempId::Entid(Entid::Entid(102)),
|
|
a: Entid::Ident(NamespacedKeyword::new("test", "b")),
|
|
v: AtomOrLookupRefOrVectorOrMapNotation::Atom(Value::Text("w".into())),
|
|
},
|
|
]);
|
|
}
|
|
|
|
// TODO: test error handling in select cases.
|