jsdoc-toolkit/app/run.js

   1 /**
   2  * @fileOverview
   3  * A bootstrap script that creates some basic required objects
   4  * for loading other scripts.
   5  * @author Michael Mathews, micmath@gmail.com
   6  * @version $Id: run.js 756 2009-01-07 21:32:58Z micmath $
   7  */
   8
   9 /**
  10  * @namespace Keep track of any messages from the running script.
  11  */
  12 LOG = {
  13         warn: function(msg, e) {
  14                 if (JSDOC.opt.q) return;
  15                 if (e) msg = e.fileName+", line "+e.lineNumber+": "+msg;
  16
  17                 msg = ">> WARNING: "+msg;
  18                 LOG.warnings.push(msg);
  19                 if (LOG.out) LOG.out.write(msg+"\n");
  20                 else print(msg);
  21         },
  22
  23         inform: function(msg) {
  24                 if (JSDOC.opt.q) return;
  25                 msg = " > "+msg;
  26                 if (LOG.out) LOG.out.write(msg+"\n");
  27                 else if (typeof LOG.verbose != "undefined" && LOG.verbose) print(msg);
  28         }
  29 };
  30 LOG.warnings = [];
  31 LOG.verbose = false
  32 LOG.out = undefined;
  33
  34 /**
  35  *      @class Manipulate a filepath.
  36  */
  37 function FilePath(absPath, separator) {
  38         this.slash =  separator || "/";
  39         this.root = this.slash;
  40         this.path = [];
  41         this.file = "";
  42
  43         var parts = absPath.split(/[\\\/]/);
  44         if (parts) {
  45                 if (parts.length) this.root = parts.shift() + this.slash;
  46                 if (parts.length) this.file =  parts.pop()
  47                 if (parts.length) this.path = parts;
  48         }
  49
  50         this.path = this.resolvePath();
  51 }
  52
  53 /** Collapse any dot-dot or dot items in a filepath. */
  54 FilePath.prototype.resolvePath = function() {
  55         var resolvedPath = [];
  56         for (var i = 0; i < this.path.length; i++) {
  57                 if (this.path[i] == "..") resolvedPath.pop();
  58                 else if (this.path[i] != ".") resolvedPath.push(this.path[i]);
  59         }
  60         return resolvedPath;
  61 }
  62
  63 /** Trim off the filename. */
  64 FilePath.prototype.toDir = function() {
  65         if (this.file) this.file = "";
  66         return this;
  67 }
  68
  69 /** Go up a directory. */
  70 FilePath.prototype.upDir = function() {
  71         this.toDir();
  72         if (this.path.length) this.path.pop();
  73         return this;
  74 }
  75
  76 FilePath.prototype.toString = function() {
  77         return this.root
  78                 + this.path.join(this.slash)
  79                 + ((this.path.length > 0)? this.slash : "")
  80                 + this.file;
  81 }
  82
  83 /**
  84  * Turn a path into just the name of the file.
  85  */
  86 FilePath.fileName = function(path) {
  87         var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
  88         return path.substring(nameStart);
  89 }
  90
  91 /**
  92  * Get the extension of a filename
  93  */
  94 FilePath.fileExtension = function(filename) {
  95    return filename.split(".").pop().toLowerCase();
  96 };
  97
  98 /**
  99  * Turn a path into just the directory part.
 100  */
 101 FilePath.dir = function(path) {
 102         var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
 103         return path.substring(0, nameStart-1);
 104 }
 105
 106
 107 importClass(java.lang.System);
 108
 109 /**
 110  * @namespace A collection of information about your system.
 111  */
 112 SYS = {
 113         /**
 114          * Information about your operating system: arch, name, version.
 115          * @type string
 116          */
 117         os: [
 118                 new String(System.getProperty("os.arch")),
 119                 new String(System.getProperty("os.name")),
 120                 new String(System.getProperty("os.version"))
 121         ].join(", "),
 122
 123         /**
 124          * Which way does your slash lean.
 125          * @type string
 126          */
 127         slash: System.getProperty("file.separator")||"/",
 128
 129         /**
 130          * The path to the working directory where you ran java.
 131          * @type string
 132          */
 133         userDir: new String(System.getProperty("user.dir")),
 134
 135         /**
 136          * Where is Java's home folder.
 137          * @type string
 138          */
 139         javaHome: new String(System.getProperty("java.home")),
 140
 141         /**
 142          * The absolute path to the directory containing this script.
 143          * @type string
 144          */
 145         pwd: undefined
 146 };
 147
 148 // jsrun appends an argument, with the path to here.
 149 if (arguments[arguments.length-1].match(/^-j=(.+)/)) {
 150         if (RegExp.$1.charAt(0) == SYS.slash || RegExp.$1.charAt(1) == ":") { // absolute path to here
 151                 SYS.pwd = new FilePath(RegExp.$1).toDir().toString();
 152         }
 153         else { // relative path to here
 154                 SYS.pwd = new FilePath(SYS.userDir + SYS.slash + RegExp.$1).toDir().toString();
 155         }
 156         arguments.pop();
 157 }
 158 else {
 159         print("The run.js script requires you use jsrun.jar.");
 160         quit();
 161 }
 162
 163 // shortcut
 164 var File = Packages.java.io.File;
 165
 166 /**
 167  * @namespace A collection of functions that deal with reading a writing to disk.
 168  */
 169 IO = {
 170
 171         /**
 172          * Create a new file in the given directory, with the given name and contents.
 173          */
 174         saveFile: function(/**string*/ outDir, /**string*/ fileName, /**string*/ content) {
 175                 var out = new Packages.java.io.PrintWriter(
 176                         new Packages.java.io.OutputStreamWriter(
 177                                 new Packages.java.io.FileOutputStream(outDir+SYS.slash+fileName),
 178                                 IO.encoding
 179                         )
 180                 );
 181                 out.write(content);
 182                 out.flush();
 183                 out.close();
 184         },
 185
 186         /**
 187          * @type string
 188          */
 189         readFile: function(/**string*/ path) {
 190                 if (!IO.exists(path)) {
 191                         throw "File doesn't exist there: "+path;
 192                 }
 193                 return readFile(path, IO.encoding);
 194         },
 195
 196         /**
 197          * @param inFile
 198          * @param outDir
 199          * @param [fileName=The original filename]
 200          */
 201         copyFile: function(/**string*/ inFile, /**string*/ outDir, /**string*/ fileName) {
 202                 if (fileName == null) fileName = FilePath.fileName(inFile);
 203
 204                 var inFile = new File(inFile);
 205                 var outFile = new File(outDir+SYS.slash+fileName);
 206
 207                 var bis = new Packages.java.io.BufferedInputStream(new Packages.java.io.FileInputStream(inFile), 4096);
 208                 var bos = new Packages.java.io.BufferedOutputStream(new Packages.java.io.FileOutputStream(outFile), 4096);
 209                 var theChar;
 210                 while ((theChar = bis.read()) != -1) {
 211                         bos.write(theChar);
 212                 }
 213                 bos.close();
 214                 bis.close();
 215         },
 216
 217         /**
 218          * Creates a series of nested directories.
 219          */
 220         mkPath: function(/**Array*/ path) {
 221                 if (path.constructor != Array) path = path.split(/[\\\/]/);
 222                 var make = "";
 223                 for (var i = 0, l = path.length; i < l; i++) {
 224                         make += path[i] + SYS.slash;
 225                         if (! IO.exists(make)) {
 226                                 IO.makeDir(make);
 227                         }
 228                 }
 229         },
 230
 231         /**
 232          * Creates a directory at the given path.
 233          */
 234         makeDir: function(/**string*/ path) {
 235                 (new File(path)).mkdir();
 236         },
 237
 238         /**
 239          * @type string[]
 240          * @param dir The starting directory to look in.
 241          * @param [recurse=1] How many levels deep to scan.
 242          * @returns An array of all the paths to files in the given dir.
 243          */
 244         ls: function(/**string*/ dir, /**number*/ recurse, _allFiles, _path) {
 245                 if (_path === undefined) { // initially
 246                         var _allFiles = [];
 247                         var _path = [dir];
 248                 }
 249                 if (_path.length == 0) return _allFiles;
 250                 if (recurse === undefined) recurse = 1;
 251
 252                 dir = new File(dir);
 253                 if (!dir.directory) return [String(dir)];
 254                 var files = dir.list();
 255
 256                 for (var f = 0; f < files.length; f++) {
 257                         var file = String(files[f]);
 258                         if (file.match(/^\.[^\.\/\\]/)) continue; // skip dot files
 259
 260                         if ((new File(_path.join(SYS.slash)+SYS.slash+file)).list()) { // it's a directory
 261                                 _path.push(file);
 262                                 if (_path.length-1 < recurse) IO.ls(_path.join(SYS.slash), recurse, _allFiles, _path);
 263                                 _path.pop();
 264                         }
 265                         else {
 266                                 _allFiles.push((_path.join(SYS.slash)+SYS.slash+file).replace(SYS.slash+SYS.slash, SYS.slash));
 267                         }
 268                 }
 269
 270                 return _allFiles;
 271         },
 272
 273         /**
 274          * @type boolean
 275          */
 276         exists: function(/**string*/ path) {
 277                 file = new File(path);
 278
 279                 if (file.isDirectory()){
 280                         return true;
 281                 }
 282                 if (!file.exists()){
 283                         return false;
 284                 }
 285                 if (!file.canRead()){
 286                         return false;
 287                 }
 288                 return true;
 289         },
 290
 291         /**
 292          *
 293          */
 294         open: function(/**string*/ path, /**string*/ append) {
 295                 var append = true;
 296                 var outFile = new File(path);
 297                 var out = new Packages.java.io.PrintWriter(
 298                         new Packages.java.io.OutputStreamWriter(
 299                                 new Packages.java.io.FileOutputStream(outFile, append),
 300                                 IO.encoding
 301                         )
 302                 );
 303                 return out;
 304         },
 305
 306         /**
 307          * Sets {@link IO.encoding}.
 308          * Encoding is used when reading and writing text to files,
 309          * and in the meta tags of HTML output.
 310          */
 311         setEncoding: function(/**string*/ encoding) {
 312                 if (/ISO-8859-([0-9]+)/i.test(encoding)) {
 313                         IO.encoding = "ISO8859_"+RegExp.$1;
 314                 }
 315                 else {
 316                         IO.encoding = encoding;
 317                 }
 318         },
 319
 320         /**
 321          * @default "utf-8"
 322          * @private
 323          */
 324         encoding: "utf-8",
 325
 326         /**
 327          * Load the given script.
 328          */
 329         include: function(relativePath) {
 330                 load(SYS.pwd+relativePath);
 331         },
 332
 333         /**
 334          * Loads all scripts from the given directory path.
 335          */
 336         includeDir: function(path) {
 337                 if (!path) return;
 338
 339                 for (var lib = IO.ls(SYS.pwd+path), i = 0; i < lib.length; i++)
 340                         if (/\.js$/i.test(lib[i])) load(lib[i]);
 341         }
 342 }
 343
 344 // now run the application
 345 IO.include("frame.js");
 346 IO.include("main.js");
 347
 348 main();