path: root/js/guix-packages.js

// guix-web - Web interface for GNU Guix
// Copyright © 2014  David Thompson <davet@gnu.org>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU Affero General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public
// License along with this program.  If not, see
// <http://www.gnu.org/licenses/>.

var guix = {};

guix.chunk = function(array, size) {
  return array.reduce(function(memo, value, i) {
    var currentSlice = _(memo).last();

    if(i / size < memo.length) {
      currentSlice.push(value);
    } else {
      memo.push([value]);
    }

    return memo;
  }, []);
};

guix.Packages = function() {
  return m.request({ method: "GET", url: "packages.json" });
};

guix.Sorter = function(field, isDescending) {
  this.field = field;
  this.isDescending = _.isUndefined(isDescending) ? false : isDescending;
};

guix.Sorter.prototype.sort = function(array) {
  var result = _.sortBy(array, this.field);

  return this.isDescending ? result.reverse() : result;
};

guix.Sorter.prototype.reverse = function() {
  return new guix.Sorter(this.field, !this.isDescending);
};

guix.controller = function() {
  var self = this;

  this.packages = guix.Packages();
  this.pages = m.prop([]);
  this.currentPageIndex = 0;
  this.pageSize = 20;
  this.searchTerm = m.prop("");
  this.columns = [
    { header: "Name", sortField: "name" },
    { header: "Version", sortField: "version" },
    { header: "Synopsis", sortField: "synopsis" },
    { header: "Home Page", sortField: "homepage" }, {
      header: "License",
      sortField: function(package) {
        if(_.isArray(package.license)) {
          // Concatenate all license names together for sorting.
          return package.license.reduce(function(memo, l) {
            return memo.concat(l.name);
          }, "");
        }

        return package.license.name;
      }
    }
  ];
  this.sorter = m.prop(new guix.Sorter("name"));

  // All packages are visible initially
  this.packages.then(function(packages) {
    self.pages(self.paginate(packages, self.pageSize));
  });
};

guix.controller.prototype.paginate = function(array, pageSize) {
  return guix.chunk(this.sorter().sort(array), pageSize);
};

guix.controller.prototype.currentPage = function() {
  return this.pages()[this.currentPageIndex] || [];
};

guix.controller.prototype.isFirstPage = function() {
  return this.currentPageIndex === 0;
};

guix.controller.prototype.isLastPage = function() {
  return this.currentPageIndex === this.pages().length - 1;
};

guix.controller.prototype.isCurrentPage = function(i) {
  return this.currentPageIndex === i;
};

guix.controller.prototype.packageCount = function() {
  return this.pages().reduce(function(memo, page) {
    return memo + page.length;
  }, 0);
};

guix.controller.prototype.doSearch = function() {
  var regexp = new RegExp(this.searchTerm(), "i");

  this.pages(this.paginate(this.packages().filter(function(package) {
    return regexp.test(package.name) ||
      regexp.test(package.synopsis);
  }), this.pageSize));
};

guix.controller.prototype.sortBy = function(field) {
  if(this.sorter().field === field) {
    // Reverse sort order if the field is the same as before.
    this.sorter(this.sorter().reverse());
  } else {
    this.sorter(new guix.Sorter(field));
  }

  this.doSearch();
};

guix.view = function(ctrl) {
  function renderName(package) {
    var name = package.name;

    return m("a", { href: "/package/".concat(name) }, name);
  }

  function renderHomepage(package) {
    if(package.homepage) {
      return m("a", { href: package.homepage }, package.homepage);
    } else {
      return "";
    }
  }

  function renderLicense(package) {
    function licenseLink(license) {
      return m("a", { href: license.uri }, license.name);
    }

    if(_.isArray(package.license)) {
      return m("ul.list-inline", package.license.map(function(license) {
        return m("li", licenseLink(license));
      }));
    } else if(package.license) {
      return licenseLink(package.license);
    } else {
      return "";
    }
  }

  function renderPagination() {
    function renderPage(text, opts) {
      return m("li", {
        class: opts.class || "",
        onclick: opts.onclick
      }, m("a", { href: "#" }, text));
    }

    return m("ul.pagination", [
      // Back page
      renderPage("«", {
        class: ctrl.isFirstPage() ? "disabled" : "",
        onclick: function() {
          ctrl.currentPageIndex--;

          return false;
        }
      })
    ].concat(ctrl.pages().map(function(page, i) {
      // Jump to page
      return renderPage(i + 1, {
        class: ctrl.isCurrentPage(i) ? "active" : "",
        onclick: function() {
          ctrl.currentPageIndex = i;

          return false;
        }
      });
    })).concat([
      // Forward page
      renderPage("»", {
        class: ctrl.isLastPage() ? "disabled" : "",
        onclick: function() {
          ctrl.currentPageIndex++;

          return false;
        }
      })
    ]));
  }

  function columnHeaderClass(column) {
    var sorter = ctrl.sorter();

    if(column.sortField === sorter.field) {
      return sorter.isDescending ? "sorter sort-descend" : "sorter sort-ascend";
    }

    return "sorter";
  }

  return [
    m("h2", [
      "Packages",
      m("span.badge", ctrl.packageCount())
    ]),
    m("input.form-control", {
      type: "text",
      placeholder: "Search",
      onchange: m.withAttr("value", function(value) {
        ctrl.searchTerm(value);
        ctrl.doSearch();
      }),
      value: ctrl.searchTerm()
    }),
    m("table.table", [
      m("thead", [
        m("tr", [
          ctrl.columns.map(function(column) {
            return m("th", {
              class: columnHeaderClass(column),
              onclick: function() {
                ctrl.sortBy(column.sortField);
              }
            }, column.header);
           })
        ])
      ]),
      m("tbody", [
        ctrl.currentPage().map(function(package) {
          return m("tr", [
            m("td", renderName(package)),
            m("td", package.version),
            m("td", package.synopsis),
            m("td", renderHomepage(package)),
            m("td", renderLicense(package))
          ]);
        })
      ])
    ]),
    renderPagination()
  ];
};

m.module(document.getElementById("guix"), guix);