Html rendering framework with dynamics

This looks really weird:

public static string RenderMarkup(MarkupBuilder builder) 
{
    return RenderMarkup(builder, builder.MarkupSchema);
}

private static string RenderMarkup(object value, MarkupSchema markupSchema)
{
    var markupBuilder = value as MarkupBuilder;
    if (markupBuilder == null)
    {
        return value == null ? string.Empty : (string)value;
    }

what is the point of casting MarkupBuilder to object and then casting it back?

As I'm sure you know, classes' and methods' names should start with capital letter and blah blah as per C# naming convention. Why do you insist on using camel case?

You should make your api more consistent:

public void Add(object content)

public MarkupBuilder AddRange(params object[] content)

either return MarkupBuilder from both methods, or make both methods void.

As for your design, my main concern is that MarkupBuilder appears to have two distinct responsibilities. First - constructing an html element using extensions and dynamic methods. Second - holding the actual result of construction: a strongly typed data. I think you should have two separate classes for that. So the usage would look like this:

var body = 
         //describe the markup
         html.body(html.p("foo"))
         //return strongly typed non-dynamic and, possibly, immutable object, that holds actual data
         .Build();

You know, similar to how StringBuilder works, where you call ToString() once you are done, and get rid of all the extra overhead.

P.S. Personally, I find dynamic objects useful as part of internal implementation, for which you write unit tests and leave it alone. I would not use dynamics as part of public API. Yes the code is shorter. But at the same time it is more complex and is more error prone. It's really easy to get dynamic objects wrong, and there is no compiler to tell you that "hey, this, html.spun method you have just called, looks suspicions, did you mean span?" So i would rather implement a bunch of extra classes once (as you did in your previous implementation), than hunt dynamic-related bugs for the rest of my life. :)

To be honest, there isn't enough to refactor here as your code looks clean but I notice in your constructors you've this:

MarkupSchema = new MarkupSchema(markupSchema ?? new MarkupSchema());

You could just do this:

MarkupSchema = markupSchema ?? new MarkupSchema();

Your two constructors are doing similar stuff and the first one is private, you could just do this

public MarkupBuilder(MarkupSchema markupSchema = null)
: this(markupSchema,string.Empty)
    {
    }

Your code can be extended for XML documents as well. All you need is to ensure xmlRenderer includes <?xml version="1.0" encoding="UTF-8"?> to the output and a root element with other contents as child elements.

This is the latest version that I currently use.

I post it here just for reference so I won't comment every class.

There are however some changes. I replaced the MarkupSchema with MarkupFormatting. I don't care for schema validation now (and I actually don't have time to implement it).

The MarkupBuilder requires an IMarkupRenderer so that we can ToString it and see the result in debug if necessary.

There were question why I don't separate it and return a specialized object. The reason for this is the following: I wouldn't be able to do this

dynamic html =
    new MarkupBuilder(new HtmlRenderer())
    .Add<cssExtension>()
    .Add<attrExtension>();    

var table = html.table(html.thead(html.tr(html.th("n"), html.th("n*n"))));

// add tfoot to table
table.tfoot(html.tr(html.td("foo"), html.td("bar")));

If the table weren't a builder I couldn't append anything to it and had to use different syntax like maybe Append or Add.

I've added also one more extension the styleExtension that allows to predefine some styles and use them by name later:

dynamic html = new MarkupBuilder(new HtmlRenderer())
    .Add<cssExtension>()
    .Add<attrExtension>()
    .Add<styleExtension>()
    .Configure<styleExtension>(ext => ext.Styles = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
    {
        { "abc", "color: #0066cc;" }
    }
);

html.p("foo").style("abc");

I have also fixed the renderer & the Add APIs as suggested by @NikitaB. It was indeed not optimal.

Complete code:

public class MarkupBuilder : DynamicObject, IEnumerable<object>
{
    private readonly Dictionary<string, string> _attributes = new Dictionary<string, string>();
    private readonly List<object> _content = new List<object>();
    private readonly List<IMarkupBuilderExtension> _extensions = new List<IMarkupBuilderExtension>();

    private MarkupBuilder(MarkupBuilder markupBuilder, string tag)
    {
        _extensions = markupBuilder._extensions;
        Renderer = markupBuilder.Renderer;
        Tag = tag;
    }

    public MarkupBuilder(IMarkupRenderer renderer)
    {
        Renderer = renderer;
    }

    public string Tag { get; private set; }

    public IDictionary<string, string> Attributes { get { return _attributes; } }

    public IReadOnlyCollection<object> Content { get { return _content; } }

    public MarkupBuilder Parent { get; private set; }

    public IEnumerable<IMarkupBuilderExtension> Extensions { get { return _extensions.AsReadOnly(); } }

    internal int Depth
    {
        get
        {
            var depth = 0;
            var parent = Parent;
            while (parent != null)
            {
                depth++;
                parent = parent.Parent;
            }
            return depth;
        }
    }

    // Using a renderer + ToString allows us to see the markup in the debug.
    public IMarkupRenderer Renderer { get; private set; }

    public MarkupBuilder Add<T>() where T : IMarkupBuilderExtension, new()
    {
        _extensions.Add(new T());
        return this;
    }

    public MarkupBuilder Configure<T>(Action<T> extension) where T : IMarkupBuilderExtension
    {
        var ext = Extensions.OfType<T>().SingleOrDefault();
        extension(ext);
        return this;
    }

    private MarkupBuilder Add(object content)
    {
        if (content == null) { return this; }
        _content.Add(content);
        var builder = content as MarkupBuilder;
        if (builder != null) { builder.Parent = this; }
        return this;
    }

    public MarkupBuilder AddRange(IEnumerable<object> content)
    {
        foreach (var item in content) { Add(item); }
        return this;
    }

    public MarkupBuilder AddRange(params object[] content)
    {
        return AddRange((IEnumerable<object>)content);
    }

    public IEnumerator<object> GetEnumerator()
    {
        return Content.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    // --- DynamicObject members

    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.ReturnType == typeof(string))
        {
            result = ToString();
            return true;
        }
        result = null;
        return false;
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        foreach (var extension in Extensions)
        {
            if (extension.TryGetMember(this, binder, out result))
            {
                return true;
            }
        }
        result = new MarkupBuilder(this, binder.Name);
        return true;
    }

    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        foreach (var extension in Extensions)
        {
            if (extension.TryInvokeMember(this, binder, args, out result))
            {
                return true;
            }
        }

        var isEnumerable = new Func<Type, bool>(t =>
        {
            return
                t.GetInterfaces()
                .Where(x => x.IsGenericType)
                .Select(x => x.GetGenericTypeDefinition())
                .Contains(typeof(IEnumerable<>)) &&
                t != typeof(string) &&
                t != typeof(MarkupBuilder);
        });

        var mb = new MarkupBuilder(this, binder.Name);
        result = mb;

        // Allows us to pass an IEnumerable<T> of elements.
        if (args != null && args.Any() && isEnumerable(args[0].GetType()))
        {
            mb.AddRange((IEnumerable<object>)args[0]);
        }
        else
        {
            mb.AddRange(args);
        }

        // The first builder is not an element and has not tag.
        var isElement = !string.IsNullOrEmpty(Tag);
        if (isElement) { Add(result); }

        return true;
    }

    public override string ToString()
    {
        return Renderer.Render(this);
    }
}

public interface IMarkupBuilderExtension
{
    bool TryGetMember(MarkupBuilder element, GetMemberBinder binder, out object result);
    bool TryInvokeMember(MarkupBuilder element, InvokeMemberBinder binder, object[] args, out object result);
}

public class cssExtension : IMarkupBuilderExtension
{
    public bool TryGetMember(MarkupBuilder builder, GetMemberBinder binder, out object result)
    {
        result = null;
        return false;
    }

    public bool TryInvokeMember(MarkupBuilder builder, InvokeMemberBinder binder, object[] args, out object result)
    {
        if (binder.Name == "css")
        {
            builder.Attributes.Add("style", (string)args[0]);
            result = builder;
            return true;
        }
        result = null;
        return false;
    }
}

public class attrExtension : IMarkupBuilderExtension
{
    public bool TryGetMember(MarkupBuilder builder, GetMemberBinder binder, out object result)
    {
        result = null;
        return false;
    }

    public bool TryInvokeMember(MarkupBuilder builder, InvokeMemberBinder binder, object[] args, out object result)
    {
        if (binder.Name == "attr")
        {
            builder.Attributes.Add(binder.Name, (string)args[0]);
            result = builder;
            return true;
        }
        result = null;
        return false;
    }
}

public class styleExtension : IMarkupBuilderExtension
{
    public IDictionary<string, string> Styles { get; set; }

    public bool TryGetMember(MarkupBuilder builder, GetMemberBinder binder, out object result)
    {
        result = null;
        return false;
    }

    public bool TryInvokeMember(MarkupBuilder builder, InvokeMemberBinder binder, object[] args, out object result)
    {
        if (binder.Name == "style")
        {
            var styleName = (string)args[0];
            var style = (string)null;
            if (Styles != null && Styles.TryGetValue(styleName, out style))
            {
                builder.Attributes.Add(binder.Name, style);
                result = builder;
                return true;
            }
        }
        result = null;
        return false;
    }
}

[Flags]
public enum MarkupFormattingOptions
{
    None = 0,
    PlaceOpeningTagOnNewLine = 1,
    PlaceClosingTagOnNewLine = 2,
    PlaceBothTagsOnNewLine =
        PlaceOpeningTagOnNewLine |
        PlaceClosingTagOnNewLine,
    IsVoid = 4,
    CloseEmptyTag = 8
}

public abstract class MarkupFormatting
{
    public MarkupFormattingOptions this[string tag]
    {
        get
        {
            var tagFormattingOptions = MarkupFormattingOptions.None;
            return
                TagFormattingOptions.TryGetValue(tag, out tagFormattingOptions)
                ? tagFormattingOptions
                : MarkupFormattingOptions.None;
        }
    }

    public Dictionary<string, MarkupFormattingOptions> TagFormattingOptions { get; set; }

    public int IndentWidth { get; set; }
}

public class HtmlFormatting : MarkupFormatting
{
    public HtmlFormatting()
    {
        TagFormattingOptions = new Dictionary<string, MarkupFormattingOptions>
        {
            { "body", MarkupFormattingOptions.PlaceClosingTagOnNewLine },
            { "br", MarkupFormattingOptions.IsVoid },
            { "span", MarkupFormattingOptions.None },
            { "p", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "pre", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h1", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h2", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h3", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h4", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h5", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "h6", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "ul", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "ol", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "li", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "table", MarkupFormattingOptions.PlaceClosingTagOnNewLine },
            { "caption", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "thead", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "tbody", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "tfoot", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "tr", MarkupFormattingOptions.PlaceBothTagsOnNewLine },
            { "th", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "td", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "colgroup", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
            { "col", MarkupFormattingOptions.PlaceOpeningTagOnNewLine },
        };
        IndentWidth = 4;
    }
}

public interface IMarkupRenderer
{
    string Render(MarkupBuilder markupBuilder);
}

public class MarkupRenderer : IMarkupRenderer
{
    public MarkupRenderer(MarkupFormatting markupFormatting)
    {
        MarkupFormatting = markupFormatting;
    }

    private MarkupFormatting MarkupFormatting { get; set; }

    public string Render(MarkupBuilder markupBuilder)
    {
        var content = markupBuilder.Aggregate(new StringBuilder(), (sb, next) =>
        {
            var mb = next as MarkupBuilder;
            return sb.Append(mb == null ? next : Render(mb));
        })
        .ToString();

        var isEmpty = string.IsNullOrEmpty(content);

        var placeOpeningTagOnNewLine = new Func<string, bool>(tag
            => markupBuilder.Parent != null && MarkupFormatting[tag].HasFlag(MarkupFormattingOptions.PlaceOpeningTagOnNewLine)
        );

        var placeClosingTagOnNewLine = new Func<string, bool>(tag
            => !isEmpty && MarkupFormatting[tag].HasFlag(MarkupFormattingOptions.PlaceClosingTagOnNewLine)
        );

        var indent = new Func<string>(() => IndentString(MarkupFormatting.IndentWidth * markupBuilder.Depth));

        var html = new StringBuilder();

        if (placeOpeningTagOnNewLine(markupBuilder.Tag))
        {
            html.AppendLine();
            html.Append(indent());
        }

        html.Append(CreateOpeningElement(markupBuilder.Tag, markupBuilder.Attributes));
        html.Append(content);

        if (placeClosingTagOnNewLine(markupBuilder.Tag))
        {
            html.AppendLine();
            html.Append(markupBuilder.Parent == null ? string.Empty : indent());
        }

        html.Append(CreateClosingElement(markupBuilder.Tag));

        return html.ToString();
    }

    private static string IndentString(int indentWidth)
    {
        return new string(' ', indentWidth);
    }

    private string CreateOpeningElement(string tag, IEnumerable<KeyValuePair<string, string>> attributes)
    {
        var attributeString = CreateAttributeString(attributes);

        var html = new StringBuilder()
            .Append("<").Append(tag)
            .Append(string.IsNullOrEmpty(attributeString) ? string.Empty : " ")
            .Append(attributeString)
            //.Append(IsVoid ? "/" : string.Empty)
            .Append(">")
            .ToString();
        return html;
    }

    private static string CreateAttributeString(IEnumerable<KeyValuePair<string, string>> attributes)
    {
        return attributes.Aggregate(
            new StringBuilder(),
            (result, kvp) => result
                .Append(result.Length > 0 ? " " : string.Empty)
                .AppendFormat("{0}=\"{1}\"", kvp.Key, kvp.Value)
        ).ToString();
    }

    private static string CreateClosingElement(string tag)
    {
        return
            new StringBuilder()
            .Append("</")
            .Append(tag)
            .Append(">")
            .ToString();
    }
}

public class HtmlRenderer : IMarkupRenderer
{
    public HtmlRenderer(MarkupFormatting markupFormatting = null)
    {
        MarkupRenderer = new MarkupRenderer(markupFormatting ?? new HtmlFormatting());
    }

    private MarkupRenderer MarkupRenderer { get; set; }

    public string Render(MarkupBuilder markupBuilder)
    {
        return MarkupRenderer.Render(markupBuilder);
    }
}