vulcan 0.0.1 → 0.0.2

data/server/node_modules/restler/bin/restler

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+require.paths.push(process.cwd());
+
+var sys  = require('sys'),
+    rest = require('../lib/restler'),
+    repl = require('repl');
+  
+var replServer = repl.start();
+
+var exportMethods = {
+  sys: sys,
+  rest: rest
+}
+
+Object.keys(exportMethods).forEach(function(exportMethod) {
+  replServer.context[exportMethod] = exportMethods[exportMethod];
+});
+
+rest.get('http://twaud.io/api/v1/7.json').on('complete', function(data, response) {
+  console.log(response.headers);
+  replServer.context.data = data;
+});

data/server/node_modules/restler/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/restler');

data/server/node_modules/restler/lib/multipartform.js

@@ -0,0 +1,202 @@
+var fs = require('fs');
+var sys = require("sys")
+exports.defaultBoundary = '48940923NODERESLTER3890457293';
+
+
+// This little object allows us hijack the write method via duck-typing
+// and write to strings or regular streams that support the write method.
+function Stream(stream) {
+	//If the user pases a string for stream,we initalize one to write to
+	if (this._isString(stream)) {
+		this.string = "";
+	}
+	this.stream = stream;
+	
+}
+
+Stream.prototype = {
+  //write to an internal String or to the Stream
+  write: function(data) {
+	if (this.string != undefined) {
+		this.string += data;
+	} else {
+		this.stream.write(data, "binary");
+	}
+  },
+
+  //stolen from underscore.js
+  _isString: function(obj) {
+    return !!(obj === '' || (obj && obj.charCodeAt && obj.substr));
+  }
+}
+
+function File(path, filename, fileSize, encoding, contentType) {
+  this.path = path;
+  this.filename = filename || this._basename(path);
+  this.fileSize = fileSize;
+  this.encoding = encoding || "binary";
+  this.contentType = contentType || 'application/octet-stream';
+}
+
+File.prototype = {
+  _basename: function(path) {
+    var parts = path.split(/\/|\\/);
+    return parts[parts.length - 1];
+  }
+};
+
+function Data(filename, contentType, data) {
+  this.filename = filename;
+  this.contentType = contentType || 'application/octet-stream';
+  this.data = data;
+}
+
+function Part(name, value, boundary) {
+  this.name = name;
+  this.value = value;
+  this.boundary = boundary;
+}
+
+
+Part.prototype = {
+	
+  //returns the Content-Disposition header		
+  header: function() {
+	  var header;
+	  
+    if (this.value.data) {
+	    header = "Content-Disposition: form-data; name=\"" + this.name + 
+  	            "\"; filename=\"" + this.value.filename + "\"\r\n" +
+  	            "Content-Type: " + this.value.contentType;
+ 	  } if (this.value instanceof File) {
+  	  header = "Content-Disposition: form-data; name=\"" + this.name + 
+  	            "\"; filename=\"" + this.value.filename + "\"\r\n" +
+  	            "Content-Length: " + this.value.fileSize + "\r\n" +	
+  	            "Content-Type: " + this.value.contentType;	
+  	} else {
+      header = "Content-Disposition: form-data; name=\"" + this.name + "\"";
+  	}
+  	
+	  return "--" + this.boundary + "\r\n" + header + "\r\n\r\n";
+  },
+
+  //calculates the size of the Part
+  sizeOf: function() {
+	  var valueSize;
+  	if (this.value instanceof File) {
+  	  valueSize = this.value.fileSize;
+  	} else if (this.value.data) {
+  	  valueSize = this.value.data.length;
+  	} else {
+  	  valueSize = this.value.length;
+  	}
+  	return valueSize + this.header().length + 2; 
+  },
+
+  // Writes the Part out to a writable stream that supports the write(data) method
+  // You can also pass in a String and a String will be returned to the callback
+  // with the whole Part
+  // Calls the callback when complete
+  write: function(stream, callback) {
+	
+    var self = this;
+	
+	  //first write the Content-Disposition
+	  stream.write(this.header());
+	
+  	//Now write out the body of the Part
+    if (this.value instanceof File) {
+  	  fs.open(this.value.path, "r", 0666, function (err, fd) { 
+    	  if (err) throw err; 
+    	  
+  		  position = 0;
+  		  
+  	    (function reader () {
+  	      fs.read(fd, 1024 * 4, position, "binary", function (er, chunk) {
+  	        if (er) callback(err);
+  	        stream.write(chunk); 
+  	        position += 1024 * 4;
+  	        if (chunk) reader();
+  	        else {
+  			      stream.write("\r\n")
+      			  callback();
+      			  fs.close(fd);
+      			}
+  	      }); 
+  	    })(); // reader() 
+  	  });
+     } else {
+  	  stream.write(this.value + "\r\n");
+  	  callback();
+  	}
+  }
+}
+
+//Renamed to MultiPartRequest from Request
+function MultiPartRequest(data, boundary) {
+  this.encoding = 'binary';
+  this.boundary = boundary || exports.defaultBoundary;
+  this.data = data;
+  this.partNames = this._partNames();
+}
+
+MultiPartRequest.prototype = {
+  _partNames: function() {
+	  partNames = []
+      for (var name in this.data) {
+  		partNames.push(name)
+  	}
+  	return partNames;
+  },
+  write: function(stream, callback) {
+    var partCount = 0, self = this;
+    
+	  // wrap the stream in our own Stream object
+  	// See the Stream function above for the benefits of this
+  	var stream = new Stream(stream);
+  	
+  	// Let each part write itself out to the stream
+  	(function writePart() {
+  	  partName = this.partNames[partCount];
+  	  part = new Part(partName, self.data[partName], self.boundary);
+  	  part.write(stream, function (err) {
+  		  if (err) {
+    			callback(err);
+    			return;
+    		}
+     		partCount += 1;
+    	  if (partCount < self.partNames.length)
+    	    writePart();
+    		else {
+    		  stream.write('--' + self.boundary + '--' + "\r\n");
+
+          if (callback) callback(stream.string || "");
+    		}
+  	  });
+    })(); 
+  }
+}
+
+var exportMethods = {
+  file: function(path, filename, fileSize, encoding, contentType) { 
+    return new File(path, filename, fileSize, encoding, contentType)
+  },
+  data: function(filename, contentType, data) {
+    return new Data(filename, contentType, data);
+  },
+  sizeOf: function(parts, boundary) {
+    var totalSize = 0;
+	  boundary = boundary || exports.defaultBoundary;
+  	for (var name in parts) totalSize += new Part(name, parts[name], boundary).sizeOf();
+  	return totalSize + boundary.length + 6;
+  },
+  write: function(stream, data, callback, boundary) {
+    var r = new MultiPartRequest(data, boundary);
+    r.write(stream, callback);
+    return r;
+  }
+}
+
+Object.keys(exportMethods).forEach(function(exportMethod) {
+  exports[exportMethod] = exportMethods[exportMethod]
+})

data/server/node_modules/restler/lib/restler.js

@@ -0,0 +1,300 @@
+var sys       = require('sys'),
+    http      = require('http'),
+    https     = require('https'),
+    url       = require('url'),
+    qs        = require('querystring'),
+    multipart = require('./multipartform');
+    
+function mixin(target, source) {
+  Object.keys(source).forEach(function(key) {
+    target[key] = source[key];
+  });
+  
+  return target;
+}
+    
+function Request(uri, options) {
+  this.url = url.parse(uri);
+  this.options = options;
+  this.headers = {
+    'Accept': '*/*',
+    'User-Agent': 'Restler for node.js',
+    'Host': this.url.host
+  }
+  
+  mixin(this.headers, options.headers || {});
+  
+  // set port and method defaults
+  if (!this.url.port) this.url.port = (this.url.protocol == 'https:') ? '443' : '80';
+  if (!this.options.method) this.options.method = (this.options.data) ? 'POST' : 'GET';
+  if (typeof this.options.followRedirects == 'undefined') this.options.followRedirects = true;
+  
+  // stringify query given in options of not given in URL
+  if (this.options.query && !this.url.query) {
+    if (typeof this.options.query == 'object') 
+      this.url.query = qs.stringify(this.options.query);
+    else this.url.query = this.options.query;
+  }
+  
+  this._applyBasicAuth();
+  
+  if (this.options.multipart) {
+    this.headers['Content-Type'] = 'multipart/form-data; boundary=' + multipart.defaultBoundary;
+  } else {
+    if (typeof this.options.data == 'object') {
+      this.options.data = qs.stringify(this.options.data);
+      this.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+      this.headers['Content-Length'] = this.options.data.length;
+    }
+  }
+  
+  var proto = (this.url.protocol == 'https:') ? https : http;
+  
+  this.request = proto.request({
+    host: this.url.hostname,
+    port: this.url.port,
+    path: this._fullPath(),
+    method: this.options.method,
+    headers: this.headers
+  });
+  
+  this._makeRequest();
+}
+
+Request.prototype = new process.EventEmitter();
+mixin(Request.prototype, {
+  _isRedirect: function(response) {
+    return ([301, 302].indexOf(response.statusCode) >= 0);
+  },
+  _fullPath: function() {
+    var path = this.url.pathname || '/';
+    if (this.url.hash) path += this.url.hash;
+    if (this.url.query) path += '?' + this.url.query;
+    return path;
+  },
+  _applyBasicAuth: function() {
+    var authParts;
+    
+    if (this.url.auth) {
+      authParts = this.url.auth.split(':');
+      this.options.username = authParts[0];
+      this.options.password = authParts[1];
+    }
+    
+    if (this.options.username && this.options.password) {
+      var b = new Buffer([this.options.username, this.options.password].join(':'));
+      this.headers['Authorization'] = "Basic " + b.toString('base64');
+    }
+  },
+  _responseHandler: function(response) {
+    var self = this;
+    
+    if (this._isRedirect(response) && this.options.followRedirects == true) {
+      try {
+        var location = url.resolve(this.url, response.headers['location']);
+        this.options.originalRequest = this;
+        
+        request(location, this.options);
+      } catch(e) {
+        self._respond('error', '', 'Failed to follow redirect');
+      }
+    } else {
+      var body = '';
+      
+      // TODO Handle different encodings
+      response.setEncoding('utf8');
+      
+      response.on('data', function(chunk) {
+        body += chunk;
+      });
+      
+      response.on('end', function() {
+         if (self.options.parser) {
+           self.options.parser.call(response, body, function(parsedData) {
+
+             self._fireEvents(parsedData, response);
+           });
+         } else {
+           self._fireEvents(body, response);
+         }
+      });
+    }
+  },
+  _respond: function(type, data, response) {
+    if (this.options.originalRequest) {
+      this.options.originalRequest.emit(type, data, response);
+    } else {
+      this.emit(type, data, response);
+    }
+  },
+  _fireEvents: function(body, response) {
+    if (parseInt(response.statusCode) >= 400) this._respond('error', body, response);
+    else this._respond('success', body, response);
+        
+    this._respond(response.statusCode.toString().replace(/\d{2}$/, 'XX'), body, response);
+    this._respond(response.statusCode.toString(), body, response);
+    this._respond('complete', body, response);
+  },
+  _makeRequest: function() { 
+    var self = this;
+       
+    this.request.on('response', function(response) {
+		  self._responseHandler(response);
+  	}).on('error', function(err) {
+  	  self._respond('error', null, err);
+  	});
+  },
+  run: function() {
+    var self = this;
+    
+    if (this.options.multipart) {
+      multipart.write(this.request, this.options.data, function() {
+        self.request.end();
+      });
+    } else {
+      if (this.options.data) {
+        this.request.write(this.options.data.toString(), this.options.encoding || 'utf8');
+      }
+		  this.request.end();
+    }
+    
+    return this;
+  }
+});
+
+function shortcutOptions(options, method) {
+  options = options || {};
+  options.method = method;
+  options.parser = (typeof options.parser !== "undefined") ? options.parser : parsers.auto;
+  return options;
+}
+    
+function request(url, options) {  
+  	return (new Request(url, options)).run();
+}
+
+function get(url, options) {
+ return request(url, shortcutOptions(options, 'GET'));
+}
+
+function post(url, options) {
+  return request(url, shortcutOptions(options, 'POST'));
+}
+
+function put(url, options) {
+  return request(url, shortcutOptions(options, 'PUT'));
+}
+
+function del(url, options) {
+  return request(url, shortcutOptions(options, 'DELETE'));
+}
+
+var parsers = {
+  auto: function(data, callback) {
+    var contentType = this.headers['content-type'];
+    
+    if (contentType) {
+      for (var matcher in parsers.auto.matchers) {
+
+        if (contentType.indexOf(matcher) == 0) {
+          return parsers.auto.matchers[matcher].call(this, data, callback);
+        }
+      }
+    }
+    
+    callback(data);
+  },
+  json: function(data, callback) {
+    callback(data && JSON.parse(data));
+  }
+}
+
+parsers.auto.matchers = {
+  'application/json': parsers.json
+};
+
+try {
+  var yaml = require('yaml');
+  
+  parsers.yaml = function(data, callback) {
+    return callback(data && yaml.eval(data));
+  };
+  
+  parsers.auto.matchers['application/yaml'] = parsers.yaml;
+} catch(e) {}
+
+try {
+  var xml2js = require('xml2js');
+
+  parsers.xml = function(data, callback) {
+    if (data) {
+      var parser = new xml2js.Parser();
+      
+      parser.on('end', function(result) {
+          callback(result);
+      });
+      
+      parser.parseString(data);
+    } else {
+      callback();
+    }
+  };
+  
+  parsers.auto.matchers['application/xml'] = parsers.xml;
+} catch(e) {}
+
+
+function Service(defaults) {
+  if (defaults.baseURL) {
+   this.baseURL = defaults.baseURL;
+   delete defaults.baseURL; 
+  }
+  
+  this.defaults = defaults;
+}
+
+mixin(Service.prototype, {
+  request: function(path, options) {
+    return request(this._url(path), this._withDefaults(options));
+  },
+  get: function(path, options) {
+    return get(this._url(path), this._withDefaults(options));
+  },
+  put: function(path, options) {
+    return put(this._url(path), this._withDefaults(options));
+  },
+  post: function(path, options) {
+    return post(this._url(path), this._withDefaults(options));
+  },
+  del: function(path, options) {
+    return del(this._url(path), this._withDefaults(options));
+  },
+  _url: function(path) {
+    if (this.baseURL) return url.resolve(this.baseURL, path);
+    else return path;
+  },
+  _withDefaults: function(options) {
+    var o = mixin({}, this.defaults);
+    return mixin(o, options);
+  }
+});
+
+function service(constructor, defaults, methods) {
+  constructor.prototype = new Service(defaults || {});
+  mixin(constructor.prototype, methods);
+  return constructor;
+}
+
+mixin(exports, {
+  Request: Request,
+  Service: Service,
+  request: request,
+  service: service,
+  get: get,
+  post: post,
+  put: put,
+  del: del,
+  parsers: parsers,
+  file: multipart.file,
+  data: multipart.data
+});