Get unpack working

Author: creationix

Diff for: lib/apply-delta.js

@@ -1,8 +1,7 @@
 // This is Chris Dickinson's code
 
 var binary = require('bodec')
-  // , Decoder = require('varint/decode.js')
-  // , vi = new Decoder
+    , vi = new Decoder
 
 // we use writeUint[8|32][LE|BE] instead of indexing
 // into buffers so that we get buffer-browserify compat.
@@ -11,7 +10,6 @@ var OFFSET_BUFFER = binary.create(4)
 
 module.exports = apply_delta;
 function apply_delta(delta, target) {
-  throw "TODO: fix me"
   var base_size_info = {size: null, buffer: null}
     , resized_size_info = {size: null, buffer: null}
     , output_buffer
@@ -107,3 +105,34 @@ function delta_header(buf, output) {
   output.buffer = binary.slice(buf, idx)
 
 }
+
+var MSB = 0x80
+  , REST = 0x7F
+
+function Decoder() {
+  this.accum = []
+}
+Decoder.prototype.write = write;
+
+function write(byte) {
+  var msb = byte & MSB
+    , accum = this.accum
+    , len
+    , out
+
+  accum[accum.length] = byte & REST
+  if(msb) {
+    return
+  }
+
+  len = accum.length
+  out = 0
+
+  for(var i = 0; i < len; ++i) {
+    out |= accum[i] << (7 * i)
+  }
+
+  accum.length = 0
+  this.ondata(out)
+  return
+}

Diff for: lib/decoders.js

@@ -0,0 +1,104 @@
+var indexOf = require('./indexof.js');
+var parseOct = require('./parseoct.js');
+var parseAscii = require('./parseascii.js');
+var parseToHex = require('./parsetohex.js');
+
+exports.commit = function decodeCommit(body) {
+  var i = 0;
+  var start;
+  var key;
+  var parents = [];
+  var commit = {
+    tree: "",
+    parents: parents,
+    author: "",
+    committer: "",
+    message: ""
+  };
+  while (body[i] !== 0x0a) {
+    start = i;
+    i = indexOf(body, 0x20, start);
+    if (i < 0) throw new SyntaxError("Missing space");
+    key = parseAscii(body, start, i++);
+    start = i;
+    i = indexOf(body, 0x0a, start);
+    if (i < 0) throw new SyntaxError("Missing linefeed");
+    var value = parseAscii(body, start, i++);
+    if (key === "parent") {
+      parents.push(value);
+    }
+    else {
+      if (key === "author" || key === "committer") {
+        value = decodePerson(value);
+      }
+      commit[key] = value;
+    }
+  }
+  i++;
+  commit.message = parseAscii(body, i, body.length);
+  return commit;
+};
+
+exports.tag = function decodeTag(body) {
+  var i = 0;
+  var start;
+  var key;
+  var tag = {};
+  while (body[i] !== 0x0a) {
+    start = i;
+    i = indexOf(body, 0x20, start);
+    if (i < 0) throw new SyntaxError("Missing space");
+    key = parseAscii(body, start, i++);
+    start = i;
+    i = indexOf(body, 0x0a, start);
+    if (i < 0) throw new SyntaxError("Missing linefeed");
+    var value = parseAscii(body, start, i++);
+    if (key === "tagger") value = decodePerson(value);
+    tag[key] = value;
+  }
+  i++;
+  tag.message = parseAscii(body, i, body.length);
+  return tag;
+};
+
+exports.tree = function decodeTree(body) {
+  var i = 0;
+  var length = body.length;
+  var start;
+  var mode;
+  var name;
+  var hash;
+  var tree = {};
+  while (i < length) {
+    start = i;
+    i = indexOf(body, 0x20, start);
+    if (i < 0) throw new SyntaxError("Missing space");
+    mode = parseOct(body, start, i++);
+    start = i;
+    i = indexOf(body, 0x00, start);
+    name = parseAscii(body, start, i++);
+    hash = parseToHex(body, i, i += 20);
+    tree[name] = {
+      mode: mode,
+      hash: hash
+    };
+  }
+  return tree;
+};
+
+exports.blob = function decodeBlob(body) {
+  return body;
+};
+
+function decodePerson(string) {
+  var match = string.match(/^([^<]*) <([^>]*)> ([^ ]*) (.*)$/);
+  if (!match) throw new Error("Improperly formatted person string");
+  var sec = parseInt(match[3], 10);
+  var date = new Date(sec * 1000);
+  date.timeZoneoffset = parseInt(match[4], 10) / 100 * -60;
+  return {
+    name: match[1],
+    email: match[2],
+    date: date
+  };
+}

Diff for: lib/inflate-stream.js

@@ -1,11 +1,54 @@
-// Taken from chrisdickinson/inflate's min.js
-// Modified to use bodec and inlined in js-git
-// Original code under MIT License
-// Copyright Chris Diskinson <[email protected]>
+var binary = require('bodec');
 
-module.exports = inflate
+// Wrapper for proposed new API to inflate:
+//
+//   var inf = inflate();
+//   inf.write(byte) -> more - Write a byte to inflate's state-machine.
+//                             Returns true if more data is expected.
+//   inf.recycle()           - Reset the internal state machine.
+//   inf.flush() -> data     - Flush the output as a binary buffer.
+//
+// This is quite slow, but could be made fast if baked into inflate itself.
+module.exports = function () {
+  var push = inflate(onEmit, onUnused);
+  var more = true;
+  var chunks = [];
+  var b = binary.create(1);
 
-var binary = require('bodec')
+  return { write: write, recycle: recycle, flush: flush };
+
+  function write(byte) {
+    b[0] = byte;
+    push(null, b);
+    return more;
+  }
+
+  function recycle() {
+    push.recycle();
+    more = true;
+  }
+
+  function flush() {
+    var buffer = binary.join(chunks);
+    chunks.length = 0;
+    return buffer;
+  }
+
+  function onEmit(err, item) {
+    if (err) throw err;
+    if (item === undefined) {
+      // console.log("onEnd");
+      more = false;
+      return;
+    }
+    chunks.push(item);
+  }
+
+  function onUnused(chunks) {
+    // console.log("onUnused", chunks);
+    more = false;
+  }
+};
 
 var MAXBITS = 15
   , MAXLCODES = 286
@@ -86,7 +129,7 @@ function inflate(emit, on_unused) {
     output_one_offs = 0
     become(noop, {}, noop)
     start_stream_header()
-    return stream
+    // return stream
   }
 
   var bytes_need = 0
@@ -596,9 +639,11 @@ function inflate(emit, on_unused) {
       output_idx = 0
       ended = true
       emit()
-      return
+      // return
+    }
+    else {
+      last = result
     }
-    last = result
   }
 
   function bits() {
@@ -720,7 +765,7 @@ function inflate(emit, on_unused) {
       output_idx &= WINDOW_MINUS_ONE
     }
 
-    emit(binary.fromArray(vals))
+    emit(null, binary.fromArray(vals))
   }
 }
 

Diff for: lib/pack-codec.js

@@ -1,4 +1,4 @@
-var inflate = require('./inflate.js');
+var inflate = require('./inflate-stream.js');
 var deflate = require('./deflate.js');
 var sha1 = require('git-sha1');
 var binary = require('bodec');

Diff for: lib/parseoct.js

@@ -0,0 +1,7 @@
+module.exports = function parseOct(buffer, start, end) {
+  var val = 0;
+  while (start < end) {
+    val = (val << 3) + buffer[start++] - 0x30;
+  }
+  return val;
+};

Diff for: lib/parsetohex.js

@@ -0,0 +1,10 @@
+var chars = "0123456789abcdef";
+
+module.exports = function parseToHex(buffer, start, end) {
+  var val = "";
+  while (start < end) {
+    var byte = buffer[start++];
+    val += chars[byte >> 4] + chars[byte & 0xf];
+  }
+  return val;
+};

Diff for: lib/xhr-node.js

@@ -44,8 +44,7 @@ module.exports = function (root, accessToken) {
         body = Buffer.concat(body).toString();
         console.log(method, url, res.statusCode);
         console.log("Rate limit %s/%s left", res.headers['x-ratelimit-remaining'], res.headers['x-ratelimit-limit']);
-        if (res.statusCode >= 400 && res.statusCode < 500) return callback();
-        else if (res.statusCode === 200 && method === "GET" && /\/refs\//.test(url)) {
+        if (res.statusCode === 200 && method === "GET" && /\/refs\//.test(url)) {
           cache[url] = {
             body: body,
             etag: res.headers.etag
@@ -55,21 +54,16 @@ module.exports = function (root, accessToken) {
           body = cache[url].body;
           res.statusCode = 200;
         }
-        else if (res.statusCode < 200 || res.statusCode >= 300) {
-          return callback(new Error("Invalid HTTP response: " + res.statusCode));
-        }
-
-        var response = {message:body};
-        if (body){
-          try { response = JSON.parse(body); }
-          catch (err) {}
-        }
-
         // Fake parts of the xhr object using node APIs
         var xhr = {
           status: res.statusCode,
           statusText: res.statusCode + " " + statusCodes[res.statusCode]
         };
+        var response = {message:body};
+        if (body){
+          try { response = JSON.parse(body); }
+          catch (err) {}
+        }
         return callback(null, xhr, response);
       });
     });