frogql 0.2.2__tar.gz → 0.2.3__tar.gz

{frogql-0.2.2 → frogql-0.2.3}/Cargo.lock

@@ -273,7 +273,7 @@ dependencies = [
 
 [[package]]
 name = "frogql-node"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "gqlrust",
  "napi",
@@ -284,7 +284,7 @@ dependencies = [
 
 [[package]]
 name = "frogql-py"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "gqlrust",
  "pyo3",

{frogql-0.2.2 → frogql-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frogql
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{frogql-0.2.2 → frogql-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "frogql"
-version = "0.2.2"
+version = "0.2.3"
 description = "froGQL — embedded GQL graph database with ISO GQL path patterns (Rust core, Python bindings)"
 readme = "README.md"
 requires-python = ">=3.8"

{frogql-0.2.2 → frogql-0.2.3}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "frogql-py"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 readme = "README.md"
 

{frogql-0.2.2 → frogql-0.2.3}/src/parser/grammar.rs

@@ -729,8 +729,11 @@ impl Parser {
         }
     }
 
-    // Try to parse element_pattern_filler: variable? (":" type_schema)? (WHERE expr)?
-    // Returns Ok((Descriptor, Option<Expr>)) on success.
+    // Try to parse element_pattern_filler:
+    //   variable? (":" type_schema | "{" record_type)? (WHERE expr)?
+    // Per ISO/IEC 39075:2024 §16, `elementPropertySpecification` ({...}) is a
+    // sibling of `isLabelExpression`, so the colon is optional in front of
+    // the record. `({k: v})` and `(x {k: v})` are both valid node patterns.
     fn try_element_pattern_filler(&mut self) -> Result<(Descriptor, Option<Expr>), String> {
         let mut var: Option<String> = None;
         let mut dtype: Option<DescriptorType> = None;
@@ -742,7 +745,7 @@ impl Parser {
             let saved = self.pos;
             self.advance();
             match self.peek() {
-                Token::Colon | Token::Where | Token::RParen => {
+                Token::Colon | Token::Where | Token::RParen | Token::LBrace => {
                     var = Some(name);
                 }
                 _ => {
@@ -752,8 +755,10 @@ impl Parser {
             }
         }
 
-        // Optional ": type_schema"
-        if self.eat(&Token::Colon) {
+        // Optional ": type_schema" or bare "{ record_type }". The LBrace-first
+        // arm of `type_schema` defaults the label to Star, which matches the
+        // ISO semantics for an absent isLabelExpression.
+        if self.eat(&Token::Colon) || matches!(self.peek(), Token::LBrace) {
             let (dt, filters) = self.type_schema()?;
             dtype = Some(dt);
             value_filters = filters;
@@ -859,7 +864,10 @@ impl Parser {
             var = Some(name);
         }
 
-        if self.eat(&Token::Colon) {
+        // Optional ": type_schema" or bare "{ record_type }" — same ISO §16
+        // shape as node fillers. `-[{since: 2020}]->` and
+        // `-[e {since: 2020}]->` are valid edge patterns.
+        if self.eat(&Token::Colon) || matches!(self.peek(), Token::LBrace) {
             let (dt, filters) = self.type_schema()?;
             dtype = Some(dt);
             value_filters = filters;

{frogql-0.2.2 → frogql-0.2.3}/tests/parse_and_run_test.rs

@@ -78,6 +78,33 @@ fn test_concat_selector() {
     assert_eq!(fraud_run("()(x:{isDummy bool})"), 1);
 }
 
+// ISO §16 elementPropertySpecification without isLabelExpression.
+// Same value-filter semantics as the colonised forms.
+
+#[test]
+fn test_node_bare_prop_spec_anonymous_runtime() {
+    // 1 node has isBlocked=true (p2 Mike).
+    assert_eq!(fraud_run("({isBlocked: true})"), 1);
+    // 4 nodes have isBlocked=false (a1, a2, p1, d1).
+    assert_eq!(fraud_run("({isBlocked: false})"), 4);
+}
+
+#[test]
+fn test_node_bare_prop_spec_with_var_runtime() {
+    assert_eq!(fraud_run("(x {owner: 'Aretha'})"), 1);
+}
+
+#[test]
+fn test_edge_bare_prop_spec_anonymous_runtime() {
+    // 2 transfers/edges with amount=2000000 (t4 Transfer, t5 Foo).
+    assert_eq!(fraud_run("()-[{amount: 2000000}]->()"), 2);
+}
+
+#[test]
+fn test_edge_bare_prop_spec_with_var_runtime() {
+    assert_eq!(fraud_run("()-[e {amount: 2500000}]->()"), 1);
+}
+
 #[test]
 fn test_union() {
     assert_eq!(fraud_run("(x: Dummy) | (y: Account)"), 5);

{frogql-0.2.2 → frogql-0.2.3}/tests/parser_test.rs

@@ -135,6 +135,50 @@ fn test_descriptor_value_filter_with_colon_still_works() {
     assert!(s.contains("\"age\""), "got: {s}");
 }
 
+// ISO/IEC 39075:2024 §16: `elementPropertySpecification` is a sibling of
+// `isLabelExpression` under `elementPatternFiller`, so the colon is
+// optional in front of the `{...}` record.
+
+#[test]
+fn test_node_bare_property_spec_anonymous() {
+    // `({k: v})` — no variable, no colon, just a property spec. Label
+    // defaults to Star (any), value filter hoisted by elaboration.
+    let parsed = parse("({age: 30})").unwrap();
+    let s = format!("{parsed:?}");
+    assert!(s.contains("value_filters"), "got: {s}");
+    assert!(s.contains("\"age\""), "got: {s}");
+    assert!(s.contains("Star"), "got: {s}");
+}
+
+#[test]
+fn test_node_bare_property_spec_with_var() {
+    // `(x {k: v})` — variable plus property spec, no colon.
+    let parsed = parse("(x {age: 30})").unwrap();
+    let s = format!("{parsed:?}");
+    assert!(s.contains("value_filters"), "got: {s}");
+    assert!(s.contains("\"x\""), "got: {s}");
+    assert!(s.contains("\"age\""), "got: {s}");
+}
+
+#[test]
+fn test_edge_bare_property_spec_anonymous() {
+    // `-[{k: v}]->` — no variable, no colon, just a property spec.
+    let parsed = parse("-[{since: 2020}]->").unwrap();
+    let s = format!("{parsed:?}");
+    assert!(s.contains("value_filters"), "got: {s}");
+    assert!(s.contains("\"since\""), "got: {s}");
+}
+
+#[test]
+fn test_edge_bare_property_spec_with_var() {
+    // `-[e {k: v}]->` — variable plus property spec, no colon.
+    let parsed = parse("-[e {since: 2020}]->").unwrap();
+    let s = format!("{parsed:?}");
+    assert!(s.contains("value_filters"), "got: {s}");
+    assert!(s.contains("\"e\""), "got: {s}");
+    assert!(s.contains("\"since\""), "got: {s}");
+}
+
 #[test]
 fn test_typed_predicate_in_where_explicit() {
     // `TYPED` is the explicit type-predicate operator in expressions.