gitlab-radiator 3.3.9 → 3.3.10

package/src/gitlab/projects.js

@@ -1,28 +1,105 @@
-import {gitlabRequest} from './client'
-
-export async function fetchProjects(gitlab) {
-  const projects = await fetchOwnProjects(gitlab)
-  return projects
-    // Ignore projects for which CI/CD is not enabled
-    .filter(project => project.jobs_enabled)
-    .map(projectMapper)
-    .filter(includeRegexFilter(gitlab))
-    .filter(excludeRegexFilter(gitlab))
-    .filter(archivedFilter(gitlab))
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchProjects = fetchProjects;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _client = require("./client");
+
+function fetchProjects(_x) {
+  return _fetchProjects.apply(this, arguments);
 }
 
-async function fetchOwnProjects(gitlab) {
-  const projects = []
-  const SAFETY_MAX_PAGE = 10
-  for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
-    // eslint-disable-next-line no-await-in-loop
-    const {data, headers} = await gitlabRequest('/projects', {page, per_page: 100, membership: true}, gitlab)
-    projects.push(data)
-    if (data.length === 0 || !headers['x-next-page']) {
-      break
-    }
-  }
-  return projects.flat()
+function _fetchProjects() {
+  _fetchProjects = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(gitlab) {
+    var projects;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetchOwnProjects(gitlab);
+
+          case 2:
+            projects = _context.sent;
+            return _context.abrupt("return", projects // Ignore projects for which CI/CD is not enabled
+            .filter(project => project.jobs_enabled).map(projectMapper).filter(includeRegexFilter(gitlab)).filter(excludeRegexFilter(gitlab)).filter(archivedFilter(gitlab)));
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _fetchProjects.apply(this, arguments);
+}
+
+function fetchOwnProjects(_x2) {
+  return _fetchOwnProjects.apply(this, arguments);
+}
+
+function _fetchOwnProjects() {
+  _fetchOwnProjects = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
+    var projects, SAFETY_MAX_PAGE, page, _yield$gitlabRequest, data, headers;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            projects = [];
+            SAFETY_MAX_PAGE = 10;
+            page = 1;
+
+          case 3:
+            if (!(page <= SAFETY_MAX_PAGE)) {
+              _context2.next = 15;
+              break;
+            }
+
+            _context2.next = 6;
+            return (0, _client.gitlabRequest)('/projects', {
+              page,
+              per_page: 100,
+              membership: true
+            }, gitlab);
+
+          case 6:
+            _yield$gitlabRequest = _context2.sent;
+            data = _yield$gitlabRequest.data;
+            headers = _yield$gitlabRequest.headers;
+            projects.push(data);
+
+            if (!(data.length === 0 || !headers['x-next-page'])) {
+              _context2.next = 12;
+              break;
+            }
+
+            return _context2.abrupt("break", 15);
+
+          case 12:
+            page += 1;
+            _context2.next = 3;
+            break;
+
+          case 15:
+            return _context2.abrupt("return", projects.flat());
+
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchOwnProjects.apply(this, arguments);
 }
 
 function projectMapper(project) {
@@ -35,39 +112,42 @@ function projectMapper(project) {
     default_branch: project.default_branch || 'master',
     url: project.web_url,
     tags: (project.tag_list || []).map(t => t.toLowerCase())
-  }
+  };
 }
 
 function getGroupName(project) {
-  const pathWithNameSpace = project.path_with_namespace
-  return pathWithNameSpace.split('/')[0]
+  var pathWithNameSpace = project.path_with_namespace;
+  return pathWithNameSpace.split('/')[0];
 }
 
 function includeRegexFilter(config) {
   return project => {
     if (config.projects && config.projects.include) {
-      const includeRegex = new RegExp(config.projects.include, "i")
-      return includeRegex.test(project.name)
+      var includeRegex = new RegExp(config.projects.include, "i");
+      return includeRegex.test(project.name);
     }
-    return true
-  }
+
+    return true;
+  };
 }
 
 function excludeRegexFilter(config) {
   return project => {
     if (config.projects && config.projects.exclude) {
-      const excludeRegex = new RegExp(config.projects.exclude, "i")
-      return !excludeRegex.test(project.name)
+      var excludeRegex = new RegExp(config.projects.exclude, "i");
+      return !excludeRegex.test(project.name);
     }
-    return true
-  }
+
+    return true;
+  };
 }
 
 function archivedFilter(config) {
   return project => {
     if (config.ignoreArchived) {
-      return !project.archived
+      return !project.archived;
     }
-    return true
-  }
-}
+
+    return true;
+  };
+}

package/src/gitlab/runners.js

@@ -1,18 +1,79 @@
-import {gitlabRequest} from './client'
-
-export async function fetchOfflineRunners(gitlab) {
-  const runners = await fetchRunners(gitlab)
-  const offline = runners.filter(r => r.status === 'offline')
-  return {
-    offline,
-    totalCount: runners.length
-  }
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchOfflineRunners = fetchOfflineRunners;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _client = require("./client");
+
+function fetchOfflineRunners(_x) {
+  return _fetchOfflineRunners.apply(this, arguments);
+}
+
+function _fetchOfflineRunners() {
+  _fetchOfflineRunners = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(gitlab) {
+    var runners, offline;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetchRunners(gitlab);
+
+          case 2:
+            runners = _context.sent;
+            offline = runners.filter(r => r.status === 'offline');
+            return _context.abrupt("return", {
+              offline,
+              totalCount: runners.length
+            });
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _fetchOfflineRunners.apply(this, arguments);
 }
 
-async function fetchRunners(gitlab) {
-  const {data: runners} = await gitlabRequest('/runners', {}, gitlab)
-  return runners.map(r => ({
-    name: r.description || r.id,
-    status: r.status
-  }))
+function fetchRunners(_x2) {
+  return _fetchRunners.apply(this, arguments);
 }
+
+function _fetchRunners() {
+  _fetchRunners = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
+    var _yield$gitlabRequest, runners;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return (0, _client.gitlabRequest)('/runners', {}, gitlab);
+
+          case 2:
+            _yield$gitlabRequest = _context2.sent;
+            runners = _yield$gitlabRequest.data;
+            return _context2.abrupt("return", runners.map(r => ({
+              name: r.description || r.id,
+              status: r.status
+            })));
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchRunners.apply(this, arguments);
+}

package/src/index.js

@@ -1,3 +1,5 @@
+"use strict";
+
 // eslint-disable-next-line no-global-assign,no-native-reassign
-require = require("esm")(module)
-module.exports = require("./app.js")
+require = require("esm")(module);
+module.exports = require("./app.js");

package/.babelrc

@@ -1,4 +0,0 @@
-{
-  "presets": ["@babel/env", "@babel/react"],
-  "plugins": ["@babel/plugin-transform-runtime"]
-}

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "env": {
-    "es6": true,
-    "mocha": true,
-    "node": true
-  },
-  "parser": "@babel/eslint-parser",
-  "plugins": [
-    "mocha",
-    "react"
-  ],
-  "extends": ["eslint:recommended"]
-}

package/.github/workflows/test.yml

@@ -1,20 +0,0 @@
-name: Run tests
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x, 14.x]
-    steps:
-     - uses: actions/checkout@v2
-     - uses: actions/setup-node@v1
-       with:
-         node-version: ${{ matrix.node-version }}
-     - run: npm ci
-     - run: npm audit
-     - run: npm run eslint
-     - run: npm test
-     - run: npm run build

package/.nvmrc

@@ -1 +0,0 @@
-14.17.0

package/build-npm

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-rm -fr build
-mkdir -p build/src
-
-# Copy static resources
-cp -r public build
-
-# Copy LICENSE, README and package.json
-cp LICENSE package.json README.md build
-
-# Copy bin script
-cp -r bin build
-
-# Bundle and minify client JS
-npx webpack --config webpack.prod.js
-
-# Transpile server
-node_modules/.bin/babel src --ignore **/client/*.js,**/dev-assets.js --out-dir build/src

package/src/client/.eslintrc

@@ -1,21 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "es6": true
-  },
-  "parser": "@typescript-eslint/parser",
-  "plugins": [
-    "@typescript-eslint"
-  ],
-  "extends": [
-    "eslint:recommended",
-    "plugin:react/recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "settings": {
-    "react": {
-      "version": "17.0"
-    }
-  }
-}

package/src/client/arguments.ts

@@ -1,75 +0,0 @@
-interface ParsedQueryString {
-  [key: string]: string | undefined
-}
-
-export function argumentsFromDocumentUrl(): {override: {columns?: number, zoom?: number}, includedTags: string[] | null, screen: {id: number, total: number}} {
-  const args = parseQueryString(document.location.search)
-  return {
-    override: overrideArguments(args),
-    includedTags: tagArguments(args),
-    screen: screenArguments(args)
-  }
-}
-
-function tagArguments(args: ParsedQueryString): string[] | null {
-  if (args.tags === undefined) {
-    return null
-  }
-  return args.tags
-    .split(',')
-    .map(t => t.toLowerCase().trim())
-    .filter(t => t)
-}
-
-function overrideArguments(args: ParsedQueryString): {columns?: number, zoom?: number} {
-  return {
-    ...parseColumns(args),
-    ...parseZoom(args)
-  }
-}
-
-function parseColumns(args: ParsedQueryString) {
-  if (args.columns) {
-    const columns = Number(args.columns)
-    if (columns > 0 && columns <= 10) {
-      return {columns}
-    }
-  }
-  return {}
-}
-
-
-function parseZoom(args: ParsedQueryString) {
-  if (args.zoom) {
-    const zoom = Number(args.zoom)
-    if (zoom > 0 && zoom <= 2) {
-      return {zoom}
-    }
-  }
-  return {}
-}
-
-function screenArguments(args: ParsedQueryString): {id: number, total: number} {
-  const matches = (/(\d)of(\d)/).exec(args.screen || '')
-  let id = matches ? Number(matches[1]) : 1
-  const total = matches ? Number(matches[2]) : 1
-  if (id > total) {
-    id = total
-  }
-  return {
-    id,
-    total
-  }
-}
-
-function parseQueryString(search: string): ParsedQueryString {
-  const entries = search
-    .slice(1)
-    .split('&')
-    .filter(parameter => parameter)
-    .map((parameter: string): [string, string | undefined] => {
-      const [key, value] = parameter.split('=')
-      return [key, value]
-    })
-  return Object.fromEntries(entries)
-}

package/src/client/gitlab-types.ts

@@ -1,54 +0,0 @@
-
-export interface GlobalState {
-  columns: number
-  error: string | null
-  groupSuccessfulProjects: boolean
-  projects: Project[] | null
-  projectsOrder: string[]
-  zoom: number
-  now: number
-}
-
-export interface Project {
-  archived: false
-  group: string
-  id: number
-  name: string
-  nameWithoutNamespace: string
-  tags: string[]
-  url: string
-  default_branch: string
-  pipelines: Pipeline[]
-  maxNonFailedJobsVisible: number
-  status: 'success' | 'failed'
-}
-
-export interface Pipeline {
-  commit: Commit | null
-  id: number
-  ref: string
-  stages: Stage[]
-  status: 'success' | 'failed'
-}
-
-export interface Commit {
-  title: string
-  author: string
-}
-
-export interface Stage {
-  jobs: Job[]
-  name: string
-}
-
-export interface Job {
-  finishedAt: string | null
-  id: number
-  name: string
-  stage: string
-  startedAt: string | null
-  status: JobStatus
-  url: string
-}
-
-export type JobStatus = 'created' | 'failed' | 'manual' | 'pending' | 'running' | 'skipped' | 'success'

package/src/client/groupedProjects.tsx

@@ -1,40 +0,0 @@
-import _ from 'lodash'
-import {Groups} from './groups'
-import type {Project} from './gitlab-types'
-import {Projects} from './projects'
-import React from 'react'
-
-export function GroupedProjects({projects, projectsOrder, groupSuccessfulProjects, zoom, columns, now, screen}: {projects: Project[], projectsOrder: string[], groupSuccessfulProjects: boolean, zoom: number, columns: number, now: number, screen: {id: number, total: number}}): JSX.Element {
-  if (groupSuccessfulProjects) {
-    return renderProjectsGrouped(projects, projectsOrder, zoom, columns, now, screen)
-  }
-  return renderProjects(projects, projectsOrder, zoom, columns, now, screen)
-}
-
-function renderProjectsGrouped(projects: Project[], projectsOrder: string[], zoom: number, columns: number, now: number, screen: {id: number, total: number}) {
-  const successfullProjects: Project[] = []
-  const otherProjects: Project[] = []
-  projects.forEach((project) => {
-    if (project.status === 'success') {
-      successfullProjects.push(project)
-    } else {
-      otherProjects.push(project)
-    }
-  })
-  const groupedProjects = _.groupBy(successfullProjects, 'group')
-  return <React.Fragment>
-    {renderProjects(otherProjects, projectsOrder, zoom, columns, now, screen)}
-    {renderGroupedProjects(groupedProjects, zoom, columns, now)}
-  </React.Fragment>
-}
-
-function renderProjects(projects: Project[], projectsOrder: string[], zoom: number, columns: number, now: number, screen: {id: number, total: number}) {
-  return <Projects now={now} zoom={zoom} columns={columns}
-                    projects={projects || []} projectsOrder={projectsOrder}
-                    screen={screen}/>
-}
-
-function renderGroupedProjects(groupedProjects: {[groupname: string]: Project[]}, zoom: number, columns: number, now: number) {
-  return <Groups zoom={zoom} columns={columns} now={now}
-                    groupedProjects={groupedProjects || []} />
-}

package/src/client/groups.tsx

@@ -1,59 +0,0 @@
-import type {Pipeline, Project} from './gitlab-types'
-import React from 'react'
-import {renderTimestamp} from './renderTimestamp'
-
-export function Groups({groupedProjects, now, zoom, columns}: {groupedProjects: {[groupname: string]: Project[]}, now: number, zoom: number, columns: number}): JSX.Element {
-  return <ol className="groups" style={zoomStyle(zoom)}>
-    {Object
-      .entries(groupedProjects)
-      .sort(([groupName1], [groupName2]) => groupName1.localeCompare(groupName2))
-      .map(([groupName, projects]) => <GroupElement columns={columns} groupName={groupName} key={groupName} projects={projects} now={now}/>)
-    }
-  </ol>
-}
-
-function GroupElement({groupName, projects, now, columns}: {groupName: string, projects: Project[], now: number, columns: number}) {
-  const pipelines: (Pipeline & {project: string})[] = []
-  projects.forEach((project) => {
-      project.pipelines.forEach((pipeline) => {
-        pipelines.push({
-          ...pipeline,
-          project: project.nameWithoutNamespace
-        })
-      })
-  })
-
-  return <li className={'group'} style={style(columns)}>
-    <h2>{groupName}</h2>
-    <div className={'group-info'}>{projects.length} Project{projects.length > 1 ? 's' : ''}</div>
-    <GroupInfoElement now={now} pipeline={pipelines[0]}/>
-  </li>
-}
-
-function GroupInfoElement({now, pipeline}: {now: number, pipeline: (Pipeline & {project: string})}) {
-  return <div className="pipeline-info">
-    <div>
-      <span>{pipeline.commit ? pipeline.commit.author : '-'}</span>
-      <span>{pipeline.commit ? pipeline.project : '-'}</span>
-    </div>
-    <div>
-      <span>{renderTimestamp(pipeline.stages, now)}</span>
-      <span>on {pipeline.ref}</span>
-    </div>
-  </div>
-}
-
-function zoomStyle(zoom: number) {
-  const widthPercentage = Math.round(100 / zoom)
-  return {
-    transform: `scale(${zoom})`,
-    width: `${widthPercentage}vmax`
-  }
-}
-
-function style(columns: number) {
-  const widthPercentage = Math.round(90 / columns)
-  return {
-    width: `${widthPercentage}%`
-  }
-}