| // Copyright 2019 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Command css appends CSS styles to content/static/stylesheet.css. |
| // It reads from the CSS file at |
| // https://github.com/sindresorhus/github-markdown-css/blob/gh-pages/github-markdown.css |
| // and removes all styles that do not belong to a .markdown-body <tag>. The |
| // .markdown-body class is then replaced with .Overview-readmeContent, for use |
| // in the discovery codebase. The remaining properties are written to content/static/css/stylesheet.css. |
| package main |
| |
| import ( |
| "bufio" |
| "flag" |
| "fmt" |
| "io/ioutil" |
| "log" |
| "net/http" |
| "os" |
| "regexp" |
| "strconv" |
| "strings" |
| ) |
| |
| const ( |
| cssFile = "content/static/css/readme.css" |
| githubStylesheet = "https://raw.githubusercontent.com/sindresorhus/github-markdown-css/gh-pages/github-markdown.css" |
| githubREADMEClass = ".markdown-body" |
| discoveryREADMEClass = ".Overview-readmeContent" |
| copyright = `/* |
| * Copyright 2019-2020 The Go Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style |
| * license that can be found in the LICENSE file. |
| */ |
| ` |
| ) |
| |
| var write = flag.Bool("write", false, "append modifications to content/static/css/stylesheet.css") |
| |
| func main() { |
| flag.Parse() |
| |
| resp, err := http.Get(githubStylesheet) |
| if err != nil { |
| log.Fatalf("http.Get(%q): %v", githubStylesheet, err) |
| } |
| if resp.StatusCode != http.StatusOK { |
| log.Fatalf("http.Get(%q): status = %d", githubStylesheet, resp.StatusCode) |
| } |
| |
| defer resp.Body.Close() |
| scanner := bufio.NewScanner(resp.Body) |
| var ( |
| atPropertyStart = true |
| curr string |
| includeProperty bool |
| properties []string |
| ) |
| for scanner.Scan() { |
| text := scanner.Text() |
| if headerString := replaceHeaderTag(text); headerString != "" { |
| text = headerString |
| } |
| if atPropertyStart && shouldIncludeProperty(text) { |
| includeProperty = true |
| } |
| if remString := replaceValueWithRems(text); remString != "" { |
| text = remString |
| } |
| if text == "}" { |
| if includeProperty { |
| properties = append(properties, curr+text+"\n") |
| } |
| curr = "" |
| includeProperty = false |
| atPropertyStart = true |
| continue |
| } |
| if includeProperty { |
| curr += text |
| curr += "\n" |
| } |
| } |
| |
| if err := scanner.Err(); err != nil { |
| log.Fatal(err) |
| } |
| |
| if err := ioutil.WriteFile(cssFile, []byte(copyright), 0644); err != nil { |
| log.Fatalf("ioutil.WriteFile(f, '', 0644): %v", err) |
| } |
| |
| file, err := os.OpenFile(cssFile, os.O_WRONLY|os.O_APPEND, 0644) |
| if err != nil { |
| log.Fatalf("os.OpenFile(f, os.O_WRONLY|os.O_APPEND, 0644): %v", err) |
| } |
| defer func() { |
| if err := file.Close(); err != nil { |
| log.Fatalf("file.Close(): %v", err) |
| } |
| }() |
| |
| if !*write { |
| fmt.Println("Dryrun only. Run with `-write` to write to stylesheet.css.") |
| } else { |
| fmt.Printf("Writing these properties to %q: \n", cssFile) |
| } |
| |
| contentsToWrite := ` |
| /* ---------- */ |
| /* |
| /* The CSS classes below are generated using devtools/cmd/css/main.go |
| /* If the generated CSS already exists, the file is overwritten |
| /* |
| /* ---------- */` |
| contentsToWrite += "\n\n" |
| |
| for _, p := range properties { |
| contentsToWrite += strings.ReplaceAll(p, githubREADMEClass, discoveryREADMEClass) |
| } |
| |
| contentsToWrite += ` |
| /* ---------- */ |
| /* |
| /* End output from devtools/cmd/css/main.go |
| /* |
| /* ---------- */` |
| |
| fmt.Println(contentsToWrite) |
| |
| if _, err := file.WriteString(contentsToWrite); err != nil { |
| log.Fatalf("file.WriteString(%q): %v", contentsToWrite, err) |
| } |
| } |
| |
| // replaceHeaderTag finds any header tags in a line of text and increases |
| // the header level by 2. replaceHeader tag returns the replaced string if a |
| // header tag is found and returns an empty string if not |
| func replaceHeaderTag(property string) string { |
| headerMap := map[string]string{ |
| "h1": "h3", "h2": "h4", "h3": "h5", "h4": "h6", "h5": "div[aria-level=7]", "h6": "div[aria-level=8]", |
| } |
| for k, v := range headerMap { |
| if strings.Contains(property, k) { |
| return strings.ReplaceAll(property, k, v) |
| } |
| } |
| return "" |
| } |
| |
| // shouldIncludeProperty reports whether this property should be included in |
| // the CSS file. |
| func shouldIncludeProperty(property string) bool { |
| parts := strings.Split(property, " ") |
| if len(parts) < 1 { |
| return false |
| } |
| if parts[0] != githubREADMEClass { |
| return false |
| } |
| for _, p := range parts[1:] { |
| if strings.HasPrefix(p, ".") { |
| return false |
| } |
| } |
| return true |
| } |
| |
| // pxToRem returns the number value of a px string to a rem string. |
| func pxToRem(value string) string { |
| valueNum, err := strconv.ParseFloat(value, 32) |
| if err != nil { |
| return "" |
| } |
| valueNum = valueNum / 16 |
| return fmt.Sprintf("%frem", valueNum) |
| } |
| |
| // replaceValueWithRems replaces the px values in a line of css with rems. |
| // e.g: padding: 25px 10px => padding: |
| func replaceValueWithRems(line string) string { |
| var cssLine string |
| valueRegex := regexp.MustCompile(`([-+]?[0-9]*\.?[0-9]+)px`) |
| matches := valueRegex.FindAllStringSubmatchIndex(line, -1) |
| for idx, m := range matches { |
| // e.g: "padding: 6px 13px;" => "padding: 0.375rem 0.8125rem;" |
| // padding: [valueStartIdx][numStartIdx]25[numEndIdx]px[valueEndIdx] 10em; |
| // The value here is the full string "25px" and num is just "25". |
| valueStartIdx, valueEndIdx, numStartIdx, numEndIdx := m[0], m[1], m[2], m[3] |
| if idx == 0 { |
| cssLine += line[0:valueStartIdx] |
| } |
| cssLine += pxToRem(line[numStartIdx:numEndIdx]) |
| if idx == len(matches)-1 { |
| cssLine += line[valueEndIdx:] |
| } else { |
| // If there are more matches for "px", add up until the start of the next match. |
| cssLine += line[valueEndIdx:matches[idx+1][0]] |
| } |
| } |
| return cssLine |
| } |