aboutsummaryrefslogtreecommitdiff
path: root/cmd/planr/sub/cli.go
blob: 4d291448b58366096bc1029e0387d4b72407cb1f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package sub

import (
	"github.com/fatih/color"
	"golang.flu0r1ne.net/planr"
        "fmt"
        "strings"
)

var (
  col_pass = color.New(color.FgGreen)
  col_fail = color.New(color.FgRed)
  col_title = color.New(color.FgHiWhite)
  col_label = color.New(color.FgCyan)
);

func tcTitle(tr planr.TestResult) string {
  title := tr.Tc.Cname

  if tr.Tc.Config.Title != "" {
    title = tr.Tc.Config.Title
  }

  return title
}

func tcStatus(tc planr.TestResult) string {
    status := "SILENT"

    if tc.Status == planr.PASSING {
      status = "PASS"
    } else {
      status = "FAIL"
    }

    return status
}

func pprintLabeled(label, value string) {
  col_label.Printf("  %s: ", label)
  fmt.Println(value)
}

const (
  FENCE_WIDTH = 78
)

func pprintFenced(title, value string) {
  wingWidth := FENCE_WIDTH - len(title) - 2
  wing := strings.Repeat("-", wingWidth / 2)
  fence := strings.Repeat("-", FENCE_WIDTH) 

  fmt.Printf("  %s %s %s\n", wing, title, wing)
  
  fmt.Print("  " + strings.ReplaceAll(value, "\n", "\n  "))

  fmt.Println(fence)
}

func tcStatusLine(tr planr.TestResult) {
  title  := tcTitle(tr)
  status := tcStatus(tr)

  if status == "PASS" {
    col_pass.Printf("[%s] ", status);
  } else {
    col_fail.Printf("[%s] ", status);
  }

  col_title.Println(title);  
}

type PrintOpts int

const (
  PRINT_CONCISE PrintOpts = 1 << iota
  PRINT_DESCRIPTION
  PRINT_POINTS
)

func (opt PrintOpts) HasFlag(flag PrintOpts) bool {
  return (opt & flag) == flag 
}

func tcPprint(tr planr.TestResult, opt PrintOpts) {
  tcStatusLine(tr)

  tc := tr.Tc

  pprintLabeled("id", tc.Cname)

  if tc.Config.Points != nil && opt.HasFlag(PRINT_POINTS) {
    points := fmt.Sprintf("%.1f", *tc.Config.Points)
    pprintLabeled("points1", points)
  }

  if tc.Config.Description != "" && opt.HasFlag(PRINT_DESCRIPTION) {
    tabbed := strings.ReplaceAll(tc.Config.Description, "\n", "\n  ")

    pprintLabeled("description", tabbed)
  }

  if tr.Status == planr.COMPILATION_FAILURE {
    
    if tr.DebugOutput != "" {
      fmt.Println()
      pprintFenced("compilation output", tr.DebugOutput);
    } else {
      fmt.Println("WARN: No debug output provided")
    }

  } else if tr.Status == planr.RUNTIME_FAILURE {

    if tr.TestOutput != "" {
      fmt.Println()
      pprintFenced("test output", tr.TestOutput);
    }
    
  }

  fmt.Println()
}

func printScoring(score planr.Scoring) {
  col_title.Println("Final Results:")
  
  pprintLabeled("passed", fmt.Sprintf("%d/%d", score.Passed, score.Total));

  percent := score.EarnedPoints / score.TotalPoints * 100

  if score.TotalPoints != 0 {
    pprintLabeled("score", fmt.Sprintf(
      "%.2f/%.2f ~= %.1f%%", score.EarnedPoints, score.TotalPoints, percent,
    ));
  }
}