Exemplo n.º 1
0
func (conn *Connection) Indexes() (indexes []*Index, err error) {
	const sql = `SELECT RDB$INDICES.RDB$RELATION_NAME, RDB$INDICES.RDB$INDEX_NAME, RDB$INDICES.RDB$UNIQUE_FLAG, RDB$INDICES.RDB$INDEX_TYPE 
	FROM RDB$INDICES 
	JOIN RDB$RELATIONS ON RDB$INDICES.RDB$RELATION_NAME = RDB$RELATIONS.RDB$RELATION_NAME 
	WHERE (RDB$RELATIONS.RDB$SYSTEM_FLAG <> 1 OR RDB$RELATIONS.RDB$SYSTEM_FLAG IS NULL);`
	var cursor *Cursor
	if cursor, err = conn.Execute(sql); err != nil {
		return
	}
	defer cursor.Close()

	for cursor.Next() {
		var index Index
		if err = cursor.Scan(&index.TableName, &index.Name, &index.Unique, &index.Unique); err != nil {
			return
		}
		index.Name = strings.TrimRightFunc(index.Name, unicode.IsSpace)
		index.TableName = strings.TrimRightFunc(index.TableName, unicode.IsSpace)
		if index.Columns, err = conn.IndexColumns(index.Name); err != nil {
			return
		}
		if conn.database.LowercaseNames && !hasLowercase(index.Name) {
			index.Name = strings.ToLower(index.Name)
		}
		if conn.database.LowercaseNames && !hasLowercase(index.TableName) {
			index.TableName = strings.ToLower(index.TableName)
		}
		indexes = append(indexes, &index)
	}
	if cursor.Err() != io.EOF {
		err = cursor.Err()
	}
	return
}
Exemplo n.º 2
0
func daemonIpcHandleConn(conn *net.UnixConn) {
	defer cluegetterRecover("daemonIpcHandleConn")
	defer conn.Close()

	for {
		message, err := bufio.NewReader(conn).ReadString('\x00')
		if err != nil {
			if message != "" {
				Log.Info("Got %s on IPC Socket. Ignoring.", err.Error())
			}
			return
		}

		kv := strings.SplitN(message, " ", 2)
		handle := strings.TrimRightFunc(kv[0], func(v rune) bool { return v == '\x00' })
		callback := ipcHandlers[handle]
		v := ""
		if len(kv) > 1 {
			v = strings.TrimRightFunc(kv[1], func(v rune) bool { return v == '\x00' })
		}
		if callback == nil {
			Log.Debug("Received IPC message but no such pattern was registered, ignoring: <%s>%s", handle, v)
			return
		}

		callback(v)
	}
}
Exemplo n.º 3
0
// a < b = -1
// a == b = 0
// a > b = 1
func compareVersions(a, b string) int {
	if a == b {
		return 0
	}
	aParts := strings.Split(a, ".")
	bParts := strings.Split(b, ".")

	for i, verA := range aParts {
		if len(bParts) <= i {
			return 1
		}
		verB := bParts[i]

		aInt, err := strconv.Atoi(strings.TrimRightFunc(verA, isNotNumber))
		if err != nil {
			aInt = 0
		}
		bInt, err := strconv.Atoi(strings.TrimRightFunc(verB, isNotNumber))
		if err != nil {
			bInt = 0
		}

		if aInt > bInt {
			return 1
		}
		if aInt < bInt {
			return -1
		}
	}
	return 0
}
Exemplo n.º 4
0
func (conn *Connection) Columns(tableName string) (columns []*Column, err error) {
	const sqlColumns = `
		SELECT r.rdb$field_name, r.rdb$field_source, f.rdb$field_type, f.rdb$field_sub_type,
			f.rdb$field_length, f.rdb$field_precision, f.rdb$field_scale,
			COALESCE(r.rdb$default_source, f.rdb$default_source) rdb$default_source,
			COALESCE(r.rdb$null_flag, f.rdb$null_flag) rdb$null_flag
		FROM rdb$relation_fields r
		JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name
		WHERE r.rdb$relation_name = ?
		ORDER BY r.rdb$field_position`

	var cursor *Cursor
	if cursor, err = conn.Execute(sqlColumns, tableName); err != nil {
		return
	}
	defer cursor.Close()

	for cursor.Next() {
		var col Column
		var sqlType int16
		if err = cursor.Scan(
			&col.Name,
			&col.Domain,
			&sqlType,
			&col.SqlSubtype,
			&col.Length,
			&col.Precision,
			&col.Scale,
			&col.Default,
			&col.Nullable); err != nil {
			return
		}
		col.Name = strings.TrimRightFunc(col.Name, unicode.IsSpace)
		if conn.database.LowercaseNames && !hasLowercase(col.Name) {
			col.Name = strings.ToLower(col.Name)
		}
		col.Domain = strings.TrimRightFunc(col.Domain, unicode.IsSpace)
		if strings.HasPrefix(col.Domain, "RDB$") {
			col.Domain = ""
		}
		col.SqlType = sqlTypeFromCode(int(sqlType), int(col.SqlSubtype.Value))
		if !col.Default.Null {
			col.Default.Value = strings.Replace(col.Default.Value, "DEFAULT ", "", 1)
			col.Default.Value = strings.TrimLeftFunc(col.Default.Value, unicode.IsSpace)
		}
		columns = append(columns, &col)
	}
	if cursor.Err() != io.EOF {
		err = cursor.Err()
	}
	return
}
Exemplo n.º 5
0
func killSmallWordLeft(ed *Editor) {
	left := strings.TrimRightFunc(ed.line[:ed.dot], unicode.IsSpace)
	// The case of left == "" is handled as well.
	r, _ := utf8.DecodeLastRuneInString(left)
	if isAlnum(r) {
		left = strings.TrimRightFunc(left, isAlnum)
	} else {
		left = strings.TrimRightFunc(
			left, func(r rune) bool { return !isAlnum(r) })
	}
	ed.line = left + ed.line[ed.dot:]
	ed.dot = len(left)
}
Exemplo n.º 6
0
func handleConnection(conn net.Conn) {
	defer conn.Close()

	tcpconn, ok := conn.(*net.TCPConn)
	if ok {
		tcpconn.SetLinger(-1)
		tcpconn.SetKeepAlive(true)
	}

	readbuf := bufio.NewReader(conn)
	sendError(conn, SmtpNoServiceHere, "This is not the SMTP Service you are looking for, move along.")
	for {
		cmd, err := readbuf.ReadString('\n')
		if err != nil {
			break
		}
		cmd = strings.TrimRightFunc(cmd, unicode.IsSpace)
		if cmd == "" {
			continue
		}
		if strings.ToLower(cmd) == "quit" {
			break
		}
		sendError(conn, SmtpBadSequenceOfCommands, "bad sequence of commands")
	}
}
Exemplo n.º 7
0
func (w wsCollapser) Write(p []byte) (n int, err error) {
	lines := strings.Split(string(p), "\n")
	for i, line := range lines {
		l := line
		if *w.prevNewLine {
			l = strings.TrimLeftFunc(l, unicode.IsSpace)
		}
		curNewLine := (i < len(lines)-1) || (len(p) > 0 && p[len(p)-1] == '\n')
		if curNewLine {
			l = strings.TrimRightFunc(l, unicode.IsSpace)
		}
		if len(l) == 0 {
			*w.prevNewLine = curNewLine
			continue
		}
		if *w.prevNewLine && !*w.prevTag && l[0] != '<' {
			_, err := (*w.writer).Write([]byte(" "))
			if err != nil {
				return 0, err
			}
		}
		_, err := (*w.writer).Write([]byte(l))
		if err != nil {
			return 0, err
		}
		*w.prevTag = l[len(l)-1] == '>'
		*w.prevNewLine = curNewLine
	}
	return len(p), nil
}
Exemplo n.º 8
0
func mainTest(t *testing.T, args ...string) string {
	os.Args = append([]string{"tinystat"}, args...)

	f, err := ioutil.TempFile(os.TempDir(), "tinystat")
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		f.Close()
	}()

	oldStdout := os.Stdout
	defer func() {
		os.Stdout = oldStdout
	}()
	os.Stdout = f
	main()

	stdout, err := ioutil.ReadFile(f.Name())
	if err != nil {
		t.Fatal(err)
	}

	// strip everything of trailing whitespace
	lines := strings.Split(string(stdout), "\n")
	for i, line := range lines {
		lines[i] = strings.TrimRightFunc(line, unicode.IsSpace)
	}
	return strings.Join(lines, "\n")
}
Exemplo n.º 9
0
// Read returns a full YAML document.
func (r *YAMLReader) Read() ([]byte, error) {
	var buffer bytes.Buffer
	for {
		line, err := r.reader.Read()
		if err != nil && err != io.EOF {
			return nil, err
		}

		sep := len([]byte(separator))
		if i := bytes.Index(line, []byte(separator)); i == 0 {
			// We have a potential document terminator
			i += sep
			after := line[i:]
			if len(strings.TrimRightFunc(string(after), unicode.IsSpace)) == 0 {
				if buffer.Len() != 0 {
					return buffer.Bytes(), nil
				}
				if err == io.EOF {
					return nil, err
				}
			}
		}
		if err == io.EOF {
			if buffer.Len() != 0 {
				// If we're at EOF, we have a final, non-terminated line. Return it.
				return buffer.Bytes(), nil
			}
			return nil, err
		}
		buffer.Write(line)
	}
}
Exemplo n.º 10
0
func (s *Service) PostApps_Repos_Points(args *cmdArgs, env *rpcutil.Env) (err error) {

	appid := args.CmdArgs[0]
	repoid := args.CmdArgs[1]
	data, err := ioutil.ReadAll(env.Req.Body)
	if err != nil {
		return err
	}

	reqSql := strings.TrimLeftFunc(string(data), isWhiteSpace)
	point := strings.TrimRightFunc(reqSql, isWhiteSpace)

	wurl := fmt.Sprintf("/v4/apps/%s/repos/%s/points", appid, repoid)
	err = s.PandoraClient.CallWith(nil, nil, "POST", wurl, "text/plain", bytes.NewBuffer([]byte(point)), len(point))
	if err != nil {
		return fmt.Errorf("write pandora fail, error:%v", err)
	}

	err = s.InfluxdbClient.CallWith(nil, nil, "POST", "/write?db=pandora&rp=default", "text/plain", bytes.NewBuffer([]byte(point)), len(point))
	if err != nil && err.Error() != "No Content" {
		return fmt.Errorf("write influxdb fail, error:%v", err)
	}

	return
}
Exemplo n.º 11
0
func (templater *templater) UsageFunc(exposedFlags ...string) func(*cobra.Command) error {
	return func(c *cobra.Command) error {
		t := template.New("custom")

		t.Funcs(template.FuncMap{
			"trim":                strings.TrimSpace,
			"trimRight":           func(s string) string { return strings.TrimRightFunc(s, unicode.IsSpace) },
			"gt":                  cobra.Gt,
			"eq":                  cobra.Eq,
			"rpad":                rpad,
			"flagsNotIntersected": flagsNotIntersected,
			"flagsUsages":         flagsUsages,
			"cmdGroups":           templater.cmdGroups,
			"rootCmd":             templater.rootCmdName,
			"isRootCmd":           templater.isRootCmd,
			"optionsCmdFor":       templater.optionsCmdFor,
			"exposed": func(c *cobra.Command) *flag.FlagSet {
				exposed := flag.NewFlagSet("exposed", flag.ContinueOnError)
				if len(exposedFlags) > 0 {
					for _, name := range exposedFlags {
						if flag := c.Flags().Lookup(name); flag != nil {
							exposed.AddFlag(flag)
						}
					}
				}
				return exposed
			},
		})

		template.Must(t.Parse(templater.UsageTemplate))
		return t.Execute(c.Out(), c)
	}
}
func main() {
	show("original", simple)
	show("leading ws removed", strings.TrimLeftFunc(simple, unicode.IsSpace))
	show("trailing ws removed", strings.TrimRightFunc(simple, unicode.IsSpace))
	// equivalent to strings.TrimFunc(simple, unicode.IsSpace)
	show("both removed", strings.TrimSpace(simple))
}
Exemplo n.º 13
0
func parseEngineeringNotation(in string) (uint64, error) {
	if in == "" {
		return 0, nil
	}
	var numerics = func(r rune) bool {
		return r >= '0' && r <= '9'
	}
	var nonNumerics = func(r rune) bool {
		return !numerics(r)
	}
	suffix := strings.TrimLeftFunc(in, numerics)
	numeric := strings.TrimRightFunc(in, nonNumerics)
	val, err := strconv.ParseUint(numeric, 10, 64)
	if err != nil {
		return 0, fmt.Errorf("Parsing engineering notation for '%s'", in)
	}
	switch suffix {
	case "K", "k":
		val *= (1 << 10)
	case "M", "m":
		val *= (1 << 20)
	case "G", "g":
		val *= (1 << 30)
	case "T", "t":
		val *= (1 << 40)
	case "":
		break
	default:
		return 0, fmt.Errorf("Parsing engineering notation for '%s'", in)
	}
	return val, nil
}
Exemplo n.º 14
0
func (templater *templater) templateFuncs(exposedFlags ...string) template.FuncMap {
	return template.FuncMap{
		"trim":                strings.TrimSpace,
		"trimRight":           func(s string) string { return strings.TrimRightFunc(s, unicode.IsSpace) },
		"trimLeft":            func(s string) string { return strings.TrimLeftFunc(s, unicode.IsSpace) },
		"gt":                  cobra.Gt,
		"eq":                  cobra.Eq,
		"rpad":                rpad,
		"appendIfNotPresent":  appendIfNotPresent,
		"flagsNotIntersected": flagsNotIntersected,
		"visibleFlags":        visibleFlags,
		"flagsUsages":         flagsUsages,
		"cmdGroups":           templater.cmdGroups,
		"cmdGroupsString":     templater.cmdGroupsString,
		"rootCmd":             templater.rootCmdName,
		"isRootCmd":           templater.isRootCmd,
		"optionsCmdFor":       templater.optionsCmdFor,
		"usageLine":           templater.usageLine,
		"exposed": func(c *cobra.Command) *flag.FlagSet {
			exposed := flag.NewFlagSet("exposed", flag.ContinueOnError)
			if len(exposedFlags) > 0 {
				for _, name := range exposedFlags {
					if flag := c.Flags().Lookup(name); flag != nil {
						exposed.AddFlag(flag)
					}
				}
			}
			return exposed
		},
	}
}
Exemplo n.º 15
0
func (cl cmdLine) Arg() string {
	s := string(cl)
	if idx := strings.Index(s, " "); idx != -1 {
		return strings.TrimRightFunc(s[idx+1:len(s)-2], unicode.IsSpace)
	}
	return ""
}
Exemplo n.º 16
0
func (b *CommandBot) HandleUpdate(_ *Bot, up *Update) {
	if up.Message == nil {
		return
	}
	if up.Message.Text == nil {
		return
	}
	text := *up.Message.Text
	if len(text) == 0 || text[0] != '/' {
		// Not a command
		return
	}
	cmd, args := Split(text[1:len(text)], ' ')
	cmd = strings.TrimRightFunc(cmd, unicode.IsSpace)
	cmd, to := Split(cmd, '@')
	if to != "" && to != b.Name {
		log.Println("addressed not to me, but to", to)
		// Not addressed to me
		return
	}
	for _, ach := range b.AnyHandlers {
		ach(b, cmd, args, up.Message)
	}
	chs, ok := b.Handlers[cmd]
	if !ok {
		log.Printf("unknown command %q", cmd)
		return
	}
	for _, ch := range chs {
		ch(b, args, up.Message)
	}
}
Exemplo n.º 17
0
func parse(line string) (cmd, req string) {
	cmd, req = "any", ""
	line = strings.TrimRightFunc(line, check)
	if strings.HasPrefix(line, "quit") {
		cmd, req = "quit", ""
		return cmd, req
	}

	if strings.HasPrefix(strings.ToLower(line), "get") {
		switch index := strings.Index(line, " "); index {
		case 3:
			str := strings.SplitN(line, " ", 2)
			cmd, req = "get", str[1]
			if req != "" {
				cmd = "get"
			} else {
				cmd = "bad"
			}
		case -1:
			if strings.EqualFold(line, "get") {
				cmd = "bad"
			} else {
				cmd = "any"
			}
		}
	}

	return
}
Exemplo n.º 18
0
func IsCloudConfig(userdata string) bool {
	header := strings.SplitN(userdata, "\n", 2)[0]

	// Trim trailing whitespaces
	header = strings.TrimRightFunc(header, unicode.IsSpace)

	return (header == "#cloud-config")
}
Exemplo n.º 19
0
// buildPath finds the absolute path based on the path parameter and the new relative path.
func (p *PaginatedResult) buildPath(path string, newRelativePath string) (string, error) {
	oldURL, err := url.Parse("http://example.com" + path)
	if err != nil {
		return "", newError(50000, err)
	}
	rootPath := strings.TrimRightFunc(oldURL.Path, func(r rune) bool { return r != '/' })
	return rootPath + strings.TrimLeft(newRelativePath, "./"), nil
}
Exemplo n.º 20
0
func (s command) Argument() string {
	d := string(s)
	data := strings.Split(d, " ")
	if len(data) > 1 {
		return strings.TrimRightFunc(strings.Join(data[1:], " "), unicode.IsSpace)
	}
	return ""
}
Exemplo n.º 21
0
func isCloudConfig(userdata []byte) bool {
	header := strings.SplitN(string(decompressIfGzipped(userdata)), "\n", 2)[0]

	// Trim trailing whitespaces
	header = strings.TrimRightFunc(header, unicode.IsSpace)

	return (header == "#cloud-config")
}
Exemplo n.º 22
0
// preprocess extracts the rectangle of lines that contain map data from the input.
func preprocess(asciiMap string) (lines []string, err error) {
	lines = strings.Split(asciiMap, "\n")

	// Remove heading and trailing empty lines.
	for len(lines) > 0 && isEmpty(lines[0]) {
		lines = lines[1:len(lines)]
	}
	for len(lines) > 0 && isEmpty(lines[len(lines)-1]) {
		lines = lines[0 : len(lines)-1]
	}

	if len(lines) == 0 {
		err = errors.New("Empty ASCII")
		return
	}

	indent := math.MaxInt32
	maxWidth := 0

	// Deterimine indent level and rightmost text level, look for forbidden things
	for _, line := range lines {
		if strings.Contains(line, "\t") {
			err = errors.New("Physical tabs in chunk ASCII")
			return
		}
		if isEmpty(line) {
			err = errors.New("Discontinuous ASCII map")
			return
		}
		startPos, endPos := measure(line)
		if startPos >= 0 {
			if startPos < indent {
				indent = startPos
			}
			if endPos > maxWidth {
				maxWidth = endPos
			}
		}
	}

	// Correct the width for the indent level.
	maxWidth -= indent

	// Pad all lines to the same width.
	for i, line := range lines {
		line = strings.TrimRightFunc(line, unicode.IsSpace)
		line = line[indent:len(line)]
		pad := maxWidth - len(line)
		if pad > 0 {
			line += strings.Repeat(" ", pad)
		}
		if len(line) != maxWidth {
			panic("Line padding broken")
		}
		lines[i] = line
	}
	return
}
Exemplo n.º 23
0
// TrimRightFunc trims the runes from the right end of the text where the specified callback function returns true,
// returning a new structure and leaving the original unchanged.
func (piece *RichText) TrimRightFunc(f func(rune) bool) *RichText {
	s := piece.String()
	trimmed := strings.TrimRightFunc(s, f)
	if len(trimmed) == len(s) {
		return piece
	}
	left, _ := piece.Split(len(trimmed))
	return left
}
Exemplo n.º 24
0
Arquivo: util.go Projeto: FIPress/fml
//get value in string
func getRawValue(input []byte) (string, int) {
	start := SkipSpace(input)
	end := start + skipUntilValueEnd(input[start:])
	val := string(input[start:end])
	val = strings.TrimRightFunc(val, unicode.IsSpace)

	idx := end + skipRest(input[end:])
	return val, idx
}
Exemplo n.º 25
0
func fSay(wr io.Writer, msg string, trim bool) (int, error) {
	if trim {
		msg = strings.TrimRightFunc(msg, unicode.IsSpace)
	}
	if c, _ := utf8.DecodeLastRuneInString(msg); unicode.IsSpace(c) {
		return fmt.Fprint(wr, msg)
	}
	return fmt.Fprintln(wr, msg)
}
Exemplo n.º 26
0
// NOTE(xiaq): A word is now defined as a series of non-whitespace chars.
func killWordLeft(ed *Editor) {
	if ed.dot == 0 {
	}
	space := strings.LastIndexFunc(
		strings.TrimRightFunc(ed.line[:ed.dot], unicode.IsSpace),
		unicode.IsSpace) + 1
	ed.line = ed.line[:space] + ed.line[ed.dot:]
	ed.dot = space
}
Exemplo n.º 27
0
func getCoverUrlFromInput() string {
	term.OutputMessage("Enter a URL the cover image: ")
	cover_url, err := STD_IN.ReadString('\n')
	if err != nil {
		term.OutputError("Error accepting input.")
		os.Exit(2)
	}
	return strings.TrimRightFunc(cover_url, unicode.IsSpace)
}
Exemplo n.º 28
0
func (u *PrefixedUi) prefixLines(prefix, message string) string {
	var result bytes.Buffer

	for _, line := range strings.Split(message, "\n") {
		result.WriteString(fmt.Sprintf("%s: %s\n", prefix, line))
	}

	return strings.TrimRightFunc(result.String(), unicode.IsSpace)
}
Exemplo n.º 29
0
func moveDotLeftWord(ed *Editor) {
	if ed.dot == 0 {
		return
	}
	space := strings.LastIndexFunc(
		strings.TrimRightFunc(ed.line[:ed.dot], unicode.IsSpace),
		unicode.IsSpace) + 1
	ed.dot = space
}
Exemplo n.º 30
0
func (this *html_cleaner) trim_empty_spaces(n *html.Node) {
	this.trim_empty_spaces_func(n, func(o string) string {
		return strings.TrimLeftFunc(o, unicode.IsSpace)
	})

	this.trim_empty_spaces_func(n, func(o string) string {
		return strings.TrimRightFunc(o, unicode.IsSpace)
	})

}