IEnumerableFormatter.cs

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using Xunit;

namespace Mustachio.Tests
{
	public class IEnumerableFormatter
	{
		private readonly IEnumerable _sourceCollection;
		public string Arguments { get; set; }

		public IEnumerableFormatter(IEnumerable sourceCollection, string arguments)
		{
			_sourceCollection = sourceCollection;
			Arguments = arguments;

			EnumerableFormatter = new Dictionary<string, Func<IEnumerable<object>, string, object>>();
			EnumerableFormatter.Add("order by desc ", (collection, arg) => collection.OrderByDescending(PropExpression(arg)));
			EnumerableFormatter.Add("order by ", (collection, arg) => collection.OrderBy(PropExpression(arg)));

			EnumerableFormatter.Add("order desc", (collection, arg) => collection.OrderByDescending(e => e));
			EnumerableFormatter.Add("order", (collection, arg) => collection.OrderBy(e => e));

			EnumerableFormatter.Add("contains ", (collection, arg) => collection.Any(e => e.Equals(arg)));
			EnumerableFormatter.Add("count", (collection, arg) => collection.Count());
			EnumerableFormatter.Add("element at ", (collection, arg) => collection.ElementAt(int.Parse(arg)));
			EnumerableFormatter.Add("distinct", (collection, arg) => collection.Distinct());
			EnumerableFormatter.Add("first or default", (collection, arg) => collection.FirstOrDefault());
			EnumerableFormatter.Add("group by ", (collection, arg) => collection.GroupBy(PropExpression(arg)));
			EnumerableFormatter.Add("max ", (collection, arg) => collection.Max(PropExpression(arg)));
			EnumerableFormatter.Add("max", (collection, arg) => collection.Max());
			EnumerableFormatter.Add("min ", (collection, arg) => collection.Min(PropExpression(arg)));
			EnumerableFormatter.Add("min", (collection, arg) => collection.Min());

			EnumerableFormatter.Add("reverse", (collection, arg) => collection.Reverse());
			EnumerableFormatter.Add("select ", (collection, arg) => collection.Select(PropExpression(arg)));
			EnumerableFormatter.Add("take ", (collection, arg) => collection.Take(int.Parse(arg)));
		}

		public Func<object, object> PropExpression(string propName)
		{
			var parameterExpression = Expression.Parameter(typeof(object));
			var propCall = Expression.Property(parameterExpression, propName);
			return Expression.Lambda<Func<object, object>>(propCall, parameterExpression).Compile();
		}

		public IDictionary<string, Func<IEnumerable<object>, string, object>> EnumerableFormatter { get; set; }

		public object FormatArgument()
		{
			var formatter = EnumerableFormatter.FirstOrDefault(e => Arguments.StartsWith(e.Key));

			if (formatter.Value != null)
			{
				return formatter.Value(this._sourceCollection.Cast<object>(), Arguments.Remove(0, formatter.Key.Length));
			}
			return _sourceCollection;
		}
	}

	public class ParserCollectionFixture
	{
		private void AddCollectionTypeFormatter(ParserOptions options)
		{
			options.AddFormatter<IEnumerable>((value, arg) =>
			{
				var val = value;
				var formats = arg.Split('|');
				foreach (var format in formats)
				{
					var formatter = new IEnumerableFormatter(val, format.Trim());
					val = (IEnumerable)formatter.FormatArgument();
				}
				return val;
			});
		}

		[Fact]
		public void TestCollectionFormatting()
		{
			var options = new ParserOptions("{{#each data(order)}}{{.}},{{/each}}", null, ParserFixture.DefaultEncoding);
			var collection = new int[] { 0, 1, 2, 3, 5, 4, 6, 7 };
			AddCollectionTypeFormatter(options);
			var report = Parser.ParseWithOptions(options).ParsedTemplate(new Dictionary<string, object>()
			{
				{
					"data", collection
				}
			}).Stringify(true, ParserFixture.DefaultEncoding);
			Assert.Equal(report, collection.OrderBy(e => e).Select(e => e.ToString()).Aggregate((e, f) => e + "," + f) + ",");
			Console.WriteLine(report);
		}
	}
}