Merge pull request #12 from FSou1/feature/introduce-is-directory-filter

Introduce where isDirectory equals/different to true/false

Author: FSou1

README.md

@@ -81,10 +81,16 @@ export interface IDirEntry {
 
 `select * from root where size <> 1000000`
 
-### TODO
-
 `select * from root where isDirectory = true`
 
+`select * from root where isDirectory = false`
+
+`select * from root where isDirectory <> true`
+
+`select * from root where isDirectory <> false`
+
+### TODO
+
 `select * from root where name = 'root.txt'`
 
 `select * from root where name like '%txt'`

deps.ts

@@ -6,5 +6,6 @@ export {
   assert,
   assertExists,
   assertEquals,
-  assertThrows
+  assertThrows,
+  assertArrayIncludes
 } from "https://deno.land/std@0.82.0/testing/asserts.ts";

mod.ts

@@ -4,6 +4,6 @@ import { IDirEntry } from "./types.ts";
 
 import { select } from "./select.ts";
 
-export async function fsselect(query: string): Promise<IDirEntry[]> {
-  return await select(parser.parse(query))
+export function fsselect(query: string): Promise<IDirEntry[]> {
+  return select(parser.parse(query))
 }

mod_test.ts

@@ -1,4 +1,4 @@
-import {assert } from "./deps.ts"
+import { assert, assertArrayIncludes, assertEquals } from "./deps.ts";
 
 import { fsselect } from "./mod.ts";
 
@@ -18,7 +18,51 @@ Deno.test("if 'select * from root/test_folder_with_file' works", async () => {
 });
 
 Deno.test("if 'select * from root/test_folder_with_files where size > 1000000' works", async () => {
-  const result = await fsselect("select * from root/test_folder_with_files where size > 1000000");
+  const result = await fsselect(
+    "select * from root/test_folder_with_files where size > 1000000",
+  );
   assert(result.length === 1);
-  assert(result[0].name === 'b-file-1MB.txt');
+  assert(result[0].name === "b-file-1MB.txt");
+});
+
+Deno.test("if 'select * from root where isDirectory = true' works", async () => {
+  const result = await fsselect("select * from root where isDirectory = true");
+  assert(result.length === 3);
+
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if 'select * from root where isDirectory = false' works", async () => {
+  const result = await fsselect("select * from root where isDirectory = false");
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isFile, true);
+});
+
+Deno.test("if 'select * from root where isDirectory <> false' works", async () => {
+  const result = await fsselect("select * from root where isDirectory <> false");
+  assert(result.length === 3);
+
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if 'select * from root where isDirectory <> true' works", async () => {
+  const result = await fsselect("select * from root where isDirectory <> true");
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isFile, true);
 });

select_test.ts

@@ -1,6 +1,7 @@
 import {
   assert,
   assertEquals,
+  assertArrayIncludes
 } from "https://deno.land/std@0.82.0/testing/asserts.ts";
 
 import { IQuery } from "./types.ts";
@@ -100,3 +101,107 @@ Deno.test("if a 1MB file is returned when the where clause is correct", async ()
   assert(result[0].createdAt);
   assert(result[0].modifiedAt);
 });
+
+Deno.test("if 3 folders are returned when the where clause has isDirectory = true", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "isDirectory",
+          op: "Equal",
+          right: "true",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 3);
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if the 'root.txt' is returned when the where clause has isDirectory = false", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "isDirectory",
+          op: "Equal",
+          right: "false",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isFile, true);
+});
+
+Deno.test("if the 'root.txt' is returned when the where clause has isDirectory <> false", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "isDirectory",
+          op: "Different",
+          right: "false",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 3);
+  const names = result.map((i) => i.name as string);
+  const expectedNames = [
+    "test_folder_with_file",
+    "test_folder_with_files",
+    "test_folder_with_folder",
+  ];
+  assertArrayIncludes<string>(names, expectedNames);
+});
+
+Deno.test("if 3 folders are returned when the where clause has isDirectory <> true", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root",
+    where: {
+      conditions: [
+        {
+          left: "isDirectory",
+          op: "Different",
+          right: "true",
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 1);
+  assertEquals(result[0].name, "root.txt");
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isFile, true);
+});

types.ts

@@ -23,5 +23,5 @@ export interface IWhereClause {
 export interface IWhereCondition {
   left: string;
   op: 'Different' | 'GreaterThan' | 'LessThan' | 'Equal' | 'Like';
-  right: string | number;
+  right: string | number | boolean;
 }

where.ts

@@ -34,27 +34,51 @@ function meet(entry: IDirEntry, condition: IWhereCondition): boolean {
       );
     }
 
-    return operation(entry.size, right);
+    return operation(entry.size, <number>right);
+  } else if (left === "isDirectory") {
+    const operations = {
+      "GreaterThan": null,
+      "LessThan": null,
+      "Equal": equalBoolean,
+      "Different": differentBoolean,
+      "Like": null,
+    };
+
+    const operation = operations[op];
+    if (!operation) {
+      throw new Error(
+        `The operation '${op}' is not supported for the '${left}' property`,
+      );
+    }
+
+    return operation(entry.isDirectory, JSON.parse(right as string));
   }
 
   return false;
 }
 
-function greaterThan(
-  left: number | undefined,
-  right: number | string,
-): boolean {
+/* Number */
+function greaterThan(left: number | undefined, right: number): boolean {
   return typeof left !== "undefined" && left > right;
 }
 
-function lessThan(left: number | undefined, right: number | string): boolean {
+function lessThan(left: number | undefined, right: number): boolean {
   return typeof left !== "undefined" && left < right;
 }
 
-function equal(left: number | undefined, right: number | string): boolean {
+function equal(left: number | undefined, right: number): boolean {
   return typeof left !== "undefined" && left === right;
 }
 
-function different(left: number | undefined, right: number | string): boolean {
+function different(left: number | undefined, right: number): boolean {
   return typeof left !== "undefined" && left !== right;
 }
+
+/* Boolean */
+function equalBoolean(left: boolean | undefined, right: boolean): boolean {
+  return typeof left !== "undefined" && left === right;
+}
+
+function differentBoolean(left: boolean | undefined, right: boolean): boolean {
+  return typeof left !== "undefined" && left !== right;
+}