gitoe 0.1.0

data/lib/gitoe.rb

@@ -0,0 +1,16 @@
+require "gitoe/version"
+
+start = Time.now
+
+$gitoe_debug = (ENV['RACK_ENV'] == 'development')
+$gitoe_log = lambda do |str|
+  if $gitoe_debug
+    $stderr.puts "#{ Time.now - start }s : #{str}"
+    true
+  else
+    false
+  end
+end
+
+module Gitoe
+end

data/lib/gitoe/httpserver/public/gitoe-draw.js

@@ -0,0 +1,399 @@
+(function() {
+  var $, DAGLayout, GitoeCanvas, R, clone, strcmp, _ref,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  $ = jQuery || (function() {
+    throw "demand jQuery";
+  })();
+
+  R = Raphael || (function() {
+    throw "demand Raphael";
+  })();
+
+  clone = function(obj) {
+    return $.extend({}, obj);
+  };
+
+  strcmp = exports.gitoe.strcmp;
+
+  DAGLayout = (function() {
+    function DAGLayout(cb) {
+      this.cb = cb;
+      this.query_pos = __bind(this.query_pos, this);
+      this.query_parents = __bind(this.query_parents, this);
+      this.add_node = __bind(this.add_node, this);
+      this.children = {};
+      this.parents = {};
+      this.layer = {};
+      this.position = {};
+      this.grid = {};
+      this.layer_span = {};
+    }
+
+    DAGLayout.prototype.add_node = function(id, parents) {
+      var layer, layer_span, pos;
+
+      this.topo(id, parents);
+      layer = this.get_layer(id);
+      layer_span = this.get_layer_span(id, layer);
+      pos = this.get_position(id, layer, layer_span);
+      return this.cb.draw_node(id, layer, pos, layer_span);
+    };
+
+    DAGLayout.prototype.get_layer = function(id) {
+      var layer, parent, parent_layer, _base, _i, _len, _ref, _ref1;
+
+      layer = 0;
+      _ref = this.parents[id];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        parent = _ref[_i];
+        parent_layer = this.layer[parent];
+        if (parent_layer >= layer) {
+          layer = parent_layer + 1;
+        }
+      }
+      if ((_ref1 = (_base = this.grid)[layer]) == null) {
+        _base[layer] = [];
+      }
+      return this.layer[id] = layer;
+    };
+
+    DAGLayout.prototype.get_layer_span = function(id, layer) {
+      var l, layer_span, parent, parent_layer, _i, _len, _ref;
+
+      layer_span = 1;
+      l = {};
+      _ref = this.parents[id];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        parent = _ref[_i];
+        parent_layer = this.layer[parent];
+        l[parent] = parent_layer;
+        if (parent_layer + layer_span < layer) {
+          layer_span = layer - parent_layer;
+        }
+      }
+      return this.layer_span[id] = layer_span;
+    };
+
+    DAGLayout.prototype.get_position = function(id, layer, layer_span) {
+      var conflict, grid, layers_to_check, occupied, position, _i, _j, _len, _ref, _ref1, _results;
+
+      position = -1;
+      conflict = true;
+      layers_to_check = (function() {
+        _results = [];
+        for (var _i = _ref = layer - layer_span + 1, _ref1 = layer; _ref <= _ref1 ? _i <= _ref1 : _i >= _ref1; _ref <= _ref1 ? _i++ : _i--){ _results.push(_i); }
+        return _results;
+      }).apply(this);
+      grid = this.grid;
+      while (conflict) {
+        position++;
+        occupied = layers_to_check.filter(function(layer) {
+          return grid[layer][position];
+        });
+        if (occupied.length === 0) {
+          conflict = false;
+        }
+      }
+      for (_j = 0, _len = layers_to_check.length; _j < _len; _j++) {
+        layer = layers_to_check[_j];
+        this.grid[layer][position] = id;
+      }
+      return this.position[id] = position;
+    };
+
+    DAGLayout.prototype.topo = function(id, parents) {
+      var cs, parent, _i, _len;
+
+      for (_i = 0, _len = parents.length; _i < _len; _i++) {
+        parent = parents[_i];
+        cs = this.children[parent];
+        if (cs === void 0) {
+          throw "<" + id + "> added before its parent <" + parent + ">";
+        } else {
+          cs.push(id);
+        }
+      }
+      if (this.parents[id]) {
+        throw "<" + id + "> added more than once";
+      }
+      this.parents[id] = parents;
+      return this.children[id] = [];
+    };
+
+    DAGLayout.prototype.query_parents = function(id) {
+      return this.parents[id];
+    };
+
+    DAGLayout.prototype.query_pos = function(id) {
+      return {
+        layer: this.layer[id],
+        pos: this.position[id]
+      };
+    };
+
+    return DAGLayout;
+
+  })();
+
+  GitoeCanvas = (function() {
+    GitoeCanvas.CONST = {
+      canvas: {
+        width: 300,
+        height: 100
+      },
+      padding_left: 60,
+      padding_top: 40,
+      outer_width: 80,
+      outer_height: 60,
+      commit_handle: 10,
+      box: {
+        width: 60,
+        height: 20,
+        radius: 2,
+        attr: {
+          fill: "lightblue",
+          "stroke-width": 2,
+          stroke: 'black'
+        }
+      },
+      text_attr: {
+        'font-family': 'mono',
+        'font-size': 12
+      },
+      path_style: {
+        fill: 'pink',
+        strokeWidth: 3
+      }
+    };
+
+    function GitoeCanvas(id_container) {
+      this.draw_async = __bind(this.draw_async, this);
+      this.add_commit_async = __bind(this.add_commit_async, this);      this.dag = new DAGLayout({
+        draw_node: this.draw_async
+      });
+      this.constant = clone(GitoeCanvas.CONST);
+      this.init_canvas(id_container);
+      this.objs = {};
+      this.div = $("#" + id_container);
+      this.ref_objs = {};
+    }
+
+    GitoeCanvas.prototype.add_commit_async = function(commit) {
+      return setTimeout(this.add_commit.bind(this, commit), 500);
+    };
+
+    GitoeCanvas.prototype.draw_async = function(sha1, layer, pos) {
+      return setTimeout(this.draw.bind(this, sha1, layer, pos), 0);
+    };
+
+    GitoeCanvas.prototype.add_commit = function(commit) {
+      return this.dag.add_node(commit.sha1, commit.parents);
+    };
+
+    GitoeCanvas.prototype.draw = function(sha1, layer, pos) {
+      var commit_box, coord, need_focus, parents, paths, text;
+
+      if (this.objs[sha1]) {
+        this.destroy(sha1);
+      }
+      coord = this.commit_coord(layer, pos);
+      parents = this.dag.query_parents(sha1).map(this.dag.query_pos);
+      commit_box = this.draw_commit_box(coord);
+      text = this.draw_commit_text(coord, sha1);
+      paths = this.draw_paths(coord, parents);
+      need_focus = !!(this.canvas_inc_height(coord.top) + this.canvas_inc_width(coord.left));
+      if (need_focus) {
+        this.focus(coord);
+      }
+      return this.objs[sha1] = {
+        commit_box: commit_box,
+        text: text,
+        paths: paths
+      };
+    };
+
+    GitoeCanvas.prototype.clear_refs = function() {
+      var obj, objs, ref_name, _ref, _results;
+
+      _ref = this.ref_objs;
+      _results = [];
+      for (ref_name in _ref) {
+        objs = _ref[ref_name];
+        _results.push((function() {
+          var _i, _len, _ref1, _results1;
+
+          _ref1 = objs || [];
+          _results1 = [];
+          for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+            obj = _ref1[_i];
+            _results1.push(obj.remove());
+          }
+          return _results1;
+        })());
+      }
+      return _results;
+    };
+
+    GitoeCanvas.prototype.set_refs = function(refs) {
+      var ref_index, ref_name, ref_names_sorted, _i, _len, _results;
+
+      this.clear_refs();
+      ref_names_sorted = Object.keys(refs).sort(strcmp);
+      _results = [];
+      for (ref_index = _i = 0, _len = ref_names_sorted.length; _i < _len; ref_index = ++_i) {
+        ref_name = ref_names_sorted[ref_index];
+        _results.push(this.ref_objs[ref_name] = this.draw_ref(ref_index, ref_name, refs[ref_name]));
+      }
+      return _results;
+    };
+
+    GitoeCanvas.prototype.draw_ref = function(ref_index, ref_name, sha1s) {
+      var coord_last, p_last, sha1_last;
+
+      sha1_last = sha1s[sha1s.length - 1];
+      p_last = this.dag.query_pos(sha1_last);
+      coord_last = this.commit_coord(p_last.layer, p_last.pos);
+      this.focus(this.commit_coord(p_last.layer, p_last.pos));
+      return [this.draw_ref_path(ref_index, sha1s), this.draw_ref_text(ref_index, coord_last, ref_name), this.draw_ref_pointer(ref_index, coord_last)];
+    };
+
+    GitoeCanvas.prototype.draw_ref_pointer = function(ref_index, p_last) {
+      return this.canvas.path();
+    };
+
+    GitoeCanvas.prototype.draw_ref_text = function(ref_index, coord_last, ref_name) {
+      console.log(ref_index, coord_last, ref_name);
+      return this.canvas.text(coord_last.left + this.constant.box.width + (0.6 + ref_index) * 30 + ref_name.length * 2, coord_last.top + this.constant.box.height * (1 + ref_index) / 3, ref_name).attr(this.constant.text_attr);
+    };
+
+    GitoeCanvas.prototype.draw_ref_path = function(ref_index, sha1s, textbox_width) {
+      var command_array, current, handler_top, index, prev, sha1, _i, _len;
+
+      command_array = [];
+      current = prev = null;
+      handler_top = this.constant.box.height * (1 + ref_index) / 3;
+      for (index = _i = 0, _len = sha1s.length; _i < _len; index = ++_i) {
+        sha1 = sha1s[index];
+        prev = current;
+        current = this.commit_coord_by_sha1(sha1);
+        if (index === 0) {
+          command_array.push.apply(command_array, ['M', current.left + this.constant.box.width, current.top + handler_top]);
+        } else {
+          command_array.push.apply(command_array, ['Q', 50 + ref_index * 40 + this.constant.box.width + Math.max(current.left, prev.left), (current.top + prev.top) / 2 + handler_top - 35, this.constant.box.width + current.left, current.top + handler_top]);
+        }
+      }
+      return this.canvas.path(command_array.join(' '));
+    };
+
+    GitoeCanvas.prototype.commit_coord = function(layer, pos) {
+      return {
+        left: this.constant.padding_left + this.constant.outer_width * pos,
+        top: this.constant.padding_top + this.constant.outer_height * layer
+      };
+    };
+
+    GitoeCanvas.prototype.commit_coord_by_sha1 = function(sha1) {
+      var p;
+
+      p = this.dag.query_pos(sha1);
+      return this.commit_coord(p.layer, p.pos);
+    };
+
+    GitoeCanvas.prototype.draw_commit_box = function(coord) {
+      return this.canvas.rect(coord.left, coord.top, this.constant.box.width, this.constant.box.height, this.constant.box.radius).attr(this.constant.box.attr);
+    };
+
+    GitoeCanvas.prototype.draw_commit_text = function(coord, sha1) {
+      return this.canvas.text(coord.left + this.constant.box.width / 2, coord.top + this.constant.box.height / 2, sha1.slice(0, 8)).attr(this.constant.text_attr);
+    };
+
+    GitoeCanvas.prototype.draw_paths = function(coord, parents_pos) {
+      var coord_p, p, path_command, paths, start, _i, _len;
+
+      paths = [];
+      start = ['M', coord.left + this.constant.box.width / 2, coord.top].join(' ');
+      for (_i = 0, _len = parents_pos.length; _i < _len; _i++) {
+        p = parents_pos[_i];
+        coord_p = this.commit_coord(p.layer, p.pos);
+        path_command = this.path_command(coord, coord_p);
+        if (path_command) {
+          paths.push(this.canvas.path(start + path_command));
+        }
+      }
+      return paths;
+    };
+
+    GitoeCanvas.prototype.path_command = function(coord, coord_p) {
+      var bottom_of_parent, ratio, top_of_highest_fake_node, vertical_distance;
+
+      bottom_of_parent = {
+        x: coord_p.left + this.constant.box.width / 2,
+        y: coord_p.top + this.constant.box.height
+      };
+      top_of_highest_fake_node = {
+        x: coord.left + this.constant.box.width / 2,
+        y: coord_p.top + this.constant.outer_height
+      };
+      if (coord.left === coord_p.left) {
+        return ['L', bottom_of_parent.x, bottom_of_parent.y].join(' ');
+      } else {
+        vertical_distance = this.constant.outer_height - this.constant.box.height;
+        ratio = 0.3;
+        return ['L', top_of_highest_fake_node.x, top_of_highest_fake_node.y, 'C', top_of_highest_fake_node.x, this.mix(top_of_highest_fake_node.y, bottom_of_parent.y, ratio), bottom_of_parent.x, this.mix(top_of_highest_fake_node.y, bottom_of_parent.y, 1 - ratio), bottom_of_parent.x, bottom_of_parent.y].join(' ');
+      }
+    };
+
+    GitoeCanvas.prototype.mix = function(a, b, ratio) {
+      return a * ratio + b * (1 - ratio);
+    };
+
+    GitoeCanvas.prototype.focus = function(coord) {
+      return this.div.scrollTo({
+        left: coord.left - 200,
+        top: coord.top - 200
+      });
+    };
+
+    GitoeCanvas.prototype.init_canvas = function(id_canvas) {
+      this.canvas_size = clone(this.constant.canvas);
+      return this.canvas = R(id_canvas, this.canvas_size.width, this.canvas_size.height);
+    };
+
+    GitoeCanvas.prototype.canvas_inc_width = function(left) {
+      if (left + this.constant.outer_width > this.canvas_size.width) {
+        this.canvas_size.width += 1 * this.constant.outer_width;
+        this.canvas_resize();
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    GitoeCanvas.prototype.canvas_inc_height = function(top) {
+      if (top + this.constant.outer_height > this.canvas_size.height) {
+        this.canvas_size.height += 1 * this.constant.outer_height;
+        this.canvas_resize();
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    GitoeCanvas.prototype.canvas_resize = function() {
+      return this.canvas.setSize(this.canvas_size.width, this.canvas_size.height);
+    };
+
+    return GitoeCanvas;
+
+  })();
+
+  if ((_ref = this.exports) == null) {
+    this.exports = {
+      gitoe: {}
+    };
+  }
+
+  exports.gitoe.GitoeCanvas = GitoeCanvas;
+
+}).call(this);

data/lib/gitoe/httpserver/public/gitoe-repo.js

@@ -0,0 +1,618 @@
+(function() {
+  var $, DAGtopo, GitoeChange, GitoeHistorian, GitoeRepo, OrderedSet, clone, exec_callback, local, strcmp, uniq, url_root, _ref,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  $ = jQuery || (function() {
+    throw "demand jQuery";
+  })();
+
+  url_root = "/repo";
+
+  exec_callback = function(context, fun, args) {
+    return fun.apply(context, args);
+  };
+
+  clone = function(obj) {
+    return $.extend({}, obj);
+  };
+
+  local = '##??!';
+
+  uniq = function(old_array, ignore_list) {
+    var elem, i, ignore, new_array, _i, _j, _len, _len1;
+
+    if (ignore_list == null) {
+      ignore_list = ['0000000000000000000000000000000000000000'];
+    }
+    ignore = {};
+    for (_i = 0, _len = ignore_list.length; _i < _len; _i++) {
+      i = ignore_list[_i];
+      ignore[i] = true;
+    }
+    new_array = [];
+    for (_j = 0, _len1 = old_array.length; _j < _len1; _j++) {
+      elem = old_array[_j];
+      if (!ignore[elem]) {
+        ignore[elem] = true;
+        new_array.push(elem);
+      }
+    }
+    return new_array;
+  };
+
+  strcmp = function(str1, str2, pos) {
+    var c1, c2;
+
+    if (pos == null) {
+      pos = 0;
+    }
+    c1 = str1.charAt(pos);
+    c2 = str2.charAt(pos);
+    if (c1 < c2) {
+      return 1;
+    } else if (c1 > c2) {
+      return -1;
+    } else if (c1 === '') {
+      return 0;
+    } else {
+      return strcmp(str1, str2, pos + 1);
+    }
+  };
+
+  OrderedSet = (function() {
+    function OrderedSet() {
+      this.elems = [];
+      this.hash = {};
+    }
+
+    OrderedSet.prototype.push = function(new_elem) {
+      if (!this.hash[new_elem]) {
+        this.hash[new_elem] = true;
+        this.elems.push(new_elem);
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    OrderedSet.prototype.length = function() {
+      return this.elems.length;
+    };
+
+    OrderedSet.prototype.shift = function() {
+      var ret;
+
+      if (!(this.elems.length > 0)) {
+        throw "empty";
+      }
+      ret = this.elems.shift();
+      delete this.hash[ret];
+      return ret;
+    };
+
+    return OrderedSet;
+
+  })();
+
+  DAGtopo = (function() {
+    function DAGtopo() {
+      this.edges = {};
+    }
+
+    DAGtopo.prototype.add_edge = function(from, to) {
+      var _base, _base1, _ref, _ref1;
+
+      if ((_ref = (_base = this.edges)[from]) == null) {
+        _base[from] = [];
+      }
+      if ((_ref1 = (_base1 = this.edges)[to]) == null) {
+        _base1[to] = [];
+      }
+      return this.edges[from].push(to);
+    };
+
+    DAGtopo.prototype.sort = function() {
+      var from, in_degree, node, nodes_whose_in_degree_is_0, sorted, to, to_s, _i, _j, _len, _len1, _ref, _ref1, _ref2, _ref3;
+
+      in_degree = {};
+      _ref = this.edges;
+      for (from in _ref) {
+        to_s = _ref[from];
+        if ((_ref1 = in_degree[from]) == null) {
+          in_degree[from] = 0;
+        }
+        for (_i = 0, _len = to_s.length; _i < _len; _i++) {
+          to = to_s[_i];
+          if ((_ref2 = in_degree[to]) == null) {
+            in_degree[to] = 0;
+          }
+          in_degree[to]++;
+        }
+      }
+      sorted = [];
+      nodes_whose_in_degree_is_0 = Object.keys(in_degree).filter(function(node) {
+        return in_degree[node] === 0;
+      });
+      while (nodes_whose_in_degree_is_0.length > 0) {
+        node = nodes_whose_in_degree_is_0.shift();
+        delete in_degree[node];
+        sorted.push(node);
+        _ref3 = this.edges[node];
+        for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
+          to = _ref3[_j];
+          if (--in_degree[to] === 0) {
+            nodes_whose_in_degree_is_0.push(to);
+          }
+        }
+      }
+      return sorted;
+    };
+
+    return DAGtopo;
+
+  })();
+
+  GitoeChange = (function() {
+    GitoeChange.parse = function(repos) {
+      var change, changes, grouped_changes, ref_content, ref_name, repo_content, repo_name, _i, _len, _ref;
+
+      changes = [];
+      for (repo_name in repos) {
+        repo_content = repos[repo_name];
+        for (ref_name in repo_content) {
+          ref_content = repo_content[ref_name];
+          _ref = ref_content.log;
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            change = _ref[_i];
+            change['repo_name'] = repo_name;
+            change["ref_name"] = ref_name;
+            changes.push(change);
+          }
+        }
+      }
+      changes.sort(function(a, b) {
+        return (a.committer.time - b.committer.time) || strcmp(a.repo_name, b.repo_name) || -((a.ref_name === "HEAD") - (b.ref_name === "HEAD")) || strcmp(a.ref_name, b.ref_name);
+      });
+      grouped_changes = this.group(changes);
+      console.log(changes, grouped_changes);
+      return grouped_changes.map(function(group) {
+        return new GitoeChange(group);
+      });
+    };
+
+    GitoeChange.group = function(changes) {
+      var begin, change, end, groups, next, _i, _len;
+
+      groups = [];
+      begin = 0;
+      for (end = _i = 0, _len = changes.length; _i < _len; end = ++_i) {
+        change = changes[end];
+        next = changes[end + 1];
+        if ((change.ref_name !== "HEAD") || (/^rebase: aborting/.test(change.message)) || (end === changes.length - 1) || (next.repo_name !== change.repo_name) || (/^checkout:/.test(change.message) && !/^(rebase|cherry-pick)/.test(next.message))) {
+          groups.push(changes.slice(begin, +end + 1 || 9e9));
+          begin = end + 1;
+        }
+      }
+      return groups;
+    };
+
+    function GitoeChange(changes) {
+      this.main = changes[changes.length - 1];
+      if (changes.length > 1) {
+        this.rest = changes.slice(0, +(changes.length - 2) + 1 || 9e9);
+      } else {
+        this.rest = [];
+      }
+      if (this.main.repo_name === local) {
+        this.is_local = true;
+      } else {
+        this.is_local = false;
+      }
+    }
+
+    GitoeChange.prototype.to_html = function() {
+      var html, matched, pattern, regex, rules, _ref;
+
+      rules = GitoeChange.message_rules;
+      html = GitoeChange.html;
+      _ref = rules.patterns;
+      for (pattern in _ref) {
+        regex = _ref[pattern];
+        if (matched = this.main.message.match(regex)) {
+          return rules.actions[pattern].apply(html, [matched, this.main, this.rest]).addClass("reflog");
+        }
+      }
+      console.log("not recognized change : ", this.main, this.rest);
+      return $('<li>').text("???").addClass("unknown");
+    };
+
+    GitoeChange.prototype.on_click = function() {
+      var change, fullname, ref_fullname, refs, sha1_s, _i, _len, _ref, _ref1, _ref2;
+
+      refs = {};
+      ref_fullname = GitoeChange.html.ref_fullname;
+      _ref = this.rest;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        change = _ref[_i];
+        fullname = ref_fullname(change);
+        if ((_ref1 = refs[fullname]) == null) {
+          refs[fullname] = [];
+        }
+        refs[fullname].push(change.oid_old);
+        refs[fullname].push(change.oid_new);
+      }
+      fullname = ref_fullname(this.main);
+      if ((_ref2 = refs[fullname]) == null) {
+        refs[fullname] = [];
+      }
+      refs[fullname].push(this.main.oid_old);
+      refs[fullname].push(this.main.oid_new);
+      for (fullname in refs) {
+        sha1_s = refs[fullname];
+        refs[fullname] = uniq(sha1_s);
+      }
+      return function() {
+        return this.set_refs(refs);
+      };
+    };
+
+    GitoeChange.html = {
+      span: function(text, classes) {
+        return $("<span>").text(text).addClass(classes);
+      },
+      li: function(content, classes) {
+        return $("<li>").append(content).addClass(classes);
+      },
+      ref: function(text) {
+        return this.span(text, 'ref_name');
+      },
+      ref_fullname: function(change) {
+        if (change.repo_name === local) {
+          return change.ref_name;
+        } else {
+          return "" + change.repo_name + "/" + change.ref_name;
+        }
+      },
+      git_command: function(text) {
+        return this.span(text, "git_command");
+      },
+      ref_realname: function(ref_name) {
+        var splited;
+
+        splited = ref_name.split("/");
+        if (splited[0] === "HEAD") {
+          return "HEAD";
+        } else if (splited[0] === "refs") {
+          switch (splited[1]) {
+            case "heads":
+              return splited[2];
+            case "remotes":
+              return "" + splited[2] + "/" + splited[3];
+            case "tags":
+              return splited[2];
+            default:
+              console.log("not recognized", ref_name);
+              return "???";
+          }
+        } else {
+          console.log("not recognized", ref_name);
+          return "???";
+        }
+      },
+      sha1_commit: function(sha1) {
+        return this.span(sha1, "sha1_commit");
+      },
+      br: function() {
+        return $('<br>');
+      }
+    };
+
+    GitoeChange.message_rules = {
+      patterns: {
+        clone: /^clone: from (.*)/,
+        branch: /^branch: Created from (.*)/,
+        commit: /^commit: /,
+        commit_amend: /^commit \(amend\): /,
+        merge_commit: /^commit \(merge\): Merge branch '?([^ ]+)'? into '?([^ ]+)'?$/,
+        merge_ff: /^merge ([^:]*):/,
+        reset: /^reset: moving to (.*)/,
+        push: /^update by push/,
+        pull: /^pull: /,
+        fetch: /^fetch/,
+        checkout: /^checkout: moving from ([^ ]+) to ([^ ]+)/,
+        rename_remote: /^remote: renamed ([^ ]+) to ([^ ]+)/,
+        rebase_finish: /^rebase (-[^ ]+)? \(finish\): returning to (.*)/,
+        rebase_finish2: /^rebase (-[^ ]+)? \(finish\): ([^ ]+) onto/,
+        rebase_finish3: /^rebase (-[^ ]+ )?finished: ([^ ]+) onto/,
+        rebase_abort: /^rebase: aborting/
+      },
+      actions: {
+        clone: function(matched, change) {
+          return this.li([this.git_command("git clone"), this.span(": create "), this.ref(this.ref_fullname(change)), this.span(" at "), this.sha1_commit(change.oid_new)]);
+        },
+        branch: function(matched, change) {
+          return this.li([this.git_command("git branch"), this.span(": branch out "), this.ref(this.ref_fullname(change)), this.span(" at "), this.sha1_commit(change.oid_new), /^refs/.test(matched[1]) ? this.span(" (was ") : void 0, /^refs/.test(matched[1]) ? this.ref(this.ref_realname(matched[1])) : void 0, /^refs/.test(matched[1]) ? this.span(" )") : void 0]);
+        },
+        commit: function(matched, change) {
+          return this.li([this.git_command("git commit"), this.span(": move "), this.ref(this.ref_fullname(change)), this.span(" from "), this.sha1_commit(change.oid_old), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        merge_commit: function(matched, change) {
+          return this.li([this.git_command("git merge"), this.span(": move "), this.span(matched[2], "ref_name"), this.span(' to '), this.sha1_commit(change.oid_new), this.span(' by merging '), this.span(matched[1], "ref_name")]);
+        },
+        commit_amend: function(matched, change) {
+          return this.li([this.git_command("git commit --amend"), this.span(": move "), this.ref(this.ref_fullname(change)), this.span(" from "), this.sha1_commit(change.oid_old), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        merge_ff: function(matched, change) {
+          return this.li([this.git_command("git merge"), this.span(": move "), this.ref(this.ref_fullname(change)), this.span(' to '), this.sha1_commit(change.oid_new), this.span(' by merging '), this.span(matched[1], "ref_name")]);
+        },
+        reset: function(matched, change) {
+          return this.li([this.git_command("git reset"), this.span(": point "), this.ref(this.ref_fullname(change)), this.span(" to "), this.sha1_commit(change.oid_new), this.span(" ( was "), this.sha1_commit(change.oid_old), this.span(" )")]);
+        },
+        push: function(matched, change) {
+          return this.li([this.git_command("git push"), this.span(": update "), this.ref(this.ref_fullname(change)), this.span(" to "), this.sha1_commit(change.oid_new), change.oid_old !== "0000000000000000000000000000000000000000" ? this.span(" ( was ") : void 0, change.oid_old !== "0000000000000000000000000000000000000000" ? this.sha1_commit(change.oid_old) : void 0, change.oid_old !== "0000000000000000000000000000000000000000" ? this.span(" )") : void 0]);
+        },
+        fetch: function(matched, change) {
+          return this.li([this.git_command("git fetch"), this.span(": update "), this.ref(this.ref_fullname(change)), this.span(" to "), this.sha1_commit(change.oid_new), change.oid_old !== "0000000000000000000000000000000000000000" ? this.span(" ( was ") : void 0, change.oid_old !== "0000000000000000000000000000000000000000" ? this.sha1_commit(change.oid_old) : void 0, change.oid_old !== "0000000000000000000000000000000000000000" ? this.span(" )") : void 0]);
+        },
+        pull: function(matched, change) {
+          return this.li([this.git_command("git pull"), this.span(": update "), this.ref(this.ref_fullname(change)), this.span(" from "), this.sha1_commit(change.oid_old), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        checkout: function(matched, change, rest) {
+          return this.li([this.git_command("git checkout"), this.span(": checkout "), this.ref(matched[2]), this.span(" at "), this.sha1_commit(change.oid_new)]);
+        },
+        rename_remote: function(matched, change) {
+          return this.li([this.git_command("git remote rename"), this.span(": rename "), this.ref(this.ref_realname(matched[1])), this.span(" to "), this.ref(this.ref_realname(matched[2]))]);
+        },
+        rebase_finish: function(matched, change) {
+          return this.li([matched[1] ? this.git_command("git rebase " + matched[1]) : this.git_command("git rebase"), this.span(": rebase "), this.ref(this.ref_realname(matched[2])), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        rebase_finish2: function(matched, change) {
+          return this.li([matched[1] ? this.git_command("git rebase " + matched[1]) : this.git_command("git rebase"), this.span(": rebase "), this.ref(this.ref_fullname(change)), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        rebase_finish3: function(matched, change) {
+          return this.li([matched[1] ? this.git_command("git rebase " + matched[1]) : this.git_command("git rebase"), this.span(": rebase "), this.ref(this.ref_fullname(change)), this.span(" to "), this.sha1_commit(change.oid_new)]);
+        },
+        rebase_abort: function(matched, change, rest) {
+          var matched_head, real_ref;
+
+          if (rest.length > 0) {
+            if (matched_head = rest[0].message.match(/^checkout: moving from ([^ ]+)/)) {
+              real_ref = matched_head[1];
+            }
+          }
+          return this.li([this.git_command("git rebase --abort"), this.span(": didn't rebase "), real_ref ? this.ref(real_ref) : void 0]);
+        }
+      }
+    };
+
+    return GitoeChange;
+
+  })();
+
+  GitoeHistorian = (function() {
+    function GitoeHistorian() {
+      this.cb = {};
+    }
+
+    GitoeHistorian.prototype.set_cb = function(new_cb) {
+      var fun, name, _results;
+
+      _results = [];
+      for (name in new_cb) {
+        fun = new_cb[name];
+        _results.push(this.cb[name] = fun);
+      }
+      return _results;
+    };
+
+    GitoeHistorian.prototype.parse = function(refs) {
+      var changes, classified, _base, _base1;
+
+      classified = this.classify(clone(refs));
+      console.log(classified);
+      if (typeof (_base = this.cb).update_num_tags === "function") {
+        _base.update_num_tags(Object.keys(classified.tags).length);
+      }
+      changes = GitoeChange.parse(classified.repos);
+      return typeof (_base1 = this.cb).update_reflog === "function" ? _base1.update_reflog(changes) : void 0;
+    };
+
+    GitoeHistorian.prototype.classify = function(refs) {
+      var ref_content, ref_name, repos, splited, tags, _name, _ref, _ref1, _ref2;
+
+      repos = {};
+      tags = {};
+      for (ref_name in refs) {
+        ref_content = refs[ref_name];
+        splited = ref_name.split("/");
+        if (splited[0] === "HEAD" && splited.length === 1) {
+          if ((_ref = repos[local]) == null) {
+            repos[local] = {};
+          }
+          repos[local]["HEAD"] = ref_content;
+        } else if (splited[0] === "refs") {
+          switch (splited[1]) {
+            case "heads":
+              if ((_ref1 = repos[local]) == null) {
+                repos[local] = {};
+              }
+              repos[local][splited[2]] = ref_content;
+              break;
+            case "remotes":
+              if ((_ref2 = repos[_name = splited[2]]) == null) {
+                repos[_name] = {};
+              }
+              repos[splited[2]][splited[3]] = ref_content;
+              break;
+            case "tags":
+              tags[splited[2]] = ref_content;
+              break;
+            default:
+              console.log("not recognized", ref_name);
+          }
+        } else {
+          console.log("not recognized", ref_name);
+        }
+      }
+      return {
+        repos: repos,
+        tags: tags
+      };
+    };
+
+    return GitoeHistorian;
+
+  })();
+
+  GitoeRepo = (function() {
+    function GitoeRepo() {
+      this.ajax_error = __bind(this.ajax_error, this);
+      this.ajax_fetch_status_success = __bind(this.ajax_fetch_status_success, this);
+      this.ajax_fetch_commits_success = __bind(this.ajax_fetch_commits_success, this);
+      this.ajax_open_success = __bind(this.ajax_open_success, this);
+      this.fetch_commits = __bind(this.fetch_commits, this);
+      this.open = __bind(this.open, this);      this.commits_to_fetch = {};
+      this.commits_fetched = {};
+      this.cb = {};
+      this.commits_ignored = {
+        "0000000000000000000000000000000000000000": true
+      };
+    }
+
+    GitoeRepo.prototype.set_cb = function(new_cb) {
+      var fun, name, _results;
+
+      _results = [];
+      for (name in new_cb) {
+        fun = new_cb[name];
+        _results.push(this.cb[name] = fun);
+      }
+      return _results;
+    };
+
+    GitoeRepo.prototype.open = function(path, cb) {
+      if (cb == null) {
+        cb = {};
+      }
+      return $.post("" + url_root + "/new", {
+        path: path
+      }).fail(this.ajax_error, cb.fail).done(this.ajax_open_success, cb.success);
+    };
+
+    GitoeRepo.prototype.fetch_commits = function(cb) {
+      var param, to_query;
+
+      if (cb == null) {
+        cb = {};
+      }
+      if (!this.path) {
+        throw "not opened";
+      }
+      to_query = Object.keys(this.commits_to_fetch).slice(0, 10);
+      param = {
+        limit: 1000
+      };
+      return $.get("" + this.path + "/commits/" + (to_query.join()), param).fail(this.ajax_error, cb.fail).done(this.ajax_fetch_commits_success, cb.success);
+    };
+
+    GitoeRepo.prototype.fetch_status = function(cb) {
+      if (cb == null) {
+        cb = {};
+      }
+      return $.get("" + this.path + "/").fail(this.ajax_error, cb.fail).done(this.ajax_fetch_status_success, cb.success);
+    };
+
+    GitoeRepo.prototype.fetch_alldone = function() {
+      var child, content, parent, sha1, sorted_commits, sorter, _base, _i, _j, _len, _len1, _ref, _ref1, _results;
+
+      sorter = new DAGtopo;
+      _ref = this.commits_fetched;
+      for (child in _ref) {
+        content = _ref[child];
+        _ref1 = content.parents;
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          parent = _ref1[_i];
+          sorter.add_edge(parent, child);
+        }
+      }
+      sorted_commits = sorter.sort();
+      _results = [];
+      for (_j = 0, _len1 = sorted_commits.length; _j < _len1; _j++) {
+        sha1 = sorted_commits[_j];
+        _results.push(typeof (_base = this.cb).yield_commit === "function" ? _base.yield_commit(this.commits_fetched[sha1]) : void 0);
+      }
+      return _results;
+    };
+
+    GitoeRepo.prototype.ajax_open_success = function(json) {
+      if (this.path) {
+        throw "already opened";
+      }
+      return this.path = "" + url_root + "/" + json.id;
+    };
+
+    GitoeRepo.prototype.ajax_fetch_commits_success = function(json) {
+      var content, fetched, sha1, sha1_parent, to_fetch, _base, _base1, _i, _len, _ref;
+
+      for (sha1 in json) {
+        content = json[sha1];
+        delete this.commits_to_fetch[sha1];
+        (_base = this.commits_fetched)[sha1] || (_base[sha1] = content);
+        _ref = content.parents;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          sha1_parent = _ref[_i];
+          if (!(this.commits_fetched[sha1] || this.commits_ignored[sha1])) {
+            this.commits_to_fetch[sha1_parent] = true;
+          }
+        }
+      }
+      to_fetch = Object.keys(this.commits_to_fetch).length;
+      fetched = Object.keys(this.commits_fetched).length;
+      return typeof (_base1 = this.cb).fetched_commit === "function" ? _base1.fetched_commit(to_fetch, fetched) : void 0;
+    };
+
+    GitoeRepo.prototype.ajax_fetch_status_success = function(response) {
+      var change, field, ref, ref_name, sha1, _base, _i, _j, _len, _len1, _ref, _ref1, _ref2;
+
+      _ref = response.refs;
+      for (ref_name in _ref) {
+        ref = _ref[ref_name];
+        _ref1 = ref.log;
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          change = _ref1[_i];
+          _ref2 = ['oid_new', 'oid_old'];
+          for (_j = 0, _len1 = _ref2.length; _j < _len1; _j++) {
+            field = _ref2[_j];
+            sha1 = change[field];
+            if (!(this.commits_fetched[sha1] || this.commits_ignored[sha1])) {
+              this.commits_to_fetch[sha1] = true;
+            }
+          }
+        }
+      }
+      return typeof (_base = this.cb).fetch_status === "function" ? _base.fetch_status(response) : void 0;
+    };
+
+    GitoeRepo.prototype.ajax_error = function(jqXHR) {
+      var _base;
+
+      return typeof (_base = this.cb).ajax_error === "function" ? _base.ajax_error(jqXHR) : void 0;
+    };
+
+    return GitoeRepo;
+
+  })();
+
+  if ((_ref = this.exports) == null) {
+    this.exports = {
+      gitoe: {}
+    };
+  }
+
+  exports.gitoe.strcmp = strcmp;
+
+  exports.gitoe.GitoeRepo = GitoeRepo;
+
+  exports.gitoe.GitoeHistorian = GitoeHistorian;
+
+}).call(this);