mirror of
https://github.com/golang/go
synced 2024-10-01 16:08:33 -06:00
16d1af8d88
This CL groups the package list into two groups - standard library(GOROOT), and third-party code(GOPATH). It also wraps the list with a collapsible div header used in the package documentation page. This makes the entire page easy to view and manage, and also makes it consistent with the rest of the pages. To implement this, a new function was added to the filesystem interface which returns the root type of the filesystem. In most cases, it is either GOROOT or GOPATH. There are other kinds of filesystems which are not used in the home page, so additional values have been added to satisfy the interface. A side effect of this is that the html template code has become a bit spaghetti-like with if conditions all over. This is because the same template is used to render a package directory as well as the package home page. A better way is to use two separate templates for the different tasks. This cleans out a lot of the if conditions and make for a much cleaner code. This has been taken care in CL 101295. Fixes golang/go#3305 Fixes golang/go#15020 Change-Id: I876357dc76280a7df2ed08d7c6bc53d9a41e69ab Reviewed-on: https://go-review.googlesource.com/95835 Run-TryBot: Andrew Bonventre <andybons@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Andrew Bonventre <andybons@golang.org>
94 lines
1.9 KiB
Go
94 lines
1.9 KiB
Go
// Copyright 2013 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.
|
|
|
|
// Package gatefs provides an implementation of the FileSystem
|
|
// interface that wraps another FileSystem and limits its concurrency.
|
|
package gatefs // import "golang.org/x/tools/godoc/vfs/gatefs"
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
|
|
"golang.org/x/tools/godoc/vfs"
|
|
)
|
|
|
|
// New returns a new FileSystem that delegates to fs.
|
|
// If gateCh is non-nil and buffered, it's used as a gate
|
|
// to limit concurrency on calls to fs.
|
|
func New(fs vfs.FileSystem, gateCh chan bool) vfs.FileSystem {
|
|
if cap(gateCh) == 0 {
|
|
return fs
|
|
}
|
|
return gatefs{fs, gate(gateCh)}
|
|
}
|
|
|
|
type gate chan bool
|
|
|
|
func (g gate) enter() { g <- true }
|
|
func (g gate) leave() { <-g }
|
|
|
|
type gatefs struct {
|
|
fs vfs.FileSystem
|
|
gate
|
|
}
|
|
|
|
func (fs gatefs) String() string {
|
|
return fmt.Sprintf("gated(%s, %d)", fs.fs.String(), cap(fs.gate))
|
|
}
|
|
|
|
func (fs gatefs) RootType(path string) vfs.RootType {
|
|
return fs.fs.RootType(path)
|
|
}
|
|
|
|
func (fs gatefs) Open(p string) (vfs.ReadSeekCloser, error) {
|
|
fs.enter()
|
|
defer fs.leave()
|
|
rsc, err := fs.fs.Open(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return gatef{rsc, fs.gate}, nil
|
|
}
|
|
|
|
func (fs gatefs) Lstat(p string) (os.FileInfo, error) {
|
|
fs.enter()
|
|
defer fs.leave()
|
|
return fs.fs.Lstat(p)
|
|
}
|
|
|
|
func (fs gatefs) Stat(p string) (os.FileInfo, error) {
|
|
fs.enter()
|
|
defer fs.leave()
|
|
return fs.fs.Stat(p)
|
|
}
|
|
|
|
func (fs gatefs) ReadDir(p string) ([]os.FileInfo, error) {
|
|
fs.enter()
|
|
defer fs.leave()
|
|
return fs.fs.ReadDir(p)
|
|
}
|
|
|
|
type gatef struct {
|
|
rsc vfs.ReadSeekCloser
|
|
gate
|
|
}
|
|
|
|
func (f gatef) Read(p []byte) (n int, err error) {
|
|
f.enter()
|
|
defer f.leave()
|
|
return f.rsc.Read(p)
|
|
}
|
|
|
|
func (f gatef) Seek(offset int64, whence int) (ret int64, err error) {
|
|
f.enter()
|
|
defer f.leave()
|
|
return f.rsc.Seek(offset, whence)
|
|
}
|
|
|
|
func (f gatef) Close() error {
|
|
f.enter()
|
|
defer f.leave()
|
|
return f.rsc.Close()
|
|
}
|