Ringo to NIO

fs-converter.js

var assert = require("assert");

var octalToString = function(octalPart) {
   switch (octalPart) {
      case 0: return "---";
      case 1: return "--x";
      case 2: return "-w-";
      case 3: return "-wx";
      case 4: return "r--";
      case 5: return "r-x";
      case 6: return "rw-";
      case 7: return "rwx";
   }

   throw "Invalid permission number!";
};

var stringToOctal = function(stringPart) {
   switch (stringPart) {
      case "---": return 0;
      case "--x": return 1;
      case "-w-": return 2;
      case "-wx": return 3;
      case "r--": return 4;
      case "r-x": return 5;
      case "rw-": return 6;
      case "rwx": return 7;
   }

   throw "Invalid POSIX string!";
};

var convertOctalToPosix = function(octal) {
   return [
      octalToString(octal >> 6),
      octalToString((octal >> 3) & 0007),
      octalToString(octal & 0007)
   ].join("");
};

var convertPosixToOctal = function(posixStr) {
   if (posixStr.length !== 9) {
      throw "Invalid POSIX string!";
   }

   return (stringToOctal(posixStr.substring(0,3)) << 6) +
      (stringToOctal(posixStr.substring(3,6)) << 3) +
      stringToOctal(posixStr.substring(6,9));
};

var convertEnumSetToOctal = function(javaEnumSet) {
   return convertPosixToOctal(java.nio.file.attribute.PosixFilePermissions.toString(javaEnumSet));
};

exports.testConvertOctalToPosix = function() {
   assert.throws(function() { convertOctalToPosix(-01) }, "Invalid permission number!");
   assert.throws(function() { convertOctalToPosix(01000) }, "Invalid permission number!");
   assert.throws(function() { convertOctalToPosix(05755) }, "Invalid permission number!");

   assert.equal(convertOctalToPosix(0777), "rwxrwxrwx");
   assert.equal(convertOctalToPosix(0776), "rwxrwxrw-");
   assert.equal(convertOctalToPosix(0775), "rwxrwxr-x");
   assert.equal(convertOctalToPosix(0774), "rwxrwxr--");
   assert.equal(convertOctalToPosix(0773), "rwxrwx-wx");
   assert.equal(convertOctalToPosix(0772), "rwxrwx-w-");
   assert.equal(convertOctalToPosix(0771), "rwxrwx--x");
   assert.equal(convertOctalToPosix(0770), "rwxrwx---");
   assert.equal(convertOctalToPosix(0766), "rwxrw-rw-");
   assert.equal(convertOctalToPosix(0755), "rwxr-xr-x");
   assert.equal(convertOctalToPosix(0744), "rwxr--r--");
   assert.equal(convertOctalToPosix(0733), "rwx-wx-wx");
   assert.equal(convertOctalToPosix(0722), "rwx-w--w-");
   assert.equal(convertOctalToPosix(0711), "rwx--x--x");
   assert.equal(convertOctalToPosix(0700), "rwx------");
   assert.equal(convertOctalToPosix(0766), "rwxrw-rw-");
   assert.equal(convertOctalToPosix(0755), "rwxr-xr-x");
   assert.equal(convertOctalToPosix(0744), "rwxr--r--");
   assert.equal(convertOctalToPosix(0733), "rwx-wx-wx");
   assert.equal(convertOctalToPosix(0722), "rwx-w--w-");
   assert.equal(convertOctalToPosix(0711), "rwx--x--x");
   assert.equal(convertOctalToPosix(0700), "rwx------");
   assert.equal(convertOctalToPosix(0666), "rw-rw-rw-");
   assert.equal(convertOctalToPosix(0555), "r-xr-xr-x");
   assert.equal(convertOctalToPosix(0444), "r--r--r--");
   assert.equal(convertOctalToPosix(0333), "-wx-wx-wx");
   assert.equal(convertOctalToPosix(0222), "-w--w--w-");
   assert.equal(convertOctalToPosix(0111), "--x--x--x");
   assert.equal(convertOctalToPosix(0000), "---------");
   assert.equal(convertOctalToPosix(0700), "rwx------");
   assert.equal(convertOctalToPosix(0070), "---rwx---");
   assert.equal(convertOctalToPosix(0007), "------rwx");
   assert.equal(convertOctalToPosix(0600), "rw-------");
   assert.equal(convertOctalToPosix(0060), "---rw----");
   assert.equal(convertOctalToPosix(0006), "------rw-");
   assert.equal(convertOctalToPosix(0500), "r-x------");
   assert.equal(convertOctalToPosix(0050), "---r-x---");
   assert.equal(convertOctalToPosix(0005), "------r-x");
   assert.equal(convertOctalToPosix(0400), "r--------");
   assert.equal(convertOctalToPosix(0040), "---r-----");
   assert.equal(convertOctalToPosix(0004), "------r--");
   assert.equal(convertOctalToPosix(0300), "-wx------");
   assert.equal(convertOctalToPosix(0030), "----wx---");
   assert.equal(convertOctalToPosix(0003), "-------wx");
   assert.equal(convertOctalToPosix(0200), "-w-------");
   assert.equal(convertOctalToPosix(0020), "----w----");
   assert.equal(convertOctalToPosix(0002), "-------w-");
   assert.equal(convertOctalToPosix(0100), "--x------");
   assert.equal(convertOctalToPosix(0010), "-----x---");
   assert.equal(convertOctalToPosix(0001), "--------x");
};

exports.testConvertPosixToOctal = function() {
   assert.throws(function() { convertPosixToOctal("srwxrwxrwx"); }, "Invalid POSIX string!");
   assert.throws(function() { convertPosixToOctal(""); }, "Invalid POSIX string!");
   assert.throws(function() { convertPosixToOctal("rwxrwxrw "); }, "Invalid POSIX string!");
   assert.throws(function() { convertPosixToOctal("rwxrwxrwe"); }, "Invalid POSIX string!");

   assert.equal(convertPosixToOctal("rwxrwxrwx"), 0777);
   assert.equal(convertPosixToOctal("rwxrwxrw-"), 0776);
   assert.equal(convertPosixToOctal("rwxrwxr-x"), 0775);
   assert.equal(convertPosixToOctal("rwxrwxr--"), 0774);
   assert.equal(convertPosixToOctal("rwxrwx-wx"), 0773);
   assert.equal(convertPosixToOctal("rwxrwx-w-"), 0772);
   assert.equal(convertPosixToOctal("rwxrwx--x"), 0771);
   assert.equal(convertPosixToOctal("rwxrwx---"), 0770);
   assert.equal(convertPosixToOctal("rwxrw-rw-"), 0766);
   assert.equal(convertPosixToOctal("rwxr-xr-x"), 0755);
   assert.equal(convertPosixToOctal("rwxr--r--"), 0744);
   assert.equal(convertPosixToOctal("rwx-wx-wx"), 0733);
   assert.equal(convertPosixToOctal("rwx-w--w-"), 0722);
   assert.equal(convertPosixToOctal("rwx--x--x"), 0711);
   assert.equal(convertPosixToOctal("rwx------"), 0700);
   assert.equal(convertPosixToOctal("rwxrw-rw-"), 0766);
   assert.equal(convertPosixToOctal("rwxr-xr-x"), 0755);
   assert.equal(convertPosixToOctal("rwxr--r--"), 0744);
   assert.equal(convertPosixToOctal("rwx-wx-wx"), 0733);
   assert.equal(convertPosixToOctal("rwx-w--w-"), 0722);
   assert.equal(convertPosixToOctal("rwx--x--x"), 0711);
   assert.equal(convertPosixToOctal("rwx------"), 0700);
   assert.equal(convertPosixToOctal("rw-rw-rw-"), 0666);
   assert.equal(convertPosixToOctal("r-xr-xr-x"), 0555);
   assert.equal(convertPosixToOctal("r--r--r--"), 0444);
   assert.equal(convertPosixToOctal("-wx-wx-wx"), 0333);
   assert.equal(convertPosixToOctal("-w--w--w-"), 0222);
   assert.equal(convertPosixToOctal("--x--x--x"), 0111);
   assert.equal(convertPosixToOctal("---------"), 0000);
   assert.equal(convertPosixToOctal("rwx------"), 0700);
   assert.equal(convertPosixToOctal("---rwx---"), 0070);
   assert.equal(convertPosixToOctal("------rwx"), 0007);
   assert.equal(convertPosixToOctal("rw-------"), 0600);
   assert.equal(convertPosixToOctal("---rw----"), 0060);
   assert.equal(convertPosixToOctal("------rw-"), 0006);
   assert.equal(convertPosixToOctal("r-x------"), 0500);
   assert.equal(convertPosixToOctal("---r-x---"), 0050);
   assert.equal(convertPosixToOctal("------r-x"), 0005);
   assert.equal(convertPosixToOctal("r--------"), 0400);
   assert.equal(convertPosixToOctal("---r-----"), 0040);
   assert.equal(convertPosixToOctal("------r--"), 0004);
   assert.equal(convertPosixToOctal("-wx------"), 0300);
   assert.equal(convertPosixToOctal("----wx---"), 0030);
   assert.equal(convertPosixToOctal("-------wx"), 0003);
   assert.equal(convertPosixToOctal("-w-------"), 0200);
   assert.equal(convertPosixToOctal("----w----"), 0020);
   assert.equal(convertPosixToOctal("-------w-"), 0002);
   assert.equal(convertPosixToOctal("--x------"), 0100);
   assert.equal(convertPosixToOctal("-----x---"), 0010);
   assert.equal(convertPosixToOctal("--------x"), 0001);
};

exports.testJavaConvertion = function() {
   var fromString = java.nio.file.attribute.PosixFilePermissions.fromString;

   assert.equal(convertEnumSetToOctal(fromString("rwxrwxrwx")), 0777);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwxrw-")), 0776);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwxr-x")), 0775);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwxr--")), 0774);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwx-wx")), 0773);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwx-w-")), 0772);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwx--x")), 0771);
   assert.equal(convertEnumSetToOctal(fromString("rwxrwx---")), 0770);
   assert.equal(convertEnumSetToOctal(fromString("rwxrw-rw-")), 0766);
   assert.equal(convertEnumSetToOctal(fromString("rwxr-xr-x")), 0755);
   assert.equal(convertEnumSetToOctal(fromString("rwxr--r--")), 0744);
   assert.equal(convertEnumSetToOctal(fromString("rwx-wx-wx")), 0733);
   assert.equal(convertEnumSetToOctal(fromString("rwx-w--w-")), 0722);
   assert.equal(convertEnumSetToOctal(fromString("rwx--x--x")), 0711);
   assert.equal(convertEnumSetToOctal(fromString("rwx------")), 0700);
   assert.equal(convertEnumSetToOctal(fromString("rwxrw-rw-")), 0766);
   assert.equal(convertEnumSetToOctal(fromString("rwxr-xr-x")), 0755);
   assert.equal(convertEnumSetToOctal(fromString("rwxr--r--")), 0744);
   assert.equal(convertEnumSetToOctal(fromString("rwx-wx-wx")), 0733);
   assert.equal(convertEnumSetToOctal(fromString("rwx-w--w-")), 0722);
   assert.equal(convertEnumSetToOctal(fromString("rwx--x--x")), 0711);
   assert.equal(convertEnumSetToOctal(fromString("rwx------")), 0700);
   assert.equal(convertEnumSetToOctal(fromString("rw-rw-rw-")), 0666);
   assert.equal(convertEnumSetToOctal(fromString("r-xr-xr-x")), 0555);
   assert.equal(convertEnumSetToOctal(fromString("r--r--r--")), 0444);
   assert.equal(convertEnumSetToOctal(fromString("-wx-wx-wx")), 0333);
   assert.equal(convertEnumSetToOctal(fromString("-w--w--w-")), 0222);
   assert.equal(convertEnumSetToOctal(fromString("--x--x--x")), 0111);
   assert.equal(convertEnumSetToOctal(fromString("---------")), 0000);
   assert.equal(convertEnumSetToOctal(fromString("rwx------")), 0700);
   assert.equal(convertEnumSetToOctal(fromString("---rwx---")), 0070);
   assert.equal(convertEnumSetToOctal(fromString("------rwx")), 0007);
   assert.equal(convertEnumSetToOctal(fromString("rw-------")), 0600);
   assert.equal(convertEnumSetToOctal(fromString("---rw----")), 0060);
   assert.equal(convertEnumSetToOctal(fromString("------rw-")), 0006);
   assert.equal(convertEnumSetToOctal(fromString("r-x------")), 0500);
   assert.equal(convertEnumSetToOctal(fromString("---r-x---")), 0050);
   assert.equal(convertEnumSetToOctal(fromString("------r-x")), 0005);
   assert.equal(convertEnumSetToOctal(fromString("r--------")), 0400);
   assert.equal(convertEnumSetToOctal(fromString("---r-----")), 0040);
   assert.equal(convertEnumSetToOctal(fromString("------r--")), 0004);
   assert.equal(convertEnumSetToOctal(fromString("-wx------")), 0300);
   assert.equal(convertEnumSetToOctal(fromString("----wx---")), 0030);
   assert.equal(convertEnumSetToOctal(fromString("-------wx")), 0003);
   assert.equal(convertEnumSetToOctal(fromString("-w-------")), 0200);
   assert.equal(convertEnumSetToOctal(fromString("----w----")), 0020);
   assert.equal(convertEnumSetToOctal(fromString("-------w-")), 0002);
   assert.equal(convertEnumSetToOctal(fromString("--x------")), 0100);
   assert.equal(convertEnumSetToOctal(fromString("-----x---")), 0010);
   assert.equal(convertEnumSetToOctal(fromString("--------x")), 0001);
};

if (require.main == module.id) {
    require("system").exit(require("test").run(module.id));
}

posix-support.js

console.log(java.nio.file.FileSystems.getDefault().supportedFileAttributeViews().contains("posix") === true ? "t" : "f");