(WIP) name and timestamp resepect permissions

src/rt/rfwfs/main.ts

@@ -1,21 +1,23 @@
-import { EntryType, PushStatus, ReadStatus, Permissions } from "./enum"
+import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum"
 import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
 
 import directory_search from "./index"
+import hash_table from "./hash"
 
 type FileInner = string | number
+type EntryFileInner = EntryValue<FileInner, FileInner | undefined>
 
-interface Entry {
+//please do not change the inner values directly on entries or else there will be catastrophic consequences
-	name: string,
+interface EntryValue<T, U = T> {
-	timestamp: number,
+	__inner: T,
-	permissions: Permissions,
+	write: (value: T) => boolean,
-	//please do not change the inner values directly on entries or else there will be catastrophic consequences
+	read: () => U,
-	readonly type: EntryType,
 }
-interface EntryFileInner {
+interface Entry {
-	__body: FileInner,
+	permissions: Permissions,
-	write: (item: FileInner) => boolean,
+	timestamp: EntryValue<number>,
-	read: () => FileInner | undefined,
+	name: EntryValue<string>,
+	readonly type: EntryType,
 }
 interface EntryFile extends Entry {
 	inner: EntryFileInner,
@@ -24,43 +26,48 @@ interface EntryFile extends Entry {
 interface EntryCollection<T extends Entry> extends Entry {
 	inner: EntryCollectionManipulate<T>,
 }
-
 interface EntryCollectionManipulate<T extends Entry> {
-	__body: T[],
+	__inner: T[],
 	clone: (file_name: string) => WrapResultEntry<T, ReadStatus>
 	find: (file_name: string) => WrapResultEntry<T, ReadStatus>
 	push: (entry: Entry) => WrapResultNone<PushStatus>,
 	sort: () => void,
 	pop: (file_name: string) => WrapResultEntry<T, ReadStatus>,
 }
-
 interface Rfwfs {
-	directory: <T extends Entry>(default_name: string, permissions: Permissions, timestamp?: number, inner_default?: T[]) => EntryCollection<T>,
+	directory: <T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]) => EntryCollection<T>,
+	file: (default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: FileInner) => Promise<EntryFile>,
+	is_binary: <T extends Entry>(entry: T) => boolean,
 	is_file: <T extends Entry>(entry: T) => boolean,
 	is_dir: <T extends Entry>(entry: T) => boolean,
-	file: (default_name: string, permissions: Permissions, timestamp?: number, inner_default?: FileInner) => EntryFile,
 }
 
-function read_write_access(permissions: Permissions): boolean {
+function execute_access<P extends ConstEnum>(permissions: P): boolean {
+	return permissions === PermissionsBinary.rwx
+		|| permissions === PermissionsBinary.rx
+		|| permissions === PermissionsBinary.wx
+		|| permissions === PermissionsBinary.x
+}
+function read_write_access<P extends ConstEnum>(permissions: P): boolean {
 	return permissions === Permissions.rw
 }
-function read_access(permissions: Permissions): boolean {
+function read_access<P extends ConstEnum>(permissions: P): boolean {
 	return read_write_access(permissions) || permissions === Permissions.r
 }
-function write_access(permissions: Permissions): boolean {
+function write_access<P extends ConstEnum>(permissions: P): boolean {
 	return read_write_access(permissions) || permissions === Permissions.w
 }
 
 function directory_sort<E extends Entry>(self: EntryCollectionManipulate<E>) {
-	self.__body.sort((a,z) => a.name.localeCompare(z.name))
+	self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
 }
 
 function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> {
 	if (write_access(self.permissions)) {
-		const no_duplicates = directory_search(self.inner.__body, entry.name)
+		const no_duplicates = directory_search(self.inner.__inner, entry.name.read())
 		if (!no_duplicates) {
-			self.inner.__body.push(entry)
+			self.inner.__inner.push(entry)
-			self.inner.__body.sort()
+			self.inner.__inner.sort()
 			return wrap_none(PushStatus.Ok)
 		}
 		return wrap_none(PushStatus.Duplicate)
@@ -70,7 +77,7 @@ function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): Wr
 
 function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
 	if (read_access(self.permissions)) {
-		const file_search = directory_search(self.inner.__body, file_name)
+		const file_search = directory_search(self.inner.__inner, file_name)
 		if (file_search) {
 			return wrap_entry(ReadStatus.Ok, file_search.result)
 		}
@@ -81,9 +88,9 @@ function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: st
 
 function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
 	if (read_write_access(self.permissions)) {
-		const pop_find = directory_search(self.inner.__body, file_name)
+		const pop_find = directory_search(self.inner.__inner, file_name)
 		if (pop_find) {
-			self.inner.__body.splice(pop_find.some, 1)
+			self.inner.__inner.splice(pop_find.some, 1)
 			return wrap_entry(ReadStatus.Ok, pop_find.result)
 		}
 		return wrap_entry(ReadStatus.NotFound)
@@ -93,7 +100,7 @@ function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: str
 
 function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
 	if (read_write_access(self.permissions)) {
-		const clone_find = directory_search(self.inner.__body, file_name)
+		const clone_find = directory_search(self.inner.__inner, file_name)
 		if (clone_find) {
 			return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
 		}
@@ -102,32 +109,32 @@ function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: s
 	return wrap_entry(ReadStatus.Denied)
 }
 
-function file_inner_read(self: EntryFileInner, permissions: Permissions): FileInner | undefined {
+function inner_read<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P): FileInner | undefined {
-	return read_access(permissions) ? self.__body : undefined
+	return read_access(permissions) ? self.__inner : undefined
 }
 
-function file_inner_write(self: EntryFileInner, permissions: Permissions, item: FileInner): boolean {
+function inner_write<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P, item: I): boolean {
 	if (write_access(permissions)) {
-		self.__body = item
+		self.__inner = item
 		return true
 	}
 	return false
 }
 
-function file_inner(permissions: Permissions, inner_default: FileInner): EntryFileInner {
+function inner<P extends ConstEnum, I, R extends EntryValue<I>>(permissions: P, inner_default: I): R {
-	const file_inner_trait = { __body: inner_default } as EntryFileInner
+	const inner_trait = { __inner: inner_default } as R
-	file_inner_trait.read  = function()     { return file_inner_read(this, permissions) }
+	inner_trait.write = function(item) { return inner_write(this, permissions, item) }
-	file_inner_trait.write = function(item) { return file_inner_write(this, permissions, item) }
+	inner_trait.read  = function()     { return inner_read(this, permissions) }
-	return file_inner_trait
+	return inner_trait
 }
 
 function dir_inner<T extends Entry>(self: EntryCollection<T>, collection: T[]): EntryCollectionManipulate<T> {
-	const collection_trait = { __body: collection } as EntryCollectionManipulate<T>
+	const collection_trait = { __inner: collection } as EntryCollectionManipulate<T>
 	collection_trait.clone = function(file_name) { return directory_clone(self, file_name) }
-	collection_trait.pop   = function(file_name) { return directory_pop(self, file_name) }
 	collection_trait.find  = function(file_name) { return directory_find(self, file_name) }
 	collection_trait.push  = function(entry)     { return directory_push(self, entry) }
 	collection_trait.sort  = function()          { return directory_sort(this) }
+	collection_trait.pop   = function(file_name) { return directory_pop(self, file_name) }
 	collection_trait.sort() //the default collection is automatically sorted on directory creation.
 	return collection_trait
 }
@@ -140,32 +147,34 @@ rfwfs.is_dir = function(entry) {
 rfwfs.is_file = function(entry) {
 	return entry.type === EntryType.File
 }
+rfwfs.is_binary = function(entry) {
+	return entry.type === EntryType.Binary
+}
 
-rfwfs.file = function(default_name, permissions, timestamp, inner_default) {
+rfwfs.file = async function(default_name, default_permissions, default_timestamp, default_inner = "") {
 	const file = { type: EntryType.File } as EntryFile
-	file.permissions = permissions
+	file.permissions = default_permissions
-	file.timestamp = timestamp ? timestamp : (Date.now()/1000)|0
+	file.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
-	file.inner = file_inner(permissions, inner_default ? inner_default : "")
+	file.inner = inner(default_permissions, default_inner)
-	file.name = default_name
+	file.name = inner(default_permissions, default_name)
-	file.hash = "0"
+	file.hash = await hash_table.sha256(default_inner)
 	return file
 }
 
-rfwfs.directory = function<T extends Entry>(default_name: string, permissions: Permissions, timestamp?: number, inner_default?: T[]): EntryCollection<T> {
+rfwfs.directory = function<T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]): EntryCollection<T> {
 	const directory = { type: EntryType.Directory } as EntryCollection<T>
-	directory.permissions = permissions
+	directory.permissions = default_permissions
-	directory.timestamp = timestamp ? timestamp : (Date.now()/1000)|0
+	directory.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
-	directory.inner = dir_inner(directory, inner_default ? inner_default : [])
+	directory.inner = inner(default_permissions, default_inner)
-	directory.name = default_name
+	directory.name = inner(default_permissions, default_name)
 	return directory
 }
 
 export default rfwfs
 export {
-	type FileInner,
-	type Entry,
-	type EntryFile,
-	type EntryFileInner,
-	type EntryCollection,
 	type EntryCollectionManipulate,
+	type EntryCollection,
+	type FileInner,
+	type EntryFile,
+	type Entry,
 }

src/rt/rfwfs/wrap.ts

@@ -1,14 +1,14 @@
-import { Result } from "./enum"
+import { Result, type ConstEnum } from "./enum"
 import { type Entry } from "./main"
 
-type ConstEnum = number
-
 type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
 type WrapBSearch<T extends Entry> = WrapResult<T, number>
 type WrapResultNone<T> = WrapResult<Result.None, T>
 
 interface WrapResult<T, U> {
+	/** The resulting value if `U` is a success */
 	readonly result: T,
+	/** Represents some arbitrary extra value, usually a success status */
 	readonly some: U
 }
 
@@ -20,7 +20,7 @@ function wrap_bsearch<T extends Entry>(index: number, result: T): WrapBSearch<T>
 	return wrap(result, index)
 }
 
-function wrap_entry<U extends ConstEnum, T extends Entry>(status: U, result?: T): WrapResultEntry<T, U> {
+function wrap_entry<T extends ConstEnum, U extends Entry>(status: T, result?: U): WrapResultEntry<U, T> {
 	return wrap(result, status)
 }
 
@@ -37,4 +37,4 @@ export {
 	type WrapResultNone,
 	type WrapBSearch,
 	type WrapResult,
-}
+}