yeray/gobyexample
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gofmt

Browse Source
This commit is contained in:
Mark McGranaghan 2012-10-01 08:01:39 -07:00
parent ebec3473f2
commit 9a3987c96a
8 changed files with 139 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@ -16,11 +16,3 @@ $ go run tool/number.go
```console ```console
$ tool/gofmt $ tool/gofmt
``` ```
### Golit'ing
```console
$ go run tool/generate.go tool/generate > build/generate.html
$ open build/generate.html
```

52
src/039-nonblocking-channel-operations/nonblocking-channel-operations.go
View File

@ -3,33 +3,33 @@ package main
import "fmt" import "fmt"
func main() { func main() {
messages := make(chan string) messages := make(chan string)
signals := make(chan bool) signals := make(chan bool)
// Non-blocking receive. // Non-blocking receive.
select { select {
case msg := <- messages: case msg := <-messages:
fmt.Println("received message", msg) fmt.Println("received message", msg)
default: default:
fmt.Println("no messages received") fmt.Println("no messages received")
} }
// Non-blocking send. // Non-blocking send.
msg := "hi" msg := "hi"
select { select {
case messages <- msg: case messages <- msg:
fmt.Println("sent message", msg) fmt.Println("sent message", msg)
default: default:
fmt.Println("no messages sent") fmt.Println("no messages sent")
} }
// Non-blocking multi-way select. // Non-blocking multi-way select.
select { select {
case msg := <- messages: case msg := <-messages:
fmt.Println("received message", msg) fmt.Println("received message", msg)
case sig := <- signals: case sig := <-signals:
fmt.Println("received signal", sig) fmt.Println("received signal", sig)
default: default:
fmt.Println("no activity") fmt.Println("no activity")
} }
} }

44
src/040-closing-channels/closing-channels.go
View File

@ -4,30 +4,30 @@ import "fmt"
import "time" import "time"
func main() { func main() {
jobs := make(chan bool, 5) jobs := make(chan bool, 5)
done := make(chan bool) done := make(chan bool)
go func() { go func() {
for { for {
_, more := <- jobs _, more := <-jobs
if more { if more {
fmt.Println("received job") fmt.Println("received job")
} else { } else {
fmt.Println("received all") fmt.Println("received all")
done <- true done <- true
return return
} }
} }
}() }()
for i := 0; i < 5 ; i++ { for i := 0; i < 5; i++ {
jobs <- false jobs <- false
fmt.Println("sent job") fmt.Println("sent job")
} }
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
close(jobs) close(jobs)
fmt.Println("sent all") fmt.Println("sent all")
<- done <-done
} }

90
src/043-state-goroutine/state-goroutine.go
View File

@ -13,35 +13,35 @@ import "sync/atomic"
// e.g. routing table // e.g. routing table
type readOp struct { type readOp struct {
key int key int
resp chan int resp chan int
} }
type writeOp struct { type writeOp struct {
key int key int
val int val int
resp chan bool resp chan bool
} }
func randKey() int { func randKey() int {
return rand.Intn(10) return rand.Intn(10)
} }
func randVal() int { func randVal() int {
return rand.Intn(100) return rand.Intn(100)
} }
func manageState(reads chan *readOp, writes chan *writeOp) { func manageState(reads chan *readOp, writes chan *writeOp) {
data := make(map[int]int) data := make(map[int]int)
for { for {
select { select {
case read := <- reads: case read := <-reads:
read.resp <- data[read.key] read.resp <- data[read.key]
case write := <- writes: case write := <-writes:
data[write.key] = write.val data[write.key] = write.val
write.resp <- true write.resp <- true
} }
} }
} }
// Keep track of how many ops we do. // Keep track of how many ops we do.
@ -49,42 +49,42 @@ var opCount int64 = 0
// Generate random reads. // Generate random reads.
func generateReads(reads chan *readOp) { func generateReads(reads chan *readOp) {
for { for {
key := randKey() key := randKey()
read := &readOp{key: key, resp: make(chan int)} read := &readOp{key: key, resp: make(chan int)}
reads <- read reads <- read
<- read.resp <-read.resp
atomic.AddInt64(&opCount, 1) atomic.AddInt64(&opCount, 1)
} }
} }
// Generate random writes. // Generate random writes.
func generateWrites(writes chan *writeOp) { func generateWrites(writes chan *writeOp) {
for { for {
key := randKey() key := randKey()
val := randVal() val := randVal()
write := &writeOp{key: key, val: val, resp: make(chan bool)} write := &writeOp{key: key, val: val, resp: make(chan bool)}
writes <- write writes <- write
<- write.resp <-write.resp
atomic.AddInt64(&opCount, 1) atomic.AddInt64(&opCount, 1)
} }
} }
func main() { func main() {
reads := make(chan *readOp) reads := make(chan *readOp)
writes := make(chan *writeOp) writes := make(chan *writeOp)
go manageState(reads, writes) go manageState(reads, writes)
for r := 0; r < 100; r++ { for r := 0; r < 100; r++ {
go generateReads(reads) go generateReads(reads)
} }
for w := 0; w < 10; w++ { for w := 0; w < 10; w++ {
go generateWrites(writes) go generateWrites(writes)
} }
atomic.StoreInt64(&opCount, 0) atomic.StoreInt64(&opCount, 0)
time.Sleep(time.Second) time.Sleep(time.Second)
finalOpCount := atomic.LoadInt64(&opCount) finalOpCount := atomic.LoadInt64(&opCount)
fmt.Println(finalOpCount) fmt.Println(finalOpCount)
} }

60
src/044-state-mutex/state-mutex.go
View File

@ -10,11 +10,11 @@ import "sync/atomic"
import "runtime" import "runtime"
func randKey() int { func randKey() int {
return rand.Intn(10) return rand.Intn(10)
} }
func randVal() int { func randVal() int {
return rand.Intn(100) return rand.Intn(100)
} }
// Globally-accessible state. // Globally-accessible state.
@ -27,40 +27,40 @@ var opCount int64 = 0
// Generate random reads. // Generate random reads.
func generateReads() { func generateReads() {
total := 0 total := 0
for { for {
key := randKey() key := randKey()
dataMutex.Lock() dataMutex.Lock()
total += data[key] total += data[key]
dataMutex.Unlock() dataMutex.Unlock()
atomic.AddInt64(&opCount, 1) atomic.AddInt64(&opCount, 1)
runtime.Gosched() runtime.Gosched()
} }
} }
// Generate random writes. // Generate random writes.
func generateWrites() { func generateWrites() {
for { for {
key := randKey() key := randKey()
val := randVal() val := randVal()
dataMutex.Lock() dataMutex.Lock()
data[key] = val data[key] = val
dataMutex.Unlock() dataMutex.Unlock()
atomic.AddInt64(&opCount, 1) atomic.AddInt64(&opCount, 1)
runtime.Gosched() runtime.Gosched()
} }
} }
func main() { func main() {
for r := 0; r < 100; r++ { for r := 0; r < 100; r++ {
go generateReads() go generateReads()
} }
for w := 0; w < 10; w++ { for w := 0; w < 10; w++ {
go generateWrites() go generateWrites()
} }
atomic.StoreInt64(&opCount, 0) atomic.StoreInt64(&opCount, 0)
time.Sleep(time.Second) time.Sleep(time.Second)
finalOpCount := atomic.LoadInt64(&opCount) finalOpCount := atomic.LoadInt64(&opCount)
fmt.Println(finalOpCount) fmt.Println(finalOpCount)
} }

30
src/060-base64-encoding/base64-encoding.go
View File

@ -4,21 +4,21 @@ import "encoding/base64"
import "fmt" import "fmt"
func main() { func main() {
// The data we'll encode/decode. // The data we'll encode/decode.
data := "abc123!?$*&()'-=@~" data := "abc123!?$*&()'-=@~"
fmt.Println(data) fmt.Println(data)
fmt.Println() fmt.Println()
// Standard base64 encoding/decoding. // Standard base64 encoding/decoding.
stdEnc := base64.StdEncoding.EncodeToString([]byte(data)) stdEnc := base64.StdEncoding.EncodeToString([]byte(data))
fmt.Println(stdEnc) fmt.Println(stdEnc)
stdDec, _ := base64.StdEncoding.DecodeString(stdEnc) stdDec, _ := base64.StdEncoding.DecodeString(stdEnc)
fmt.Println(string(stdDec)) fmt.Println(string(stdDec))
fmt.Println() fmt.Println()
// URL base64 encoding/decoding. // URL base64 encoding/decoding.
urlEnc := base64.URLEncoding.EncodeToString([]byte(data)) urlEnc := base64.URLEncoding.EncodeToString([]byte(data))
fmt.Println(urlEnc) fmt.Println(urlEnc)
urlDec, _ := base64.URLEncoding.DecodeString(urlEnc) urlDec, _ := base64.URLEncoding.DecodeString(urlEnc)
fmt.Println(string(urlDec)) fmt.Println(string(urlDec))
} }

168
tool/generate.go
View File

@ -1,168 +0,0 @@
// ## golit
// **golit** generates literate-programming style HTML
// documentation from a Go source files.
package main
import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"regexp"
"strings"
)
// Recognize doc lines, extract their comment prefixes.
var docsPat = regexp.MustCompile("^\\s*\\/\\/\\s")
// Recognize title prefixes, for titling web page.
var titlePat = regexp.MustCompile("^\\/\\/\\s##\\s")
// Abort on non-nil errors.
func check(err error) {
if err != nil {
panic(err)
}
}
// We'll implement Markdown rendering and Pygments
// syntax highlighting by piping the source data through
// external programs. This is a general helper for
// handling both cases.
func pipe(bin string, arg []string, src string) string {
cmd := exec.Command(bin, arg...)
in, err := cmd.StdinPipe()
check(err)
out, err := cmd.StdoutPipe()
check(err)
err = cmd.Start()
check(err)
in.Write([]byte(src))
check(err)
err = in.Close()
check(err)
bytes, err := ioutil.ReadAll(out)
check(err)
err = cmd.Wait()
check(err)
return string(bytes)
}
// We'll break the code into {docs, code} pairs, and
// then render those text segments before including them
// in the HTML doc.
type seg struct {
docs, code, docsRendered, codeRendered string
}
func main() {
// Accept exactly 1 argument - the input filename,
// less the .go extension.
if len(os.Args) != 2 {
fmt.Fprintln(os.Stderr, "unexpected args")
os.Exit(1)
}
// Ensure that we have `markdown` and `pygmentize`,
// binaries, remember their paths.
markdownPath, err := exec.LookPath("markdown")
check(err)
pygmentizePath, err := exec.LookPath("pygmentize")
check(err)
// Read the source file in, split into lines.
srcBytes, err := ioutil.ReadFile(os.Args[1]+".go")
check(err)
lines := strings.Split(string(srcBytes), "\n")
// Group lines into docs/code segments. First,
// special case the header to go in its own segment.
headerDoc := docsPat.ReplaceAllString(lines[0], "")
segs := []*seg{}
segs = append(segs, &seg{code: "", docs: headerDoc})
// Then handle the remaining as code/doc pairs.
segs = append(segs, &seg{code: "", docs: ""})
last := ""
for _, line := range lines[2:] {
head := segs[len(segs)-1]
docsMatch := docsPat.MatchString(line)
emptyMatch := line == ""
lastDocs := last == "docs"
newDocs := (last == "code") && head.docs != ""
newCode := (last == "docs") && head.code != ""
// Docs line - strip out comment indicator.
if docsMatch || (emptyMatch && lastDocs) {
trimed := docsPat.ReplaceAllString(line, "")
if newDocs {
newSeg := seg{docs: trimed, code: ""}
segs = append(segs, &newSeg)
} else {
head.docs = head.docs + "\n" + trimed
}
last = "docs"
// Code line - preserve all whitespace.
} else {
if newCode {
newSeg := seg{docs: "", code: line}
segs = append(segs, &newSeg)
} else {
head.code = head.code + "\n" + line
}
last = "code"
}
}
// Render docs via `markdown` and code via
// `pygmentize` in each segment.
for _, seg := range segs {
seg.docsRendered = pipe(
markdownPath,
[]string{},
seg.docs)
seg.codeRendered = pipe(
pygmentizePath,
[]string{"-l", "go", "-f", "html"},
seg.code+" ")
}
// Print HTML header.
title := titlePat.ReplaceAllString(lines[0], "")
fmt.Printf(`
<!DOCTYPE html>
<html>
<head>
<meta http-eqiv="content-type"
content="text/html;charset=utf-8">
<title>%s</title>
<link rel=stylesheet href="../style/lit.css">
</head>
<body>
<div id="container">
<div id="background"></div>
<table cellspacing="0" cellpadding="0">
<thead>
<tr>
<td class=docs></td>
<td class=code></td>
</tr>
</thead>
<tbody>`, title)
// Print HTML docs/code segments.
for _, seg := range segs {
fmt.Printf(
`<tr>
<td class=docs>%s</td>
<td class=code>%s</td>
</tr>`, seg.docsRendered, seg.codeRendered)
}
// Print HTML footer.
fmt.Print(`</tbody>
</table>
</div>
</body>
</html>`)
}

2
tool/gofmt
View File

@ -1,3 +1,3 @@
#!/bin/bash #!/bin/bash
ls */*.go | xargs -n 1 gofmt -tabs=false -tabwidth=4 -w=true ls src/*/*.go | xargs -n 1 gofmt -tabs=false -tabwidth=4 -w=true