Naming of the customized functions

Hi Alex,

From #14,

• the default renamer setup is StandardMemberRenamer which is basically transforming a camel/pascal case identifier to a lowercase+underscore identifier
• you could also use context.MemberRenamer = new DelegateMemberRenamer(name => name); and it should just work without changing “Title” and “title”.
• Note that this rename doesn’t affect the renamer used for all the builtins

My question is,

Suppose my C# customized function is named as MyCustomizedFunction, it will be available as mylib.my_customized_function normally, right? and if I’ve used context.MemberRenamer = new DelegateMemberRenamer(name => name), it will be available as-is as mylib.MyCustomizedFunction, right?

Thanks

[xoofx]

This is a working sample:

using System;
using Scriban.Runtime;

namespace Scriban.Tests
{
    class Program
    {
        public static class MyLib
        {
            public static string UpCase(string text)
            {
                return text.ToUpperInvariant();
            }

            public static string DownCase(string text)
            {
                return text.ToLowerInvariant();
            }
        }

        static void Main(string[] args)
        {
            // Create a renamer as-is
            var renamer = new DelegateMemberRenamer(name => name);

            // Create an object that will contains these functions
            var myfunctions = new ScriptObject();
            myfunctions.Import(typeof(MyLib), ScriptMemberImportFlags.Method, null, renamer);

            // Prase the template
            var template = Template.Parse("This is UpCase {{ 'xXx' | UpCase }} and DownCase {{ 'YyY' | DownCase}}");


            var context = new TemplateContext { MemberRenamer = renamer }; // Use the same rename for member object access
            context.PushGlobal(myfunctions); // Use myfunctions as the current context
            // we could also push another object here to be the real nested context 
            template.Render(context);
            context.PopGlobal();

            Console.WriteLine(context.Output.ToString());
        }
    }
}

It is similar to how it is done for builtin functions:

• you import some functions, properties, whatever to a ScriptObject
• you push this ScriptObject as global context.

The difference for builtin functions is that they are created by default in the TemplateContext constructor and pushed (context.PushGlobal) as a global context… but you can have your nested context as well.

From the example above you could choose for example to expose these functions through a “myfunctions.DownCase” for example:

var obj = new ScriptObject();
obj.SetValue("myfunctions", myfunctions);
...
context.PushGlobal(obj)

[suntong]

Thank you so much!!!