feat: 초기 프로젝트 설정 및 룰.md 파일 추가

api.hyungi.net/node_modules/js-git/net/git-fetch-pack.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var wrapHandler = require('../lib/wrap-handler');
+var bodec = require('bodec');
+
+module.exports = fetchPack;
+
+function fetchPack(transport, onError) {
+
+  if (!onError) onError = throwIt;
+
+  // Wrap our handler functions to route errors properly.
+  onRef = wrapHandler(onRef, onError);
+  onWant = wrapHandler(onWant, onError);
+  onNak = wrapHandler(onNak, onError);
+  onMore = wrapHandler(onMore, onError);
+  onReady = wrapHandler(onReady, onError);
+
+  var caps = null;
+  var capsSent = false;
+  var refs = {};
+  var haves = {};
+  var havesCount = 0;
+
+  // Create a duplex channel for talking with the agent.
+  var libraryChannel = makeChannel();
+  var agentChannel = makeChannel();
+  var api = {
+    put: libraryChannel.put,
+    drain: libraryChannel.drain,
+    take: agentChannel.take
+  };
+
+  // Start the connection and listen for the response.
+  var socket = transport("git-upload-pack", onError);
+  socket.take(onRef);
+
+  // Return the other half of the duplex API channel.
+  return {
+    put: agentChannel.put,
+    drain: agentChannel.drain,
+    take: libraryChannel.take
+  };
+
+  function onRef(line) {
+    if (line === undefined) {
+      throw new Error("Socket disconnected");
+    }
+    if (line === null) {
+      api.put(refs);
+      api.take(onWant);
+      return;
+    }
+    else if (!caps) {
+      caps = {};
+      Object.defineProperty(refs, "caps", {value: caps});
+      Object.defineProperty(refs, "shallows", {value:[]});
+      var index = line.indexOf("\0");
+      if (index >= 0) {
+        line.substring(index + 1).split(" ").forEach(function (cap) {
+          var i = cap.indexOf("=");
+          if (i >= 0) {
+            caps[cap.substring(0, i)] = cap.substring(i + 1);
+          }
+          else {
+            caps[cap] = true;
+          }
+        });
+        line = line.substring(0, index);
+      }
+    }
+    var match = line.match(/(^[0-9a-f]{40}) (.*)$/);
+    if (!match) {
+      if (typeof line === "string" && /^ERR/i.test(line)) {
+        throw new Error(line);
+      }
+      throw new Error("Invalid line: " + JSON.stringify(line));
+    }
+    refs[match[2]] = match[1];
+    socket.take(onRef);
+  }
+
+  var packChannel;
+  var progressChannel;
+  var errorChannel;
+
+  function onWant(line) {
+    if (line === undefined) return socket.put();
+    if (line === null) {
+      socket.put(null);
+      return api.take(onWant);
+    }
+    if (line.deepen) {
+      socket.put("deepen " + line.deepen + "\n");
+      return api.take(onWant);
+    }
+    if (line.have) {
+      haves[line.have] = true;
+      havesCount++;
+      socket.put("have " + line.have + "\n");
+      return api.take(onWant);
+    }
+    if (line.want) {
+      var extra = "";
+      if (!capsSent) {
+        capsSent = true;
+        if (caps["ofs-delta"]) extra += " ofs-delta";
+        if (caps["thin-pack"]) extra += " thin-pack";
+        // if (caps["multi_ack_detailed"]) extra += " multi_ack_detailed";
+        // else if (caps["multi_ack"]) extra +=" multi_ack";
+        if (caps["side-band-64k"]) extra += " side-band-64k";
+        else if (caps["side-band"]) extra += " side-band";
+        // if (caps["agent"]) extra += " agent=" + agent;
+        if (caps.agent) extra += " agent=" + caps.agent;
+      }
+      extra += "\n";
+      socket.put("want " + line.want + extra);
+      return api.take(onWant);
+    }
+    if (line.done) {
+      socket.put("done\n");
+      return socket.take(onNak);
+    }
+    throw new Error("Invalid have/want command");
+  }
+
+  function onNak(line) {
+    if (line === undefined) return api.put();
+    if (line === null) return socket.take(onNak);
+    if (bodec.isBinary(line) || line.progress || line.error) {
+      packChannel = makeChannel();
+      progressChannel = makeChannel();
+      errorChannel = makeChannel();
+      api.put({
+        pack: { take: packChannel.take },
+        progress: { take: progressChannel.take },
+        error: { take: errorChannel.take },
+      });
+      return onMore(null, line);
+    }
+    var match = line.match(/^shallow ([0-9a-f]{40})$/);
+    if (match) {
+      refs.shallows.push(match[1]);
+      return socket.take(onNak);
+    }
+    match = line.match(/^ACK ([0-9a-f]{40})$/);
+    if (match) {
+      return socket.take(onNak);
+    }
+    if (line === "NAK") {
+      return socket.take(onNak);
+    }
+    throw new Error("Expected NAK, but got " + JSON.stringify(line));
+  }
+
+  function onMore(line) {
+
+    if (line === undefined) {
+      packChannel.put();
+      progressChannel.put();
+      errorChannel.put();
+      return api.put();
+    }
+    if (line === null) {
+      api.put(line);
+    }
+    else {
+      if (line.progress) {
+        progressChannel.put(line.progress);
+      }
+      else if (line.error) {
+        errorChannel.put(line.error);
+      }
+      else {
+        if (!packChannel.put(line)) {
+          return packChannel.drain(onReady);
+        }
+      }
+    }
+    socket.take(onMore);
+  }
+
+  function onReady() {
+    socket.take(onMore);
+  }
+
+}
+
+var defer = require('js-git/lib/defer');
+function throwIt(err) {
+  defer(function () {
+    throw err;
+  });
+  // throw err;
+}

api.hyungi.net/node_modules/js-git/net/request-xhr.js

@@ -0,0 +1,36 @@
+"use strict";
+
+module.exports = request;
+
+function request(method, url, headers, body, callback) {
+  if (typeof body === "function") {
+    callback = body;
+    body = undefined;
+  }
+  if (!callback) {
+    return request.bind(null, method, url, headers, body);
+  }
+  var xhr = new XMLHttpRequest();
+  xhr.open(method, url, true);
+  xhr.responseType = "arraybuffer";
+
+  Object.keys(headers).forEach(function (name) {
+    xhr.setRequestHeader(name, headers[name]);
+  });
+
+  xhr.onreadystatechange = function () {
+    if (xhr.readyState !== 4) return;
+    var resHeaders = {};
+    xhr.getAllResponseHeaders().trim().split("\r\n").forEach(function (line) {
+      var index = line.indexOf(":");
+      resHeaders[line.substring(0, index).toLowerCase()] = line.substring(index + 1).trim();
+    });
+
+    callback(null, {
+      statusCode: xhr.status,
+      headers: resHeaders,
+      body: xhr.response && new Uint8Array(xhr.response)
+    });
+  };
+  xhr.send(body);
+}

api.hyungi.net/node_modules/js-git/net/tcp-chrome-sockets.js

@@ -0,0 +1,108 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var wrapHandler = require('../lib/wrap-handler');
+var tcp = window.chrome.sockets.tcp;
+var runtime = window.chrome.runtime;
+
+module.exports = connect;
+
+function connect(host, port, onError) {
+  port = port|0;
+  host = String(host);
+  if (!port || !host) throw new TypeError("host and port are required");
+
+  onCreate = wrap(onCreate, onError);
+  onConnect = wrap(onConnect, onError);
+  onInfo = wrap(onInfo, onError);
+  onReceive = wrap(onReceive, onError);
+  onReceiveError = wrap(onReceiveError, onError);
+  onData = wrapHandler(onData, onError);
+  onWrite = wrap(onWrite, onError);
+
+  var paused = false;
+  var open = false;
+  var socketId;
+
+  var serverChannel = makeChannel();
+  var clientChannel = makeChannel();
+  var socket = {
+    put: serverChannel.put,
+    drain: serverChannel.drain,
+    take: clientChannel.take
+  };
+
+  tcp.onReceive.addListener(onReceive);
+  tcp.onReceiveError.addListener(onReceiveError);
+  tcp.create(onCreate);
+
+  return {
+    put: clientChannel.put,
+    drain: clientChannel.drain,
+    take: serverChannel.take
+  };
+
+  function onCreate(createInfo) {
+    socketId = createInfo.socketId;
+    tcp.connect(socketId, host, port, onConnect);
+  }
+
+  function onConnect(result) {
+    if (result < 0) throw new Error(runtime.lastError.message + " Connection error");
+    tcp.getInfo(socketId, onInfo);
+  }
+
+  function onInfo(socketInfo) {
+    if (!socketInfo.connected) {
+      throw new Error("Connection failed");
+    }
+    open = true;
+    socket.take(onData);
+  }
+
+  function onReceive(info) {
+    if (info.socketId !== socketId) return;
+    if (socket.put(new Uint8Array(info.data)) || paused) return;
+    paused = true;
+    tcp.setPaused(socketId, true);
+    socket.drain(onDrain);
+  }
+
+  function onDrain() {
+    if (!paused) return;
+    paused = false;
+    if (open) tcp.setPaused(socketId, false);
+  }
+
+  function onReceiveError(info) {
+    if (info.socketId !== socketId) return;
+    open = false;
+    tcp.close(socketId);
+    socket.put();
+    // TODO: find a way to tell close and error apart.
+    // throw new Error("Code " + info.resultCode + " error while receiving.");
+  }
+
+  function onData(data) {
+    tcp.send(socketId, data.buffer, onWrite);
+  }
+
+  function onWrite(info) {
+    if (info.resultCode < 0) {
+      throw new Error(runtime.lastError.message + " Error writing.");
+    }
+    socket.take(onData);
+  }
+}
+
+
+function wrap(fn, onError) {
+  return function () {
+    try {
+      return fn.apply(this, arguments);
+    }
+    catch (err) {
+      onError(err);
+    }
+  };
+}

api.hyungi.net/node_modules/js-git/net/tcp-node.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var wrapHandler = require('../lib/wrap-handler');
+var net = require('net');
+
+module.exports = connect;
+
+function connect(host, port, onError) {
+  port = port|0;
+  host = String(host);
+  if (!port || !host) throw new TypeError("host and port are required");
+
+  // Wrap event handlers from node stream
+  onConnect = wrap(onConnect, onError);
+  pump = wrap(pump, onError);
+  onEnd = wrap(onEnd, onError);
+  onDrain = wrap(onDrain, onError);
+
+  // Wrap event handlers from culvert socket
+  onTake = wrapHandler(onTake, onError);
+
+  var serverChannel = makeChannel();
+  var clientChannel = makeChannel();
+  var socket = {
+    put: serverChannel.put,
+    drain: serverChannel.drain,
+    take: clientChannel.take
+  };
+
+  var client = net.connect({ host: host, port: port }, onConnect);
+  if (onError) client.on("error", onError);
+
+  return {
+    put: clientChannel.put,
+    drain: clientChannel.drain,
+    take: serverChannel.take
+  };
+
+  function onConnect() {
+    socket.take(onTake);
+    client.on("end", onEnd);
+    client.on("readable", pump);
+    client.on("drain", onDrain);
+    client.on("error", onError);
+  }
+
+  function pump() {
+    var chunk;
+    do {
+      chunk = client.read();
+      if (!chunk) return;
+    } while (socket.put(chunk));
+    socket.drain(pump);
+  }
+
+  function onEnd() {
+    socket.put();
+  }
+
+  function onTake(data) {
+    if (data === undefined) {
+      client.end();
+    }
+    else if (client.write(data)) {
+      socket.take(onTake);
+    }
+  }
+
+  function onDrain() {
+    socket.take(onTake);
+  }
+
+}
+
+function wrap(fn, onError) {
+  return function () {
+    try {
+      return fn.apply(this, arguments);
+    }
+    catch (err) {
+      onError(err);
+    }
+  };
+}

api.hyungi.net/node_modules/js-git/net/tcp-ws-proxy.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var wrapHandler = require('../lib/wrap-handler');
+
+module.exports = function (proxyUrl) {
+  if (proxyUrl[proxyUrl.length - 1] !== "/") proxyUrl += "/";
+
+  return function connect(host, port, onError) {
+    port = port|0;
+    host = String(host);
+    if (!port || !host) throw new TypeError("host and port are required");
+
+    onData = wrapHandler(onData, onError);
+
+    var serverChannel = makeChannel();
+    var clientChannel = makeChannel();
+    var socket = {
+      put: serverChannel.put,
+      drain: serverChannel.drain,
+      take: clientChannel.take
+    };
+
+    var connected = false;
+    var ws = new WebSocket(proxyUrl  + "tcp/" + host + "/" + port);
+    ws.binaryType = "arraybuffer";
+
+    ws.onopen = wrap(onOpen, onError);
+    ws.onclose = wrap(onClose, onError);
+    ws.onmessage = wrap(onMessage, onError);
+    ws.onerror = wrap(onWsError, onError);
+
+    return {
+      put: clientChannel.put,
+      drain: clientChannel.drain,
+      take: serverChannel.take
+    };
+
+    function onOpen() {
+      ws.send("connect");
+    }
+
+    function onClose() {
+      socket.put();
+    }
+
+    function onMessage(evt) {
+      if (!connected && evt.data === "connect") {
+        connected = true;
+        socket.take(onData);
+        return;
+      }
+
+      socket.put(new Uint8Array(evt.data));
+    }
+
+    function onWsError() {
+      console.error(arguments);
+      throw new Error("Generic websocket error");
+    }
+
+    function onData(chunk) {
+      ws.send(chunk.buffer);
+      socket.take(onData);
+    }
+
+  };
+};
+
+function wrap(fn, onError) {
+  return function () {
+    try {
+      return fn.apply(this, arguments);
+    }
+    catch (err) {
+      onError(err);
+    }
+  };
+}

api.hyungi.net/node_modules/js-git/net/transport-http.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var bodec = require('bodec');
+var pktLine = require('../lib/pkt-line');
+var wrapHandler = require('../lib/wrap-handler');
+
+module.exports = function (request) {
+
+  return function httpTransport(gitUrl, username, password) {
+    // Send Auth header if username is set
+    var auth;
+    if (username) {
+      auth = "Basic " + btoa(username + ":" + (password || ""));
+    }
+
+    return function (serviceName, onError) {
+
+      // Wrap our handler functions to route errors properly.
+      onResponse = wrapHandler(onResponse, onError);
+      onWrite = wrapHandler(onWrite, onError);
+      onResult = wrapHandler(onResult, onError);
+
+      // Create a duplex channel with transform for internal use.
+      var serverChannel = makeChannel();//0, "server");
+      var clientChannel = makeChannel();//0, "client");
+      var socket = {
+        put: serverChannel.put,
+        drain: serverChannel.drain,
+        take: clientChannel.take
+      };
+
+      // Send the initial request to start the connection.
+      var headers = {};
+      if (auth) headers.Authorization = auth;
+      request("GET", gitUrl + "/info/refs?service=" + serviceName, headers, onResponse);
+
+      // Prep for later requests
+      var bodyParts = [];
+      var bodyWrite = pktLine.framer(function (chunk) {
+        bodyParts.push(chunk);
+      });
+      headers["Content-Type"] = "application/x-" + serviceName + "-request";
+      socket.take(onWrite);
+
+      var verified = 0;
+      var parseResponse = pktLine.deframer(function (line) {
+        if (verified === 2) {
+          socket.put(line);
+        }
+        else if (verified === 0) {
+          if (line !== "# service=" + serviceName) {
+            throw new Error("Illegal service response");
+          }
+          verified = 1;
+        }
+        else if (verified === 1) {
+          if (line !== null) {
+            throw new Error("Expected null after service name");
+          }
+          verified = 2;
+        }
+      });
+
+      // Return the other half of the duplex channel for the protocol logic to use.
+      return {
+        put: clientChannel.put,
+        drain: clientChannel.drain,
+        take: serverChannel.take
+      };
+
+      function onResponse(res) {
+        if (res.statusCode !== 200) {
+          throw new Error("Invalid response: " + res.statusCode);
+        }
+        if (res.headers["content-type"] !== "application/x-" + serviceName + "-advertisement") {
+          throw new Error("Not a smart http git server");
+        }
+        parseResponse(res.body);
+      }
+
+      function onWrite(item) {
+        if (item === undefined) return socket.put();
+        bodyWrite(item);
+        socket.take(onWrite);
+        if (item !== "done\n" || !bodyParts.length) return;
+        var body = bodec.join(bodyParts);
+        bodyParts.length = 0;
+        request("POST", gitUrl + "/" + serviceName, headers, body, onResult);
+      }
+
+      function onResult(res) {
+        if (res.statusCode !== 200) {
+          throw new Error("Invalid result: " + res.statusCode);
+        }
+        if (res.headers["content-type"] !== "application/x-" + serviceName + "-result") {
+          throw new Error("Not a smart http git server");
+        }
+        parseResponse(res.body);
+      }
+    };
+  };
+};

api.hyungi.net/node_modules/js-git/net/transport-tcp.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var makeChannel = require('culvert');
+var bodec = require('bodec');
+var pktLine = require('../lib/pkt-line');
+var wrapHandler = require('../lib/wrap-handler');
+
+module.exports = function (connect) {
+
+  return function tcpTransport(path, host, port) {
+    port = (port|0) || 9418;
+    if (!path || !host) throw new Error("path and host are required");
+
+    return function (serviceName, onError) {
+
+      onData = wrapHandler(onData, onError);
+      onDrain = wrapHandler(onDrain, onError);
+
+      var socket = connect(host, port, onError);
+      var inter = makeChannel();
+      inter.put = pktLine.deframer(inter.put);
+
+      socket.put = pktLine.framer(socket.put);
+      var greeting = bodec.fromRaw(serviceName + " " + path + "\0host=" + host + "\0");
+      socket.put(greeting);
+
+      // Pipe socket to inter with backpressure
+      socket.take(onData);
+      function onData(chunk) {
+        if (inter.put(chunk)) {
+          socket.take(onData);
+        }
+        else {
+          inter.drain(onDrain);
+        }
+      }
+      function onDrain() {
+        socket.take(onData);
+      }
+
+      return {
+        put: socket.put,
+        drain: socket.drain,
+        take: inter.take
+      };
+    };
+  };
+};