String manipulations in templates

[romz-pl]

Hi,

In my opinion it would be valuable to have (by default) the string manipulations in template.
In particular, I would like to call following code in template file:

{{range .Messages}}
{{$nn := .Name}}
{{$w = string.replace($nn, 'AAA', 'bbb')}}
{{end}}

As a result I would like to get string $w with all replaced string 'AAA' with 'bbb' in string $nn.
Could you suggest the solution for this problem?

Kind regards,
Zbigniew Romanowski
romz@wp.pl

[suntong]

Hi Zbigniew,

I totally agree that the way to use existing function in Go template is really cumbersome in that you have to (re)define it before you can use it. However, because of this very reason, I don't want to predefine a bunch of things that nobody uses, but rather, only includes those functions that are really useful to people.

So to answer your request specifically,

• First, luckily string.replace is so useful that is already define in easygen:

  easygen/tf-strings.go

  Lines 24 to 26 in 9378bb6

  	func replace(replStr string) string {
  	return re.ReplaceAllString(replStr, Opts.StrTo)
  	}

• Second, if you find any string manipulations functions missing but you need, please define them in tf-strings.go, and submit a PR.
• Lastly, If you really want to define all the string manipulations functions, then please use the plugable
  approach, e.g. https://github.com/go-easygen/easygen/blob/master/egVar/EgVar.go

Thx

[suntong]

Ahh, speaking too soon -- the https://github.com/go-easygen/easygen/blob/master/tf-strings.go#L24-L26 does not answer your request actually, when I took a second look -- it ties closely with -rf string & -rt string, so, hmm, ..., how would you want to proceed?

The replace has already taken the name space in tf-strings.go, so you either have to put it in a plugable class, or call it something else.

All these comes down to, how many string manipulations functions do you want to add...

[suntong]

How to avoid name collision is another consideration I had, which resulted in that I didn't add all the string manipulations functions. For e.g., there is a strings.Replace and there need to be a regexp.Replace as well. And I don't know if strings.replace can be used as Go template function name or not, and if yes, should I better leave it as strings.Replace or use strings.replace. If no, what better naming convention I should go with...

I.e., you've asked something that I don't have an answer yet, for now, and it needs some serious consideration and planning.

[romz-pl]

Hi suntong,

Thanks for seedy response.
Currently I need functions in string replacement, only.
At the begging it would be sufficient to have function replacing all sub-strings with another
with prototype

string_replace_all( str, a, b )

For example, for str="AAxxAAyyAA", and a="AA", and b="BB" the function string_replace_all(str, a, b) should return BBxxBByy.

Could you add this function into the easygen? I need this in my project.
What do you think?

[suntong]

Writing such a function is easy, but having a consistent naming convention that is good (and align with) the future is the hardest. That's why I need to do some serious consideration and planning and don't want to rush it.

That being said, I think I've finally have a good idea. But let me consult with @grrtrr first. Gerrit, please go through this thought trail and tell me if the following would be a good idea,

• Instead of providing two functions, strings.Replace and regexp.Replace, I'm going to provide only the regexp one.
• Instead of naming regexp.Replacexxx, I'll name it regexpReplaceAllString, thus avoiding the problem whether regexp.Replace can be used as Go template function or not.

@romz-pl,

The regexpReplaceAllString will be as simple as:

func regexpReplaceAllString(str, fromRexp, to string) {
    return regexp.MustCompile(fromRexp).
		ReplaceAllString(str, to)
}

If you can't wait, then please put that in yourself. Else, I'll find sometime to put it in, after reaching a consent with Gerrit first.

Cheers

[grrtrr]

Thank you @suntong. From my own experiences, it would be useful to have such a string manipulation function available inside the template.

Once in a while the template data contains things that are not interesting.

With regard to the command-line options for replacing strings (from -> to), would it be possible to express them in terms of a string template function (i.e. solve the conflict he other direction)?

[suntong]

Thanks @grrtrr,

As long as you are not opposing it, I'll keep the regexpReplaceAllString naming convention. The main advantage is that they'll be self-explanatory, by their names. I.e., regexpReplaceAllString will correspond to regexp.ReplaceAllString, so even if we add a bunch of them, we don't need to spend time documenting each and every one of them.

@romz-pl, I'll find sometime this weekend to put it/some in.

As to the command-line options for replacing strings, let's continue the discussion at
#19

[suntong]

I ended up adding a bunch of them:

easygen/t_strings_test.go

Lines 35 to 171 in 8022ae3

	// == strings functions
	{
	`{{ stringsContains "seafood" "foo" }}`,
	"true",
	},
	{
	`{{ stringsContains "seafood" "bar" }}`,
	"false",
	},
	{
	`{{ stringsContainsAny "team" "i" }}`,
	"false",
	},
	{
	`{{ stringsContainsAny "failure" "u & i" }}`,
	"true",
	},
	{
	`{{ stringsCount "cheese" "e" }}`,
	"3",
	},
	{
	`{{ stringsEqualFold "Go" "go" }}`,
	"true",
	},
	{
	`{{ stringsFields " foo bar baz " }}`,
	"[foo bar baz]",
	},
	{
	`{{ stringsIndex "go gopher" "go" }}`,
	"0",
	},
	{
	`{{ stringsLastIndex "go gopher" "go" }}`,
	"3",
	},
	{
	`ba{{ stringsRepeat "na" 2 }}`,
	"banana",
	},
	{
	`{{ stringsReplace "oink oink oink" "k" "ky" 2 }}`,
	"oinky oinky oink",
	},
	{
	`{{ stringsReplace "oink oink oink" "oink" "moo" -1 }}`,
	"moo moo moo",
	},
	{
	`{{ stringsSplitN "a,b,c" "," 0 }}`,
	`[]`,
	},
	{
	`{{ stringsSplitAfter "a,b,c" "," }}`,
	`[a, b, c]`,
	},
	{
	`{{ stringsSplitAfterN "a,b,c" "," 2 }}`,
	`[a, b,c]`,
	},
	{
	`{{ stringsTitle "her royal highness" }}`,
	"Her Royal Highness",
	},
	{
	`{{ stringsToLower "Gopher" }}`,
	"gopher",
	},
	{
	`{{ stringsToUpper "Gopher" }}`,
	"GOPHER",
	},
	{
	`{{ stringsTrimSpace " \t\n a lone gopher \n\t\r\n" }}`,
	"a lone gopher",
	},
	{
	`{{ stringsTrim " !!! Achtung !!! " "! " }}`,
	"Achtung",
	},
	{
	`{{ stringsTrimPrefix "Goodbye,, world!" "Goodbye," }}`,
	", world!",
	},
	{
	`{{ stringsTrimSuffix "Hello, goodbye, etc!" "goodbye, etc!" }}`,
	"Hello, ",
	},
	// aliases
	{
	`The {{if eq .StrTest "these rights belong to those people"}}eq says Yea{{else}}eq says Nay{{end}} but {{if eqf .StrTest "these rights belong to those people"}}eqf says Yea{{else}}eqf says Nay{{end}}.`,
	"The eq says Nay but eqf says Yea.",
	},
	// == regexp functions
	{
	`{{ regexpFindString "peach punch" "p([a-z]+)ch" }}`,
	"peach",
	},
	{
	`{{ regexpFindAllString "peach punch" "p([a-z]+)ch" -1 }}`,
	"[peach punch]",
	},
	{
	`{{ regexpFindAllString "peach punch" "p([a-z]+)ch" 1 }}`,
	"[peach]",
	},
	{
	`{{ regexpFindStringIndex "peach punch" "p([a-z]+)ch" }}`,
	"[0 5]",
	},
	{
	`{{ regexpFindStringSubmatch "peach punch" "p([a-z]+)ch" }}`,
	"[peach ea]",
	},
	{
	`{{ regexpFindStringSubmatchIndex "peach punch" "p([a-z]+)ch" }}`,
	"[0 5 1 3]",
	},
	//
	{
	`{{ regexpMatchString "HTTPS://site/" "(?i)^http" }}`,
	"true",
	},
	//
	{
	`{{ regexpReplaceAllLiteralString "html HTML Html aa uml bb Uml" "(?i)html|uml" "XML" }}`,
	"XML XML XML aa XML bb XML",
	},
	{
	`{{ regexpReplaceAllString .StrTest "(?i)th[eo]se" "the" }}`,
	"the rights belong to the people",
	},
	{
	`{{ regexpReplaceAllString "This and these are for THOSE people" "(?i)(this|th[eo]se)" "<b>${1}</b>" }}`,
	"<b>This</b> and <b>these</b> are for <b>THOSE</b> people",

[grrtrr]

That looks great, I was looking for quite a few of these, and it was getting hard to work around.

Thank you for making easygen even more valuable!

[romz-pl]

That looks great!