How to choose other property if property doesn't exist?

[KamilTheDev]

If I had data like:

var data = new
{
    nickname = "J",
    name = "John"
};

var data2 = new
{
    name = "John"
};

How can I make it use nickname if the property exists, otherwise use name? I tried a few attempts but they will all error with Could not evaluate the selector "nickname" for the data2.

[axunonb]

Hi
In the most simple case you could just ignore formatting errors like this:

using System;
using SmartFormat;
using SmartFormat.Core.Settings;
					
public class Program
{
	public static void Main()
	{
		var data = new
		{
			nickname = "J",
			name = "John"
		};

		var data2 = new
		{
			name = "John"
		};
		
		var settings = new SmartSettings();
		settings.Formatter.ErrorAction = SmartFormat.Core.Settings.FormatErrorAction.Ignore;
		
		var smart = Smart.CreateDefaultSmartFormat(settings);
		Console.WriteLine(smart.Format("{name} {nickname}", data2));
		Console.WriteLine(smart.Format("{name} {nickname}", data));
               // Output:
               // John 
               // John J
	}
}

Does this help in your use case, or do you need more finegrained control?

[KamilTheDev]

Essentially what I'd want is to be able to know if we're using the choose formatter, and if this selector is the last choice in the choose formatter. Pseudo code:

public class MakeMissingBeNull : ISource
{
    public bool TryEvaluateSelector(ISelectorInfo selectorInfo)
    {
        var current = selectorInfo.CurrentValue;
        var selector = selectorInfo.SelectorText;

        if (current == null || string.IsNullOrEmpty(selector))
        {
            return false;
        }

        var type = current.GetType();
        var property = type.GetProperty(selector);
        if (property != null)
        {
            selectorInfo.Result = property.GetValue(current);
            return true;
        }

        var field = type.GetField(selector);
        if (field != null)
        {
            selectorInfo.Result = field.GetValue(current);
            return true;
        }

        // Pseudo code: Return error if not using choose formatter, or is the last choice in the choose formatter
        if (!usingChooseFormatter || isLastChooseFormatterChoice)
        {
            return false;
        }

        // Set to null if property or field not found
        selectorInfo.Result = null;
        return true;
    }
}

I'm not sure that's possible.

[axunonb]

Within an ISource you don't know which of the IFormatters will kick in out-of-the-box, unless you can rely on the named formatter used in the Placeholder. Then you could get the usingChooseFormatter from the pseudo code. Next you were to mimic the ChooseFormatter to see, which of the formatting arguments would apply to get the isLastChooseFormatterChoice.
This all looks like a combined custom ISource and IFormatter extension was the way to a clean solution. For an example have a look at the ListFormatter.

[axunonb]

How did you finally resolve the challenge?

[KamilTheDev]

Here's what I came up with:

using System;
using SmartFormat;
using SmartFormat.Core.Extensions;
using SmartFormat.Core.Formatting;
using UnityEngine;
using Debug = UnityEngine.Debug;

public class FallbackFormatter : IFormatter, ISource
{
    public string Name { get; set; } = "fallback";

    public bool CanAutoDetect { get; set; } = false;

    public bool TryEvaluateFormat(IFormattingInfo formattingInfo)
    {
        Debug.Log("fallback TryEvaluateFormat called");

        // Replace escaped split characters with a placeholder
        string placeholder = "\uE000"; // Use a Unicode private use area character as a placeholder
        string options = formattingInfo.FormatterOptions.Replace("||", placeholder);

        var pairs = options.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);

        foreach (var pair in pairs)
        {
            string propertyOption;
            string textOption;

            if (pair.Contains("=>"))
            {
                var parts = pair.Split(new[] { "=>" }, StringSplitOptions.RemoveEmptyEntries);
                if (parts.Length != 2)
                {
                    throw new FormatException("Each pair must be in the format 'property => text' or just 'property'");
                }
                propertyOption = parts[0].Trim();
                textOption = parts[1].Trim();
            }
            else
            {
                propertyOption = pair.Trim();
                textOption = "[" + propertyOption + "]";
            }

            if (TryGetPropertyOrField(formattingInfo.CurrentValue, propertyOption, out var value))
            {
                if (value == null || (value is string str && string.IsNullOrEmpty(str)))
                {
                    Debug.Log($"Value for option '{propertyOption}' is null or empty, treating as missing");
                    continue;
                }

                Debug.Log($"Found value for option '{propertyOption}': {value}");

                // Replace the placeholder back with the actual split character
                textOption = textOption.Replace(placeholder, "|");

                // Replace square brackets with curly braces
                textOption = textOption.Replace("[", "{").Replace("]", "}");

                // Use Smart.Format to parse the textOption as a SmartFormat string
                string formattedText = Smart.Format(textOption, formattingInfo.CurrentValue);

                formattingInfo.Write(formattedText);
                return true;
            }
            else
            {
                Debug.Log($"No value found for option '{propertyOption}'");
            }
        }

        throw new FormatException($"None of the options '{string.Join(", ", pairs)}' could be found.");
    }

    public bool TryEvaluateSelector(ISelectorInfo selectorInfo)
    {
        if (!TryGetPropertyOrField(selectorInfo.CurrentValue, selectorInfo.SelectorText, out var value))
        {
            return false;
        }

        selectorInfo.Result = value;
        return true;
    }

    private bool TryGetPropertyOrField(object obj, string name, out object value)
    {
        value = null;
        if (obj == null) return false;

        var names = name.Split('.');
        var currentObject = obj;

        foreach (var propName in names)
        {
            if (currentObject == null) return false;

            var type = currentObject.GetType();
            var property = type.GetProperty(propName);
            if (property != null)
            {
                currentObject = property.GetValue(currentObject);
                continue;
            }

            var field = type.GetField(propName);
            if (field != null)
            {
                currentObject = field.GetValue(currentObject);
                continue;
            }

            return false;
        }

        value = currentObject;
        return true;
    }
}

Example usage:

Smart.Default.AddExtensions((IFormatter)new FallbackFormatter());

var person = new
{
    Name = "John",
    Nickname = "Johnny",
    Username = "john_doe",
};

// Example 1
string format = "{Person:fallback(Name|Nickname|Username)}";
string result = Smart.Format(format, new { Person = person });
Debug.Log("Result: " + result);

// Example 2
string format2 = "{Person:fallback(Name => Nice name, [Name]|Nickname => Cool nickname, [Nickname]|Username => Awesome username, [Username])}";
string result2 = Smart.Format(format2, new { Person = person });
Debug.Log("Result 2: " + result2);

Supports directly getting the property, or using a custom result text.

The only issue is that I don't know I can use { } without SmartFormat mistakenly trying to parse it. This is why I used [ ] instead for custom result text, and then replace them with the proper brackets inside the formatter.

[axunonb]

Any special character can be used, as long as is escaped with a backslash. This also applies to { }. See the examples in the EscapedLiteralTests
Thanks for sharing your solution. This will be helpful for others coming across the the challenge.