public void TestWhamMasterTemplate()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema, true);
wham.AddSchema(Schemas.ShippingAddressSchema, true);
wham.AddSchema(Schemas.AddressCollectionSchema, true);
var namedStream = SetupFakeOutput();
var masterResult = wham.Liquidize(BuiltInTemplates.WhamMasterTemplate);
var errors = ("" + string.Join("\r\n", wham.Context.Errors.Select(e => e.ToString()))).Trim();
Assert.AreEqual(string.Empty, errors);
Assert.IsNotEmpty(masterResult);
masterResult = masterResult.Trim();
Assert.AreEqual(string.Empty, masterResult.ToLower());
Assert.IsTrue(namedStream.Items.Count >= 4);
Console.WriteLine(string.Join("\r\n", namedStream.Items.Select(i => i.Name)));
Assert.IsNotNull(namedStream.Items.First().Name);
Assert.IsTrue(namedStream.Items.First().Name.ToLower().EndsWith("address.cs"));
Assert.IsNotNull(namedStream.Items.First().WrittenContents);
Assert.IsTrue(namedStream.Items.First().WrittenContents.StartsWith("using"));
Assert.IsNotNull(namedStream.Items.Any(s => s.Name.ToLower().EndsWith(".csproj")));
Assert.AreEqual(2, namedStream.Items.Count(s => s.Name.ToLower().EndsWith(".config")));
Assert.AreEqual(5, namedStream.Items.Count(s => s.WrittenContents.StartsWith("<?xml")));
}
public void TestIsEmptyOperator()
{
WhamEngine.InitEngine();
Assert.AreEqual("EMPTY", Template.Parse("{% if NOCOLLECTION is_empty %}EMPTY{% endif %}").Render());
Assert.AreEqual("EMPTY", Template.Parse("{% if '' is_empty %}EMPTY{% endif %}").Render());
Assert.AreEqual("", Template.Parse("{% if 'aaa' is_empty %}EMPTY{% endif %}").Render());
}
public void TestTrimTag()
{
WhamEngine.InitEngine();
var t = Template.Parse("{% Trim %} {% endTrim %}").Render();
Assert.IsEmpty(t);
t = Template.Parse("{% Trim %} NOT EMPTY {% endTrim %}").Render();
Assert.IsNotEmpty(t);
Assert.AreEqual("NOT EMPTY", t);
}
public void TestIncludedPropertyTypes()
{
WhamEngine.InitEngine();
var schemaDrop = Schemas.ShippingAddressDrop;
var hash = Hash.FromAnonymousObject(new { schema = schemaDrop });
string res;
res = Template.Parse("{% for propType in schema.IncludedProperties %}{{propType.Value | FullClassName : propType.Key}}, {% endfor %}").RenderWithErrors(hash);
Assert.IsNotEmpty(res);
Assert.AreEqual("string, string, string, string, TypesEnum?, ", res);
}
public void TestIncludedProperties()
{
WhamEngine.InitEngine();
var schemaDrop = Schemas.ShippingAddressDrop;
var hash = Hash.FromAnonymousObject(new { schema = schemaDrop });
string res;
res = Template.Parse("{% for propName in schema.IncludedPropertyNames %}{{propName}}, {% endfor %}").RenderWithErrors(hash);
Assert.IsNotEmpty(res);;
Assert.AreEqual("line1, line2, city, country, type, ", res);
}
public void TestResolverAddSchema()
{
WhamEngine ctx = new WhamEngine();
ctx.Resolver.Add(new Uri("http://wham.org/Base.Address"), Schemas.AddressBaseSchema);
JSchema addressCollection = null;
Assert.DoesNotThrow(() =>
addressCollection = JSchema.Parse(Schemas.AddressCollectionSchema, ctx.Resolver)
);
Assert.AreEqual("Base.AddressCollection", addressCollection.Title);
}
public void TestAddressToCS_ClassTemplateProperties()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema, true);
var cs = wham.Liquidize(BuiltInTemplates.CS_ClassTemplate);
Assert.IsNotNull(cs);
Assert.IsTrue(cs.IndexOf("Wham.Base") > 0);
Assert.IsTrue(cs.IndexOf("Liquid error:") < 0);
Assert.IsEmpty(wham.Context.Errors);
Console.WriteLine(cs);
}
public void TestSchemaProperties()
{
WhamEngine.InitEngine();
var schemaDrop = Schemas.ShippingAddressDrop;
var hash = Hash.FromAnonymousObject(new { schema = schemaDrop });
string res;
res = Template.Parse("{{schema.Title}}").Render(hash);
Assert.AreEqual(schemaDrop.Title, res);
res = Template.Parse("{{schema.BaseClassName}}").RenderWithErrors(hash);
Assert.IsNotEmpty(res);
Assert.IsFalse(res.Contains("BaseClassName"));
Assert.AreEqual(schemaDrop.BaseClassName, res);
}
public void TestAddressToCS_ClassTemplate()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema, true);
var cs = wham.Liquidize(BuiltInTemplates.CS_ClassTemplate);
Assert.IsNotNull(wham.Context.Strainer);
Assert.IsTrue(wham.Context.Strainer.RespondTo("Namespace"));
Assert.IsNotNull(cs);
Assert.IsTrue(cs.IndexOf("Wham.Base") > 0);
Assert.IsTrue(cs.IndexOf("Liquid error:") < 0);
Assert.IsEmpty(wham.Context.Errors);
}
public void TestWhamMasterTemplateWithFileOutput()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema, true);
wham.AddSchema(Schemas.ShippingAddressSchema, true);
wham.AddSchema(Schemas.AddressCollectionSchema, true);
var masterResult = wham.Liquidize(BuiltInTemplates.WhamMasterTemplate);
Console.WriteLine(masterResult.Trim());
var errors = ("" + string.Join("\r\n", wham.Context.Errors.Select(e => e.ToString()))).Trim();
Console.WriteLine(errors);
Assert.AreEqual(string.Empty, errors);
}
public void TestIsRegisterClassFilter()
{
WhamEngine.InitEngine();
int wasCalled = 0;
ClassNameFilters.RegisterClassCallback = new WeakReference <Action <string, string, object> >((input, name, data) =>
{
wasCalled++;
});
var rc1 = Template.Parse("{{ 'OK' | RegisterClass :'X' }}").Render();
Assert.AreEqual("OK", rc1);
Assert.AreEqual(1, wasCalled);
Assert.AreEqual("OK", Template.Parse("{{ 'OK' | RegisterResource :'X' }}").Render());
Assert.AreEqual(2, wasCalled);
}
public void TestMasterCSTemplate()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema, true);
var namedStream = SetupFakeOutput();
var masterResult = wham.Liquidize(MasterTemplate);
Assert.IsTrue(wham.Context.Errors == null || wham.Context.Errors.Count == 0);
Assert.IsNotEmpty(masterResult);
masterResult = masterResult.Trim();
Assert.AreEqual("address.cs", masterResult.ToLower());
Assert.IsNotNull(namedStream.Name);
Assert.IsTrue(namedStream.Name.ToLower().EndsWith("address.cs"));
Assert.IsNotNull(namedStream.WrittenContents);
Assert.IsTrue(namedStream.WrittenContents.StartsWith("using"));
}
public void TestShippingAddressToCS_ClassTemplate()
{
WhamEngine wham = new WhamEngine();
wham.AddSchema(Schemas.AddressBaseSchema);
wham.AddSchema(Schemas.ShippingAddressSchema, true);
var cs = wham.Liquidize(BuiltInTemplates.CS_ClassTemplate);
Assert.IsNotNull(wham.Context.Strainer);
Assert.IsNotNull(cs);
Assert.IsTrue(cs.IndexOf("Wham.Base") > 0);
Assert.IsTrue(cs.IndexOf("Liquid error:") < 0);
Assert.IsEmpty(wham.Context.Errors);
Assert.IsTrue(cs.IndexOf("public enum TypesEnum {") > 0);
Console.WriteLine(cs);
}
public void TestGuidTag()
{
Guid guid;
WhamEngine.InitEngine();
var g1 = Template.Parse("{% Guid 'D' %}").Render();
Assert.IsNotEmpty(g1);
Assert.IsTrue(Guid.TryParseExact(g1, "D", out guid));
var g2 = Template.Parse("{% Guid %}").Render();
Assert.IsNotEmpty(g2);
Assert.AreNotSame(g1, g2);
g1 = Template.Parse("{% Guid 'N' %}").Render();
Assert.IsNotEmpty(g1);
Assert.IsTrue(Guid.TryParseExact(g1, "N", out guid));
Assert.Throws <WhamException>(() => Template.Parse("{% Guid 'INVALID' %}").Render());
}
// $ mono whamrun.exe /Users/Sten/Documents/Projects/Wham/JsonSchemas
public static void Main(string[] args)
{
AppDomain.CurrentDomain.FirstChanceException += (sender, e) =>
{
if (e.Exception is TargetInvocationException)
{
Console.WriteLine("[TGIAODIFQWR] Target Invocation Exception: " + e.Exception.Message);
}
else
{
Console.WriteLine("[ATIOAEIRJQW] Exception: " + e.Exception);
}
};
if (args == null || !args.Any())
{
Console.WriteLine("Usage: WhamRun inputFolder [outputFolder]\r\n inputFolder must contain JSON Schema files");
}
else
{
if (Directory.Exists(args[0]))
{
Directory.SetCurrentDirectory(args[0]);
var files = Directory.GetFiles(args[0]);
var schemas = files
.Select(f => new Tuple <string, string>(f, File.ReadAllText(f)))
.Where(ft => ft.Item2.Contains("\"title\""))
.Select(t => new SchemaItem {
FileName = t.Item1, Content = t.Item2
})
.ToList();
WhamEngine engine = new WhamEngine();
while (schemas.Any())
{
var added = schemas
.Where(s => string.IsNullOrEmpty(s.Uri))
.Where(s =>
{
try
{
var uri = engine.AddSchema(s.Content);
s.Uri = uri.AbsolutePath;
return(!string.IsNullOrEmpty(s.Uri));
}
catch (Exception sx)
{
s.Error = sx;
}
return(false);
})
.ToList();
if (!added.Any())
{
break;
}
}
if (schemas.Any(s => string.IsNullOrEmpty(s.Uri)))
{
Console.WriteLine("Not all schemas can be added");
Console.WriteLine(String.Join("\r\n",
schemas.Where(s => string.IsNullOrEmpty(s.Uri))
.Select(s => " File: " + s.FileName + " ERROR: " + s.Error)));
}
else
{
Console.WriteLine("All schemas loaded.");
var outPath = args.Skip(1).FirstOrDefault() ?? Path.Combine(args.First(), "WhAM");
if (!Directory.Exists(outPath))
{
Directory.CreateDirectory(outPath);
}
Directory.SetCurrentDirectory(outPath);
Console.WriteLine("Wham output to: " + outPath);
var result = ("" + engine.Liquidize(BuiltInTemplates.WhamMasterTemplate)).Trim();
Console.WriteLine(result);
if (engine.Context.Errors != null && engine.Context.Errors.Any())
{
Console.WriteLine("dotLIQUID ERRORS:");
Console.WriteLine(string.Join(System.Environment.NewLine,
engine.Context.Errors.Select(e => " - Error: " + e.Message + " " + e.InnerException)));
}
Console.WriteLine("Done.");
}
}
else
{
Console.WriteLine("input folder must exist");
}
}
}
