256-color terminal support

commands/issue.go

@@ -595,8 +595,9 @@ func formatLabel(label github.IssueLabel, colorize bool) string {
 }
 
 func colorizeLabel(label github.IssueLabel, color *utils.Color) string {
-	return fmt.Sprintf("\033[38;5;%d;48;2;%d;%d;%dm %s \033[m",
-		getSuitableLabelTextColor(color), color.Red, color.Green, color.Blue, label.Name)
+	bgColorCode := utils.RgbToTermColorCode(color)
+	return fmt.Sprintf("\033[38;5;%d;48;%sm %s \033[m",
+		getSuitableLabelTextColor(color), bgColorCode, label.Name)
 }
 
 func getSuitableLabelTextColor(color *utils.Color) int {

utils/color.go

+package utils
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+)
+
+func init() {
+	initColorCube()
+}
+
+type Color struct {
+	Red   int64
+	Green int64
+	Blue  int64
+}
+
+func NewColor(hex string) (*Color, error) {
+	red, err := strconv.ParseInt(hex[0:2], 16, 16)
+	if err != nil {
+		return nil, err
+	}
+	green, err := strconv.ParseInt(hex[2:4], 16, 16)
+	if err != nil {
+		return nil, err
+	}
+	blue, err := strconv.ParseInt(hex[4:6], 16, 16)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Color{
+		Red:   red,
+		Green: green,
+		Blue:  blue,
+	}, nil
+}
+
+func (c *Color) Brightness() float32 {
+	return (0.299*float32(c.Red) +
+		0.587*float32(c.Green) +
+		0.114*float32(c.Blue)) / 255
+}
+
+func (c *Color) Distance(other *Color) float64 {
+	return math.Sqrt(float64(math.Pow(float64(c.Red-other.Red), 2) +
+		math.Pow(float64(c.Green-other.Green), 2) +
+		math.Pow(float64(c.Blue-other.Blue), 2)))
+}
+
+var x6colorIndexes = [6]int64{0, 95, 135, 175, 215, 255}
+var x6colorCube [216]Color
+
+func initColorCube() {
+	i := 0
+	for iR := 0; iR < 6; iR++ {
+		for iG := 0; iG < 6; iG++ {
+			for iB := 0; iB < 6; iB++ {
+				x6colorCube[i] = Color{
+					x6colorIndexes[iR],
+					x6colorIndexes[iG],
+					x6colorIndexes[iB],
+				}
+				i++
+			}
+		}
+	}
+}
+
+func ditherTo256ColorCode(color *Color) (code int) {
+	iMatch := -1
+	minDistance := float64(99999)
+	for i := 0; i < 216; i++ {
+		distance := color.Distance(&x6colorCube[i])
+		if distance < minDistance {
+			iMatch = i
+			minDistance = distance
+		}
+	}
+	return iMatch + 16
+}
+
+var non24bitColorTerms = []string{
+	"Apple_Terminal",
+}
+var isTerm24bitColorCapableCache bool
+var isTerm24bitColorCapableCacheIsInit bool = false
+
+func isTerm24bitColorCapable() bool {
+	if !isTerm24bitColorCapableCacheIsInit {
+		isTerm24bitColorCapableCache = true
+		myTermProg := os.Getenv("TERM_PROGRAM")
+		for _, brokenTerm := range non24bitColorTerms {
+			if myTermProg == brokenTerm {
+				isTerm24bitColorCapableCache = false
+				break
+			}
+		}
+		isTerm24bitColorCapableCacheIsInit = true
+	}
+	return isTerm24bitColorCapableCache
+}
+
+func RgbToTermColorCode(color *Color) string {
+	if isTerm24bitColorCapable() {
+		return fmt.Sprintf("2;%d;%d;%d", color.Red, color.Green, color.Blue)
+	} else {
+		intCode := ditherTo256ColorCode(color)
+		return fmt.Sprintf("5;%d", intCode)
+	}
+}

utils/color_test.go

+package utils
+
+import (
+	"github.com/bmizerany/assert"
+	"testing"
+)
+
+func TestColorBrightness(t *testing.T) {
+	c, err := NewColor("880000")
+	assert.Equal(t, nil, err)
+	actual := c.Brightness()
+	assert.Equal(t, float32(0.15946665406227112), actual)
+}

utils/utils.go

@@ -7,7 +7,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
 	"time"
 
@@ -83,37 +82,6 @@ func IsOption(confirm, short, long string) bool {
 	return strings.EqualFold(confirm, short) || strings.EqualFold(confirm, long)
 }
 
-type Color struct {
-	Red   int64
-	Green int64
-	Blue  int64
-}
-
-func NewColor(hex string) (*Color, error) {
-	red, err := strconv.ParseInt(hex[0:2], 16, 16)
-	if err != nil {
-		return nil, err
-	}
-	green, err := strconv.ParseInt(hex[2:4], 16, 16)
-	if err != nil {
-		return nil, err
-	}
-	blue, err := strconv.ParseInt(hex[4:6], 16, 16)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Color{
-		Red:   red,
-		Green: green,
-		Blue:  blue,
-	}, nil
-}
-
-func (c *Color) Brightness() float32 {
-	return (0.299*float32(c.Red) + 0.587*float32(c.Green) + 0.114*float32(c.Blue)) / 255
-}
-
 func TimeAgo(t time.Time) string {
 	duration := timeNow().Sub(t)
 	minutes := duration.Minutes()

utils/utils_test.go

@@ -69,10 +69,3 @@ func TestTimeAgo(t *testing.T) {
 	actual = TimeAgo(yearsAgo)
 	assert.Equal(t, "2 years ago", actual)
 }
-
-func TestColorBrightness(t *testing.T) {
-	c, err := NewColor("880000")
-	assert.Equal(t, nil, err)
-	actual := c.Brightness()
-	assert.Equal(t, float32(0.15946665406227112), actual)
-}