generate annotated spreadsheet

groups.py

import re

not_xorigin_re = re.compile(r'(?<!!)xorigin')
debug_re = re.compile(r'xorigin && \(?debug')
opt_re = re.compile(r'xorigin && !debug')
comment_re = re.compile(r'xorigin[^\n#]#\s*([^\n]*)')

def match(condition, debug):
    if not condition:
        return False
    if debug:
        return not opt_re.search(condition) and (debug_re.search(condition) or
                                                 not_xorigin_re.search(condition))
    else:
        return not debug_re.search(condition) and (opt_re.search(condition) or
                                                 not_xorigin_re.search(condition))


def get_status(test, debug):
    if match(test.get('skip-if'), debug):
        return 'skipped'
    if match(test.get('fail-if'), debug):
        return 'fails'
    return 'passes'


def get_comment(expr):
    if expr:
        match = comment_re.search(expr)
        if match:
            return match.group(1)


class Test(object):

    def __init__(self, group, data):
        self.group = group
        self.name = data['test']
        self.opt_status = get_status(data, False)
        self.debug_status = get_status(data, True)
        self.comment = (get_comment(data.get('skip-if')) or
                        get_comment(data.get('fail-if')))


class Group(object):

    def __init__(self, group, raw_tests):
        self.group = group
        self.tests = []
        for test in raw_tests:
            self.tests.append(Test(group, test))

xorigin_spreadsheet.py

#!/usr/bin/env python
# vim:se sts=4 sw=4 et fenc=utf-8 ft=python:
import json
import sys
import time

import googleapiclient.discovery
from fission import auth  # noqa
from groups import Group

SPREADSHEET_ID = ''
STATUSES_RANGE = 'xorigin-tests'
SHEET_ID = ''

service = googleapiclient.discovery.build('sheets', 'v4', credentials=auth())


COLOURS = {
    "gray": {"red": 0.5, "green": 0.5, "blue": 0.5, "alpha": 0.6},
    "red": {"red": 1, "green": 0, "blue": 0, "alpha": 0.6},
    "green": {"red": 0, "green": 1, "blue": 0, "alpha": 0.6},
    "blue": {"red": 0, "green": 0, "blue": 1, "alpha": 0.6},
}
COLOURS["passes"] = COLOURS["green"]
COLOURS["fails"] = COLOURS["red"]
COLOURS["skipped"] = COLOURS["blue"]


def text_format(bold=False, underline=False):
    return {"textFormat": {"bold":bold,"underline":underline}}


def colour(name):
    return {"backgroundColor":COLOURS[name]}


def borders(top=False, bottom=False, left=False, right=False):
    borders = {}
    if bottom:
        borders["bottom"] = {"style":"SOLID_MEDIUM"}
    return {"borders": borders}


def cell(value):
    return {"userEnteredValue":{"stringValue":value}}


def row_values(args):
    values = []
    for v in args:
        value = {}
        value.update(cell(v.value))
        if v.colour or v.formatting:
            formatting =  {}
            if v.colour:
                formatting.update(colour(v.colour))
            if v.formatting:
                formatting.update(text_format(**v.formatting))
            if v.borders:
                formatting.update(borders(**v.borders))
            value["userEnteredFormat"] = formatting
        values.append(value)
    return {"values": values}

def request_update_cells(row_index, rows):
    req = {"updateCells":{"range":{"sheetId":SHEET_ID,"startRowIndex":row_index},"fields":"*"}}
    req["updateCells"]["rows"] = []
    for row in rows:
        req["updateCells"]["rows"].append(row_values(row))
    return req

def request_merge_row(row_index):
    return {"mergeCells":{"range":{"sheetId":SHEET_ID,"startRowIndex":row_index,"endRowIndex":row_index+1,"startColumnIndex":0},"mergeType":"MERGE_ALL"}}

class Cell:
    def __init__(self, value, colour=None, formatting=None, borders=None):
        self.value = value
        self.colour = colour
        self.formatting = formatting
        self.borders = borders

class MainHeader:
    fields = [Cell("Test"), Cell("Opt Status"), Cell("Debug Status"), Cell("Comments")]

    def requests(self):
        return [
        request_update_cells(ROW, [self.fields]),
        ]

class GroupHeader:

    def __init__(self, group):
        self.fields = [Cell(group, colour="gray", formatting={"bold": True}, borders={"bottom":True})]

    def requests(self):
        return [
            request_merge_row(ROW),
            request_update_cells(ROW, [self.fields]),
        ]

class TestRows:
    def __init__(self, tests):
        self.fields = []
        for test in tests:
            self.fields.append([
                Cell(test.name),
                Cell(test.opt_status, colour=test.opt_status),
                Cell(test.debug_status, colour=test.debug_status),
                Cell(test.comment),
             ])

    def requests(self):
        return [
            request_update_cells(ROW, self.fields),
        ]

BATCH_SIZE = 40
ROW = 0

# Add header
all_requests = []
header = MainHeader()
all_requests.extend(header.requests())
ROW += 1

data = json.load(sys.stdin)
tests = data['tests']
groups = []
for group, subtests in tests.items():
    g = Group(group, subtests)
    all_requests.extend(GroupHeader(group).requests())
    groups.append(g)
    ROW += 1
    all_requests.extend(TestRows(g.tests).requests())
    ROW += (len(g.tests))
    if len(all_requests) > BATCH_SIZE:
        r = service.spreadsheets().batchUpdate(spreadsheetId=SPREADSHEET_ID,body={"requests": all_requests}).execute()
        all_requests = []
        time.sleep(0.5)

if all_requests:
        r = service.spreadsheets().batchUpdate(spreadsheetId=SPREADSHEET_ID,body={"requests": all_requests}).execute()
        all_requests = []