flowquery 1.0.46 → 1.0.48

package/flowquery-py/tests/tokenization/test_tokenizer.py

@@ -1,198 +0,0 @@
-"""Tests for the FlowQuery tokenizer."""
-
-import pytest
-from flowquery.tokenization.tokenizer import Tokenizer
-
-
-class TestTokenizer:
-    """Test cases for the Tokenizer class."""
-
-    def test_tokenize_returns_array_of_tokens(self):
-        """Tokenizer.tokenize() should return an array of tokens."""
-        tokenizer = Tokenizer("MATCH (n:Person) RETURN n")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_tokenize_handles_escaped_quotes(self):
-        """Tokenizer.tokenize() should handle escaped quotes."""
-        tokenizer = Tokenizer('return "hello \\"world"')
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_predicate_function(self):
-        """Test predicate function tokenization."""
-        tokenizer = Tokenizer("RETURN sum(n in [1, 2, 3] | n where n > 1)")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_f_string(self):
-        """Test f-string tokenization."""
-        tokenizer = Tokenizer('RETURN f"hello {world}"')
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_another_f_string(self):
-        """Test another f-string tokenization."""
-        tokenizer = Tokenizer("RETURN f`Value is: {value}`")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_basic(self):
-        """Test basic tokenization."""
-        tokenizer = Tokenizer("WITH 1 AS n RETURN n")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_associative_array_with_backtick_string(self):
-        """Test associative array with backtick string."""
-        tokenizer = Tokenizer("RETURN {`key`: `value`}")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_limit(self):
-        """Test limit keyword."""
-        tokenizer = Tokenizer("unwind range(1, 10) as n limit 5 return n")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_return_negative_number(self):
-        """Test return with negative number."""
-        tokenizer = Tokenizer("return [:-2], -2")
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_range_with_function(self):
-        """Test range with function."""
-        tokenizer = Tokenizer("""
-            with range(1,10) as data
-            return range(0, size(data)-1) as indices
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_create_virtual_node(self):
-        """Test CREATE VIRTUAL node tokenization."""
-        tokenizer = Tokenizer("""
-            CREATE VIRTUAL (:Person) AS {
-                call users() YIELD id, name
-            }
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_create_virtual_relationship(self):
-        """Test CREATE VIRTUAL relationship tokenization."""
-        tokenizer = Tokenizer("""
-            CREATE VIRTUAL (:Person)-[:KNOWS]->(:Person) AS {
-                call friendships() YIELD user1_id, user2_id
-            }
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_match_based_on_virtual_node(self):
-        """Test match based on virtual node."""
-        tokenizer = Tokenizer("""
-            MATCH (a:Person)
-            RETURN a.name
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_match_based_on_virtual_nodes_and_relationships(self):
-        """Test match based on virtual nodes and relationships."""
-        tokenizer = Tokenizer("""
-            MATCH (a:Person)-[r:KNOWS]->(b:Person)
-            RETURN a.name, b.name
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_not_equal_operator(self):
-        """Test not equal operator."""
-        tokenizer = Tokenizer("""
-            MATCH (n:Person)
-            WHERE n.age <> 30
-            RETURN n.name AS name, n.age AS age
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_equal_operator(self):
-        """Test equal operator."""
-        tokenizer = Tokenizer("""
-            MATCH (n:Person)
-            WHERE n.age = 30
-            RETURN n.name AS name, n.age AS age
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_boolean_operators(self):
-        """Test boolean operators."""
-        tokenizer = Tokenizer("""
-            return true AND false OR true NOT false
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_relationship_with_hops(self):
-        """Test relationship with hops."""
-        tokenizer = Tokenizer("""
-            MATCH (a:Person)-[r:KNOWS*1..3]->(b:Person)
-            RETURN a.name, b.name
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_reserved_keywords_as_identifiers(self):
-        """Test reserved keywords as identifiers."""
-        tokenizer = Tokenizer("""
-            WITH 1 AS return
-            RETURN return
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_reserved_keywords_as_part_of_identifiers(self):
-        """Test reserved keywords as part of identifiers."""
-        tokenizer = Tokenizer("""
-            unwind [
-                {from: "Alice", to: "Bob", organizer: "Charlie"},
-                {from: "Bob", to: "Charlie", organizer: "Alice"},
-                {from: "Charlie", to: "Alice", organizer: "Bob"}
-            ] as data
-            return data.from, data.to
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0
-
-    def test_reserved_keywords_as_relationship_types_and_labels(self):
-        """Test reserved keywords as relationship types and labels."""
-        tokenizer = Tokenizer("""
-            MATCH (a:RETURN)-[r:WITH]->(b:RETURN)
-            RETURN a, b
-        """)
-        tokens = tokenizer.tokenize()
-        assert tokens is not None
-        assert len(tokens) > 0

package/flowquery-py/tests/tokenization/test_trie.py

@@ -1,30 +0,0 @@
-"""Tests for the Trie data structure."""
-
-import pytest
-from flowquery.tokenization.trie import Trie
-from flowquery.tokenization.token import Token
-from flowquery.tokenization.keyword import Keyword
-
-
-class TestTrie:
-    """Test cases for the Trie class."""
-
-    def test_trie_insert_and_find(self):
-        """Test Trie insert and find operations."""
-        trie = Trie()
-        
-        # Insert all keywords
-        for keyword in Keyword:
-            token = Token.method(keyword.value)
-            if token is not None and token.value is not None:
-                trie.insert(token)
-                found = trie.find(keyword.value)
-                assert found is not None
-        
-        # Test for non-existent values
-        assert trie.find("not_a_keyword") is None
-        assert trie.find("not_an_operator") is None
-        assert trie.find("not_a_keyword_or_operator") is None
-        assert trie.find("") is None
-        assert trie.find(" ") is None
-        assert trie.find("a") is None

package/flowquery-vscode/.vscode-test.mjs

@@ -1,5 +0,0 @@
-import { defineConfig } from '@vscode/test-cli';
-
-export default defineConfig({
-	files: 'test/**/*.test.js',
-});

package/flowquery-vscode/.vscodeignore

@@ -1,13 +0,0 @@
-.vscode/**
-.vscode-test/**
-test/**
-demo/**
-_vsix_extract/**
-node_modules/**
-.gitignore
-.yarnrc
-vsc-extension-quickstart.md
-**/jsconfig.json
-**/*.map
-**/eslint.config.mjs
-**/.vscode-test.*

package/flowquery-vscode/LICENSE

@@ -1,21 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE

package/flowquery-vscode/README.md

@@ -1,11 +0,0 @@
-# FlowQuery for VSCode
-
-Run FlowQuery statements from within VSCode.
-
-### Howto?
-1. Open a .cql file and press shift+enter.
-2. Query results show up in a separate tab.
-
-You can create a .env (key=value pairs) file in the same directory as your .cql files and refer to variables defined in the .env file from cql files, for example '$key'.
-
-![FlowQuery Demo](https://raw.githubusercontent.com/microsoft/FlowQuery/refs/heads/main/flowquery-vscode/demo/FlowQueryVSCodeDemo.gif).

package/flowquery-vscode/eslint.config.mjs

@@ -1,25 +0,0 @@
-import globals from "globals";
-
-export default [{
-    files: ["**/*.js"],
-    languageOptions: {
-        globals: {
-            ...globals.commonjs,
-            ...globals.node,
-            ...globals.mocha,
-        },
-
-        ecmaVersion: 2022,
-        sourceType: "module",
-    },
-
-    rules: {
-        "no-const-assign": "warn",
-        "no-this-before-super": "warn",
-        "no-undef": "warn",
-        "no-unreachable": "warn",
-        "no-unused-vars": "warn",
-        "constructor-super": "warn",
-        "valid-typeof": "warn",
-    },
-}];