_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q8500 | Rotate | train | func (gp *GoPdf) Rotate(angle, x, y float64) {
gp.UnitsToPointsVar(&x, &y)
gp.getContent().appendRotate(angle, x, y)
} | go | {
"resource": ""
} |
q8501 | UnitsToPoints | train | func (gp *GoPdf) UnitsToPoints(u float64) float64 {
return UnitsToPoints(gp.config.Unit, u)
} | go | {
"resource": ""
} |
q8502 | UnitsToPointsVar | train | func (gp *GoPdf) UnitsToPointsVar(u ...*float64) {
UnitsToPointsVar(gp.config.Unit, u...)
} | go | {
"resource": ""
} |
q8503 | PointsToUnits | train | func (gp *GoPdf) PointsToUnits(u float64) float64 {
return PointsToUnits(gp.config.Unit, u)
} | go | {
"resource": ""
} |
q8504 | PointsToUnitsVar | train | func (gp *GoPdf) PointsToUnitsVar(u ...*float64) {
PointsToUnitsVar(gp.config.Unit, u...)
} | go | {
"resource": ""
} |
q8505 | PointsToUnits | train | func (rect *Rect) PointsToUnits(t int) (r *Rect) {
if rect == nil {
return
}
if rect.unitOverride != Unit_Unset {
t = rect.unitOverride
}
r = &Rect{W: rect.W, H: rect.H}
PointsToUnitsVar(t, &r.W, &r.H)
return
} | go | {
"resource": ""
} |
q8506 | UnitsToPoints | train | func (rect *Rect) UnitsToPoints(t int) (r *Rect) {
if rect == nil {
return
}
if rect.unitOverride != Unit_Unset {
t = rect.unitOverride
}
r = &Rect{W: rect.W, H: rect.H}
UnitsToPointsVar(t, &r.W, &r.H)
return
} | go | {
"resource": ""
} |
q8507 | ImgReactagleToWH | train | func ImgReactagleToWH(imageRect image.Rectangle) (float64, float64) {
k := 1
w := -128 //init
h := -128 //init
if w < 0 {
w = -imageRect.Dx() * 72 / w / k
}
if h < 0 {
h = -imageRect.Dy() * 72 / h / k
}
if w == 0 {
w = h * imageRect.Dx() / imageRect.Dy()
}
if h == 0 {
h = w * imageRect.Dy() / imageRec... | go | {
"resource": ""
} |
q8508 | URL | train | func (i *item) URL() *url.URL {
str, err := i.bucket.FileURL(i.name)
if err != nil {
return nil
}
url, _ := url.Parse(str)
url.Scheme = Kind
return url
} | go | {
"resource": ""
} |
q8509 | Metadata | train | func (i *item) Metadata() (map[string]interface{}, error) {
if err := i.ensureInfo(); err != nil {
return nil, errors.Wrap(err, "retrieving item metadata")
}
return i.metadata, nil
} | go | {
"resource": ""
} |
q8510 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
_, r, err := i.bucket.DownloadFileByName(i.name)
return r, err
} | go | {
"resource": ""
} |
q8511 | ETag | train | func (i *item) ETag() (string, error) {
if err := i.ensureInfo(); err != nil {
return "", errors.Wrap(err, "retreiving etag")
}
return i.lastModified.String(), nil
} | go | {
"resource": ""
} |
q8512 | CreateContainer | train | func (l *location) CreateContainer(name string) (stow.Container, error) {
err := l.client.ContainerCreate(name, nil)
if err != nil {
return nil, err
}
container := &container{
id: name,
client: l.client,
}
return container, nil
} | go | {
"resource": ""
} |
q8513 | Containers | train | func (l *location) Containers(prefix, cursor string, count int) ([]stow.Container, string, error) {
params := &swift.ContainersOpts{
Limit: count,
Prefix: prefix,
Marker: cursor,
}
response, err := l.client.Containers(params)
if err != nil {
return nil, "", err
}
containers := make([]stow.Container, len(... | go | {
"resource": ""
} |
q8514 | Container | train | func (l *location) Container(id string) (stow.Container, error) {
_, _, err := l.client.Container(id)
// TODO: grab info + headers
if err != nil {
return nil, stow.ErrNotFound
}
c := &container{
id: id,
client: l.client,
}
return c, nil
} | go | {
"resource": ""
} |
q8515 | RemoveContainer | train | func (l *location) RemoveContainer(id string) error {
return l.client.ContainerDelete(id)
} | go | {
"resource": ""
} |
q8516 | Register | train | func Register(kind string, makefn func(Config) (Location, error), kindmatchfn func(*url.URL) bool, validatefn func(Config) error) {
lock.Lock()
defer lock.Unlock()
// if already registered, leave
if _, ok := locations[kind]; ok {
return
}
locations[kind] = makefn
configurations[kind] = validatefn
kinds = appe... | go | {
"resource": ""
} |
q8517 | Dial | train | func Dial(kind string, config Config) (Location, error) {
fn, ok := locations[kind]
if !ok {
return nil, errUnknownKind(kind)
}
return fn(config)
} | go | {
"resource": ""
} |
q8518 | Validate | train | func Validate(kind string, config Config) error {
fn, ok := configurations[kind]
if !ok {
return errUnknownKind(kind)
}
return fn(config)
} | go | {
"resource": ""
} |
q8519 | KindByURL | train | func KindByURL(u *url.URL) (string, error) {
lock.RLock()
defer lock.RUnlock()
for _, fn := range kindmatches {
kind := fn(u)
if kind == "" {
continue
}
return kind, nil
}
return "", errUnknownKind("")
} | go | {
"resource": ""
} |
q8520 | Config | train | func (c ConfigMap) Config(name string) (string, bool) {
val, ok := c[name]
return val, ok
} | go | {
"resource": ""
} |
q8521 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
return os.Open(i.path)
} | go | {
"resource": ""
} |
q8522 | URL | train | func (i *item) URL() *url.URL {
if i.container.customEndpoint == "" {
genericURL := fmt.Sprintf("https://s3-%s.amazonaws.com/%s/%s", i.container.Region(), i.container.Name(), i.Name())
return &url.URL{
Scheme: "s3",
Path: genericURL,
}
}
genericURL := fmt.Sprintf("%s/%s", i.container.Name(), i.Name()... | go | {
"resource": ""
} |
q8523 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
params := &s3.GetObjectInput{
Bucket: aws.String(i.container.Name()),
Key: aws.String(i.ID()),
}
response, err := i.client.GetObject(params)
if err != nil {
return nil, errors.Wrap(err, "Open, getting the object")
}
return response.Body, nil
} | go | {
"resource": ""
} |
q8524 | Tags | train | func (i *item) Tags() (map[string]interface{}, error) {
i.tagsOnce.Do(func() {
params := &s3.GetObjectTaggingInput{
Bucket: aws.String(i.container.name),
Key: aws.String(i.ID()),
}
res, err := i.client.GetObjectTagging(params)
if err != nil {
if strings.Contains(err.Error(), "NoSuchKey") {
i.t... | go | {
"resource": ""
} |
q8525 | ensureInfo | train | func (i *item) ensureInfo() error {
// If lastModified is empty, so is hash. get info on the Item and
// update the necessary fields at the same time.
if i.lastModified.IsZero() || i.hash == "" || i.metadata == nil {
i.infoOnce.Do(func() {
itemInfo, infoErr := i.getInfo()
if infoErr != nil {
i.infoErr = ... | go | {
"resource": ""
} |
q8526 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
r, _, err := i.client.ObjectOpen(i.container.id, i.id, false, nil)
var res io.ReadCloser = r
// FIXME: this is a workaround to issue https://github.com/graymeta/stow/issues/120
if s, ok := res.(readSeekCloser); ok {
res = &fixReadSeekCloser{readSeekCloser: s, item: i... | go | {
"resource": ""
} |
q8527 | LastMod | train | func (i *item) LastMod() (time.Time, error) {
// If an object is PUT, certain information is missing. Detect
// if the lastModified field is missing, send a request to retrieve
// it, and save both this and other missing information so that a
// request doesn't have to be sent again.
err := i.ensureInfo()
if err ... | go | {
"resource": ""
} |
q8528 | parseMetadata | train | func parseMetadata(md swift.Headers) (map[string]interface{}, error) {
m := make(map[string]interface{}, len(md))
for key, value := range md.ObjectMetadata() {
m[key] = value
}
return m, nil
} | go | {
"resource": ""
} |
q8529 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
params := &swift.ObjectsOpts{
Limit: count,
Marker: cursor,
Prefix: prefix,
}
objects, err := c.client.Objects(c.id, params)
if err != nil {
return nil, "", err
}
items := make([]stow.Item, len(objects))
for i, o... | go | {
"resource": ""
} |
q8530 | Put | train | func (c *container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, errors.Wrap(err, "unable to create or update Item, preparing metadata")
}
_, err = c.client.ObjectPut(c.id, name, r, false, "", ... | go | {
"resource": ""
} |
q8531 | prepUrl | train | func prepUrl(str string) (*url.URL, error) {
u, err := url.Parse(str)
if err != nil {
return nil, err
}
u.Scheme = "google"
// Discard the query string
u.RawQuery = ""
return u, nil
} | go | {
"resource": ""
} |
q8532 | Containers | train | func (l *location) Containers(prefix string, cursor string, count int) ([]stow.Container, string, error) {
response, err := l.client.ListBuckets()
if err != nil {
return nil, "", err
}
containers := make([]stow.Container, 0, len(response))
for _, cont := range response {
// api and/or library don't seem to su... | go | {
"resource": ""
} |
q8533 | Container | train | func (l *location) Container(id string) (stow.Container, error) {
bucket, err := l.client.Bucket(id)
if err != nil || bucket == nil {
return nil, stow.ErrNotFound
}
return &container{
bucket: bucket,
}, nil
} | go | {
"resource": ""
} |
q8534 | ItemByURL | train | func (l *location) ItemByURL(u *url.URL) (stow.Item, error) {
if u.Scheme != Kind {
return nil, errors.New("not valid b2 URL")
}
// b2://f001.backblaze.com/file/<container_name>/<path_to_object>
pieces := strings.SplitN(u.Path, "/", 4)
c, err := l.Container(pieces[2])
if err != nil {
return nil, err
}
fi... | go | {
"resource": ""
} |
q8535 | RemoveContainer | train | func (l *location) RemoveContainer(id string) error {
stowCont, err := l.Container(id)
if err != nil {
return err
}
return stowCont.(*container).bucket.Delete()
} | go | {
"resource": ""
} |
q8536 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
itemLimit := int64(count)
params := &s3.ListObjectsV2Input{
Bucket: aws.String(c.Name()),
StartAfter: &cursor,
MaxKeys: &itemLimit,
Prefix: &prefix,
}
response, err := c.client.ListObjectsV2(params)
if e... | go | {
"resource": ""
} |
q8537 | getItem | train | func (c *container) getItem(id string) (*item, error) {
params := &s3.HeadObjectInput{
Bucket: aws.String(c.name),
Key: aws.String(id),
}
res, err := c.client.HeadObject(params)
if err != nil {
// stow needs ErrNotFound to pass the test but amazon returns an opaque error
if aerr, ok := err.(awserr.Error... | go | {
"resource": ""
} |
q8538 | parseMetadata | train | func parseMetadata(md map[string]*string) (map[string]interface{}, error) {
m := make(map[string]interface{}, len(md))
for key, value := range md {
k := strings.ToLower(key)
m[k] = *value
}
return m, nil
} | go | {
"resource": ""
} |
q8539 | flatdirs | train | func flatdirs(path string) ([]os.FileInfo, error) {
var list []os.FileInfo
err := filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
flatname, err := filepath.Rel(path, p)
if err != nil {
return err
}
list = appe... | go | {
"resource": ""
} |
q8540 | determineChunkSize | train | func determineChunkSize(size int64) (int64, error) {
var chunkSize = int64(startChunkSize)
for {
parts := size / chunkSize
rem := size % chunkSize
if rem != 0 {
parts++
}
if parts <= maxParts {
break
}
if chunkSize == maxChunkSize {
return 0, errMultiPartUploadTooBig
}
chunkSize *= 2
... | go | {
"resource": ""
} |
q8541 | multipartUpload | train | func (c *container) multipartUpload(name string, r io.Reader, size int64) error {
chunkSize, err := determineChunkSize(size)
if err != nil {
return err
}
var buf = make([]byte, chunkSize)
var blocks []az.Block
var rawID uint64
blob := c.client.GetContainerReference(c.id).GetBlobReference(name)
// TODO: uplo... | go | {
"resource": ""
} |
q8542 | CreateContainer | train | func (l *location) CreateContainer(containerName string) (stow.Container, error) {
createBucketParams := &s3.CreateBucketInput{
Bucket: aws.String(containerName), // required
}
_, err := l.client.CreateBucket(createBucketParams)
if err != nil {
return nil, errors.Wrap(err, "CreateContainer, creating the bucket... | go | {
"resource": ""
} |
q8543 | Containers | train | func (l *location) Containers(prefix, cursor string, count int) ([]stow.Container, string, error) {
// Response returns exported Owner(*s3.Owner) and Bucket(*s3.[]Bucket)
var params *s3.ListBucketsInput
bucketList, err := l.client.ListBuckets(params)
if err != nil {
return nil, "", errors.Wrap(err, "Containers, l... | go | {
"resource": ""
} |
q8544 | Walk | train | func Walk(container Container, prefix string, pageSize int, fn WalkFunc) error {
var (
err error
items []Item
cursor = CursorStart
)
for {
items, cursor, err = container.Items(prefix, cursor, pageSize)
if err != nil {
err = fn(nil, err)
if err != nil {
return err
}
}
for _, item := ran... | go | {
"resource": ""
} |
q8545 | WalkContainers | train | func WalkContainers(location Location, prefix string, pageSize int, fn WalkContainersFunc) error {
var (
err error
containers []Container
cursor = CursorStart
)
for {
containers, cursor, err = location.Containers(prefix, cursor, pageSize)
if err != nil {
err = fn(nil, err)
if err != nil {
... | go | {
"resource": ""
} |
q8546 | Item | train | func (c *Container) Item(id string) (stow.Item, error) {
res, err := c.client.Objects.Get(c.name, id).Do()
if err != nil {
return nil, stow.ErrNotFound
}
t, err := time.Parse(time.RFC3339, res.Updated)
if err != nil {
return nil, err
}
u, err := prepUrl(res.MediaLink)
if err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q8547 | Items | train | func (c *Container) Items(prefix string, cursor string, count int) ([]stow.Item, string, error) {
// List all objects in a bucket using pagination
call := c.client.Objects.List(c.name).MaxResults(int64(count))
if prefix != "" {
call.Prefix(prefix)
}
if cursor != "" {
call = call.PageToken(cursor)
}
res, e... | go | {
"resource": ""
} |
q8548 | Put | train | func (c *Container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, err
}
object := &storage.Object{
Name: name,
Metadata: mdPrepped,
}
res, err := c.client.Objects.Insert(c.name, objec... | go | {
"resource": ""
} |
q8549 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
items := make([]stow.Item, 0, count)
for {
response, err := c.bucket.ListFileNames(cursor, count)
if err != nil {
return nil, "", err
}
for _, obj := range response.Files {
if prefix != stow.NoPrefix && !strings.... | go | {
"resource": ""
} |
q8550 | Put | train | func (c *container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
// Convert map[string]interface{} to map[string]string
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, errors.Wrap(err, "unable to create or update item, preparing metadata")
}
... | go | {
"resource": ""
} |
q8551 | RemoveItem | train | func (c *container) RemoveItem(id string) error {
item, err := c.getItem(id)
if err != nil {
return err
}
// files can have multiple versions in backblaze. You have to delete
// files one version at a time.
for {
response, err := item.bucket.ListFileNames(item.Name(), 1)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q8552 | filesToContainers | train | func (l *location) filesToContainers(root string, files ...string) ([]stow.Container, error) {
cs := make([]stow.Container, 0, len(files))
for _, f := range files {
info, err := os.Stat(f)
if err != nil {
return nil, err
}
if !info.IsDir() {
continue
}
absroot, err := filepath.Abs(root)
if err != ... | go | {
"resource": ""
} |
q8553 | CreateContainer | train | func (l *Location) CreateContainer(containerName string) (stow.Container, error) {
projId, _ := l.config.Config(ConfigProjectId)
// Create a bucket.
_, err := l.client.Buckets.Insert(projId, &storage.Bucket{Name: containerName}).Do()
//res, err := l.client.Buckets.Insert(projId, &storage.Bucket{Name: containerName... | go | {
"resource": ""
} |
q8554 | Containers | train | func (l *Location) Containers(prefix string, cursor string, count int) ([]stow.Container, string, error) {
projId, _ := l.config.Config(ConfigProjectId)
// List all objects in a bucket using pagination
call := l.client.Buckets.List(projId).MaxResults(int64(count))
if prefix != "" {
call.Prefix(prefix)
}
if ... | go | {
"resource": ""
} |
q8555 | Register | train | func Register(mock Mock) {
if Exists(mock) {
return
}
// Make ops thread safe
mutex.Lock()
defer mutex.Unlock()
// Expose mock in request/response for delegation
mock.Request().Mock = mock
mock.Response().Mock = mock
// Registers the mock in the global store
mocks = append(mocks, mock)
} | go | {
"resource": ""
} |
q8556 | Exists | train | func Exists(m Mock) bool {
storeMutex.RLock()
defer storeMutex.RUnlock()
for _, mock := range mocks {
if mock == m {
return true
}
}
return false
} | go | {
"resource": ""
} |
q8557 | Remove | train | func Remove(m Mock) {
for i, mock := range mocks {
if mock == m {
storeMutex.Lock()
mocks = append(mocks[:i], mocks[i+1:]...)
storeMutex.Unlock()
}
}
} | go | {
"resource": ""
} |
q8558 | Clean | train | func Clean() {
storeMutex.Lock()
defer storeMutex.Unlock()
buf := []Mock{}
for _, mock := range mocks {
if mock.Done() {
continue
}
buf = append(buf, mock)
}
mocks = buf
} | go | {
"resource": ""
} |
q8559 | Add | train | func (m *MockMatcher) Add(fn MatchFunc) {
m.Matchers = append(m.Matchers, fn)
} | go | {
"resource": ""
} |
q8560 | Match | train | func (m *MockMatcher) Match(req *http.Request, ereq *Request) (bool, error) {
for _, matcher := range m.Matchers {
matches, err := matcher(req, ereq)
if err != nil {
return false, err
}
if !matches {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8561 | MatchMock | train | func MatchMock(req *http.Request) (Mock, error) {
for _, mock := range GetAll() {
matches, err := mock.Match(req)
if err != nil {
return nil, err
}
if matches {
return mock, nil
}
}
return nil, nil
} | go | {
"resource": ""
} |
q8562 | NewRequest | train | func NewRequest() *Request {
return &Request{
Counter: 1,
URLStruct: &url.URL{},
Header: make(http.Header),
PathParams: make(map[string]string),
}
} | go | {
"resource": ""
} |
q8563 | URL | train | func (r *Request) URL(uri string) *Request {
r.URLStruct, r.Error = url.Parse(uri)
return r
} | go | {
"resource": ""
} |
q8564 | SetURL | train | func (r *Request) SetURL(u *url.URL) *Request {
r.URLStruct = u
return r
} | go | {
"resource": ""
} |
q8565 | method | train | func (r *Request) method(method, path string) *Request {
if path != "/" {
r.URLStruct.Path = path
}
r.Method = strings.ToUpper(method)
return r
} | go | {
"resource": ""
} |
q8566 | BodyString | train | func (r *Request) BodyString(body string) *Request {
r.BodyBuffer = []byte(body)
return r
} | go | {
"resource": ""
} |
q8567 | File | train | func (r *Request) File(path string) *Request {
r.BodyBuffer, r.Error = ioutil.ReadFile(path)
return r
} | go | {
"resource": ""
} |
q8568 | Compression | train | func (r *Request) Compression(scheme string) *Request {
r.Header.Set("Content-Encoding", scheme)
r.CompressionScheme = scheme
return r
} | go | {
"resource": ""
} |
q8569 | JSON | train | func (r *Request) JSON(data interface{}) *Request {
if r.Header.Get("Content-Type") == "" {
r.Header.Set("Content-Type", "application/json")
}
r.BodyBuffer, r.Error = readAndDecode(data, "json")
return r
} | go | {
"resource": ""
} |
q8570 | BasicAuth | train | func (r *Request) BasicAuth(username, password string) *Request {
r.Header.Set("Authorization", "Basic "+basicAuth(username, password))
return r
} | go | {
"resource": ""
} |
q8571 | MatchHeader | train | func (r *Request) MatchHeader(key, value string) *Request {
r.Header.Set(key, value)
return r
} | go | {
"resource": ""
} |
q8572 | HeaderPresent | train | func (r *Request) HeaderPresent(key string) *Request {
r.Header.Set(key, ".*")
return r
} | go | {
"resource": ""
} |
q8573 | MatchHeaders | train | func (r *Request) MatchHeaders(headers map[string]string) *Request {
for key, value := range headers {
r.Header.Set(key, value)
}
return r
} | go | {
"resource": ""
} |
q8574 | MatchParam | train | func (r *Request) MatchParam(key, value string) *Request {
query := r.URLStruct.Query()
query.Set(key, value)
r.URLStruct.RawQuery = query.Encode()
return r
} | go | {
"resource": ""
} |
q8575 | MatchParams | train | func (r *Request) MatchParams(params map[string]string) *Request {
query := r.URLStruct.Query()
for key, value := range params {
query.Set(key, value)
}
r.URLStruct.RawQuery = query.Encode()
return r
} | go | {
"resource": ""
} |
q8576 | ParamPresent | train | func (r *Request) ParamPresent(key string) *Request {
r.MatchParam(key, ".*")
return r
} | go | {
"resource": ""
} |
q8577 | Times | train | func (r *Request) Times(num int) *Request {
r.Counter = num
return r
} | go | {
"resource": ""
} |
q8578 | AddMatcher | train | func (r *Request) AddMatcher(fn MatchFunc) *Request {
r.Mock.AddMatcher(fn)
return r
} | go | {
"resource": ""
} |
q8579 | SetMatcher | train | func (r *Request) SetMatcher(matcher Matcher) *Request {
r.Mock.SetMatcher(matcher)
return r
} | go | {
"resource": ""
} |
q8580 | Map | train | func (r *Request) Map(fn MapRequestFunc) *Request {
r.Mappers = append(r.Mappers, fn)
return r
} | go | {
"resource": ""
} |
q8581 | EnableNetworking | train | func (r *Request) EnableNetworking() *Request {
if r.Response != nil {
r.Response.UseNetwork = true
}
return r
} | go | {
"resource": ""
} |
q8582 | Reply | train | func (r *Request) Reply(status int) *Response {
return r.Response.Status(status)
} | go | {
"resource": ""
} |
q8583 | ReplyError | train | func (r *Request) ReplyError(err error) *Response {
return r.Response.SetError(err)
} | go | {
"resource": ""
} |
q8584 | ReplyFunc | train | func (r *Request) ReplyFunc(replier func(*Response)) *Response {
replier(r.Response)
return r.Response
} | go | {
"resource": ""
} |
q8585 | Responder | train | func Responder(req *http.Request, mock *Response, res *http.Response) (*http.Response, error) {
// If error present, reply it
err := mock.Error
if err != nil {
return nil, err
}
if res == nil {
res = createResponse(req)
}
// Apply response filter
for _, filter := range mock.Filters {
if !filter(res) {
... | go | {
"resource": ""
} |
q8586 | createResponse | train | func createResponse(req *http.Request) *http.Response {
return &http.Response{
ProtoMajor: 1,
ProtoMinor: 1,
Proto: "HTTP/1.1",
Request: req,
Header: make(http.Header),
Body: createReadCloser([]byte{}),
}
} | go | {
"resource": ""
} |
q8587 | mergeHeaders | train | func mergeHeaders(res *http.Response, mres *Response) http.Header {
for key, values := range mres.Header {
for _, value := range values {
res.Header.Add(key, value)
}
}
return res.Header
} | go | {
"resource": ""
} |
q8588 | createReadCloser | train | func createReadCloser(body []byte) io.ReadCloser {
return ioutil.NopCloser(bytes.NewReader(body))
} | go | {
"resource": ""
} |
q8589 | startHTTPServer | train | func startHTTPServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Local server received a GET request")
res, err := http.Get("http://httpbin.org/nope")
if err != nil {
msg := fmt.Sprintf("Error from request to httpbin: %s", err)
... | go | {
"resource": ""
} |
q8590 | MatchMethod | train | func MatchMethod(req *http.Request, ereq *Request) (bool, error) {
return ereq.Method == "" || req.Method == ereq.Method, nil
} | go | {
"resource": ""
} |
q8591 | MatchScheme | train | func MatchScheme(req *http.Request, ereq *Request) (bool, error) {
return ereq.URLStruct.Scheme == "" || req.URL.Scheme == "" || ereq.URLStruct.Scheme == req.URL.Scheme, nil
} | go | {
"resource": ""
} |
q8592 | MatchHost | train | func MatchHost(req *http.Request, ereq *Request) (bool, error) {
url := ereq.URLStruct
if strings.EqualFold(url.Host, req.URL.Host) {
return true, nil
}
return regexp.MatchString(url.Host, req.URL.Host)
} | go | {
"resource": ""
} |
q8593 | MatchPath | train | func MatchPath(req *http.Request, ereq *Request) (bool, error) {
if req.URL.Path == ereq.URLStruct.Path {
return true, nil
}
return regexp.MatchString(ereq.URLStruct.Path, req.URL.Path)
} | go | {
"resource": ""
} |
q8594 | MatchHeaders | train | func MatchHeaders(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.Header {
var err error
var match bool
for _, field := range req.Header[key] {
match, err = regexp.MatchString(value[0], field)
if err != nil {
return false, err
}
if match {
break
}
}
if ... | go | {
"resource": ""
} |
q8595 | MatchQueryParams | train | func MatchQueryParams(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.URLStruct.Query() {
var err error
var match bool
for _, field := range req.URL.Query()[key] {
match, err = regexp.MatchString(value[0], field)
if err != nil {
return false, err
}
if match {
b... | go | {
"resource": ""
} |
q8596 | MatchPathParams | train | func MatchPathParams(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.PathParams {
var s string
if err := parth.Sequent(req.URL.Path, key, &s); err != nil {
return false, nil
}
if s != value {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8597 | Status | train | func (r *Response) Status(code int) *Response {
r.StatusCode = code
return r
} | go | {
"resource": ""
} |
q8598 | SetHeader | train | func (r *Response) SetHeader(key, value string) *Response {
r.Header.Set(key, value)
return r
} | go | {
"resource": ""
} |
q8599 | AddHeader | train | func (r *Response) AddHeader(key, value string) *Response {
r.Header.Add(key, value)
return r
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.