spade-packager 0.1.0

data/packages/ivory/LICENSE.txt

@@ -0,0 +1 @@
+// TODO: Add MIT License here

data/packages/ivory/README.md

@@ -0,0 +1,19 @@
+# Ivory - A basic filesystem 
+
+Ivory is a basic filesystem API for JS.  It is based mostly on the node.js 
+API but internally uses a ruby binding for use with the spade runtime.
+
+Currently Ivory is considered unstable.  The API can change at any time.  In
+general we try to keep it close to node.js.
+
+## Usage
+
+You can use the API just like the node.js format:
+
+    var fs = require('ivory/fs');
+    
+You can also import the entire API into a global context.
+
+    require('ivory/fs');
+    $fs.open(..);
+    

data/packages/ivory/lib/buffer.js

@@ -0,0 +1,111 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+var SlowBuffer = require('./ruby/buffer').SlowBuffer;
+var Buffer; 
+
+var pool;
+
+function allocPool() {
+  pool = new SlowBuffer(Buffer.poolSize);
+  pool.used = 0;
+}
+
+
+function toHex(n) {
+  if (n < 16) return '0' + n.toString(16);
+  return n.toString(16);
+}
+
+
+SlowBuffer.prototype.inspect = function() {
+  var out = [],
+      len = this.length;
+  for (var i = 0; i < len; i++) {
+    out[i] = toHex(this[i]);
+  }
+  return '<SlowBuffer ' + out.join(' ') + '>';
+};
+
+
+SlowBuffer.prototype.toString = function(encoding, start, end) {
+  encoding = String(encoding || 'utf8').toLowerCase();
+  start = +start || 0;
+  if (typeof end == 'undefined') end = this.length;
+
+  // Fastpath empty strings
+  if (+end == start) {
+    return '';
+  }
+
+  switch (encoding) {
+    case 'utf8':
+    case 'utf-8':
+      return this.utf8Slice(start, end);
+
+    case 'ascii':
+      return this.asciiSlice(start, end);
+
+    case 'binary':
+      return this.binarySlice(start, end);
+
+    case 'base64':
+      return this.base64Slice(start, end);
+
+    default:
+      throw new Error('Unknown encoding');
+  }
+};
+
+
+SlowBuffer.prototype.write = function(string, offset, encoding) {
+  // Support both (string, offset, encoding)
+  // and the legacy (string, encoding, offset)
+  if (!isFinite(offset)) {
+    var swap = encoding;
+    encoding = offset;
+    offset = swap;
+  }
+
+  offset = +offset || 0;
+  encoding = String(encoding || 'utf8').toLowerCase();
+
+  switch (encoding) {
+    case 'utf8':
+    case 'utf-8':
+      return this.utf8Write(string, offset);
+
+    case 'ascii':
+      return this.asciiWrite(string, offset);
+
+    case 'binary':
+      return this.binaryWrite(string, offset);
+
+    case 'base64':
+      return this.base64Write(string, offset);
+
+    default:
+      throw new Error('Unknown encoding');
+  }
+};
+
+
+// slice(start, end)
+SlowBuffer.prototype.slice = function(start, end) {
+  if (end > this.length) {
+    throw new Error('oob');
+  }
+  if (start > end) {
+    throw new Error('oob');
+  }
+
+  return new Buffer(this, end - start, +start);
+};
+
+exports.Buffer = exports.SlowBuffer = SlowBuffer;
+
+// TODO: reintroduce some of the enhancements from node 0.3
+

data/packages/ivory/lib/events.js

@@ -0,0 +1,137 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+var EventEmitter = require('./ruby/events').EventEmitter;
+exports.EventEmitter = EventEmitter;
+
+var isArray = Array.isArray;
+
+EventEmitter.prototype.emit = function(type) {
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events || !this._events.error ||
+        (isArray(this._events.error) && !this._events.error.length))
+    {
+      if (arguments[1] instanceof Error) {
+        throw arguments[1]; // Unhandled 'error' event
+      } else {
+        throw new Error("Uncaught, unspecified 'error' event.");
+      }
+      return false;
+    }
+  }
+
+  if (!this._events) return false;
+  var handler = this._events[type];
+  if (!handler) return false;
+
+  if (typeof handler == 'function') {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        var args = Array.prototype.slice.call(arguments, 1);
+        handler.apply(this, args);
+    }
+    return true;
+
+  } else if (isArray(handler)) {
+    var args = Array.prototype.slice.call(arguments, 1);
+
+    var listeners = handler.slice();
+    for (var i = 0, l = listeners.length; i < l; i++) {
+      listeners[i].apply(this, args);
+    }
+    return true;
+
+  } else {
+    return false;
+  }
+};
+
+// EventEmitter is defined in src/node_events.cc
+// EventEmitter.prototype.emit() is also defined there.
+EventEmitter.prototype.addListener = function(type, listener) {
+  if ('function' !== typeof listener) {
+    throw new Error('addListener only takes instances of Function');
+  }
+
+  if (!this._events) this._events = {};
+
+  // To avoid recursion in the case that type == "newListeners"! Before
+  // adding it to the listeners, first emit "newListeners".
+  this.emit('newListener', type, listener);
+
+  if (!this._events[type]) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  } else if (isArray(this._events[type])) {
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  } else {
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  var self = this;
+  self.on(type, function g() {
+    self.removeListener(type, g);
+    listener.apply(this, arguments);
+  });
+};
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+  if ('function' !== typeof listener) {
+    throw new Error('removeListener only takes instances of Function');
+  }
+
+  // does not use listeners(), so no side effect of creating _events[type]
+  if (!this._events || !this._events[type]) return this;
+
+  var list = this._events[type];
+
+  if (isArray(list)) {
+    var i = list.indexOf(listener);
+    if (i < 0) return this;
+    list.splice(i, 1);
+    if (list.length == 0)
+      delete this._events[type];
+  } else if (this._events[type] === listener) {
+    delete this._events[type];
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  // does not use listeners(), so no side effect of creating _events[type]
+  if (type && this._events && this._events[type]) this._events[type] = null;
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  if (!this._events) this._events = {};
+  if (!this._events[type]) this._events[type] = [];
+  if (!isArray(this._events[type])) {
+    this._events[type] = [this._events[type]];
+  }
+  return this._events[type];
+};

data/packages/ivory/lib/fs.js

@@ -0,0 +1,266 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+// borrows from node.js
+var Buffer  = require('./buffer').Buffer;
+
+var util = require('./util');
+
+var binding = require('./ruby/fs');
+var constants = require('./ruby/constants');
+var fs = exports;
+
+for(var key in constants) fs[key] = constants[key];
+
+fs.STDIN = binding.stdin;
+fs.STDOUT = binding.stdout;
+
+fs.Stats = binding.Stats;
+
+fs.Stats.prototype._checkModeProperty = function(property) {
+  return ((this.mode & constants.S_IFMT) === property);
+};
+
+fs.Stats.prototype.isDirectory = function() {
+  return this._checkModeProperty(constants.S_IFDIR);
+};
+
+fs.Stats.prototype.isFile = function() {
+  return this._checkModeProperty(constants.S_IFREG);
+};
+
+fs.Stats.prototype.isBlockDevice = function() {
+  return this._checkModeProperty(constants.S_IFBLK);
+};
+
+fs.Stats.prototype.isCharacterDevice = function() {
+  return this._checkModeProperty(constants.S_IFCHR);
+};
+
+fs.Stats.prototype.isSymbolicLink = function() {
+  return this._checkModeProperty(constants.S_IFLNK);
+};
+
+fs.Stats.prototype.isFIFO = function() {
+  return this._checkModeProperty(constants.S_IFIFO);
+};
+
+fs.Stats.prototype.isSocket = function() {
+  return this._checkModeProperty(constants.S_IFSOCK);
+};
+
+fs.readFile = function(path, encoding_) {
+  var encoding = typeof(encoding_) === 'string' ? encoding_ : null;
+  var callback = arguments[arguments.length - 1];
+  if (typeof(callback) !== 'function') callback = null;
+  return binding.readFile(path, encoding, callback);
+};
+
+
+// Used by binding.open and friends
+function stringToFlags(flag) {
+  // Only mess with strings
+  if (typeof flag !== 'string') {
+    return flag;
+  }
+  switch (flag) {
+    case 'r':
+      return constants.O_RDONLY;
+
+    case 'r+':
+      return constants.O_RDWR;
+
+    case 'w':
+      return constants.O_CREAT | constants.O_TRUNC | constants.O_WRONLY;
+
+    case 'w+':
+      return constants.O_CREAT | constants.O_TRUNC | constants.O_RDWR;
+
+    case 'a':
+      return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY;
+
+    case 'a+':
+      return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR;
+
+    default:
+      throw new Error('Unknown file open flag: ' + flag);
+  }
+}
+
+function noop() {}
+
+// Yes, the follow could be easily DRYed up but I provide the explicit
+// list to make the arguments clear.
+
+fs.close = function(fd, callback) {
+  binding.close(fd, callback);
+};
+
+fs.open = function(path, flags, mode_, callback) {
+  var mode = (typeof(mode_) === 'number' ? mode_ : 0666);
+  var callback_ = arguments[arguments.length - 1];
+  callback = (typeof(callback_) == 'function' ? callback_ : null);
+
+  return binding.open(path, stringToFlags(flags), mode, callback);
+};
+
+fs.read = function(fd, buffer, offset, length, position, callback) {
+  return binding.read(fd, buffer, offset, length, position, callback);
+};
+
+fs.write = function(fd, buffer, offset, length, position, callback) {
+  return binding.write(fd, buffer, offset, length, position, callback);
+};
+
+fs.rename = function(oldPath, newPath, callback) {
+  return binding.rename(oldPath, newPath, callback);
+};
+
+fs.truncate = function(fd, len, callback) {
+  return binding.truncate(fd, len, callback);
+};
+
+fs.rmdir = function(path, callback) {
+  return binding.rmdir(path, callback);
+};
+
+fs.fdatasync = function(fd, callback) {
+  return binding.fdatasync(fd, callback);
+};
+
+fs.fsync = function(fd, callback) {
+  return binding.fsync(fd, callback);
+};
+
+fs.mkdir = function(path, mode, callback) {
+  return binding.mkdir(path, mode, callback);
+};
+
+fs.mkdir_p = function(path, mode, callback) {
+  return binding.mkdir_p(path, mode, callback);
+};
+
+fs.sendfile = function(outFd, inFd, inOffset, length, callback) {
+  return binding.sendfile(outFd, inFd, inOffset, length, callback);
+};
+
+fs.readdir = function(path, callback) {
+  return binding.readdir(path, callback);
+};
+
+fs.readdir_p = function(path, callback) {
+  if (!fs.exists(path)) {
+    if (callback) callback(null, []);
+    else return [];
+  } else return fs.readdir(path, callback);
+};
+
+fs.fstat = function(fd, callback) {
+  return binding.fstat(fd, callback);
+};
+
+fs.lstat = function(path, callback) {
+  return binding.lstat(path, callback);
+};
+
+fs.stat = function(path, callback) {
+  return binding.stat(path, callback);
+};
+
+fs.readlink = function(path, callback) {
+  return binding.readlink(path, callback);
+};
+
+fs.symlink = function(destination, path, callback) {
+  return binding.symlink(destination, path, callback);
+};
+
+fs.link = function(srcpath, dstpath, callback) {
+  return binding.link(srcpath, dstpath, callback);
+};
+
+fs.unlink = function(path, callback) {
+  return binding.unlink(path, callback);
+};
+
+fs.chmod = function(path, mode, callback) {
+  return binding.chmod(path, mode, callback);
+};
+
+fs.chown = function(path, uid, gid, callback) {
+  return binding.chown(path, uid, gid, callback);
+};
+
+function writeAll(fd, buffer, offset, length, callback) {
+  // write(fd, buffer, offset, length, position, callback)
+  fs.write(fd, buffer, offset, length, offset, function(writeErr, written) {
+    if (writeErr) {
+      fs.close(fd, function() {
+        if (callback) callback(writeErr);
+      });
+    } else {
+      if (written === length) {
+        fs.close(fd, callback);
+      } else {
+        writeAll(fd, buffer, offset + written, length - written, callback);
+      }
+    }
+  });
+}
+
+fs.writeFile = function(path, data, encoding_, callback) {
+  var encoding = (typeof(encoding_) == 'string' ? encoding_ : 'utf8');
+  var callback_ = arguments[arguments.length - 1];
+  callback = (typeof(callback_) == 'function' ? callback_ : null);
+  binding.writeFile(path, data, encoding, callback);
+};
+
+// Stat Change Watchers
+
+var statWatchers = {};
+
+fs.watchFile = function(filename) {
+  var stat;
+  var options;
+  var listener;
+
+  if ('object' == typeof arguments[1]) {
+    options = arguments[1];
+    listener = arguments[2];
+  } else {
+    options = {};
+    listener = arguments[1];
+  }
+
+  if (options.persistent === undefined) options.persistent = true;
+  if (options.interval === undefined) options.interval = 0;
+
+  if (statWatchers[filename]) {
+    stat = statWatchers[filename];
+  } else {
+    statWatchers[filename] = new binding.StatWatcher();
+    stat = statWatchers[filename];
+    stat.start(filename, options.persistent, options.interval);
+  }
+  stat.addListener('change', listener);
+  return stat;
+};
+
+fs.unwatchFile = function(filename) {
+  var stat;
+  if (statWatchers[filename]) {
+    stat = statWatchers[filename];
+    stat.stop();
+    statWatchers[filename] = undefined;
+  }
+};
+
+fs.exists = function(path, callback) {
+  var ret = binding.exists(path);
+  if (callback) callback(false, ret);
+  return ret ;
+};
+