randomise

Author: oyamo-go

Makefile

@@ -0,0 +1,9 @@
+GO=go
+
+
+test:
+
+bench:
+
+clean:
+    rm -f *.out

README.md

@@ -1,9 +0,0 @@
-GO=go
-
-
-test:
-
-bench:
-
-clean:
-    rm -f *.out

main

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"github.com/oyamo/rmx/src"
+)
+
+func main () {
+	engine, err := src.NewEngine()
+	if err != nil {
+		panic(err)
+	}
+	
+	engine.Run()
+}

main.go

@@ -0,0 +1,91 @@
+package src
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+)
+
+const (
+	RE_REGEXP = `^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$`
+)
+
+func  (e *Engine)DeleteFolder(folder string) error { 
+	err := filepath.WalkDir(folder, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() {
+			return nil
+		}
+		
+		// if it is a file, delete it
+
+		e.DeleteFile(path)
+		return nil
+	}) 
+
+	if err != nil {
+		return err
+	}
+
+	return os.Remove(folder)
+}
+
+func  (e *Engine)DeleteFile(file string)  error{
+   // Open the file
+   fd, err := os.OpenFile(file, os.O_RDWR, 0666)
+   if err != nil {
+	  return err
+   }
+   defer fd.Close()
+   // Write random bytes to the file
+   err = RandomiseFile(fd)
+
+   if err != nil {
+	  return err
+   }
+
+   return os.Remove(file)
+
+}
+
+func (e *Engine)UnlinkFile(file string) {
+
+}
+
+func (e *Engine)DeleteItem(item string) error {
+	files, err := e.MatchWildCard(item)
+	if err != nil {
+		return err
+	}
+
+	if len(files) == 0 {
+		return errors.New("no files found")
+	}
+
+	for _, file := range files {
+		// get the file descriptor
+		fd, err := os.Stat(file)
+		if err != nil {
+			return err
+		}
+
+		// check if it is a directory
+		if fd.IsDir() {
+			if e.Input.HasFlag(FLAG_R) || e.Input.HasFlag(FLAG_D) {
+				e.DeleteFolder(file)
+			} else {
+				return errors.New("cannot remove " + file + ": Is a directory")
+			}
+		} else {
+			e.DeleteFile(file)
+		}
+	}
+
+	return nil
+}
+
+func (e *Engine) MatchWildCard(wildcard string) ([]string,error) {
+	return filepath.Glob(wildcard)
+}

src/deletion.go

@@ -0,0 +1,58 @@
+package src
+
+import "os"
+
+const (
+   VERSION = "0.0.1"
+)
+
+type Engine struct {
+   Input *Input
+   Cwd string
+}
+
+
+func NewEngine() (*Engine, error) {
+   cwd, err := os.Getwd()
+   if err != nil {
+      return nil, err
+   }
+   return &Engine{
+      Input: nil,
+      Cwd: cwd,
+   } , nil
+}
+
+func (e *Engine) Run ()  error {
+   input, err := NewInput()
+
+   if err != nil {
+	  UsageError()
+	  return err
+   }
+
+   e.Input = input
+
+   if input.HasFlag(FLAG_HELP) {
+	  Usage()
+	  return nil
+   }
+
+   if input.HasFlag(FLAG_V) {
+      Version()
+      return nil
+   }
+
+   return e.delete()
+}
+
+func (e *Engine) delete() error {
+   for _, file := range e.Input.Files {
+     err := e.DeleteItem(file)
+     if err != nil {
+       return err
+     }
+   }
+
+   return nil
+}

src/engine.go

@@ -0,0 +1,103 @@
+package src
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+const (
+	FLAG_F = iota  // -f, --force
+	FLAG_I // -i
+	FLAG_R // -r, -R, --recursive
+	FLAG_D // -d, --dir
+	FLAG_V // -v, --verbose
+	FLAG_HELP // --help, -h
+)
+
+type Input struct {
+	Files []string
+	Flags []uint8 // tiny for less mem
+}
+
+
+type InputParser interface {
+	HasFlag(uint8) bool
+}
+
+
+// NewInput creates a new Input struct and parses the command line arguments.
+// It returns the Input struct and an error if there is one.
+func NewInput() (*Input, error) {
+	args := os.Args[1:]
+
+	if len(args) == 0 {
+		return nil, fmt.Errorf("no arguments")
+	}
+
+	input := &Input{
+		Files: make([]string, 0),
+		Flags: make([]uint8, 0),
+	}
+
+	// set flag usage
+	flag.Usage = Usage
+
+	var help = flag.Bool("help", false, "")
+	var version = flag.Bool("version", false, "")
+	var force = flag.Bool("f", false, "")
+	var forceShort = flag.Bool("force", false, "")
+	var recursive = flag.Bool("recursive", false, "")
+	var recursiveShort = flag.Bool("r", false, "")
+	var dir = flag.Bool("dir", false, "dir")
+	var dirShort = flag.Bool("d", false, "dir")
+	var verbose = flag.Bool("verbose", false, "")
+	var verboseShort = flag.Bool("v", false, "")
+	var i = flag.Bool("i", false, "i")
+
+	flag.Parse()
+
+	if *help {
+		input.Flags = append(input.Flags, FLAG_HELP)
+		return input, nil
+	}
+
+	if *version {
+		input.Flags = append(input.Flags, FLAG_V)
+		return input, nil
+	}
+
+	if *force  || *forceShort {
+		input.Flags = append(input.Flags, FLAG_F)
+	}
+
+	if *recursive || *recursiveShort {
+		input.Flags = append(input.Flags, FLAG_R)
+	}
+
+	if *dir || *dirShort {
+		input.Flags = append(input.Flags, FLAG_D)
+	}
+
+	if *verbose || *verboseShort {
+		input.Flags = append(input.Flags, FLAG_V)
+	}
+
+	if *i {
+		input.Flags = append(input.Flags, FLAG_I)
+	}
+
+	input.Files = flag.Args()
+
+	return input, nil
+}
+
+// HasFlag returns true if the input has the flag.
+func (i *Input) HasFlag(flag uint8) bool {
+	for _, f := range i.Flags {
+		if f == flag {
+			return true
+		}
+	}
+	return false
+}

src/input.go

@@ -0,0 +1,30 @@
+package src
+import(
+	"fmt"
+	"os"
+)
+
+// PrintErr prints the error message to stderr.
+func PrintErr (err string) {
+	fmt.Fprintf(os.Stderr, "rmx: %s", err)
+	fmt.Fprintln(os.Stderr)
+}
+
+// PrintErrf prints the error message to stderr.
+func PrintErrf (format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "rmx: " + format + "", args...)
+	fmt.Fprintln(os.Stderr)
+}
+
+// PrintErr prints the info message to stdout.
+func PrintInfof(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stdout, format, args...)
+	fmt.Fprintln(os.Stdout)
+}
+
+// PrintErr prints info message to stdout.
+func PrintInfo (info string) {
+	fmt.Fprint(os.Stdout, info)
+	fmt.Fprintln(os.Stdout)
+}
+

src/printer.go

@@ -0,0 +1,41 @@
+/**
+ * Writes pseudo-random bytes into a file or zeroes it.
+ *
+**/
+
+package src
+
+import (
+	"bufio"
+	"crypto/rand"
+	"io"
+	"os"
+)
+
+const (
+	BUFFER_SIZE = 1024
+)
+
+func ZeroFile(file string) {
+ 
+}
+
+
+func RandomiseFile(file *os.File) error {
+	// use io.CopyN to write random bytes to the file
+	fb := bufio.NewWriter(file)
+	defer fb.Flush()
+
+	// Get the block size of the file
+	stat, err := file.Stat()
+	if err != nil {
+	   return err
+	 }
+ 
+	 // 
+	size := stat.Size()
+
+	_, err = io.CopyN(fb, rand.Reader, size)
+
+	return err
+}

src/rand.go

@@ -0,0 +1,8 @@
+package src
+
+func If[T any](cond bool, v1, v0 T) T {
+    if cond {
+        return v1
+    }
+    return v0
+}