spade-packager 0.1.0

data/packages/ivory/lib/ruby/events.rb

@@ -0,0 +1,32 @@
+# ==========================================================================
+# Project:   Ivory
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+module Ivory
+  class EventEmitterExports < Spade::Runtime::Exports
+
+    class EventEmitter
+      attr_accessor :_events
+
+      def emit(e, *args)
+        return unless @_events
+        case notify = @_events[e]
+        when V8::Function
+          notify.methodcall(self, *args)
+        when V8::Array
+          notify.each {|listener| listener.methodcall(self, *args) if listener}
+        else
+          return false
+        end
+        return true
+      end
+
+    end
+        
+  end
+
+end
+
+Spade.exports = Ivory::EventEmitterExports

data/packages/ivory/lib/ruby/fs.rb

@@ -0,0 +1,245 @@
+# ==========================================================================
+# Project:   Ivory
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'fileutils'
+
+module Ivory
+  class Fs < Spade::Runtime::Exports
+  
+    def initialize(ctx)
+      @ctx = ctx
+      @descriptors = {}
+      @descriptors[STDOUT] = Class.new do
+        def self.write(chars)
+          $stdout.write(chars.pack("C*"))
+        end
+      end
+    end
+
+    def stdin
+      $stdin
+    end
+    
+    def stdout
+      $stdout
+    end
+    
+    def readFile(path, encoding, callback = nil)
+      async(callback) do
+        File.read(path)
+      end
+    end
+    
+    def writeFile(path, data, encoding, callback=nil)
+      async(callback) do
+        File.open(path, 'w+') { |fd| fd.write(data); }
+      end
+    end
+    
+    def chmod(path, mode, callback = nil)
+      async(callback) do
+        File.chmod(mode, path)
+      end
+    end
+
+    def exists(path)
+      File.exists?(path)
+    end
+    
+    def open(path, flags, mode, callback = nil)
+      async(callback) do
+        file = File.new(path, flags, mode)
+        file.fileno.tap do |fd|
+          @descriptors[fd] = file
+        end
+      end
+    end
+
+    def close(fd, callback = nil)
+      async(callback) do
+        file(fd) do |f|
+          f.close()
+          @descriptors.delete(fd)
+        end
+      end
+    end
+
+    def read(fd, buffer, offset, length, position, callback = nil)
+      raise "Offset is out of bounds" unless offset <= buffer.length
+      raise "Length is extends beyond buffer" unless (offset + length) <= buffer.length
+      async(callback) do
+        file(fd) do |f|
+          f.seek(position) if position
+          data = buffer.send(:data)
+          bytes = f.read(length)
+          data[offset, bytes.length] = bytes.unpack('C*')
+          bytes.length
+        end
+      end
+    end
+
+    def write(fd, buffer, offset, length, position, callback = nil)
+      async(callback) do
+        file(fd) do |f|
+          f.seek(position) if position
+          data = buffer.send(:data)
+          f.write(data[offset, length])
+        end
+        length
+      end
+    end
+
+    def stat(path, callback = nil)
+      async(callback) do
+        Stats.new(File.stat(path))
+      end
+    end
+
+    def lstat(path, callback = nil)
+      async(callback) do
+        Stats.new(File.lstat(path))
+      end
+    end
+
+    def fstat(fd, callback = nil)
+      async(callback) do
+        file(fd) do |f|
+          Stats.new(f.stat)
+        end
+      end
+    end
+
+    def fsync(fd, callback = nil)
+      async(callback) do
+        file(fd) do |f|
+          f.fsync
+        end
+      end
+    end
+
+    def readlink(path, callback = nil)
+      async(callback) do
+        File.readlink(path)
+      end
+    end
+
+    def link(old_name, new_name, callback = nil)
+      async(callback) do
+        File.link(old_name, new_name)
+      end
+    end
+
+    def symlink(old_name, new_name, callback = nil)
+      async(callback) do
+        File.symlink(old_name, new_name)
+      end
+    end
+
+    def unlink(filename, callback = nil)
+      async(callback) do
+        File.unlink(filename)
+      end
+    end
+
+    def rename(old_name, new_name, callback = nil)
+      async(callback) do
+        File.rename(old_name, new_name)
+      end
+    end
+
+    def rmdir(dir, callback = nil)
+      async(callback) do
+        Dir.rmdir(dir)
+      end
+    end
+
+    def mkdir(name, mode, callback = nil)
+      async(callback) do
+        Dir.mkdir(name)
+      end
+    end
+
+    def mkdir_p(name, mode, callback = nil)
+      async(callback) do
+        FileUtils.mkdir_p(name, mode)
+      end
+    end
+
+    def readdir(path, callback = nil)
+      async(callback) do
+        Dir.entries(path).reject { |e| ['.', '..'].include?(e) }
+      end
+    end
+
+    #TODO: figure out how to call fdatasync from ruby
+    alias_method :fdatasync, :fsync
+
+    class Stats
+      def initialize(stat)
+        @stat = stat
+      end
+
+      def size
+        @stat.size
+      end
+
+      def mtime
+        @stat.mtime
+      end
+
+      def mode
+        @stat.mode
+      end
+
+      def isSymbolicLink(*a)
+        @stat.symlink?
+      end
+
+      def isDirectory(*a)
+        @stat.directory?
+      end
+
+      def dev
+        @stat.dev
+      end
+
+      def ino
+        @stat.ino
+      end
+    end
+
+    private
+
+    def file(fd)
+      if file = @descriptors[fd]
+        yield file
+      end
+    end
+
+    def async(callback)
+      if callback
+        begin
+          result = yield
+          begin
+            callback.call(false, result)
+          rescue Exception
+          end
+        rescue Exception => e
+          begin
+            callback.call(e,nil)
+          rescue Exception => e
+          end
+        end
+      else
+        yield
+      end
+    end
+  end
+end
+
+Spade.exports = Ivory::Fs
+
+

data/packages/ivory/lib/ruby/process.rb

@@ -0,0 +1,28 @@
+# ==========================================================================
+# Project:   Ivory
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+module Ivory
+  
+  class Process
+
+    def initialize(ctx=nil)
+      @ctx = ctx
+    end
+    
+    # *args req to make this appear as a func
+    def cwd(*args)
+      Dir.pwd
+    end
+    
+    def stdout
+      $stdout
+    end
+        
+  end
+  
+end
+
+Spade.exports = Ivory::Process

data/packages/ivory/lib/stream.js

@@ -0,0 +1,115 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+var events = require('./events');
+var util = require('./util');
+
+function Stream() {
+  events.EventEmitter.call(this);
+}
+util.inherits(Stream, events.EventEmitter);
+exports.Stream = Stream;
+
+Stream.prototype.pipe = function(dest /* options, filter */) {
+  var source = this;
+
+  // parse arguments
+  var options, filter;
+  if (typeof arguments[1] == 'object') {
+    options = arguments[1];
+    filter = arguments[2];
+  } else {
+    filter = arguments[1];
+  }
+
+  function ondata(chunk) {
+    // FIXME shouldn't need to test writable - this is working around bug.
+    // .writable should not change before a 'end' event is fired.
+    if (dest.writable) {
+      if (false === dest.write(chunk)) source.pause();
+    }
+  }
+
+  if (!filter) {
+    source.on('data', ondata);
+  } else {
+    //
+    // TODO: needs tests
+    //
+    var wait = false;
+    var waitQueue = [];
+
+    function done () {
+      wait = false;
+      // Drain the waitQueue
+      if (dest.writable && waitQueue.length) {
+        wait = true;
+        filter(waitQueue.shift(), ondata, done);
+      }
+    }
+
+    source.on('data', function (d) {
+      if (wait) {
+        waitQueue.push(d);
+        source.pause();
+      } else {
+        wait = true;
+        filter(d, ondata, done);
+      }
+    });
+  }
+
+
+  function ondrain() {
+    if (source.readable) source.resume();
+  }
+
+  dest.on('drain', ondrain);
+
+  /*
+   * If the 'end' option is not supplied, dest.end() will be called when
+   * source gets the 'end' event.
+   */
+
+  if (!options || options.end !== false) {
+    function onend() {
+      dest.end();
+    }
+
+    source.on('end', onend);
+  }
+
+  dest.on('close', function() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+    source.removeListener('end', onend);
+  });
+
+
+  /*
+   * Questionable:
+   */
+
+  if (!source.pause) {
+    source.pause = function() {
+      source.emit('pause');
+    };
+  }
+
+  if (!source.resume) {
+    source.resume = function() {
+      source.emit('resume');
+    };
+  }
+
+  dest.on('pause', function() {
+    source.pause();
+  });
+
+  dest.on('resume', function() {
+    if (source.readable) source.resume();
+  });
+};

data/packages/ivory/lib/util.js

@@ -0,0 +1,414 @@
+// ==========================================================================
+// Project:   Ivory
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license
+// ==========================================================================
+
+var process = require('./ruby/process');
+var events  = require('./events');
+
+
+exports.print = function() {
+  for (var i = 0, len = arguments.length; i < len; ++i) {
+    process.stdout.write(String(arguments[i]));
+  }
+};
+
+
+exports.puts = function() {
+  for (var i = 0, len = arguments.length; i < len; ++i) {
+    process.stdout.write(arguments[i] + '\n');
+  }
+};
+
+exports.println = exports.puts;
+
+exports.debug = function(x) {
+  console.debug(x);
+};
+
+
+exports.error = function(x) {
+  console.error(x);
+};
+var error = exports.error;
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Boolean} showHidden Flag that shows hidden (not enumerable)
+ *    properties of objects.
+ * @param {Number} depth Depth in which to descend in object. Default is 2.
+ * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
+ *    output. Default is false (no coloring).
+ */
+exports.inspect = function(obj, showHidden, depth, colors) {
+  var seen = [];
+
+  var stylize = function(str, styleType) {
+    // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+    var styles =
+        { 'bold' : [1, 22],
+          'italic' : [3, 23],
+          'underline' : [4, 24],
+          'inverse' : [7, 27],
+          'white' : [37, 39],
+          'grey' : [90, 39],
+          'black' : [30, 39],
+          'blue' : [34, 39],
+          'cyan' : [36, 39],
+          'green' : [32, 39],
+          'magenta' : [35, 39],
+          'red' : [31, 39],
+          'yellow' : [33, 39] };
+
+    var style =
+        { 'special': 'cyan',
+          'number': 'blue',
+          'boolean': 'yellow',
+          'undefined': 'grey',
+          'null': 'bold',
+          'string': 'green',
+          'date': 'magenta',
+          // "name": intentionally not styling
+          'regexp': 'red' }[styleType];
+
+    if (style) {
+      return '\033[' + styles[style][0] + 'm' + str +
+             '\033[' + styles[style][1] + 'm';
+    } else {
+      return str;
+    }
+  };
+  if (! colors) {
+    stylize = function(str, styleType) { return str; };
+  }
+
+  function format(value, recurseTimes) {
+    // Provide a hook for user-specified inspect functions.
+    // Check that value is an object with an inspect function on it
+    if (value && typeof value.inspect === 'function' &&
+        // Filter out the util module, it's inspect function is special
+        value !== exports &&
+        // Also filter out any prototype objects using the circular check.
+        !(value.constructor && value.constructor.prototype === value)) {
+      return value.inspect(recurseTimes);
+    }
+
+    // Primitive types cannot have properties
+    switch (typeof value) {
+      case 'undefined':
+        return stylize('undefined', 'undefined');
+
+      case 'string':
+        var simple = JSON.stringify(value).replace(/'/g, "\\'")
+                                          .replace(/\\"/g, '"')
+                                          .replace(/(^"|"$)/g, "'");
+        return stylize(simple, 'string');
+
+      case 'number':
+        return stylize('' + value, 'number');
+
+      case 'boolean':
+        return stylize('' + value, 'boolean');
+    }
+    // For some reason typeof null is "object", so special case here.
+    if (value === null) {
+      return stylize('null', 'null');
+    }
+
+    // Look up the keys of the object.
+    var visible_keys = Object.keys(value);
+    var keys = showHidden ? Object.getOwnPropertyNames(value) : visible_keys;
+
+    // Functions without properties can be shortcutted.
+    if (typeof value === 'function' && keys.length === 0) {
+      if (isRegExp(value)) {
+        return stylize('' + value, 'regexp');
+      } else {
+        var name = value.name ? ': ' + value.name : '';
+        return stylize('[Function' + name + ']', 'special');
+      }
+    }
+
+    // Dates without properties can be shortcutted
+    if (isDate(value) && keys.length === 0) {
+      return stylize(value.toUTCString(), 'date');
+    }
+
+    var base, type, braces;
+    // Determine the object type
+    if (isArray(value)) {
+      type = 'Array';
+      braces = ['[', ']'];
+    } else {
+      type = 'Object';
+      braces = ['{', '}'];
+    }
+
+    // Make functions say that they are functions
+    if (typeof value === 'function') {
+      var n = value.name ? ': ' + value.name : '';
+      base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
+    } else {
+      base = '';
+    }
+
+    // Make dates with properties first say the date
+    if (isDate(value)) {
+      base = ' ' + value.toUTCString();
+    }
+
+    if (keys.length === 0) {
+      return braces[0] + base + braces[1];
+    }
+
+    if (recurseTimes < 0) {
+      if (isRegExp(value)) {
+        return stylize('' + value, 'regexp');
+      } else {
+        return stylize('[Object]', 'special');
+      }
+    }
+
+    seen.push(value);
+
+    var output = keys.map(function(key) {
+      var name, str;
+      if (value.__lookupGetter__) {
+        if (value.__lookupGetter__(key)) {
+          if (value.__lookupSetter__(key)) {
+            str = stylize('[Getter/Setter]', 'special');
+          } else {
+            str = stylize('[Getter]', 'special');
+          }
+        } else {
+          if (value.__lookupSetter__(key)) {
+            str = stylize('[Setter]', 'special');
+          }
+        }
+      }
+      if (visible_keys.indexOf(key) < 0) {
+        name = '[' + key + ']';
+      }
+      if (!str) {
+        if (seen.indexOf(value[key]) < 0) {
+          if (recurseTimes === null) {
+            str = format(value[key]);
+          } else {
+            str = format(value[key], recurseTimes - 1);
+          }
+          if (str.indexOf('\n') > -1) {
+            if (isArray(value)) {
+              str = str.split('\n').map(function(line) {
+                return '  ' + line;
+              }).join('\n').substr(2);
+            } else {
+              str = '\n' + str.split('\n').map(function(line) {
+                return '   ' + line;
+              }).join('\n');
+            }
+          }
+        } else {
+          str = stylize('[Circular]', 'special');
+        }
+      }
+      if (typeof name === 'undefined') {
+        if (type === 'Array' && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify('' + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.substr(1, name.length - 2);
+          name = stylize(name, 'name');
+        } else {
+          name = name.replace(/'/g, "\\'")
+                     .replace(/\\"/g, '"')
+                     .replace(/(^"|"$)/g, "'");
+          name = stylize(name, 'string');
+        }
+      }
+
+      return name + ': ' + str;
+    });
+
+    seen.pop();
+
+    var numLinesEst = 0;
+    var length = output.reduce(function(prev, cur) {
+      numLinesEst++;
+      if (cur.indexOf('\n') >= 0) numLinesEst++;
+      return prev + cur.length + 1;
+    }, 0);
+
+    if (length > (require('readline').columns || 50)) {
+      output = braces[0] +
+               (base === '' ? '' : base + '\n ') +
+               ' ' +
+               output.join(',\n  ') +
+               ' ' +
+               braces[1];
+
+    } else {
+      output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+    }
+
+    return output;
+  }
+  return format(obj, (typeof depth === 'undefined' ? 2 : depth));
+};
+
+
+function isArray(ar) {
+  return ar instanceof Array ||
+         Array.isArray(ar) ||
+         (ar && ar !== Object.prototype && isArray(ar.__proto__));
+}
+
+
+function isRegExp(re) {
+  var s = '' + re;
+  return re instanceof RegExp || // easy case
+         // duck-type for context-switching evalcx case
+         typeof(re) === 'function' &&
+         re.constructor.name === 'RegExp' &&
+         re.compile &&
+         re.test &&
+         re.exec &&
+         s.match(/^\/.*\/[gim]{0,3}$/);
+}
+
+
+function isDate(d) {
+  if (d instanceof Date) return true;
+  if (typeof d !== 'object') return false;
+  var properties = Date.prototype && Object.getOwnPropertyNames(Date.prototype);
+  var proto = d.__proto__ && Object.getOwnPropertyNames(d.__proto__);
+  return JSON.stringify(proto) === JSON.stringify(properties);
+}
+
+
+var pWarning;
+
+exports.p = function() {
+  if (!pWarning) {
+    pWarning = 'util.p will be removed in future versions of Node. ' +
+               'Use util.puts(util.inspect()) instead.\n';
+    exports.error(pWarning);
+  }
+  for (var i = 0, len = arguments.length; i < len; ++i) {
+    error(exports.inspect(arguments[i]));
+  }
+};
+
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+exports.log = function(msg) {
+  exports.puts(timestamp() + ' - ' + msg.toString());
+};
+
+
+var execWarning;
+exports.exec = function() {
+  if (!execWarning) {
+    execWarning = 'util.exec has moved to the "child_process" module.' +
+                  ' Please update your source code.';
+    error(execWarning);
+  }
+  return require('child_process').exec.apply(this, arguments);
+};
+
+
+exports.pump = function(readStream, writeStream, callback) {
+  var callbackCalled = false;
+
+  function call(a, b, c) {
+    if (callback && !callbackCalled) {
+      callback(a, b, c);
+      callbackCalled = true;
+    }
+  }
+
+  if (!readStream.pause) {
+    readStream.pause = function() {readStream.emit('pause');};
+  }
+
+  if (!readStream.resume) {
+    readStream.resume = function() {readStream.emit('resume');};
+  }
+
+  readStream.addListener('data', function(chunk) {
+    if (writeStream.write(chunk) === false) readStream.pause();
+  });
+
+  writeStream.addListener('pause', function() {
+    readStream.pause();
+  });
+
+  writeStream.addListener('drain', function() {
+    readStream.resume();
+  });
+
+  writeStream.addListener('resume', function() {
+    readStream.resume();
+  });
+
+  readStream.addListener('end', function() {
+    writeStream.end();
+  });
+
+  readStream.addListener('close', function() {
+    call();
+  });
+
+  readStream.addListener('error', function(err) {
+    writeStream.end();
+    call(err);
+  });
+
+  writeStream.addListener('error', function(err) {
+    readStream.destroy();
+    call(err);
+  });
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be revritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ *     prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = function(ctor, superCtor) {
+  ctor.super_ = superCtor;
+  ctor.prototype = Object.create(superCtor.prototype, {
+    constructor: { value: ctor, enumerable: false }
+  });
+};