rhpidfyre.io/wunix.rhpidfyre.io
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

(WIP) name and timestamp resepect permissions

Browse Source
This commit is contained in:
rhpidfyre
2025-03-11 03:23:13 -04:00
parent d7abe20d1a
commit 050c0f1aca
2 changed files with 68 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
src/rt/rfwfs/main.ts
View File

@ -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 {
name: string,
timestamp: number,
permissions: Permissions,
//please do not change the inner values directly on entries or else there will be catastrophic consequences
readonly type: EntryType,
interface EntryValue<T, U = T> {
__inner: T,
write: (value: T) => boolean,
read: () => U,
}
interface EntryFileInner {
__body: FileInner,
write: (item: FileInner) => boolean,
read: () => FileInner | undefined,
interface Entry {
permissions: Permissions,
timestamp: EntryValue<number>,
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.__body.sort()
self.inner.__inner.push(entry)
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 {
return read_access(permissions) ? self.__body : undefined
function inner_read<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P): FileInner | 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 {
const file_inner_trait = { __body: inner_default } as EntryFileInner
file_inner_trait.read = function() { return file_inner_read(this, permissions) }
file_inner_trait.write = function(item) { return file_inner_write(this, permissions, item) }
return file_inner_trait
function inner<P extends ConstEnum, I, R extends EntryValue<I>>(permissions: P, inner_default: I): R {
const inner_trait = { __inner: inner_default } as R
inner_trait.write = function(item) { return inner_write(this, permissions, item) }
inner_trait.read = function() { return inner_read(this, permissions) }
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.timestamp = timestamp ? timestamp : (Date.now()/1000)|0
file.inner = file_inner(permissions, inner_default ? inner_default : "")
file.name = default_name
file.hash = "0"
file.permissions = default_permissions
file.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
file.inner = inner(default_permissions, default_inner)
file.name = inner(default_permissions, default_name)
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.timestamp = timestamp ? timestamp : (Date.now()/1000)|0
directory.inner = dir_inner(directory, inner_default ? inner_default : [])
directory.name = default_name
directory.permissions = default_permissions
directory.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
directory.inner = inner(default_permissions, default_inner)
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,
}

8
src/rt/rfwfs/wrap.ts
View File

@ -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)
}