gitlab-radiator 3.3.9 → 3.3.10

package/src/client/index.tsx

@@ -1,94 +0,0 @@
-import 'core-js/stable'
-import 'regenerator-runtime/runtime'
-
-import type {GlobalState, Project} from './gitlab-types'
-import {argumentsFromDocumentUrl} from './arguments'
-import {GroupedProjects} from './groupedProjects'
-import React from 'react'
-import ReactDOM from 'react-dom'
-
-class RadiatorApp extends React.Component<unknown, GlobalState> {
-  public args: {override: {columns?: number, zoom?: number}, includedTags: string[] | null, screen: {id: number, total: number}}
-
-  constructor(props: unknown) {
-    super(props)
-    this.state = {
-      columns: 1,
-      error: null,
-      groupSuccessfulProjects: false,
-      projects: null,
-      projectsOrder: [],
-      now: 0,
-      zoom: 1
-    }
-
-    this.args = argumentsFromDocumentUrl()
-  }
-
-  componentDidMount = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const socket = (window as any).io()
-    socket.on('state', this.onServerStateUpdated.bind(this))
-    socket.on('disconnect', this.onDisconnect.bind(this))
-  }
-
-  render = () =>
-    <div>
-      {this.renderErrorMessage()}
-      {this.renderProgressMessage()}
-
-      {this.state.projects &&
-        <GroupedProjects now={this.state.now} zoom={this.state.zoom} columns={this.state.columns}
-                        projects={this.state.projects} projectsOrder={this.state.projectsOrder}
-                        groupSuccessfulProjects={this.state.groupSuccessfulProjects}
-                        screen={this.args.screen}/>
-      }
-    </div>
-
-  renderErrorMessage = () =>
-    this.state.error && <div className="error">{this.state.error}</div>
-
-  renderProgressMessage = () => {
-    if (!this.state.projects) {
-      return <h2 className="loading">Fetching projects and CI pipelines from GitLab...</h2>
-    } else if (this.state.projects.length === 0) {
-      return <h2 className="loading">No projects with CI pipelines found.</h2>
-    }
-    return null
-  }
-
-  onServerStateUpdated = (state: GlobalState) => {
-    this.setState({
-      ...state,
-      ...this.args.override,
-      projects: this.filterProjectsByTags(state.projects)
-    })
-  }
-
-  onDisconnect = () => this.setState({error: 'gitlab-radiator server is offline'})
-
-  filterProjectsByTags = (projects: Project[] | null) => {
-    if (projects === null) {
-      return null
-    }
-
-    // No tag list specified, include all projects
-    if (!this.args.includedTags) {
-      return projects
-    }
-    // Empty tag list specified, include projects without tags
-    if (this.args.includedTags.length === 0) {
-      return projects.filter(project =>
-        project.tags.length === 0
-      )
-    }
-    // Tag list specified, include projects which have at least one of them
-    return projects.filter(project =>
-      project.tags.some(tag => this.args.includedTags?.includes(tag))
-    )
-  }
-}
-
-ReactDOM.render(<RadiatorApp/>, document.getElementById('app'))
-
-module.hot?.accept()

package/src/client/info.tsx

@@ -1,16 +0,0 @@
-import type {Pipeline} from './gitlab-types'
-import React from 'react'
-import {renderTimestamp} from './renderTimestamp'
-
-export function Info({pipeline, now}: {pipeline: Pipeline, now: number}): JSX.Element {
-  return <div className="pipeline-info">
-    <div>
-      <span>{pipeline.commit ? pipeline.commit.author : '-'}</span>
-      <span>{pipeline.commit ? `'${pipeline.commit.title}'` : '-'}</span>
-    </div>
-    <div>
-      <span>{renderTimestamp(pipeline.stages, now)}</span>
-      <span>on {pipeline.ref}</span>
-    </div>
-  </div>
-}

package/src/client/jobs.tsx

@@ -1,56 +0,0 @@
-import type {Job, JobStatus} from './gitlab-types'
-import _ from 'lodash'
-import React from 'react'
-
-const NON_BREAKING_SPACE = '\xa0'
-
-const JOB_STATES_IN_INTEREST_ORDER: JobStatus[] = [
-  'failed',
-  'running',
-  'created',
-  'pending',
-  'success',
-  'skipped'
-]
-
-export function Jobs({jobs, maxNonFailedJobsVisible}: {jobs: Job[], maxNonFailedJobsVisible: number}): JSX.Element {
-  const [failedJobs, nonFailedJobs] = _.partition(jobs, {status: 'failed'})
-  const filteredJobs = sortByOriginalOrder(
-    failedJobs.concat(
-      _.orderBy(nonFailedJobs, ({status}) => JOB_STATES_IN_INTEREST_ORDER.indexOf(status))
-        .slice(0, Math.max(0, maxNonFailedJobsVisible - failedJobs.length))
-    ),
-    jobs
-  )
-
-  const hiddenJobs = jobs.filter(job => filteredJobs.indexOf(job) === -1)
-  const hiddenCountsByStatus = _.mapValues(
-    _.groupBy(hiddenJobs, 'status'),
-    jobsForStatus => jobsForStatus.length
-  )
-
-  const hiddenJobsText = _(hiddenCountsByStatus)
-    .toPairs()
-    .orderBy(([status]) => status)
-    .value()
-    .map(([status, count]) => `${count}${NON_BREAKING_SPACE}${status}`)
-    .join(', ')
-
-  return <ol className="jobs">
-    {filteredJobs.map(job => <JobElement job={job} key={job.id}/>)}
-    {
-      hiddenJobs.length > 0 ? <li className="hidden-jobs">+&nbsp;{hiddenJobsText}</li> : null
-    }
-  </ol>
-}
-
-function JobElement({job}: {job: Job}) {
-  return <li className={job.status}>
-    <a href={job.url} target="_blank" rel="noopener noreferrer">{job.name}</a>
-    {!job.url && job.name}
-  </li>
-}
-
-function sortByOriginalOrder(filteredJobs: Job[], jobs: Job[]) {
-  return _.orderBy(filteredJobs, (job: Job) => jobs.indexOf(job))
-}

package/src/client/projects.tsx

@@ -1,51 +0,0 @@
-import _ from 'lodash'
-import {Info} from './info'
-import type {Project} from './gitlab-types'
-import React from 'react'
-import {Stages} from './stages'
-
-export function Projects({columns, now, projects, projectsOrder, screen, zoom}: {columns: number, now: number, projects: Project[], projectsOrder: string[], screen: {id: number, total: number}, zoom: number}): JSX.Element {
-  return <ol className="projects" style={zoomStyle(zoom)}>
-    {_.sortBy(projects, projectsOrder)
-      .filter(forScreen(screen, projects.length))
-      .map(project => <ProjectElement now={now} columns={columns} project={project} key={project.id}/>)
-    }
-  </ol>
-}
-
-function ProjectElement({columns, now, project}: {columns: number, now: number, project: Project}) {
-  const [pipeline] = project.pipelines
-
-  return <li className={`project ${project.status}`} style={style(columns)}>
-    <h2>
-      {project.url && <a href={`${project.url}/pipelines`} target="_blank" rel="noopener noreferrer">{project.name}</a>}
-      {!project.url && project.name}
-    </h2>
-    <Stages stages={pipeline.stages} maxNonFailedJobsVisible={project.maxNonFailedJobsVisible}/>
-    <Info now={now} pipeline={pipeline}/>
-  </li>
-}
-
-function forScreen(screen: {id: number, total: number}, projectsCount: number) {
-  const perScreen = Math.ceil(projectsCount / screen.total)
-  const first = perScreen * (screen.id - 1)
-  const last = perScreen * screen.id
-  return (_project: Project, projectIndex: number) => projectIndex >= first && projectIndex < last
-}
-
-function zoomStyle(zoom: number) {
-  const widthPercentage = Math.round(100 / zoom)
-  return {
-    transform: `scale(${zoom})`,
-    width: `${widthPercentage}vmax`
-  }
-}
-
-function style(columns: number) {
-  const marginPx = 12
-  const widthPercentage = Math.floor(100 / columns)
-  return {
-    margin: `${marginPx}px`,
-    width: `calc(${widthPercentage}% - ${2 * marginPx}px)`
-  }
-}

package/src/client/renderTimestamp.tsx

@@ -1,45 +0,0 @@
-import {formatDistance} from 'date-fns'
-import type {Stage} from './gitlab-types'
-
-export function renderTimestamp(stages: Stage[], now: number): string {
-  const timestamps = getTimestamps(stages)
-
-  if (timestamps.length === 0) {
-    return 'Pending...'
-  }
-
-  const finished = timestamps
-    .map(t => t.finishedAt)
-    .filter((t): t is number => t !== null)
-  const inProgress = timestamps.length > finished.length
-  if (inProgress) {
-    const [timestamp] = timestamps.sort((a, b) => a.startedAt - b.startedAt)
-    return renderDistance('Started', timestamp.startedAt, now)
-  }
-
-  const [latestFinishedAt] = finished.sort((a, b) => b - a)
-  return renderDistance('Finished', latestFinishedAt, now)
-}
-
-function getTimestamps(stages: Stage[]): {startedAt: number, finishedAt: number | null}[] {
-  return stages
-    .flatMap(s => s.jobs)
-    .map(job => {
-      const startedAt = job.startedAt ? new Date(job.startedAt).valueOf() : null
-      const finishedAt = job.finishedAt ? new Date(job.finishedAt).valueOf() : null
-      return {
-        startedAt,
-        finishedAt
-      }
-    })
-    .filter((t): t is {startedAt: number, finishedAt: number | null} => t.startedAt !== null)
-}
-
-function renderDistance(predicate: string, timestamp: number, now: number) {
-  const distance = formatDate(timestamp, now)
-  return `${predicate} ${distance} ago`
-}
-
-function formatDate(timestamp: number, now: number) {
-  return formatDistance(new Date(timestamp), new Date(now))
-}

package/src/client/stages.tsx

@@ -1,18 +0,0 @@
-import {Jobs} from './jobs'
-import React from 'react'
-import type {Stage} from './gitlab-types'
-
-export function Stages({stages, maxNonFailedJobsVisible}: {stages: Stage[], maxNonFailedJobsVisible: number}): JSX.Element {
-  return <ol className="stages">
-    {stages.map(stage =>
-      <StageElement stage={stage} maxNonFailedJobsVisible={maxNonFailedJobsVisible} key={stage.name}/>
-    )}
-  </ol>
-}
-
-function StageElement({stage, maxNonFailedJobsVisible}: {stage: Stage, maxNonFailedJobsVisible: number}) {
-  return <li className="stage">
-    <div className="name">{stage.name}</div>
-    <Jobs jobs={stage.jobs} maxNonFailedJobsVisible={maxNonFailedJobsVisible}/>
-  </li>
-}

package/src/dev-assets.js

@@ -1,10 +0,0 @@
-import config from '../webpack.dev.js'
-import webpack from 'webpack'
-import webpackDevMiddleware from 'webpack-dev-middleware'
-import webpackHotMiddleware from 'webpack-hot-middleware'
-
-export function bindDevAssets(app) {
-  const compiler = webpack(config)
-  app.use(webpackDevMiddleware(compiler))
-  app.use(webpackHotMiddleware(compiler))
-}

package/test/gitlab/projects.test.js

@@ -1,75 +0,0 @@
-import * as clientMock from './../../src/gitlab/client'
-import {expect} from 'chai'
-import {fetchProjects} from './../../src/gitlab/projects'
-import sinon from 'sinon'
-
-describe("projects", () => {
-    const response = {
-        data: [
-            {
-                path_with_namespace: "group1/pro",
-                jobs_enabled: true
-            },
-            {
-                path_with_namespace: "group1/pro-other",
-                jobs_enabled: true
-            },
-            {
-                path_with_namespace: "group2/something",
-                jobs_enabled: true
-            },
-            {
-                path_with_namespace: "group3/no-ci-pipelines",
-                jobs_enabled: false
-            }
-        ],
-        headers: {}
-    }
-
-    before(() => {
-        sinon.stub(clientMock, 'gitlabRequest').callsFake(() => {
-            return new Promise((resolve) => {
-                resolve(response)
-            })
-        })
-    })
-
-    after(() => {
-        sinon.resetBehavior()
-    })
-
-    it('should return only included projects', async () => {
-        const gitlab = {
-            projects: {
-                include: '.*/pro.*'
-            }
-        }
-        const projects = await fetchProjects(gitlab)
-        expect(projects.length).to.equal(2)
-        expect(projects[0].name).to.equal('group1/pro')
-        expect(projects[1].name).to.equal('group1/pro-other')
-    })
-
-    it('should not return excluded projects', async () => {
-        const gitlab = {
-            projects: {
-                exclude: '.*/pro.*'
-            }
-        }
-        const projects = await fetchProjects(gitlab)
-        expect(projects.length).to.equal(1)
-        expect(projects[0].name).to.equal('group2/something')
-    })
-
-    it('should not return excluded and return only included', async () => {
-        const gitlab = {
-            projects: {
-                include: '.*/pro.*',
-                exclude: '.*/pro-other.*'
-            }
-        }
-        const projects = await fetchProjects(gitlab)
-        expect(projects.length).to.equal(1)
-        expect(projects[0].name).to.equal('group1/pro')
-    })
-})