public void Does_not_include_protected_filters_by_default()
        {
            var context = new TemplatePagesContext().Init();

            context.VirtualFiles.WriteFile("index.txt", "file contents");

            Assert.That(new PageResult(context.OneTimePage("{{ 'index.txt' | includeFile }}")).Result,
                        Is.EqualTo("{{ 'index.txt' | includeFile }}"));

            using (new BasicAppHost().Init())
            {
                var feature = new TemplatePagesFeature().Init();
                feature.VirtualFiles.WriteFile("index.txt", "file contents");

                Assert.That(new PageResult(context.OneTimePage("{{ 'index.txt' | includeFile }}")).Result,
                            Is.EqualTo("{{ 'index.txt' | includeFile }}"));
            }
        }
        public void Can_use_protected_includeFiles_in_context_or_PageResult()
        {
            var context = new TemplatePagesContext
            {
                TemplateFilters = { new TemplateProtectedFilters() }
            }.Init();

            context.VirtualFiles.WriteFile("index.txt", "file contents");

            Assert.That(new PageResult(context.OneTimePage("{{ 'index.txt' | includeFile }}")).Result,
                        Is.EqualTo("file contents"));
        }
        public void Can_incrment_and_decrement()
        {
            var context = new TemplatePagesContext
            {
                Args =
                {
                    ["ten"] = 10
                }
            }.Init();

            Assert.That(new PageResult(context.OneTimePage("{{ 1 | incr }}")).Result, Is.EqualTo("2"));
            Assert.That(new PageResult(context.OneTimePage("{{ ten | incr }}")).Result, Is.EqualTo("11"));
            Assert.That(new PageResult(context.OneTimePage("{{ 1 | incrBy(2) }}")).Result, Is.EqualTo("3"));
            Assert.That(new PageResult(context.OneTimePage("{{ ten | incrBy(2) }}")).Result, Is.EqualTo("12"));
            Assert.That(new PageResult(context.OneTimePage("{{ incr(1) }}")).Result, Is.EqualTo("2"));
            Assert.That(new PageResult(context.OneTimePage("{{ incr(ten) }}")).Result, Is.EqualTo("11"));
            Assert.That(new PageResult(context.OneTimePage("{{ incrBy(ten,2) }}")).Result, Is.EqualTo("12"));

            Assert.That(new PageResult(context.OneTimePage("{{ 1 | decr }}")).Result, Is.EqualTo("0"));
            Assert.That(new PageResult(context.OneTimePage("{{ ten | decrBy(2) }}")).Result, Is.EqualTo("8"));
        }
        public void Can_compare_strings()
        {
            var context = new TemplatePagesContext
            {
                Args =
                {
                    ["foo"] = "foo",
                    ["bar"] = "bar",
                }
            }.Init();

            Assert.That(new PageResult(context.OneTimePage("{{ 'foo >  \"foo\"' | if(gt(foo,\"foo\")) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'foo >= \"foo\"' | if(gte(foo,\"foo\")) | raw }}")).Result, Is.EqualTo("foo >= \"foo\""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'foo <= \"foo\"' | if(lte(foo,\"foo\")) | raw }}")).Result, Is.EqualTo("foo <= \"foo\""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'foo <  \"foo\"' | if(lt(foo,\"foo\")) }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ 'bar >  \"foo\"' | if(gt(bar,\"foo\")) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'bar >= \"foo\"' | if(gte(bar,\"foo\")) | raw }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'bar <= \"foo\"' | if(lte(bar,\"foo\")) | raw }}")).Result, Is.EqualTo("bar <= \"foo\""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'bar <  \"foo\"' | if(lt(bar,\"foo\")) | raw }}")).Result, Is.EqualTo("bar <  \"foo\""));
        }
        public void Can_use_logical_boolean_operators()
        {
            var context = new TemplatePagesContext
            {
                Args =
                {
                    ["foo"]          = "foo",
                    ["bar"]          = "bar",
                    ["year2000"]     = new DateTime(2000, 1, 1),
                    ["year2100"]     = new DateTime(2100, 1, 1),
                    ["contextTrue"]  = true,
                    ["contextFalse"] = false,
                }
            }.Init();

            Assert.That(new PageResult(context.OneTimePage("{{ 'or(true,true)' | if(or(true,true)) | raw }}")).Result, Is.EqualTo("or(true,true)"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'or(true,false)' | if(or(true,false)) | raw }}")).Result, Is.EqualTo("or(true,false)"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'or(false,false)' | if(or(false,false)) | raw }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ 'and(true,true)' | if(and(true,true)) | raw }}")).Result, Is.EqualTo("and(true,true)"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'and(true,false)' | if(and(true,false)) | raw }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'and(false,false)' | if(and(false,false)) | raw }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ 'or(contextTrue,contextTrue)' | if(or(contextTrue,contextTrue)) | raw }}")).Result, Is.EqualTo("or(contextTrue,contextTrue)"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'or(contextTrue,contextFalse)' | if(or(contextTrue,contextFalse)) | raw }}")).Result, Is.EqualTo("or(contextTrue,contextFalse)"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'or(contextFalse,contextFalse)' | if(or(contextFalse,contextFalse)) | raw }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ 'or(gt(now,year2000),eq(\"foo\",bar))' | if(or(gt(now,year2000),eq(\"foo\",bar))) | raw }}")).Result,
                        Is.EqualTo("or(gt(now,year2000),eq(\"foo\",bar))"));

            Assert.That(new PageResult(context.OneTimePage(@"{{ 'or(gt(now,year2000),eq(""foo"",bar))' | 
            if (
                or (
                    gt ( now, year2000 ),
                    eq ( ""foo"",  bar )
                )
            ) | raw }}")).Result,
                        Is.EqualTo("or(gt(now,year2000),eq(\"foo\",bar))"));


            Assert.That(new PageResult(context.OneTimePage(@"{{ 'or(and(gt(now,year2000),eq(""foo"",bar)),and(gt(now,year2000),eq(""foo"",foo)))' | 
            if ( 
                or (
                    and (
                        gt ( now, year2000 ),
                        eq ( ""foo"", bar  )
                    ),
                    and (
                        gt ( now, year2000 ),
                        eq ( ""foo"", foo  )
                    )
                ) 
            ) | raw }}")).Result,
                        Is.EqualTo(@"or(and(gt(now,year2000),eq(""foo"",bar)),and(gt(now,year2000),eq(""foo"",foo)))"));
        }
        public void Can_compare_DateTime()
        {
            var context = new TemplatePagesContext
            {
                Args =
                {
                    ["year2000"] = new DateTime(2000, 1, 1),
                    ["year2100"] = new DateTime(2100, 1, 1),
                }
            }.Init();

            Assert.That(new PageResult(context.OneTimePage("{{ 'now >  year2000' | if(gt(now,year2000)) | raw }}")).Result, Is.EqualTo("now >  year2000"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now >= year2000' | if(gte(now,year2000)) | raw }}")).Result, Is.EqualTo("now >= year2000"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now <= year2000' | if(lte(now,year2000)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now <  year2000' | if(lt(now,year2000)) }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ 'now >  year2100' | if(gt(now,year2100)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now >= year2100' | if(gte(now,year2100)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now <= year2100' | if(lte(now,year2100)) | raw }}")).Result, Is.EqualTo("now <= year2100"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'now <  year2100' | if(lt(now,year2100)) | raw }}")).Result, Is.EqualTo("now <  year2100"));

            Assert.That(new PageResult(context.OneTimePage("{{ '\"2001-01-01\" >  year2100' | if(gt(\"2001-01-01\",year2100)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '\"2001-01-01\" >= year2100' | if(gte(\"2001-01-01\",year2100)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '\"2001-01-01\" <= year2100' | if(lte(\"2001-01-01\",year2100)) | raw }}")).Result, Is.EqualTo("\"2001-01-01\" <= year2100"));
            Assert.That(new PageResult(context.OneTimePage("{{ '\"2001-01-01\" <  year2100' | if(lt(\"2001-01-01\",year2100)) | raw }}")).Result, Is.EqualTo("\"2001-01-01\" <  year2100"));
        }
        public void Can_compare_numbers()
        {
            var context = new TemplatePagesContext
            {
                Args =
                {
                    ["two"] = 2
                }
            }.Init();

            Assert.That(new PageResult(context.OneTimePage("{{ 2 | greaterThan(1) }}")).Result, Is.EqualTo("True"));
            Assert.That(new PageResult(context.OneTimePage("{{ two | greaterThan(1) }}")).Result, Is.EqualTo("True"));
            Assert.That(new PageResult(context.OneTimePage("{{ greaterThan(two,1) }}")).Result, Is.EqualTo("True"));
            Assert.That(new PageResult(context.OneTimePage("{{ greaterThan(2,2) }}")).Result, Is.EqualTo("False"));
            Assert.That(new PageResult(context.OneTimePage("{{ greaterThan(two,2) }}")).Result, Is.EqualTo("False"));
            Assert.That(new PageResult(context.OneTimePage("{{ greaterThan(two,two) }}")).Result, Is.EqualTo("False"));

            Assert.That(new PageResult(context.OneTimePage("{{ 'two > 1'    | if(gt(two,1)) | raw }}")).Result, Is.EqualTo("two > 1"));
            Assert.That(new PageResult(context.OneTimePage("{{ 'two > 2'    | if(greaterThan(two,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'two > 3'    | if(greaterThan(two,3)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'two > two'  | if(greaterThan(two,two)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ 'two >= two' | if(greaterThanEqual(two,two)) | raw }}")).Result, Is.EqualTo("two >= two"));

            Assert.That(new PageResult(context.OneTimePage("{{ '1 >= 2' | if(greaterThanEqual(1,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 >= 2' | if(greaterThanEqual(2,2)) | raw }}")).Result, Is.EqualTo("2 >= 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '3 >= 2' | if(greaterThanEqual(3,2)) | raw }}")).Result, Is.EqualTo("3 >= 2"));

            Assert.That(new PageResult(context.OneTimePage("{{ '1 > 2'  | if(greaterThan(1,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 > 2'  | if(greaterThan(2,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '3 > 2'  | if(greaterThan(3,2)) | raw }}")).Result, Is.EqualTo("3 > 2"));

            Assert.That(new PageResult(context.OneTimePage("{{ '1 <= 2' | if(lessThanEqual(1,2)) | raw }}")).Result, Is.EqualTo("1 <= 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 <= 2' | if(lessThanEqual(2,2)) | raw }}")).Result, Is.EqualTo("2 <= 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '3 <= 2' | if(lessThanEqual(3,2)) }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ '1 < 2'  | if(lessThan(1,2)) | raw }}")).Result, Is.EqualTo("1 < 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 < 2'  | if(lessThan(2,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '3 < 2'  | if(lessThan(3,2)) }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ '2 >  2' | if(gt(2,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 >= 2' | if(gte(2,2)) | raw }}")).Result, Is.EqualTo("2 >= 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 <= 2' | if(lte(2,2)) | raw }}")).Result, Is.EqualTo("2 <= 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 <  2' | if(lt(2,2)) }}")).Result, Is.EqualTo(""));

            Assert.That(new PageResult(context.OneTimePage("{{ '2 == 2' | if(equals(2,2)) }}")).Result, Is.EqualTo("2 == 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 == 2' | if(eq(2,2)) }}")).Result, Is.EqualTo("2 == 2"));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 != 2' | if(notEquals(2,2)) }}")).Result, Is.EqualTo(""));
            Assert.That(new PageResult(context.OneTimePage("{{ '2 != 2' | if(not(2,2)) }}")).Result, Is.EqualTo(""));
        }