strings

Documentation

Overview

Package strings provides strings module implementing simple functions to manipulate UTF-8 encoded strings for Gad script language. It wraps ToInterface's strings package functionalities.

Index

• Variables

Variables

var Module = map[string]gad.Object{

	"Contains": &gad.Function{
		Name:  "Contains",
		Value: stdlib.FuncPssRO(containsFunc),
	},

	"ContainsAny": &gad.Function{
		Name:  "ContainsAny",
		Value: stdlib.FuncPssRO(containsAnyFunc),
	},

	"ContainsChar": &gad.Function{
		Name:  "ContainsChar",
		Value: stdlib.FuncPsrRO(containsCharFunc),
	},

	"Count": &gad.Function{
		Name:  "Count",
		Value: stdlib.FuncPssRO(countFunc),
	},

	"EqualFold": &gad.Function{
		Name:  "EqualFold",
		Value: stdlib.FuncPssRO(equalFoldFunc),
	},

	"Fields": &gad.Function{
		Name:  "Fields",
		Value: stdlib.FuncPsRO(fieldsFunc),
	},

	"FieldsFunc": &gad.Function{
		Name:  "FieldsFunc",
		Value: fieldsFuncInv,
	},

	"HasPrefix": &gad.Function{
		Name:  "HasPrefix",
		Value: stdlib.FuncPssRO(hasPrefixFunc),
	},

	"HasSuffix": &gad.Function{
		Name:  "HasSuffix",
		Value: stdlib.FuncPssRO(hasSuffixFunc),
	},

	"Index": &gad.Function{
		Name:  "Index",
		Value: stdlib.FuncPssRO(indexFunc),
	},

	"IndexAny": &gad.Function{
		Name:  "IndexAny",
		Value: stdlib.FuncPssRO(indexAnyFunc),
	},

	"IndexByte": &gad.Function{
		Name:  "IndexByte",
		Value: stdlib.FuncPsrRO(indexByteFunc),
	},

	"IndexChar": &gad.Function{
		Name:  "IndexChar",
		Value: stdlib.FuncPsrRO(indexCharFunc),
	},

	"IndexFunc": &gad.Function{
		Name:  "IndexFunc",
		Value: newIndexFuncInv(strings.IndexFunc),
	},

	"Join": &gad.Function{
		Name:  "Join",
		Value: stdlib.FuncPAsRO(joinFunc),
	},

	"JoinAnd": &gad.Function{
		Name:  "JoinAnd",
		Value: stdlib.FuncPAssRO(joinAndFunc),
	},

	"LastIndex": &gad.Function{
		Name:  "LastIndex",
		Value: stdlib.FuncPssRO(lastIndexFunc),
	},

	"LastIndexAny": &gad.Function{
		Name:  "LastIndexAny",
		Value: stdlib.FuncPssRO(lastIndexAnyFunc),
	},

	"LastIndexByte": &gad.Function{
		Name:  "LastIndexByte",
		Value: stdlib.FuncPsrRO(lastIndexByteFunc),
	},

	"LastIndexFunc": &gad.Function{
		Name:  "LastIndexFunc",
		Value: newIndexFuncInv(strings.LastIndexFunc),
	},

	"Dict": &gad.Function{
		Name:  "Dict",
		Value: mapFuncInv,
	},

	"PadLeft": &gad.Function{
		Name: "PadLeft",
		Value: func(c gad.Call) (gad.Object, error) {
			return pad(c, true)
		},
	},

	"PadRight": &gad.Function{
		Name: "PadRight",
		Value: func(c gad.Call) (gad.Object, error) {
			return pad(c, false)
		},
	},

	"Repeat": &gad.Function{
		Name:  "Repeat",
		Value: stdlib.FuncPsiRO(repeatFunc),
	},

	"Replace": &gad.Function{
		Name:  "Replace",
		Value: replaceFunc,
	},

	"Split": &gad.Function{
		Name:  "Split",
		Value: newSplitFunc(strings.SplitN),
	},

	"SplitAfter": &gad.Function{
		Name:  "SplitAfter",
		Value: newSplitFunc(strings.SplitAfterN),
	},

	"Title": &gad.Function{
		Name:  "Title",
		Value: stdlib.FuncPsRO(titleFunc),
	},

	"ToLower": &gad.Function{
		Name:  "ToLower",
		Value: stdlib.FuncPsRO(toLowerFunc),
	},

	"ToTitle": &gad.Function{
		Name:  "ToTitle",
		Value: stdlib.FuncPsRO(toTitleFunc),
	},

	"ToUpper": &gad.Function{
		Name:  "ToUpper",
		Value: stdlib.FuncPsRO(toUpperFunc),
	},

	"ToValidUTF8": &gad.Function{
		Name:  "ToValidUTF8",
		Value: toValidUTF8Func,
	},

	"Trim": &gad.Function{
		Name:  "Trim",
		Value: stdlib.FuncPssRO(trimFunc),
	},

	"TrimFunc": &gad.Function{
		Name:  "TrimFunc",
		Value: newTrimFuncInv(strings.TrimFunc),
	},

	"TrimLeft": &gad.Function{
		Name:  "TrimLeft",
		Value: stdlib.FuncPssRO(trimLeftFunc),
	},

	"TrimLeftFunc": &gad.Function{
		Name:  "TrimLeftFunc",
		Value: newTrimFuncInv(strings.TrimLeftFunc),
	},

	"TrimPrefix": &gad.Function{
		Name:  "TrimPrefix",
		Value: stdlib.FuncPssRO(trimPrefixFunc),
	},

	"TrimRight": &gad.Function{
		Name:  "TrimRight",
		Value: stdlib.FuncPssRO(trimRightFunc),
	},

	"TrimRightFunc": &gad.Function{
		Name:  "TrimRightFunc",
		Value: newTrimFuncInv(strings.TrimRightFunc),
	},

	"TrimSpace": &gad.Function{
		Name:  "TrimSpace",
		Value: stdlib.FuncPsRO(trimSpaceFunc),
	},

	"TrimSuffix": &gad.Function{
		Name:  "TrimSuffix",
		Value: stdlib.FuncPssRO(trimSuffixFunc),
	},

	"Trunc": &gad.Function{
		Name: "Trunc",
		Value: func(c gad.Call) (gad.Object, error) {
			if err := c.Args.CheckLen(2); err != nil {
				return gad.Nil, err
			}

			var (
				emph = &gad.NamedArgVar{
					Name:          "emph",
					Value:         gad.Str("..."),
					TypeAssertion: gad.TypeAssertionFromTypes(gad.TStr),
				}
			)
			if err := c.NamedArgs.Get(emph); err != nil {
				return gad.Nil, err
			}

			s1, ok := gad.ToGoString(c.Args.Get(0))
			if !ok {
				return gad.Nil, gad.NewArgumentTypeError("1st", "str", c.Args.Get(0).Type().Name())
			}
			i, ok := gad.ToGoInt(c.Args.Get(1))
			if !ok {
				return gad.Nil, gad.NewArgumentTypeError("2nd", "int", c.Args.Get(1).Type().Name())
			}
			return truncFunc(s1, i, emph.Value.ToString()), nil
		},
	},

	"SlitWords": &gad.Function{
		Name: "Trunc",
		Value: func(c gad.Call) (gad.Object, error) {
			if err := c.Args.CheckLen(1); err != nil {
				return gad.Nil, err
			}

			var (
				arg    = c.Args.Get(0)
				_, raw = arg.(gad.RawStr)
				s      string
				ret    gad.Array
			)

			if arg == gad.Nil {
				return ret, nil
			}

			s = arg.ToString()

			words := reSpaces.Split(s, -1)

			if len(words) == 0 {
				return ret, nil
			}

			if words[0] == "" {
				words = words[1:]
			}

			ret = make(gad.Array, len(words))

			if raw {
				for i, word := range words {
					ret[i] = gad.RawStr(word)
				}
			} else {
				for i, word := range words {
					ret[i] = gad.Str(word)
				}
			}

			return ret, nil
		},
	},

	"TruncWords": &gad.Function{
		Name: "Trunc",
		Value: func(c gad.Call) (gad.Object, error) {
			if err := c.Args.CheckLen(2); err != nil {
				return gad.Nil, err
			}

			var (
				emph = &gad.NamedArgVar{
					Name:          "emph",
					Value:         gad.Str("..."),
					TypeAssertion: gad.TypeAssertionFromTypes(gad.TStr),
				}
				atlimit = &gad.NamedArgVar{
					Name:  "atlimit",
					Value: gad.No,
				}
			)

			if err := c.NamedArgs.Get(emph, atlimit); err != nil {
				return gad.Nil, err
			}

			var (
				arg    = c.Args.Get(0)
				_, raw = arg.(gad.RawStr)
				s      string
			)

			if arg == gad.Nil {
				return gad.Str(""), nil
			}

			s = arg.ToString()
			limit, ok := gad.ToGoInt(c.Args.Get(1))
			if !ok {
				return gad.Nil, gad.NewArgumentTypeError("2nd", "int", c.Args.Get(1).Type().Name())
			}

			if atlimit.Value.IsFalsy() {
				var (
					words = reSpaces.Split(s, limit+1)
					b     strings.Builder
					emphs = emph.Value.ToString()
					limit = limit - len(emphs)
				)

				for _, word := range words {
					if word == "" {
						continue
					}
					if b.Len()+len(word) > limit {
						break
					}
					b.WriteByte(' ')
					b.WriteString(word)
				}
				b.WriteString(emphs)
				s = strings.TrimSpace(b.String())
				if raw {
					return gad.RawStr(s), nil
				}
				return gad.Str(s), nil
			}

			return truncFunc(s, limit, emph.Value.ToString()), nil
		},
	},
}

Module represents time module.