dolt 0.23.0 → 0.24.0

data/vendor/ui/js/src/components/loading.js

@@ -0,0 +1,33 @@
+/*global Spinner, dome*/
+this.gts = this.gts || {};
+
+/**
+ * Put a spinner in an element that's waiting to be loaded with some content.
+ */
+this.gts.loading = function (element, options) {
+    dome.cn.add("loading", element);
+    element.innerHTML = "";
+    options = options || {};
+
+    var spinner = new Spinner({
+        lines: options.hasOwnProperty("lines") ? options.lines : 8,
+        length: options.hasOwnProperty("length") ? options.length : 2,
+        width: options.hasOwnProperty("width") ? options.width : 2,
+        radius: options.hasOwnProperty("radius") ? options.radius : 3,
+        color: options.color || "#000",
+        speed: options.hasOwnProperty("speed") ? options.speed : 1,
+        trail: options.hasOwnProperty("trail") ? options.trail : 100,
+        shadow: options.hasOwnProperty("shadow") ? options.shadow : false
+    }).spin();
+
+    spinner.el.style.top = options.topPos || "10px";
+    element.appendChild(spinner.el);
+
+    var text = options.hasOwnProperty("text") ? options.text : "Loading...";
+
+    if (text) {
+        var textEl = document.createElement("span");
+        textEl.innerHTML = text;
+        element.appendChild(textEl);
+    }
+};

data/vendor/ui/js/src/components/oid-ref-interpolator.js

@@ -0,0 +1,9 @@
+this.gts = this.gts || {};
+
+this.gts.oidRefInterpolator = function (element, refs, urlTemplate) {
+    var current = this.gts.refSelector.getCurrentRef("heads", element.innerHTML, refs);
+    if (current) {
+        element.title = current[1];
+        element.innerHTML = current[0];
+    }
+};

data/vendor/ui/js/src/components/profile-menu.js

@@ -8,6 +8,7 @@ var gts = this.gts || {};
  */
 (function (d, e) {
     function button(text, path, icon) {
+        text = " " + text;
         var content = icon ? [e.i({className: "icon-" + icon}), text] : [text];
         return e.li(e.a({ href: path }, content));
     }
@@ -30,5 +31,6 @@ var gts = this.gts || {};
                 button("Log out", user.logoutPath)
             ])
         ], root);
+        gts.dropdown(root);
     };
 }(dome, dome.el));

data/vendor/ui/js/src/components/rails-links.js

@@ -0,0 +1,24 @@
+/*global dome*/
+this.gts = this.gts || {};
+
+this.gts.railsLinks = function (csrfParam, csrfToken) {
+    dome.on(document.body, "click", function (e) {
+        var method = dome.data.get("method", e.target);
+        if (!method || method === "get") { return true; }
+        e.preventDefault();
+        e.stopPropagation();
+        var href = e.target.href;
+
+        var form = dome.el("form", {
+            method: "post",
+            action: href,
+            style: { display: "none" }
+        }, [
+            dome.el("input", { name: "_method", value: method, type: "hidden" }),
+            dome.el("input", { name: csrfParam, value: csrfToken, type: "hidden" })
+        ]);
+
+        document.body.appendChild(form);
+        form.submit();
+    });
+};

data/vendor/ui/js/src/components/ref-selector.js

@@ -105,10 +105,12 @@ this.gts.refSelector = (function (e) {
 
     function refSelector(placeholder, refs, ref, refUrlTemplate) {
         var selector = build(refs, ref, refUrlTemplate);
-        placeholder.appendChild(selector);
+        placeholder.parentNode.insertBefore(selector, placeholder);
+        placeholder.parentNode.removeChild(placeholder);
         this.gts.dropdown(selector);
     }
 
     refSelector.build = build;
+    refSelector.getCurrentRef = getCurrent;
     return refSelector;
 }(dome.el));

data/vendor/ui/js/src/components/repository.js

@@ -0,0 +1,161 @@
+/*global dome, gts*/
+this.gts = this.gts || {};
+
+this.gts.repository = (function (el) {
+    /**
+     * Build the repository admin tab into the menu if the data indicates that
+     * the current user can admin the repository. Initialize as a dropdown
+     * toggler if built.
+     */
+    function bullet(type, text) {
+        return [el.i({ className: type }), " " + text];
+    }
+
+    function link(href, type, text) {
+        return el.a({ href: href }, bullet(type, text));
+    }
+
+    function build(data, tagName) {
+        return el[tagName || "li"]({ className: "pull-right dropdown" }, [
+            el.a({
+                href: "#",
+                "data-toggle": "dropdown",
+                className: "dropdown-toggle"
+            }, bullet("icon-cog", "Admin")),
+            el.ul({ className: "dropdown-menu" }, [
+                el.li(link(data.editPath, "icon-pencil", "Edit repository")),
+                el.li(link(data.destroyPath, "icon-trash", "Delete repository")),
+                el.li({ className: "divider" }),
+                el.li(link(data.ownershipPath, "i", "Transfer ownership")),
+                el.li(link(data.committershipsPath, "i", "Manage collaborators"))
+            ])
+        ]);
+    }
+
+    function repositoryAdmin(placeholder, data) {
+        var toggler = build(data, placeholder.tagName.toLowerCase());
+        dome.replace(placeholder, toggler);
+        this.gts.dropdown(toggler);
+
+        if (dome.data.get("gts-active", toggler.parentNode) === "admin") {
+            dome.cn.add("active", toggler);
+        }
+    }
+
+    repositoryAdmin.build = build;
+
+    /**
+     * Generate and power the "Watch"/"Unwatch" button on repository pages. To
+     * use this component, put a placeholder on the page, and call
+     * repositoryWatching(placeHolder, repositoryWatch);
+     * 
+     * The viewstate object is expected to contain at least
+     *   - watching (boolean)
+     *   - watchPath (string)
+     *   - unwatchPath (string, only required if watching is true)
+     */
+    function render(link, repository) {
+        if (repository.watching) {
+            link.innerHTML = "<i class=\"icon icon-star\"></i> Unwatch";
+            link.href = repository.unwatchPath;
+        } else {
+            link.innerHTML = "<i class=\"icon icon-star-empty\"></i> Watch";
+            link.href = repository.watchPath;
+        }
+    }
+
+    function unwatch(link, repository) {
+        gts.request({
+            url: repository.unwatchPath,
+            method: "delete",
+            type: "js",
+            headers: {
+                "Accept": "application/javascript, text/javascript"
+            },
+            success: function (xhr) {
+                repository.watching = false;
+                render(link, repository);
+            },
+            error: function () {
+                link.innerHTML = "Failed, try watching again";
+            }
+        });
+    }
+
+    function watch(link, repository) {
+        gts.request({
+            url: repository.watchPath,
+            method: "post",
+            type: "text",
+            headers: {
+                "Accept": "application/javascript, text/javascript"
+            },
+            success: function (xhr) {
+                repository.watching = true;
+                repository.unwatchPath = xhr.getResponseHeader("location");
+                render(link, repository);
+            },
+            error: function () {
+                link.innerHTML = "Failed, try unwatching again";
+            }
+        });
+    }
+
+    function toggleState(link, repository) {
+        gts.loading(link);
+        if (repository.watching) {
+            unwatch(link, repository);
+        } else {
+            watch(link, repository);
+        }
+    }
+
+    function repositoryWatching(ph, repositoryWatch) {
+        var link = dome.el("a", { className: "btn" });
+        dome.replace(ph, link);
+        render(link, repositoryWatch);
+        dome.on(link, "click", function (e) {
+            e.preventDefault();
+            e.stopPropagation();
+            toggleState(link, repositoryWatch);
+        });
+    };
+
+    repositoryWatching.watch = watch;
+    repositoryWatching.unwatch = unwatch;
+    repositoryWatching.toggleState = toggleState;
+    repositoryWatching.render = render;
+
+    /**
+     * Display button to clone repository if the current user is
+     * offered a clone URL
+     */
+    function repositoryCloning(placeholder, repository) {
+        if (!repository.clonePath) { return; }
+        dome.replace(placeholder, dome.el("a", {
+            href: repository.clonePath,
+            className: "btn"
+        }, "Clone"));
+    }
+
+    /**
+     * Display button to merge repository clone if the current user
+     * is offered a request merge URL.
+     */
+    function mergeRequest(placeholder, repository) {
+        if (!repository.requestMergePath) { return; }
+        dome.replace(placeholder, dome.el("li", { className: "pull-right" }, [
+            dome.el("a", { href: repository.requestMergePath }, [
+                dome.el("i", { className: "icon icon-random" }),
+                " Request merge"
+            ])
+        ]));
+    }
+
+    return {
+        admin: repositoryAdmin,
+        watching: repositoryWatching,
+        cloning: repositoryCloning,
+        mergeRequest: mergeRequest
+    };
+}(dome.el));

data/vendor/ui/js/src/components/timeago.js

@@ -0,0 +1,38 @@
+/*global timeago, gts*/
+this.gts = this.gts || {};
+
+/**
+ * Replace content of <abbr> elements with a casual representation of the
+ * ISO8601 date in its title attribute.
+ */
+this.gts.timeago = (function (ta) {
+    function timeago(el, time) {
+        var date = ta.parse(time || el.title);
+        if (isNaN(date.getTime())) { return el; }
+        var text = el.innerHTML.trim() || el.title;
+        el.innerHTML = ta.relative(date);
+        el.title = text;
+        return el;
+    };
+
+    var cache = {};
+
+    timeago.periodic = function (timeout) {
+        if (!cache[timeout]) {
+            cache[timeout] = [];
+            setInterval(function () {
+                for (var i = 0, l = cache[timeout].length, item; i < l; ++i) {
+                    item = cache[timeout][i];
+                    gts.timeago(item.element, item.time);
+                }
+            }, timeout);
+        }
+
+        return function (el) {
+            cache[timeout].push({ element: el, time: el.title });
+            return timeago(el, el.title);
+        };
+    };
+
+    return timeago;
+}(timeago));

data/vendor/ui/js/src/components/url.js

@@ -52,7 +52,7 @@ this.gts.url = (function () {
     }
 
     function currentRef(url) {
-        var regexp = /(blame|blob|tree|history|raw|source|readme)\//;
+        var regexp = /(blame|blob|tree|history|raw|source|readme|commits)\//;
         var refPath = url.split(regexp)[2];
         return (refPath && refPath.split(":")[0]) || null;
     }

data/vendor/ui/js/src/gitorious.js

@@ -1,4 +1,4 @@
-/*global gts, reqwest, cull*/
+/*global gts, cull, reqwest*/
 
 // Environment variables
 gts.app.env("url", window.location.href);
@@ -10,6 +10,21 @@ if (window.hasOwnProperty("onpopstate")) {
     };
 }
 
+cull.doall(function (meta) {
+    if (meta.name === "csrf-param") {
+        gts.app.env("csrf-param", meta.content);
+    }
+    if (meta.name === "csrf-token") {
+        gts.app.env("csrf-token", meta.content);
+    }
+}, document.getElementsByTagName("meta"));
+
+gts.request = function (options) {
+    options.headers = options.headers || {};
+    options.headers["X-CSRF-Token"] = gts.app.env["csrf-token"];
+    reqwest(options);
+};
+
 // Data
 gts.app.data("ref-url-template", function (url, ref) {
     return gts.url.templatize(url, { ref: ref });
@@ -18,17 +33,23 @@ gts.app.data("ref-url-template", function (url, ref) {
     serializeArgs: function (url, ref) { return [url.split("#")[0], ref]; }
 });
 
-gts.app.data("repository-refs", function (url) {
-    return reqwest({ url: url, type: "json" });
-}, { depends: ["repository-refs-url"] });
-
+gts.app.data("repository-refs", this.gts.jsonRequest, { depends: ["repository-refs-url"] });
 gts.app.data("current-ref", gts.url.currentRef, { depends: ["url"] });
-gts.app.data("user-repo-view-state", gts.userRepoViewState, {
+gts.app.data("user-repo-view-state", gts.cache(gts.userRepoViewState), {
     depends: ["user-repository-path"]
 });
 gts.app.data("current-user", cull.prop("user"), {
     depends: ["user-repo-view-state"]
 });
+gts.app.data("current-repository", cull.prop("repository"), {
+    depends: ["user-repo-view-state"]
+});
+gts.app.data("repository-watch", cull.prop("watch"), {
+    depends: ["current-repository"]
+});
+gts.app.data("repository-admin", cull.prop("admin"), {
+    depends: ["current-repository"]
+});
 gts.app.data("blob-region", gts.blob.regionFromUrl, { depends: ["url"] });
 
 // Features
@@ -40,11 +61,20 @@ gts.app.feature("google-analytics", gts.googleAnalytics, {
     depends: ["analytics-account", "analytics-domain-name"]
 });
 
+gts.app.feature("dropdown", gts.dropdown, {
+    elements: ["dropdown"]
+});
+
 gts.app.feature("ref-selector", gts.refSelector, {
     elements: ["gts-ref-selector-ph"],
     depends: ["repository-refs", "current-ref", "ref-url-template"]
 });
 
+gts.app.feature("oid-ref-interpolator", gts.oidRefInterpolator, {
+    elements: ["gts-oid"],
+    depends: ["repository-refs", "ref-url-template"]
+});
+
 gts.app.feature("tree-history", gts.treeHistory, {
     elements: ["gts-tree-explorer"],
     depends: ["tree-history-url"]
@@ -78,11 +108,49 @@ gts.app.feature("live-markdown-preview", gts.liveMarkdownPreview, {
     elements: ["gts-live-markdown-preview"]
 });
 
+gts.app.feature("timeago", gts.timeago.periodic(60000), {
+    elements: ["timeago"]
+});
+
+gts.app.feature("collapse", gts.collapse);
+
+gts.app.feature("clone-name-suggestion", gts.cloneNameSuggestion, {
+    elements: ["clone-repository-form"]
+});
+
+gts.app.feature("loading", gts.loading, {
+    elements: ["loading"]
+});
+
+gts.app.feature("rails-links", gts.railsLinks, {
+    depends: ["csrf-param", "csrf-token"]
+});
+
+gts.app.feature("repository-admin-menu", gts.repository.admin, {
+    elements: ["gts-repository-admin-ph"],
+    depends: ["repository-admin"]
+});
+
+gts.app.feature("repository-watching", gts.repository.watching, {
+    elements: ["gts-watch-repository-ph"],
+    depends: ["repository-watch"]
+});
+
+gts.app.feature("repository-cloning", gts.repository.cloning, {
+    elements: ["gts-clone-repository-ph"],
+    depends: ["current-repository"]
+});
+
+gts.app.feature("repository-merge-request", gts.repository.mergeRequest, {
+    elements: ["gts-request-merge-ph"],
+    depends: ["current-repository"]
+});
+
 // Spin off app asynchronously so subsequent scripts have a chance
 // to register loggers etc before we roll
 setTimeout(function () {
     // Scan the document for data-gts-* attributes that set
     // "environment variables"
     gts.app.scanEnvAttrs(document.body, "data-gts-env-");
-    gts.app.load(document.body);
+    gts.app.load(document.documentElement);
 }, 10);

data/vendor/ui/js/src/json-request.js

@@ -0,0 +1,6 @@
+/*global reqwest*/
+this.gts = this.gts || {};
+
+this.gts.jsonRequest = function (url) {
+    return reqwest({ url: url, type: "json" });
+};

data/vendor/ui/js/src/spacer.js

@@ -0,0 +1,5 @@
+/**
+ * This is kinda sad, but sometimes needed in between scripts that do
+ * not work when concatenated.
+ */
+;

data/vendor/ui/js/test/cache-test.js

@@ -0,0 +1,47 @@
+/*global gts*/
+
+buster.testCase("Cache", {
+    "caches function": function () {
+        var spy = this.spy();
+        var fn = gts.cache(spy);
+        fn();
+        fn();
+        fn();
+
+        assert.calledOnce(spy);
+    },
+
+    "caches function's return value": function () {
+        var stub = this.stub().returns(42);
+        var fn = gts.cache(stub);
+
+        assert.equals(fn(), 42);
+        assert.equals(fn(), 42);
+        assert.equals(fn(), 42);
+    },
+
+    "caches function's return value per argument": function () {
+        var adder = 1;
+        var fn = gts.cache(function (a) {
+            return a + adder;
+        });
+
+        assert.equals(fn(1), 2);
+        adder = 2;
+        assert.equals(fn(1), 2);
+        assert.equals(fn(2), 4);
+    },
+
+    "caches function's return value per arguent set": function () {
+        var adder = 1;
+        var fn = gts.cache(function (a, b) {
+            return a + b + adder;
+        });
+
+        var object = { valueOf: this.stub().returns(1) };
+        assert.equals(fn(1, object), 3);
+        adder = 2;
+        assert.equals(fn(1, object), 3);
+        assert.equals(fn(2, object), 5);
+    }
+});

data/vendor/ui/js/test/components/blob-test.js

@@ -3,10 +3,10 @@
 buster.testCase("Blob", {
     setUp: function () {
         this.el = dome.el("ol", [
-            dome.el("li", { className: "L0" }, "First line"),
-            dome.el("li", { className: "L1" }, "Second line"),
-            dome.el("li", { className: "L2" }, "Third line"),
-            dome.el("li", { className: "L3" }, "Fourth line")
+            dome.el("li", { className: "L1" }, "First line"),
+            dome.el("li", { className: "L2" }, "Second line"),
+            dome.el("li", { className: "L3" }, "Third line"),
+            dome.el("li", { className: "L4" }, "Fourth line")
         ]);
     },
 

data/vendor/ui/js/test/components/clone-name-suggestion-test.js

@@ -0,0 +1,37 @@
+/*global buster, dome, gts*/
+
+buster.testCase("Clone name suggestion", {
+    setUp: function () {
+        this.form = dome.el("form", {
+            "data": { "gts-repository-to-clone": "gitorious" }
+        }, [
+            dome.el("input", {
+                checked: "checked",
+                id: "repository_owner_type_user",
+                name: "repository[owner_type]",
+                value: "User",
+                type: "radio",
+                data: { "gts-cloning-user": "christian" }
+            }),
+
+            dome.el("input", {
+                id: "repository_owner_type_group",
+                name: "repository[owner_type]",
+                type: "radio",
+                value: "Group"
+            }),
+
+            dome.el("select", {
+                id: "repository_owner_id_group_select",
+                name: "repository[owner_id]"
+            }, [
+                dome.el("option", { value: 1 }, "gitorians"),
+                dome.el("option", { value: 2 }, "blargians")
+            ])
+        ]);
+    },
+
+    "//suggests username-scoped clone name": function () {
+        
+    }
+});

data/vendor/ui/js/test/components/clone-url-selection-test.js

@@ -5,21 +5,21 @@ buster.testCase("Clone URL selection", {
         /*:DOC element = <div class="btn-group gts-repo-urls">
             <a class="btn gts-repo-url" href="git://gitorious.org/gitorious/mainline.git">Git</a>
             <a class="btn gts-repo-url" href="http://git.gitorious.org/gitorious/mainline.git">HTTP</a>
-            <a class="active btn gts-repo-url" href="git@gitorious.org:gitorious/mainline.git">SSH</a>
+            <a class="active btn gts-repo-url" href="ssh://git@gitorious.org:gitorious/mainline.git">SSH</a>
             <input class="span4 gts-current-repo-url gts-select-onfocus" type="url" value="git@gitorious.org:gitorious/mainline.git">
             <button data-toggle="collapse" data-target="#repo-url-help" class="gts-repo-url-help btn">?</button>
           </div>*/
         this.input = this.element.getElementsByTagName("input")[0];
-        document.body.appendChild(this.element);
-        var buttons = this.element.getElementsByTagName("a");
-        this.click = function (num) {
-            jQuery(buttons[num]).trigger("click");
-        };
+        this.buttons = this.element.getElementsByTagName("a");
     },
 
-    "// copies href to input on click": "Click triggering currently not working"
-    /*function () {
-        this.click(0);
+    "copies git:// href to input": function () {
+        gts.cloneUrlSelection.select(this.element, this.buttons[0]);
         assert.equals(this.input.value, "git://gitorious.org/gitorious/mainline.git");
-    }*/
+    },
+
+    "copies ssh:// href to input": function () {
+        gts.cloneUrlSelection.select(this.element, this.buttons[2]);
+        assert.equals(this.input.value, "git@gitorious.org:gitorious/mainline.git");
+    }
 });