Initial project import

tools/v/vlib/os/os.js.v

@@ -0,0 +1,207 @@
+module os
+
+$if js_node {
+	#var $fs = require('fs');
+	#var $path = require('path');
+	#var tty = require('tty')
+}
+
+pub const path_delimiter = get_path_delimiter()
+pub const path_separator = get_path_separator()
+pub const path_devnull = '/dev/null' // TODO
+
+pub const args = []string{}
+
+const executable_suffixes = ['']
+
+fn get_path_delimiter() string {
+	delimiter := ':'
+	$if js_node {
+		#delimiter.str = $path.delimiter
+	}
+	return delimiter
+}
+
+fn get_path_separator() string {
+	separator := '/'
+	$if js_node {
+		#separator.str = $path.sep
+	}
+	return separator
+}
+
+fn init() {
+	$if js_node {
+		#$process.argv.forEach(function(val,index) { os__args.arr[index] = new string(val); })
+	}
+}
+
+// real_path returns the full absolute path for fpath, with all relative ../../, symlinks and so on resolved.
+// See http://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html
+// Also https://insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
+// and https://insanecoding.blogspot.com/2007/11/implementing-realpath-in-c.html
+// Note: this particular rabbit hole is *deep* ...
+pub fn real_path(fpath string) string {
+	$if js_node {
+		mut res := ''
+		#res = new string( $fs.realpathSync(fpath))
+
+		return res
+	} $else {
+		return fpath
+	}
+}
+
+// flush will flush the stdout buffer.
+pub fn flush() {
+	$if js_node {
+		#$process.stdout.write('')
+	}
+}
+
+pub fn getpid() int {
+	res := 0
+	#res.val = $process.pid
+
+	return res
+}
+
+// chmod change file access attributes of `path` to `mode`.
+// Octals like `0o600` can be used.
+pub fn chmod(path string, mode int) ! {
+	$if js_node {
+		#try {
+		#$fs.chmodSync(''+path,mode.valueOf())
+		#} catch (error) {
+		#return error_with_code(new string("chmod failed: " + error.message),new int(error.code))
+		#}
+	} $else {
+		return error('os.chmod() is available only for NodeJS')
+	}
+}
+
+// chown changes the owner and group attributes of `path` to `owner` and `group`.
+// Octals like `0o600` can be used.
+pub fn chown(path string, owner int, group int) ! {
+	$if js_node {
+		#try {
+		#$fs.chownSync(''+path,owner.valueOf(),group.valueOf())
+		#} catch (error) { return error_with_code(new string("chown failed: " + error.message),new int(error.code)) }
+	} $else {
+		return error('os.chown() is available only for NodeJS')
+	}
+}
+
+pub fn temp_dir() string {
+	mut res := ''
+	$if js_node {
+		#res = new string($os.tmpdir())
+	}
+	return res
+}
+
+pub fn home_dir() string {
+	mut res := ''
+	$if js_node {
+		#res = new string($os.homedir())
+	}
+	return res
+}
+
+// join_path returns a path as string from input string parameter(s).
+pub fn join_path(base string, dirs ...string) string {
+	mut result := []string{}
+	result << base.trim_right('\\/')
+	for d in dirs {
+		result << d
+	}
+	mut path_sep := ''
+	#path_sep = $path.sep;
+
+	res := result.join(path_sep)
+	return res
+}
+
+pub fn join_path_single(base string, elem string) string {
+	// TODO: deprecate this
+	return join_path(base, elem)
+}
+
+pub fn execute(cmd string) Result {
+	mut exit_code := 0
+	mut out := ''
+	#let commands = cmd.str.split(' ');
+	#let output = $child_process.spawnSync(commands[0],commands.slice(1,commands.length));
+	#exit_code = new int(output.status)
+	#out = new string(output.stdout + '')
+
+	return Result{
+		exit_code: exit_code
+		output:    out
+	}
+}
+
+// exec starts the specified command with arguments, waits for it to complete, and returns its output.
+pub fn exec(args []string) Result {
+	if args.len == 0 {
+		return Result{
+			exit_code: -1
+			output:    'exec requires at least one argument'
+		}
+	}
+	mut exit_code := 0
+	mut out := ''
+	#let commands = args.arr.map((x) => x.valueOf() + '');
+	#let output = $child_process.spawnSync(commands[0], commands.slice(1, commands.length));
+	#exit_code = new int(output.status === null ? -1 : output.status)
+	#out = new string((output.stdout ? output.stdout + '' : '') + (output.stderr ? output.stderr + '' : ''))
+
+	return Result{
+		exit_code: exit_code
+		output:    out
+	}
+}
+
+pub fn system(cmd string) int {
+	exit_code := 0
+	#let commands = cmd.str.split(' ');
+	#exit_code.val = $child_process.execSync(commands[0],commands.slice(1,commands.length));
+
+	return exit_code
+}
+
+pub fn is_atty(fd int) int {
+	res := 0
+	#res.val = +tty.isatty(fd.val)
+
+	return res
+}
+
+pub fn glob(patterns ...string) ![]string {
+	panic('not yet implemented')
+	return error('not yet implemented')
+}
+
+pub fn write_file_array(path string, buffer array) ! {
+	mut f := create(path)!
+	f.write_array(buffer)!
+	f.close()
+}
+
+pub fn chdir(s string) ! {
+	#try { $process.chdir(s.str); } catch (e) { return error(new string('' + s)) }
+}
+
+pub fn file_last_mod_unix(path string) int {
+	mtime := 0
+	#mtime.val = Math.floor($fs.lstatSync(path.str).mtime.getTime() / 1000)
+
+	return mtime
+}
+
+pub fn ensure_folder_is_writable(path string) ! {
+	fpath := join_path(path, 'some_newfile')
+	#try { $fs.writeFileSync(fpath); $fs.unlinkSync(fpath) } catch(e) { return error(new string('could not write to ' + path)) }
+
+	_ := fpath
+}