func quotedWordCutter(reader *strings.Reader) (string, bool) {
var buffer bytes.Buffer
for {
if reader.Len() <= 0 {
return "", false
}
ch, _, _ := reader.ReadRune()
if ch != ' ' {
reader.UnreadRune()
break
}
}
quote := NULQUOTE
yenCount := 0
for reader.Len() > 0 {
ch, _, _ := reader.ReadRune()
if yenCount%2 == 0 {
if quote == NULQUOTE && (ch == '"' || ch == '\'') {
quote = ch
} else if quote != NULQUOTE && ch == quote {
quote = NULQUOTE
}
}
if ch == ' ' && quote == NULQUOTE {
break
}
if ch == '\\' {
yenCount++
} else {
yenCount = 0
}
buffer.WriteRune(ch)
}
return buffer.String(), true
}
// Looks ahead to see if the next character completes the entry. Does not read
// any characters from the reader.
func entryCompleted(r *strings.Reader) bool {
if r.Len() > 0 {
b, _ := r.ReadByte()
r.UnreadByte()
return b == lineSeparator || b == entrySeparator
}
return true
}
// Attempts to consume the wanted character from the reader. Returns true if
// character was read successfully, false otherwise. If the character could
// not be read, then no characters are consumed from the reader.
func consume(r *strings.Reader, wanted byte) bool {
if r.Len() > 0 {
b, _ := r.ReadByte()
if b == wanted {
return true
}
r.UnreadByte()
}
return false
}
func (s *GitUploadPackService) applyHeadersToRequest(req *http.Request, content *strings.Reader) {
req.Header.Add("User-Agent", "git/1.0")
req.Header.Add("Host", "github.com")
if content == nil {
req.Header.Add("Accept", "*/*")
} else {
req.Header.Add("Accept", "application/x-git-upload-pack-result")
req.Header.Add("Content-Type", "application/x-git-upload-pack-request")
req.Header.Add("Content-Length", string(content.Len()))
}
}
func atoi_(reader *strings.Reader) (int, int) {
n := 0
count := 0
for reader.Len() > 0 {
ch, _, _ := reader.ReadRune()
index := strings.IndexRune("0123456789", ch)
if index >= 0 {
n = n*10 + index
count++
} else {
reader.UnreadRune()
break
}
}
return n, count
}
func (n *Node) MatchReader(reader *strings.Reader) bool {
if reader.Len() == 0 && n.Terminal {
return true
}
r, _, err := reader.ReadRune()
if err != nil {
fmt.Println("Bad rune")
}
next, ok := n.Next(r)
if !ok {
return false
}
return next.MatchReader(reader)
}
func (c *Client) merchantUploadImageFromStringsReader(filename string, reader *strings.Reader) (imageURL string, err error) {
originalOffset, err := reader.Seek(0, 1)
if err != nil {
return
}
FormDataFileName := escapeQuotes(filename)
ContentLength := int64(multipart_constPartLen + len(FormDataFileName) + reader.Len())
hasRetry := false
RETRY:
token, err := c.Token()
if err != nil {
return
}
url_ := merchantUploadImageURL(token, filename)
if hasRetry {
if _, err = reader.Seek(originalOffset, 0); err != nil {
return
}
}
mr := io.MultiReader(
strings.NewReader(multipart_formDataFront),
strings.NewReader(FormDataFileName),
strings.NewReader(multipart_formDataMiddle),
reader,
strings.NewReader(multipart_formDataEnd),
)
httpReq, err := http.NewRequest("POST", url_, mr)
if err != nil {
return
}
httpReq.Header.Set("Content-Type", multipart_ContentType)
httpReq.ContentLength = ContentLength
httpResp, err := c.httpClient.Do(httpReq)
if err != nil {
return
}
defer httpResp.Body.Close()
if httpResp.StatusCode != http.StatusOK {
err = fmt.Errorf("http.Status: %s", httpResp.Status)
return
}
var result struct {
Error
ImageURL string `json:"image_url"`
}
if err = json.NewDecoder(httpResp.Body).Decode(&result); err != nil {
return
}
switch result.ErrCode {
case errCodeOK:
imageURL = result.ImageURL
return
case errCodeTimeout:
if !hasRetry {
hasRetry = true
timeoutRetryWait()
goto RETRY
}
fallthrough
default:
err = &result.Error
return
}
}