spade 0.0.8.1 → 0.1.0

data/packages/ivory/lib/main.js

@@ -1,13 +0,0 @@
-// ==========================================================================
-// Project:   Ivory
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license
-// ==========================================================================
-/*globals process Buffer $fs $path $util */
-
-process = require('./ruby/process');
-Buffer  = require('./buffer').Buffer ;
-
-$fs   = require('./fs');
-$path = require('./path');
-$util = require('./util');

data/packages/ivory/lib/path.js

@@ -1,158 +0,0 @@
-// ==========================================================================
-// Project:   Ivory
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license
-// ==========================================================================
-
-var process = require('./ruby/process');
-
-function validPathPart(p, keepBlanks) {
-  return typeof p === 'string' && (p || keepBlanks);
-}
-
-exports.cwd = function() { return process.cwd(); };
-
-exports.join = function() {
-  var args = Array.prototype.slice.call(arguments);
-  // edge case flag to switch into url-resolve-mode
-  var keepBlanks = false;
-  if (args[args.length - 1] === true) {
-    keepBlanks = args.pop();
-  }
-  // return exports.split(args.join("/"), keepBlanks).join("/");
-  var joined = exports.normalizeArray(args, keepBlanks).join('/');
-  return joined;
-};
-
-
-exports.split = function(path, keepBlanks) {
-  // split based on /, but only if that / is not at the start or end.
-  return exports.normalizeArray(path.split(/^|\/(?!$)/), keepBlanks);
-};
-
-
-function cleanArray(parts, keepBlanks) {
-  var i = 0;
-  var l = parts.length - 1;
-  var stripped = false;
-
-  // strip leading empty args
-  while (i < l && !validPathPart(parts[i], keepBlanks)) {
-    stripped = true;
-    i++;
-  }
-
-  // strip tailing empty args
-  while (l >= i && !validPathPart(parts[l], keepBlanks)) {
-    stripped = true;
-    l--;
-  }
-
-  if (stripped) {
-    // if l chopped all the way back to i, then this is empty
-    parts = Array.prototype.slice.call(parts, i, l + 1);
-  }
-
-  return parts.filter(function(p) { return validPathPart(p, keepBlanks); })
-              .join('/')
-              .split(/^|\/(?!$)/);
-}
-
-
-exports.normalizeArray = function(original, keepBlanks) {
-  var parts = cleanArray(original, keepBlanks);
-  if (!parts.length || (parts.length === 1 && !parts[0])) return ['.'];
-
-  // now we're fully ready to rock.
-  // leading/trailing invalids have been stripped off.
-  // if it comes in starting with a slash, or ending with a slash,
-  var leadingSlash = (parts[0].charAt(0) === '/');
-
-  if (leadingSlash) parts[0] = parts[0].substr(1);
-  var last = parts.slice(-1)[0];
-  var tailingSlash = (last.substr(-1) === '/');
-  if (tailingSlash) parts[parts.length - 1] = last.slice(0, -1);
-  var directories = [];
-  var prev;
-  for (var i = 0, l = parts.length - 1; i <= l; i++) {
-    var directory = parts[i];
-
-    // if it's blank, and we're not keeping blanks, then skip it.
-    if (directory === '' && !keepBlanks) continue;
-
-    // if it's a dot, then skip it
-    if (directory === '.' && (directories.length ||
-        (i === 0 && !(tailingSlash && i === l)) ||
-        (i === 0 && leadingSlash))) continue;
-
-    // if we're dealing with an absolute path, then discard ..s that go
-    // above that the base.
-    if (leadingSlash && directories.length === 0 && directory === '..') {
-      continue;
-    }
-    // trying to go up a dir
-    if (directory === '..' && directories.length && prev !== '..' &&
-        prev !== undefined) {
-      directories.pop();
-      prev = directories.slice(-1)[0];
-    } else {
-      directories.push(directory);
-      prev = directory;
-    }
-  }
-  if (!directories.length) {
-    directories = [leadingSlash || tailingSlash ? '' : '.'];
-  }
-  
-  last = directories.slice(-1)[0];
-  if (tailingSlash && last.substr(-1) !== '/') {
-    directories[directories.length - 1] += '/';
-  }
-  if (leadingSlash && directories[0].charAt(0) !== '/') {
-    if (directories[0] === '.') directories[0] = '';
-    directories[0] = '/' + directories[0];
-  }
-  return directories;
-};
-
-
-exports.normalize = function(path, keepBlanks) {
-  return exports.join(path, keepBlanks || false);
-};
-
-
-exports.dirname = function(path) {
-  if (path.length > 1 && '/' === path[path.length - 1]) {
-    path = path.replace(/\/+$/, '');
-  }
-  var lastSlash = path.lastIndexOf('/');
-  switch (lastSlash) {
-    case -1:
-      return '.';
-    case 0:
-      return '/';
-    default:
-      return path.substring(0, lastSlash);
-  }
-};
-
-
-exports.basename = function(path, ext) {
-  var f = path.substr(path.lastIndexOf('/') + 1);
-  if (ext && f.substr(-1 * ext.length) === ext) {
-    f = f.substr(0, f.length - ext.length);
-  }
-  return f;
-};
-
-
-exports.extname = function(path) {
-  var dot = path.lastIndexOf('.'),
-      slash = path.lastIndexOf('/');
-  // The last dot must be in the last path component, and it (the last dot) must
-  // not start the last path component (i.e. be a dot that signifies a hidden
-  // file in UNIX).
-  return dot <= slash + 1 ? '' : path.substring(dot);
-};
-
-exports.exists = require('./fs').exists;

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

@@ -1,145 +0,0 @@
-# ==========================================================================
-# Project:   Ivory
-# Copyright: ©2010 Strobe Inc. All rights reserved.
-# License:   Licened under MIT license (see LICENSE)
-# ==========================================================================
-
-require 'v8'
-
-module Ivory
-  class BufferModule < Spade::Exports
-    
-    class SlowBuffer
-      attr_reader :data
-      protected :data
-
-      def initialize(opt, *args)
-        case opt
-        when Numeric
-          @data = Array.new(opt.to_i, 0)
-        when V8::Array
-          @data = opt.to_a
-        when String
-          encoding = *args
-          @data = case encoding
-          when 'ascii'                        then opt.unpack('U*')
-          when 'utf8','utf-8','binary',nil    then opt.unpack('C*')
-          when 'base64'
-            (opt + "=" * (4 - opt.length % 4)).unpack('m').first.unpack('C*')
-          else
-            raise "Unknown encoding"
-          end
-        when self.class
-          start, stop = *args
-          @data = opt.send(:data)[start..stop-1]
-        else
-          raise "Bad argument"
-        end
-      end
-      
-      def length
-        @data.length
-      end
-
-      def [](index)
-        index.kind_of?(Numeric) ? @data[index] : yield
-      end
-
-      def []=(index, value)
-        index.kind_of?(Numeric) ? @data[index] = value : yield
-      end
-
-      def slice(start, stop)
-        SlowBuffer.new(self, start, stop)
-      end
-
-      def unpack(format, index)
-        raise ArgumentError, "Argument must be a string" unless format.kind_of?(String)
-        @data[index..-1].pack('C*').unpack(format).tap do |array|
-          raise ArgumentError, "Out of bounds" if array.last.nil?
-        end
-      end
-
-      def utf8Slice(start, stop)
-        @data[start..stop-1].pack('C*')
-      end
-
-      def asciiSlice(start, stop)
-        raise ArgumentError, "Bad argument." unless start.kind_of?(Numeric) && stop.kind_of?(Numeric)
-        raise ArgumentError, "Bad argument." if start < 0 || stop < 0
-        raise ArgumentError, "Must have start <= end" unless start <= stop
-        raise ArgumentError, "end cannot be longer than parent" if stop > @data.length
-
-        @data[start..stop-1].pack('C*').tap do |slice|
-          # puts "Buffer(#{self.length}).asciiSlice(#{start}, #{stop}) -> #{slice}"
-        end
-      end
-
-      def binarySlice(start, stop)
-        @data[start..stop-1]
-      end
-
-      def base64Slice(start, stop)
-        [@data[start..stop-1].pack('C*')].pack('m').gsub(/\n/,'')
-      end
-
-      def utf8Write(string, offset)
-        written = 0
-        string.scan(/./mu) do |codepoint|
-          bytes = codepoint.unpack('C*')
-          if bytes.length <= self.length - offset - written
-            @data[offset + written, bytes.length] = bytes
-            written += bytes.length
-          end
-        end
-        return written
-      end
-
-      def asciiWrite(string, offset)
-        raise "Argument must be a string" unless string.kind_of?(String)
-        raise "Offset is out of bounds" if string.length > 0 && offset >= self.length
-        to_write = [string.length, self.length - offset].min
-        @data[offset, to_write] = string.unpack('C*')
-        to_write
-      end
-
-      def binaryWrite(string, offset)
-        raise "Argument must be a string" unless string.kind_of?(String)
-        0
-      end
-
-      def base64Write(string, offset)
-        return 0 if offset == 0 && self.length == 0
-        raise "Offset is out of bounds" if offset >= self.length
-        bytes = string.unpack('m').first.unpack('C*')
-        raise "Buffer too small" if bytes.length > (self.length - offset)
-        @data[offset, bytes.length] = bytes
-        bytes.length
-      end
-
-      def copy(target, position, start, finish = self.length)
-        raise "First arg should be a Buffer" unless target.kind_of?(self.class)
-        raise "sourceEnd < sourceStart" if finish < start
-        return 0 if start == finish
-
-        raise "targetStart out of bounds" if position < 0 || position >= target.length
-        raise "sourceStart out of bounds" if start < 0 || start >= self.length
-        raise "sourceEnd out of bounds" if finish < 0 || finish > self.length
-
-        to_copy = [finish - start, target.length - position].min.tap do |bytes|
-          for i in 0..bytes - 1
-            target[i] = self[i]
-          end
-        end
-      end
-      
-      def to_s
-        @data.pack("C*")
-      end
-      
-    end
-  end
-end
-
-Spade.exports = Ivory::BufferModule
-

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

@@ -1,585 +0,0 @@
-# ==========================================================================
-# Project:   Ivory
-# Copyright: ©2010 Strobe Inc. All rights reserved.
-# License:   Licened under MIT license (see LICENSE)
-# ==========================================================================
-
-module Ivory
-  class Constants < Spade::Exports
-    
-    def self.defc(name, value)
-      self.send(:define_method, name) do ||
-        value
-      end
-    end
-
-    #   NODE_DEFINE_CONSTANT(target, EV_MINPRI);
-    #   NODE_DEFINE_CONSTANT(target, EV_MAXPRI);
-    # 
-    #   // file access modes
-    #   NODE_DEFINE_CONSTANT(target, O_RDONLY);
-    #   NODE_DEFINE_CONSTANT(target, O_WRONLY);
-    #   NODE_DEFINE_CONSTANT(target, O_RDWR);
-
-    defc :O_RDONLY, File::RDONLY
-    defc :O_WRONLY, File::WRONLY
-    defc :O_RDWR, File::RDWR
-
-    # 
-    #   NODE_DEFINE_CONSTANT(target, S_IFMT);
-    #   NODE_DEFINE_CONSTANT(target, S_IFREG);
-    #   NODE_DEFINE_CONSTANT(target, S_IFDIR);
-    #   NODE_DEFINE_CONSTANT(target, S_IFCHR);
-    #   NODE_DEFINE_CONSTANT(target, S_IFBLK);
-    #   NODE_DEFINE_CONSTANT(target, S_IFIFO);
-    #   NODE_DEFINE_CONSTANT(target, S_IFLNK);
-    #   NODE_DEFINE_CONSTANT(target, S_IFSOCK);
-    # 
-    # #ifdef O_CREAT
-    #   NODE_DEFINE_CONSTANT(target, O_CREAT);
-    # #endif
-    defc :O_CREAT, File::CREAT
-    # 
-    # #ifdef O_EXCL
-    #   NODE_DEFINE_CONSTANT(target, O_EXCL);
-    # #endif
-    defc :OEXCL, File::EXCL
-    # 
-    # #ifdef O_NOCTTY
-    #   NODE_DEFINE_CONSTANT(target, O_NOCTTY);
-    # #endif
-    defc :OEXCL, File::EXCL
-    # 
-    # #ifdef O_TRUNC
-    #   NODE_DEFINE_CONSTANT(target, O_TRUNC);
-    # #endif
-    defc :O_TRUNC, File::TRUNC
-    # 
-    # #ifdef O_APPEND
-    #   NODE_DEFINE_CONSTANT(target, O_APPEND);
-    # #endif
-    # 
-    # #ifdef O_DIRECTORY
-    #   NODE_DEFINE_CONSTANT(target, O_DIRECTORY);
-    # #endif
-    # 
-    # #ifdef O_EXCL
-    #   NODE_DEFINE_CONSTANT(target, O_EXCL);
-    # #endif
-    # 
-    # #ifdef O_NOFOLLOW
-    #   NODE_DEFINE_CONSTANT(target, O_NOFOLLOW);
-    # #endif
-    # 
-    # #ifdef O_SYNC
-    #   NODE_DEFINE_CONSTANT(target, O_SYNC);
-    # #endif
-    # 
-    # #ifdef S_IRWXU
-    #   NODE_DEFINE_CONSTANT(target, S_IRWXU);
-    # #endif
-    # 
-    # 
-    # #ifdef S_IRUSR
-    #   NODE_DEFINE_CONSTANT(target, S_IRUSR);
-    # #endif
-    # 
-    # #ifdef S_IWUSR
-    #   NODE_DEFINE_CONSTANT(target, S_IWUSR);
-    # #endif
-    # 
-    # #ifdef S_IXUSR
-    #   NODE_DEFINE_CONSTANT(target, S_IXUSR);
-    # #endif
-    # 
-    # 
-    # #ifdef S_IRWXG
-    #   NODE_DEFINE_CONSTANT(target, S_IRWXG);
-    # #endif
-    # 
-    # 
-    # #ifdef S_IRGRP
-    #   NODE_DEFINE_CONSTANT(target, S_IRGRP);
-    # #endif
-    # 
-    # #ifdef S_IWGRP
-    #   NODE_DEFINE_CONSTANT(target, S_IWGRP);
-    # #endif
-    # 
-    # #ifdef S_IXGRP
-    #   NODE_DEFINE_CONSTANT(target, S_IXGRP);
-    # #endif
-    # 
-    # 
-    # #ifdef S_IRWXO
-    #   NODE_DEFINE_CONSTANT(target, S_IRWXO);
-    # #endif
-    # 
-    # 
-    # #ifdef S_IROTH
-    #   NODE_DEFINE_CONSTANT(target, S_IROTH);
-    # #endif
-    # 
-    # #ifdef S_IWOTH
-    #   NODE_DEFINE_CONSTANT(target, S_IWOTH);
-    # #endif
-    # 
-    # #ifdef S_IXOTH
-    #   NODE_DEFINE_CONSTANT(target, S_IXOTH);
-    # #endif
-    # 
-    # #ifdef E2BIG
-    #   NODE_DEFINE_CONSTANT(target, E2BIG);
-    # #endif
-    # 
-    # #ifdef EACCES
-    #   NODE_DEFINE_CONSTANT(target, EACCES);
-    # #endif
-    # 
-    # #ifdef EADDRINUSE
-    #   NODE_DEFINE_CONSTANT(target, EADDRINUSE);
-    # #endif
-    # 
-    # #ifdef EADDRNOTAVAIL
-    #   NODE_DEFINE_CONSTANT(target, EADDRNOTAVAIL);
-    # #endif
-    # 
-    # #ifdef EAFNOSUPPORT
-    #   NODE_DEFINE_CONSTANT(target, EAFNOSUPPORT);
-    # #endif
-    # 
-    # #ifdef EAGAIN
-    #   NODE_DEFINE_CONSTANT(target, EAGAIN);
-    # #endif
-    # 
-    # #ifdef EALREADY
-    #   NODE_DEFINE_CONSTANT(target, EALREADY);
-    # #endif
-    # 
-    # #ifdef EBADF
-    #   NODE_DEFINE_CONSTANT(target, EBADF);
-    # #endif
-    # 
-    # #ifdef EBADMSG
-    #   NODE_DEFINE_CONSTANT(target, EBADMSG);
-    # #endif
-    # 
-    # #ifdef EBUSY
-    #   NODE_DEFINE_CONSTANT(target, EBUSY);
-    # #endif
-    # 
-    # #ifdef ECANCELED
-    #   NODE_DEFINE_CONSTANT(target, ECANCELED);
-    # #endif
-    # 
-    # #ifdef ECHILD
-    #   NODE_DEFINE_CONSTANT(target, ECHILD);
-    # #endif
-    # 
-    # #ifdef ECONNABORTED
-    #   NODE_DEFINE_CONSTANT(target, ECONNABORTED);
-    # #endif
-    # 
-    # #ifdef ECONNREFUSED
-    #   NODE_DEFINE_CONSTANT(target, ECONNREFUSED);
-    # #endif
-    # 
-    # #ifdef ECONNRESET
-    #   NODE_DEFINE_CONSTANT(target, ECONNRESET);
-    # #endif
-    # 
-    # #ifdef EDEADLK
-    #   NODE_DEFINE_CONSTANT(target, EDEADLK);
-    # #endif
-    # 
-    # #ifdef EDESTADDRREQ
-    #   NODE_DEFINE_CONSTANT(target, EDESTADDRREQ);
-    # #endif
-    # 
-    # #ifdef EDOM
-    #   NODE_DEFINE_CONSTANT(target, EDOM);
-    # #endif
-    # 
-    # #ifdef EDQUOT
-    #   NODE_DEFINE_CONSTANT(target, EDQUOT);
-    # #endif
-    # 
-    # #ifdef EEXIST
-    #   NODE_DEFINE_CONSTANT(target, EEXIST);
-    # #endif
-    # 
-    # #ifdef EFAULT
-    #   NODE_DEFINE_CONSTANT(target, EFAULT);
-    # #endif
-    # 
-    # #ifdef EFBIG
-    #   NODE_DEFINE_CONSTANT(target, EFBIG);
-    # #endif
-    # 
-    # #ifdef EHOSTUNREACH
-    #   NODE_DEFINE_CONSTANT(target, EHOSTUNREACH);
-    # #endif
-    # 
-    # #ifdef EIDRM
-    #   NODE_DEFINE_CONSTANT(target, EIDRM);
-    # #endif
-    # 
-    # #ifdef EILSEQ
-    #   NODE_DEFINE_CONSTANT(target, EILSEQ);
-    # #endif
-    # 
-    # #ifdef EINPROGRESS
-    #   NODE_DEFINE_CONSTANT(target, EINPROGRESS);
-    # #endif
-    # 
-    # #ifdef EINTR
-    #   NODE_DEFINE_CONSTANT(target, EINTR);
-    # #endif
-    # 
-    # #ifdef EINVAL
-    #   NODE_DEFINE_CONSTANT(target, EINVAL);
-    # #endif
-    # 
-    # #ifdef EIO
-    #   NODE_DEFINE_CONSTANT(target, EIO);
-    # #endif
-    # 
-    # #ifdef EISCONN
-    #   NODE_DEFINE_CONSTANT(target, EISCONN);
-    # #endif
-    # 
-    # #ifdef EISDIR
-    #   NODE_DEFINE_CONSTANT(target, EISDIR);
-    # #endif
-    # 
-    # #ifdef ELOOP
-    #   NODE_DEFINE_CONSTANT(target, ELOOP);
-    # #endif
-    # 
-    # #ifdef EMFILE
-    #   NODE_DEFINE_CONSTANT(target, EMFILE);
-    # #endif
-    # 
-    # #ifdef EMLINK
-    #   NODE_DEFINE_CONSTANT(target, EMLINK);
-    # #endif
-    # 
-    # #ifdef EMSGSIZE
-    #   NODE_DEFINE_CONSTANT(target, EMSGSIZE);
-    # #endif
-    # 
-    # #ifdef EMULTIHOP
-    #   NODE_DEFINE_CONSTANT(target, EMULTIHOP);
-    # #endif
-    # 
-    # #ifdef ENAMETOOLONG
-    #   NODE_DEFINE_CONSTANT(target, ENAMETOOLONG);
-    # #endif
-    # 
-    # #ifdef ENETDOWN
-    #   NODE_DEFINE_CONSTANT(target, ENETDOWN);
-    # #endif
-    # 
-    # #ifdef ENETRESET
-    #   NODE_DEFINE_CONSTANT(target, ENETRESET);
-    # #endif
-    # 
-    # #ifdef ENETUNREACH
-    #   NODE_DEFINE_CONSTANT(target, ENETUNREACH);
-    # #endif
-    # 
-    # #ifdef ENFILE
-    #   NODE_DEFINE_CONSTANT(target, ENFILE);
-    # #endif
-    # 
-    # #ifdef ENOBUFS
-    #   NODE_DEFINE_CONSTANT(target, ENOBUFS);
-    # #endif
-    # 
-    # #ifdef ENODATA
-    #   NODE_DEFINE_CONSTANT(target, ENODATA);
-    # #endif
-    # 
-    # #ifdef ENODEV
-    #   NODE_DEFINE_CONSTANT(target, ENODEV);
-    # #endif
-    # 
-    # #ifdef ENOENT
-    #   NODE_DEFINE_CONSTANT(target, ENOENT);
-    # #endif
-    # 
-    # #ifdef ENOEXEC
-    #   NODE_DEFINE_CONSTANT(target, ENOEXEC);
-    # #endif
-    # 
-    # #ifdef ENOLCK
-    #   NODE_DEFINE_CONSTANT(target, ENOLCK);
-    # #endif
-    # 
-    # #ifdef ENOLINK
-    #   NODE_DEFINE_CONSTANT(target, ENOLINK);
-    # #endif
-    # 
-    # #ifdef ENOMEM
-    #   NODE_DEFINE_CONSTANT(target, ENOMEM);
-    # #endif
-    # 
-    # #ifdef ENOMSG
-    #   NODE_DEFINE_CONSTANT(target, ENOMSG);
-    # #endif
-    # 
-    # #ifdef ENOPROTOOPT
-    #   NODE_DEFINE_CONSTANT(target, ENOPROTOOPT);
-    # #endif
-    # 
-    # #ifdef ENOSPC
-    #   NODE_DEFINE_CONSTANT(target, ENOSPC);
-    # #endif
-    # 
-    # #ifdef ENOSR
-    #   NODE_DEFINE_CONSTANT(target, ENOSR);
-    # #endif
-    # 
-    # #ifdef ENOSTR
-    #   NODE_DEFINE_CONSTANT(target, ENOSTR);
-    # #endif
-    # 
-    # #ifdef ENOSYS
-    #   NODE_DEFINE_CONSTANT(target, ENOSYS);
-    # #endif
-    # 
-    # #ifdef ENOTCONN
-    #   NODE_DEFINE_CONSTANT(target, ENOTCONN);
-    # #endif
-    # 
-    # #ifdef ENOTDIR
-    #   NODE_DEFINE_CONSTANT(target, ENOTDIR);
-    # #endif
-    # 
-    # #ifdef ENOTEMPTY
-    #   NODE_DEFINE_CONSTANT(target, ENOTEMPTY);
-    # #endif
-    # 
-    # #ifdef ENOTSOCK
-    #   NODE_DEFINE_CONSTANT(target, ENOTSOCK);
-    # #endif
-    # 
-    # #ifdef ENOTSUP
-    #   NODE_DEFINE_CONSTANT(target, ENOTSUP);
-    # #endif
-    # 
-    # #ifdef ENOTTY
-    #   NODE_DEFINE_CONSTANT(target, ENOTTY);
-    # #endif
-    # 
-    # #ifdef ENXIO
-    #   NODE_DEFINE_CONSTANT(target, ENXIO);
-    # #endif
-    # 
-    # #ifdef EOPNOTSUPP
-    #   NODE_DEFINE_CONSTANT(target, EOPNOTSUPP);
-    # #endif
-    # 
-    # #ifdef EOVERFLOW
-    #   NODE_DEFINE_CONSTANT(target, EOVERFLOW);
-    # #endif
-    # 
-    # #ifdef EPERM
-    #   NODE_DEFINE_CONSTANT(target, EPERM);
-    # #endif
-    # 
-    # #ifdef EPIPE
-    #   NODE_DEFINE_CONSTANT(target, EPIPE);
-    # #endif
-    # 
-    # #ifdef EPROTO
-    #   NODE_DEFINE_CONSTANT(target, EPROTO);
-    # #endif
-    # 
-    # #ifdef EPROTONOSUPPORT
-    #   NODE_DEFINE_CONSTANT(target, EPROTONOSUPPORT);
-    # #endif
-    # 
-    # #ifdef EPROTOTYPE
-    #   NODE_DEFINE_CONSTANT(target, EPROTOTYPE);
-    # #endif
-    # 
-    # #ifdef ERANGE
-    #   NODE_DEFINE_CONSTANT(target, ERANGE);
-    # #endif
-    # 
-    # #ifdef EROFS
-    #   NODE_DEFINE_CONSTANT(target, EROFS);
-    # #endif
-    # 
-    # #ifdef ESPIPE
-    #   NODE_DEFINE_CONSTANT(target, ESPIPE);
-    # #endif
-    # 
-    # #ifdef ESRCH
-    #   NODE_DEFINE_CONSTANT(target, ESRCH);
-    # #endif
-    # 
-    # #ifdef ESTALE
-    #   NODE_DEFINE_CONSTANT(target, ESTALE);
-    # #endif
-    # 
-    # #ifdef ETIME
-    #   NODE_DEFINE_CONSTANT(target, ETIME);
-    # #endif
-    # 
-    # #ifdef ETIMEDOUT
-    #   NODE_DEFINE_CONSTANT(target, ETIMEDOUT);
-    # #endif
-    # 
-    # #ifdef ETXTBSY
-    #   NODE_DEFINE_CONSTANT(target, ETXTBSY);
-    # #endif
-    # 
-    # #ifdef EWOULDBLOCK
-    #   NODE_DEFINE_CONSTANT(target, EWOULDBLOCK);
-    # #endif
-    # 
-    # #ifdef EXDEV
-    #   NODE_DEFINE_CONSTANT(target, EXDEV);
-    # #endif
-    # 
-    # #ifdef SIGHUP
-    #   NODE_DEFINE_CONSTANT(target, SIGHUP);
-    # #endif
-    # 
-    # #ifdef SIGINT
-    #   NODE_DEFINE_CONSTANT(target, SIGINT);
-    # #endif
-    # 
-    # #ifdef SIGQUIT
-    #   NODE_DEFINE_CONSTANT(target, SIGQUIT);
-    # #endif
-    # 
-    # #ifdef SIGILL
-    #   NODE_DEFINE_CONSTANT(target, SIGILL);
-    # #endif
-    # 
-    # #ifdef SIGTRAP
-    #   NODE_DEFINE_CONSTANT(target, SIGTRAP);
-    # #endif
-    # 
-    # #ifdef SIGABRT
-    #   NODE_DEFINE_CONSTANT(target, SIGABRT);
-    # #endif
-    # 
-    # #ifdef SIGIOT
-    #   NODE_DEFINE_CONSTANT(target, SIGIOT);
-    # #endif
-    # 
-    # #ifdef SIGBUS
-    #   NODE_DEFINE_CONSTANT(target, SIGBUS);
-    # #endif
-    # 
-    # #ifdef SIGFPE
-    #   NODE_DEFINE_CONSTANT(target, SIGFPE);
-    # #endif
-    # 
-    # #ifdef SIGKILL
-    #   NODE_DEFINE_CONSTANT(target, SIGKILL);
-    # #endif
-    # 
-    # #ifdef SIGUSR1
-    #   NODE_DEFINE_CONSTANT(target, SIGUSR1);
-    # #endif
-    # 
-    # #ifdef SIGSEGV
-    #   NODE_DEFINE_CONSTANT(target, SIGSEGV);
-    # #endif
-    # 
-    # #ifdef SIGUSR2
-    #   NODE_DEFINE_CONSTANT(target, SIGUSR2);
-    # #endif
-    # 
-    # #ifdef SIGPIPE
-    #   NODE_DEFINE_CONSTANT(target, SIGPIPE);
-    # #endif
-    # 
-    # #ifdef SIGALRM
-    #   NODE_DEFINE_CONSTANT(target, SIGALRM);
-    # #endif
-    # 
-    #   NODE_DEFINE_CONSTANT(target, SIGTERM);
-    #   NODE_DEFINE_CONSTANT(target, SIGCHLD);
-    # 
-    # #ifdef SIGSTKFLT
-    #   NODE_DEFINE_CONSTANT(target, SIGSTKFLT);
-    # #endif
-    # 
-    # 
-    # #ifdef SIGCONT
-    #   NODE_DEFINE_CONSTANT(target, SIGCONT);
-    # #endif
-    # 
-    # #ifdef SIGSTOP
-    #   NODE_DEFINE_CONSTANT(target, SIGSTOP);
-    # #endif
-    # 
-    # #ifdef SIGTSTP
-    #   NODE_DEFINE_CONSTANT(target, SIGTSTP);
-    # #endif
-    # 
-    # #ifdef SIGTTIN
-    #   NODE_DEFINE_CONSTANT(target, SIGTTIN);
-    # #endif
-    # 
-    # #ifdef SIGTTOU
-    #   NODE_DEFINE_CONSTANT(target, SIGTTOU);
-    # #endif
-    # 
-    # #ifdef SIGURG
-    #   NODE_DEFINE_CONSTANT(target, SIGURG);
-    # #endif
-    # 
-    # #ifdef SIGXCPU
-    #   NODE_DEFINE_CONSTANT(target, SIGXCPU);
-    # #endif
-    # 
-    # #ifdef SIGXFSZ
-    #   NODE_DEFINE_CONSTANT(target, SIGXFSZ);
-    # #endif
-    # 
-    # #ifdef SIGVTALRM
-    #   NODE_DEFINE_CONSTANT(target, SIGVTALRM);
-    # #endif
-    # 
-    # #ifdef SIGPROF
-    #   NODE_DEFINE_CONSTANT(target, SIGPROF);
-    # #endif
-    # 
-    # #ifdef SIGWINCH
-    #   NODE_DEFINE_CONSTANT(target, SIGWINCH);
-    # #endif
-    # 
-    # #ifdef SIGIO
-    #   NODE_DEFINE_CONSTANT(target, SIGIO);
-    # #endif
-    # 
-    # #ifdef SIGPOLL
-    #   NODE_DEFINE_CONSTANT(target, SIGPOLL);
-    # #endif
-    # 
-    # #ifdef SIGLOST
-    #   NODE_DEFINE_CONSTANT(target, SIGLOST);
-    # #endif
-    # 
-    # #ifdef SIGPWR
-    #   NODE_DEFINE_CONSTANT(target, SIGPWR);
-    # #endif
-    # 
-    # #ifdef SIGSYS
-    #   NODE_DEFINE_CONSTANT(target, SIGSYS);
-    # #endif
-    # 
-    # #ifdef SIGUNUSED
-    #   NODE_DEFINE_CONSTANT(target, SIGUNUSED);
-    # #endif
-  end
-end
-
-Spade.exports = Ivory::Constants