├── .eslintignore
├── .eslintrc
├── .gitignore
├── .prettierrc
├── HtmlHelper.ts
├── HtmlString.ts
├── babel.config.js
├── index.ts
├── package.json
├── razor.test.ts
├── razor.ts
├── reader.test.ts
├── reader.ts
├── readme.md
├── tests
    ├── Example.html
    ├── async-test.html
    ├── encoding.js
    ├── index.html
    ├── node.js
    ├── parse.js
    ├── shBrushRazor.js
    └── views
    │   ├── _layout.html
    │   ├── _sub-layout.html
    │   └── index.html
├── tsconfig.json
└── yarn.lock


/.eslintignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | dist


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
1 | {
2 |   "root": true,
3 |   "parser": "@typescript-eslint/parser",
4 |   "plugins": ["@typescript-eslint"],
5 |   "extends": ["eslint:recommended", "plugin:@typescript-eslint/eslint-recommended", "plugin:@typescript-eslint/recommended"]
6 | }
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | dist/
3 | tests/cg/*
4 | .DS_Store
5 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | { "printWidth": 180, "singleQuote": true }
2 | 


--------------------------------------------------------------------------------
/HtmlHelper.ts:
--------------------------------------------------------------------------------
 1 | import { HtmlString } from './HtmlString';
 2 | 
 3 | export function doubleEncode(txt: string): string {
 4 |   return txt.split('\\').join('\\\\').split('\r').join('\\r').split('\n').join('\\n').split('"').join('\\"');
 5 | }
 6 | 
 7 | export class HtmlHelper {
 8 |   encode(value: HtmlString | string | undefined): HtmlString {
 9 |     if (value === null || value === undefined) value = '';
10 |     if (HtmlString.isHtmlString(value)) return value;
11 |     if (typeof value !== 'string') value = String(value);
12 |     value = value.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('"').join('&quot;');
13 |     return new HtmlString(value);
14 |   }
15 |   attributeEncode(value: HtmlString | string | undefined): HtmlString {
16 |     return this.encode(value);
17 |   }
18 |   raw(value: unknown): HtmlString {
19 |     return new HtmlString(value);
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/HtmlString.ts:
--------------------------------------------------------------------------------
 1 | export class HtmlString {
 2 |   #value: unknown;
 3 | 
 4 |   get isHtmlString(): boolean {
 5 |     return true;
 6 |   }
 7 | 
 8 |   constructor(value: unknown) {
 9 |     this.#value = value;
10 |   }
11 |   toString(): string {
12 |     return String(this.#value ?? '');
13 |   }
14 | 
15 |   static isHtmlString(value: unknown): value is HtmlString {
16 |     const html = value as HtmlString;
17 |     return typeof html === 'object' && html.isHtmlString;
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/babel.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   presets: [['@babel/preset-env', { targets: { node: 'current' } }], '@babel/preset-typescript'],
3 | };
4 | 


--------------------------------------------------------------------------------
/index.ts:
--------------------------------------------------------------------------------
1 | export * from './razor';
2 | export * from './reader';
3 | export * from './HtmlHelper';
4 | export * from './HtmlString';
5 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "title": "RazorJS",
 3 |   "name": "@andyedinborough/razor-js",
 4 |   "description": "A JavaScript implementation of the Razor view engine",
 5 |   "version": "0.4.3",
 6 |   "author": {
 7 |     "name": "Andy Edinborough (@andyedinborough)"
 8 |   },
 9 |   "repository": "https://github.com/andyedinborough/RazorJS",
10 |   "licenses": [
11 |     {
12 |       "type": "MIT"
13 |     }
14 |   ],
15 |   "devDependencies": {
16 |     "@babel/core": "^7.15.0",
17 |     "@babel/preset-env": "^7.15.0",
18 |     "@babel/preset-typescript": "^7.15.0",
19 |     "@types/jest": "^27.0.1",
20 |     "@typescript-eslint/eslint-plugin": "^4.29.3",
21 |     "@typescript-eslint/parser": "^4.29.3",
22 |     "babel-jest": "^27.1.0",
23 |     "eslint": "^7.32.0",
24 |     "jest": "^27.1.0",
25 |     "typescript": "4.4.2"
26 |   },
27 |   "scripts": {
28 |     "compile": "./node_modules/.bin/tsc",
29 |     "build": "rm -rf ./dist/ && yarn lint && yarn test && yarn compile",
30 |     "lint": "eslint . --ext .ts --fix",
31 |     "test": "jest",
32 |     "x-publish": "yarn build && cp ./package.json ./dist/package.json && npm publish ./dist --access=public"
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/razor.test.ts:
--------------------------------------------------------------------------------
  1 | import 'jest';
  2 | import { Razor } from './razor';
  3 | 
  4 | it('can render without code blocks', async () => expect(await new Razor().render('hi')).toBe('hi'));
  5 | it('can render code blocks', async () =>
  6 |   expect(
  7 |     (
  8 |       await new Razor().render(`
  9 | @{ var test = 'bob';}
 10 | hi @test
 11 | `)
 12 |     ).trim()
 13 |   ).toBe('hi bob'));
 14 | 
 15 | it('can render <text>', async () =>
 16 |   expect(
 17 |     (
 18 |       await new Razor().render(`
 19 | @{ <text>hi bob</text> }
 20 | `)
 21 |     ).trim()
 22 |   ).toBe('hi bob'));
 23 | 
 24 | it('can render <text> in if', async () =>
 25 |   expect(
 26 |     (
 27 |       await new Razor().render(`
 28 |         @{ var test = 'bob';}
 29 |         hi @if(test === 'bob') { <text>bill</text> }
 30 |   `)
 31 |     ).trim()
 32 |   ).toBe('hi bill'));
 33 | 
 34 | it('can render if statements', async () =>
 35 |   expect(
 36 |     (
 37 |       await new Razor().render(`
 38 | @{ var test = 'bob';}
 39 | hi @if(test === 'bob') { @:bill }
 40 | `)
 41 |     ).trim()
 42 |   ).toBe('hi bill'));
 43 | 
 44 | it('can render helpers', async () =>
 45 |   expect(
 46 |     (
 47 |       await new Razor().render(`
 48 |   @helper name(x){ @:bill }
 49 |   hi @name('bill')
 50 |   `)
 51 |     ).trim()
 52 |   ).toBe('hi bill'));
 53 | 
 54 | it('renders layouts', async () => {
 55 |   const razor = new Razor({
 56 |     async findView(id) {
 57 |       switch (id) {
 58 |         case 'layout':
 59 |           return 'begin @renderBody() end';
 60 |       }
 61 |     },
 62 |   });
 63 | 
 64 |   const result = await razor.render('@{ layout = "layout"; } test');
 65 |   expect(result.replace(/\s+/g, ' ')).toBe('begin test end');
 66 | });
 67 | 
 68 | it('renders layouts with sections', async () => {
 69 |   const razor = new Razor({
 70 |     async findView(id) {
 71 |       switch (id) {
 72 |         case 'layout':
 73 |           return 'begin @renderBody() end @renderSection("afterEnd", false)';
 74 |       }
 75 |     },
 76 |   });
 77 | 
 78 |   const result = await razor.render('@{ layout = "layout"; } test @section afterEnd(){ @: after }');
 79 |   expect(result.replace(/\s+/g, ' ').trim()).toBe('begin test end after');
 80 | });
 81 | 
 82 | it('does not try to process emails', async () => expect(await new Razor().render('my email is test@test.com')).toBe('my email is test@test.com'));
 83 | 
 84 | it('encodes values', async () => {
 85 |   const result = await new Razor().render(`
 86 |     @{ var test = '<script>alert("fail")</script'; }
 87 |     @test
 88 |   `);
 89 |   expect(result).not.toContain('<script>');
 90 | });
 91 | 
 92 | it('does not encode raw values', async () => {
 93 |   const result = await new Razor().render(`
 94 |     @{ var test = '<script>alert("fail")</script'; }
 95 |     @html.raw(test)
 96 |   `);
 97 |   expect(result).toContain('<script>');
 98 | });
 99 | 
100 | it('supports async', async () => {
101 |   const result = await new Razor().render(`
102 |     @(await new Promise(resolve => setTimeout(() => resolve('hi'), 10)))
103 |   `);
104 |   expect(result.trim()).toBe('hi');
105 | });
106 | 
107 | it('supports async w/o parens', async () => {
108 |   const result = await new Razor().render(`
109 |     @await new Promise(resolve => setTimeout(() => resolve('hi'), 10))
110 |   `);
111 |   expect(result.trim()).toBe('hi');
112 | });
113 | 
114 | it('supports custom locals', async () => {
115 |   const result = await new Razor({ locals: ['hi'] }).render(`@hi`, {}, { hi: 'hi' });
116 |   expect(result.trim()).toBe('hi');
117 | });
118 | 
119 | it('can change dialect', async () => {
120 |   const razor = new Razor({
121 |     dialect: { layout: 'Layout', renderBody: 'RenderBody' },
122 |     async findView(id) {
123 |       switch (id) {
124 |         case 'asdf':
125 |           return 'begin @RenderBody() end';
126 |       }
127 |     },
128 |   });
129 | 
130 |   const result = await razor.render('@{ Layout = "asdf"; } test');
131 |   expect(result.replace(/\s+/g, ' ')).toBe('begin test end');
132 | });
133 | 
134 | it('passes legacy tests', async () => {
135 |   const razor = new Razor();
136 |   expect((await razor.render('@{ <a b=@0 c=@1> </a> }')).trim()).toBe('<a b=0 c=1> </a>');
137 |   expect((await razor.render('test\\test')).trim()).toBe('test\\test');
138 |   expect((await razor.render('@if(true) { if(true){ <a @(0>1?0:1) /> } }')).trim()).toBe('<a 1 />');
139 |   expect((await razor.render('@if(true) { if(true){ <a @(0>1?0:1) /> <a> </a> } }')).trim()).toBe('<a 1 /><a> </a>');
140 |   expect(await razor.render('@{ model.items.forEach(function(x){ @x }); }', { items: [0] })).toBe('0');
141 |   expect(await razor.render('test')).toBe('test');
142 |   expect(await razor.render('@@test')).toBe('@test');
143 |   expect(await razor.render('test@test.com')).toBe('test@test.com');
144 |   expect(await razor.render('test@@@(model.test).com', { test: 'test' })).toBe('test@test.com');
145 |   expect(await razor.render('hello @model.name', { name: 'world' })).toBe('hello world');
146 |   expect(await razor.render('hello @model.name[0]', { name: 'world'.split('') })).toBe('hello w');
147 |   expect(await razor.render("hello @model['name']", { name: 'world' })).toBe('hello world');
148 |   expect(
149 |     await razor.render('hello @model.name("world")', {
150 |       name: function (n: unknown) {
151 |         return n;
152 |       },
153 |     })
154 |   ).toBe('hello world');
155 |   expect(await razor.render('te@*FAIL*@st')).toBe('test');
156 |   expect(await razor.render('@if(model.name){ @model.name }', { name: 'test' })).toBe('test');
157 |   expect(await razor.render('@if(!model.name){ @fail(); } else { @model.name; }', { name: 'test' })).toBe('test');
158 |   expect((await razor.render('@if(true){ @:test }')).trim()).toBe('test');
159 |   expect((await razor.render('@helper test(name){ @:Hi @name } @test("bob")')).trim()).toBe('Hi bob');
160 |   expect((await razor.render('@if(true){ <div><div>nested</div></div>  }')).trim()).toBe('<div><div>nested</div></div>');
161 |   expect((await razor.render('@{  }')).trim()).toBe('');
162 |   expect((await razor.render('@switch(model.test){ case 0: <br/> break; }', { test: 0 })).trim()).toBe('<br/>');
163 |   expect((await razor.render('@if(true){ <text>hi</text> }')).trim()).toBe('hi');
164 |   expect((await razor.render('@if(true){ if(false) { @:fail } else { @:win } }')).trim()).toBe('win');
165 |   expect((await razor.render('@if(true){ if(false) { @:fail } else { <div>Hi!</div> if(false) { } <div>Hi!</div> } }')).trim()).toBe('<div>Hi!</div><div>Hi!</div>');
166 | 
167 |   try {
168 |     await razor.render('@(');
169 |     await razor.render('@{');
170 |   } catch {
171 |     // yolo
172 |   }
173 | 
174 |   expect((await razor.render('@model.forEach(function(x){ @x })', [0])).trim()).toBe('0');
175 | });
176 | 
177 | it('outputs html from codeblock, but continues code', async () =>
178 |   expect(
179 |     (
180 |       await new Razor().render(`
181 | @{ 
182 |   // incomplete quote in text
183 |   <p>test's</p>
184 |   var asdfdddf = 'rock'; 
185 |   <p>@asdfdddf</p>
186 | }
187 | `)
188 |     )
189 |       .trim()
190 |       .replace(/[\r\n\s\t]/g, '')
191 |   ).toBe(`<p>test's</p><p>rock</p>`));
192 | 
193 | it('supports @functions { }', async () => {
194 |   expect(await (await new Razor().render(`@functions { function sayHi(){ @:hi } }\n@sayHi()`)).trim()).toBe('hi');
195 | });
196 | 


--------------------------------------------------------------------------------
/razor.ts:
--------------------------------------------------------------------------------
  1 | import { Chunk, last, readBlock, Reader, readQuotedUntil, readUntil, readWhitespace } from './reader';
  2 | import { doubleEncode, HtmlHelper } from './HtmlHelper';
  3 | import { HtmlString } from './HtmlString';
  4 | 
  5 | const html = new HtmlHelper();
  6 | 
  7 | const rxValid = /^(?:await\s+)?(?:new\s+)?[a-z0-9._]+/i,
  8 |   rxTagName = /^[a-z]+(?::[a-z]+)?/i,
  9 |   rxFunction = /\s*function[\s*(]/;
 10 | 
 11 | const NEWLINE = '\r\n';
 12 | const NEWLINETAB = `${NEWLINE}\t`;
 13 | 
 14 | enum CmdType {
 15 |   Code = 0,
 16 |   Output = 1,
 17 |   Literal = 2,
 18 | }
 19 | 
 20 | class Cmd {
 21 |   code = '';
 22 |   type = 0;
 23 |   constructor(code: string, type = CmdType.Code) {
 24 |     this.code = code;
 25 |     this.type = type;
 26 |   }
 27 |   toString() {
 28 |     const { type, code } = this;
 29 |     switch (type) {
 30 |       case CmdType.Code:
 31 |         return code;
 32 |       case CmdType.Literal:
 33 |         return `writeLiteral("${doubleEncode(code)}");`;
 34 |       default:
 35 |         return `write(${code});`;
 36 |     }
 37 |   }
 38 | }
 39 | 
 40 | function functionTemplateBasic(dialect: RazorDialect) {
 41 |   const { html } = dialect;
 42 |   return `const writer = [];
 43 | function writeLiteral(a) { writer.push(a); }
 44 | function write(a){ writeLiteral(${html}.encode(a)); };
 45 | `;
 46 | }
 47 | 
 48 | function functionTemplate(id: string | undefined, code: string, dialect: RazorDialect, locals: string[]) {
 49 |   const { model, viewBag, html, isSectionDefined, renderSection, renderBody, layout } = dialect;
 50 |   return `return async function ${id?.replace(/\W+/g, '_') ?? 'template'}(page, sections) {
 51 | "use strict";
 52 | const { 
 53 |   model: ${model}, viewBag: ${viewBag}, html: ${html}, 
 54 |   isSectionDefined: ${isSectionDefined}, renderSection: ${renderSection}, 
 55 |   renderBody: ${renderBody}, layout: _rzr_layout 
 56 | } = page;
 57 | ${locals.length ? `const { ${locals.join(', ')} } = page;` : ''}
 58 | ${functionTemplateBasic(dialect)}
 59 | let ${layout} = _rzr_layout;
 60 | ${code}
 61 | if(_rzr_layout !== ${dialect.layout}) { page.layout = ${dialect.layout}; }
 62 | return writer.join("");
 63 | }`;
 64 | }
 65 | 
 66 | enum Mode {
 67 |   Text = 0,
 68 |   Code = 1,
 69 | }
 70 | 
 71 | interface ParseContext {
 72 |   helpers: string[];
 73 |   sections: string[];
 74 |   dialect: RazorDialect;
 75 |   options: RazorOptions;
 76 | }
 77 | 
 78 | function parseImpl(template: string, level: number, mode: Mode, ctx: ParseContext): Cmd[] {
 79 |   const rdr = new Reader(template);
 80 |   const cmds: Cmd[] = [];
 81 |   let chunk: Chunk | undefined, peek: string, block: string | Chunk | undefined, bracket: number;
 82 | 
 83 |   function parseCodeBlock() {
 84 |     peek = rdr.peek();
 85 |     if (peek === '*') readUntil(rdr, '*@');
 86 |     else if (peek === '(') {
 87 |       block = readBlock(rdr, '(', ')');
 88 |       cmds.push(new Cmd(block.substr(1, block.length - 2), CmdType.Output));
 89 |     } else if (peek === '{') {
 90 |       block = readBlock(rdr, '{', '}');
 91 |       cmds.push(new Cmd(parseImpl(block.substr(1, block.length - 2), level + 1, Mode.Code, ctx).join(NEWLINE)));
 92 |     } else if (peek === ':' && mode === Mode.Code) {
 93 |       block = readUntil(rdr, '\r', '\n', '@', '}');
 94 |       while (block?.next === '@' && rdr.peek() === '@') {
 95 |         const temp = readUntil(rdr, '\r', '\n', '@', '}');
 96 |         if (temp) {
 97 |           block.value += temp.value;
 98 |           block.next = temp.next;
 99 |         }
100 |       }
101 |       rdr.seek(-1);
102 |       if (block) {
103 |         block.value = block.value.substr(1);
104 |         cmds.push(new Cmd(block.value, CmdType.Literal));
105 |       }
106 |     } else if (
107 |       (peek === 'i' && rdr.peek(2) === 'if') ||
108 |       (peek === 'd' && rdr.peek(2) === 'do') ||
109 |       (peek === 'f' && rdr.peek(3) === 'for') ||
110 |       (peek === 'f' && rdr.peek(9) === 'functions') ||
111 |       (peek === 'w' && rdr.peek(5) === 'while') ||
112 |       (peek === 'h' && rdr.peek(6) === ctx.dialect.helper) ||
113 |       (peek === 's' && rdr.peek(6) === 'switch') ||
114 |       (peek === 's' && rdr.peek(7) === ctx.dialect.section)
115 |     ) {
116 |       //TODO: trim whitespace before the {
117 |       block = readBlock(rdr, '{', '}');
118 | 
119 |       if (peek === 'i') {
120 |         while (!rdr.eof()) {
121 |           const whiteSpace = readWhitespace(rdr);
122 |           if (!whiteSpace) break;
123 |           else if (rdr.peek(4) !== 'else') {
124 |             rdr.seek(-whiteSpace.length);
125 |             break;
126 |           }
127 |           block += whiteSpace + readBlock(rdr, '{', '}');
128 |         }
129 |       }
130 | 
131 |       const parsed = parseImpl(block.substr(0, block.length - 1), level + 1, Mode.Code, ctx).join(NEWLINETAB);
132 |       let paren = parsed.indexOf('(');
133 |       bracket = parsed.indexOf('{');
134 | 
135 |       if (paren === -1 || bracket < paren) paren = bracket;
136 |       if (peek === 'h')
137 |         ctx.helpers.push(
138 |           `function ${parsed.substring(7, bracket).trim()} {${functionTemplateBasic(ctx.dialect)}${parsed.substr(bracket + 1)}${NEWLINE}return ${
139 |             ctx.dialect.html
140 |           }.raw(writer.join(""));${NEWLINE}}${NEWLINE}`
141 |         );
142 |       else if (peek === 's' && block.substr(0, 6) !== 'switch')
143 |         ctx.sections.push(
144 |           `sections.${parsed.substr(8, paren - 8).trim()} = function () {${functionTemplateBasic(ctx.dialect)}${parsed.substr(
145 |             bracket + 1
146 |           )}${NEWLINE}return writer.join("");${NEWLINE}}${NEWLINE}`
147 |         );
148 |       else if (peek === 'f' && block.substr(0, 9) === 'functions') cmds.push(new Cmd(parsed.substr(parsed.indexOf('{') + 1)));
149 |       else cmds.push(new Cmd(parsed + '}'));
150 |     } else if (peek && chunk && !rxValid.test(last(chunk.value))) {
151 |       let remain: string, match: RegExpMatchArray | null;
152 |       block = '';
153 |       while (!rdr.eof()) {
154 |         remain = rdr.text.substr(rdr.position + 1);
155 |         match = remain.match(rxValid);
156 |         if (!match) break;
157 |         block += rdr.read(match[0].length);
158 |         peek = rdr.peek();
159 |         if (!peek) break;
160 |         if (peek === '[' || peek === '(') {
161 |           remain = readBlock(rdr, peek, peek === '[' ? ']' : ')');
162 |           if (peek === '(' && rxFunction.test(remain)) {
163 |             bracket = remain.indexOf('{');
164 |             block += remain.substr(0, bracket);
165 |             block += parseImpl(remain.substr(bracket), level + 1, Mode.Code, ctx).join(NEWLINETAB);
166 |           } else {
167 |             block += remain;
168 |           }
169 |           break;
170 |         }
171 |       }
172 |       if (block) cmds.push(new Cmd(block, CmdType.Output));
173 |     } else if (mode === Mode.Text) {
174 |       if (chunk?.next) cmds.push(new Cmd('@', CmdType.Literal));
175 |     }
176 |   }
177 | 
178 |   while (!rdr.eof()) {
179 |     chunk = mode === Mode.Text ? readUntil(rdr, '@') : readQuotedUntil(rdr, '@', '<');
180 |     if (!chunk) break;
181 |     peek = rdr.peek();
182 |     if (peek === '@' && chunk.next === '@') {
183 |       rdr.read();
184 |       cmds.push(new Cmd(chunk.value + peek, CmdType.Literal));
185 |       continue;
186 |     }
187 | 
188 |     do {
189 |       peek = rdr.peek();
190 | 
191 |       if (mode === Mode.Code && chunk.next === '<') {
192 |         //the longest tagname is 8 chars, reading 30 out to cover it
193 |         let tagWritten = false;
194 |         const tagname = rdr.text.substr(rdr.position + 1, 30).match(rxTagName)?.[0] ?? '';
195 |         if (tagname) {
196 |           cmds.push(new Cmd(chunk.value, 0));
197 |           while (!rdr.eof()) {
198 |             chunk = readUntil(rdr, '@', '>');
199 |             if (chunk?.next === '@') {
200 |               cmds.push(new Cmd((tagWritten ? '' : '<') + chunk.value, CmdType.Literal));
201 |               tagWritten = true;
202 |               parseCodeBlock();
203 |             } else break;
204 |           }
205 |           block = chunk + '';
206 |           if (last(chunk?.value) !== '/') {
207 |             let nestedCount = 1,
208 |               nested: Chunk | undefined;
209 |             while (nestedCount > 0) {
210 |               nested = readUntil(rdr, '</' + tagname, '<' + tagname);
211 |               block += nested;
212 |               if (rdr.eof()) break;
213 |               if (nested) {
214 |                 nestedCount += nested.next.substr(1, 1) === '/' ? -1 : 1;
215 |               }
216 |             }
217 |             block += readQuotedUntil(rdr, '>');
218 |           }
219 |           if (!tagWritten) {
220 |             if (tagname === 'text') {
221 |               block = block.substr(5, block.length - 5 - 7);
222 |             } else block = '<' + block;
223 |           }
224 |           cmds.push(...parseImpl(block, level + 1, Mode.Text, ctx));
225 |         } else {
226 |           const chunk1 = readQuotedUntil(rdr, '@', '<');
227 |           if (chunk1) {
228 |             chunk.value += chunk.next + chunk1.value;
229 |             chunk.next = chunk1.next;
230 |           }
231 |           continue;
232 |         }
233 |       } else if (chunk.value) {
234 |         if (mode === Mode.Text) cmds.push(new Cmd(chunk.value, CmdType.Literal));
235 |         else cmds.push(new Cmd(chunk.value));
236 |       }
237 |       break;
238 |     } while (chunk.value || chunk.next);
239 | 
240 |     parseCodeBlock();
241 |   }
242 | 
243 |   if (ctx.options.processCommand) {
244 |     const proc = ctx.options.processCommand;
245 |     return cmds.map((x) => (x.type === CmdType.Code ? new Cmd(proc(x.code), CmdType.Code) : x));
246 |   }
247 |   return cmds;
248 | }
249 | 
250 | export type View = (model?: unknown, page?: Record<string, unknown>) => Promise<string>;
251 | 
252 | const DEFAULT_DIALECT = {
253 |   helper: 'helper',
254 |   section: 'section',
255 |   layout: 'layout',
256 |   model: 'model',
257 |   viewBag: 'viewBag',
258 |   html: 'html',
259 |   isSectionDefined: 'isSectionDefined',
260 |   renderSection: 'renderSection',
261 |   renderBody: 'renderBody',
262 | };
263 | 
264 | type RazorDialect = typeof DEFAULT_DIALECT;
265 | 
266 | interface RazorOptions {
267 |   findView?: (id: string) => Promise<string | undefined>;
268 |   dialect?: Partial<RazorDialect>;
269 |   locals?: string[];
270 |   processCommand?: (cmd: string) => string;
271 |   viewCompiled?: (code: string) => string;
272 |   log?: (msg: string) => void;
273 | }
274 | 
275 | export class Razor {
276 |   #templates = new Map<string, View>();
277 |   #dialect: RazorDialect;
278 |   #locals: string[];
279 |   #options: RazorOptions;
280 | 
281 |   constructor(options?: RazorOptions) {
282 |     this.#options = options ?? {};
283 |     this.#dialect = { ...DEFAULT_DIALECT, ...options?.dialect };
284 |     this.#locals = (options?.locals ?? []).filter(Boolean);
285 |   }
286 | 
287 |   parse(template: string): { code: string; sections: string[]; helpers: string[] } {
288 |     const ctx: ParseContext = { helpers: [], sections: [], dialect: this.#dialect, options: this.#options };
289 |     const cmds = parseImpl(template, 0, Mode.Text, ctx);
290 |     return {
291 |       code: cmds.join(NEWLINE),
292 |       sections: ctx.sections,
293 |       helpers: ctx.helpers,
294 |     };
295 |   }
296 | 
297 |   compile(code: string, page?: Record<string, unknown>, id?: string): View {
298 |     const parsed = this.parse(code);
299 |     let functionCode = functionTemplate(id, parsed.helpers.join(NEWLINE) + NEWLINE + parsed.sections.join(NEWLINE) + parsed.code, this.#dialect, this.#locals);
300 |     functionCode = this.#options.viewCompiled?.(functionCode) ?? functionCode;
301 | 
302 |     let func: (page: Record<string, unknown>, sections: Record<string, View>) => Promise<string>;
303 |     try {
304 |       func = new Function('page', 'sections', functionCode)();
305 |     } catch (x) {
306 |       throw new Error(`Unable to compile: ${x}${NEWLINE}${NEWLINE}${functionCode}`);
307 |     }
308 | 
309 |     return async (model: unknown, page1?: Record<string, unknown>) => {
310 |       const ctx = { layout: '', viewBag: {}, [this.#dialect.html]: html, ...page, ...page1, model },
311 |         sections: Record<string, View> = {};
312 | 
313 |       let result: string;
314 | 
315 |       try {
316 |         result = await func(ctx, sections);
317 |       } catch (x) {
318 |         throw new Error(`Unable to execute template: ${x}${NEWLINE}${NEWLINE}${functionCode}`);
319 |       }
320 | 
321 |       if (ctx.layout) {
322 |         const layoutView = await this.view(ctx.layout);
323 |         if (!layoutView) {
324 |           throw new Error(`Layout ${ctx.layout} not found`);
325 |         }
326 |         const isSectionDefined = (name: string) => typeof sections[name] === 'function';
327 |         result = await layoutView(undefined, {
328 |           ...page1,
329 |           renderBody() {
330 |             return new HtmlString(result);
331 |           },
332 |           viewBag: ctx.viewBag,
333 |           isSectionDefined,
334 |           renderSection(name: string, required?: boolean) {
335 |             if (isSectionDefined(name)) {
336 |               return new HtmlString(sections[name]());
337 |             } else if (required) {
338 |               throw `Section "${name}" not found.`;
339 |             }
340 |           },
341 |         });
342 |       }
343 | 
344 |       return result;
345 |     };
346 |   }
347 | 
348 |   async view(id: string, page?: Record<string, unknown>): Promise<View | undefined> {
349 |     const key = '~/' + id;
350 | 
351 |     let template = this.#templates.get(key);
352 |     if (!template) {
353 |       const script = await this.#options.findView?.(id);
354 |       if (script === undefined) {
355 |         return undefined;
356 |       }
357 |       template = this.compile(script, page, id);
358 |       this.#templates.set(key, template);
359 |     }
360 | 
361 |     return template;
362 |   }
363 | 
364 |   async render(markup: string, model?: unknown, page?: Record<string, unknown>): Promise<string> {
365 |     let template = this.#templates.get(markup);
366 |     if (!template) {
367 |       template = this.compile(markup);
368 |       this.#templates.set(markup, template);
369 |     }
370 |     return await template(model, page);
371 |   }
372 | }
373 | 


--------------------------------------------------------------------------------
/reader.test.ts:
--------------------------------------------------------------------------------
 1 | import 'jest';
 2 | import { Reader } from './reader';
 3 | 
 4 | it('can read all', () => {
 5 |   const rdr = new Reader('test');
 6 |   expect(rdr.readAll()).toBe('test');
 7 | });
 8 | 
 9 | it('can read', () => {
10 |   const rdr = new Reader('test');
11 |   rdr.seek(2);
12 |   expect(rdr.position).toBe(1);
13 |   expect(rdr.read(2)).toBe('st');
14 |   expect(rdr.position).toBe(3);
15 | });
16 | 
17 | it('can peek', () => {
18 |   const rdr = new Reader('test');
19 |   expect(rdr.peek(2)).toBe('te');
20 |   rdr.seek(2);
21 |   expect(rdr.position).toBe(1);
22 |   expect(rdr.peek(2)).toBe('st');
23 | });
24 | 
25 | it('can read until eof', () => {
26 |   const rdr = new Reader('test');
27 |   let result = '';
28 |   while (!rdr.eof()) {
29 |     result += rdr.read();
30 |   }
31 |   expect(result).toBe('test');
32 | });
33 | 


--------------------------------------------------------------------------------
/reader.ts:
--------------------------------------------------------------------------------
  1 | enum Position {
  2 |   Begin = 0,
  3 |   End = 2,
  4 | }
  5 | 
  6 | export class Chunk {
  7 |   value: string;
  8 |   next: string;
  9 |   public length: number;
 10 |   constructor(value: string, next?: string) {
 11 |     this.value = value ?? '';
 12 |     this.next = next ?? '';
 13 |     this.length = this.value.length + this.next.length;
 14 |   }
 15 |   toString(): string {
 16 |     return this.value + this.next;
 17 |   }
 18 |   static create(value: string, next?: string): Chunk | undefined {
 19 |     if (!value && !next) return undefined;
 20 |     return new Chunk(value, next);
 21 |   }
 22 | }
 23 | 
 24 | function read(rdr: Reader, chars: string[], until: boolean) {
 25 |   const cache: string[] = [];
 26 |   let result = '',
 27 |     next = '';
 28 |   let l: number | undefined;
 29 |   function predicate(chr: string) {
 30 |     l = chr.length;
 31 |     next = cache[l] || (cache[l] = rdr.peek(l));
 32 |     return next === chr;
 33 |   }
 34 | 
 35 |   while (!rdr.eof()) {
 36 |     cache.length = 0;
 37 |     if (until === chars.some(predicate)) {
 38 |       if (until) {
 39 |         rdr.seek(l);
 40 |       } else {
 41 |         next = last(result);
 42 |         result = result.length > 0 ? result.substr(0, result.length - 1) : '';
 43 |       }
 44 |       return Chunk.create(result, next);
 45 |     }
 46 | 
 47 |     next = rdr.read();
 48 |     if (next) {
 49 |       result += next;
 50 |     } else break;
 51 |   }
 52 | 
 53 |   return Chunk.create(result, next);
 54 | }
 55 | 
 56 | export class Reader {
 57 |   public text: string;
 58 |   public position = -1;
 59 |   public length = 0;
 60 | 
 61 |   constructor(text: string) {
 62 |     this.text = String(text ?? '');
 63 |     this.position = -1;
 64 |     this.length = this.text.length;
 65 |   }
 66 | 
 67 |   eof(): boolean {
 68 |     return this.position >= this.length;
 69 |   }
 70 | 
 71 |   read(len = 1): string {
 72 |     const value = this.peek(len);
 73 |     this.position = Math.min(this.length, this.position + len);
 74 |     return value;
 75 |   }
 76 | 
 77 |   readAll(): string {
 78 |     if (this.position >= this.length) return '';
 79 |     const value = this.text.substr(this.position + 1);
 80 |     this.position = this.length;
 81 |     return value;
 82 |   }
 83 | 
 84 |   peek(len = 1): string {
 85 |     if (this.position + 1 >= this.length) return '';
 86 |     return this.text.substr(this.position + 1, len);
 87 |   }
 88 | 
 89 |   seek(offset = 0, pos?: Position): boolean {
 90 |     const next = (pos === Position.Begin ? -1 : pos === Position.End ? this.length : this.position) + (offset || 1);
 91 |     this.position = Math.max(0, Math.min(this.length, next));
 92 |     return this.position === this.length;
 93 |   }
 94 | }
 95 | 
 96 | export function readUntil(rdr: Reader, ...chars: string[]): Chunk | undefined {
 97 |   return read(rdr, chars, true);
 98 | }
 99 | 
100 | export function readWhile(rdr: Reader, ...chars: string[]): Chunk | undefined {
101 |   return read(rdr, chars, false);
102 | }
103 | 
104 | export function readWhitespace(rdr: Reader): Chunk | undefined {
105 |   return readWhile(rdr, '\r', '\n', '\t', ' ');
106 | }
107 | 
108 | export function readQuoted(rdr: Reader, ...quote: string[]): string {
109 |   let result = '',
110 |     block: Chunk | undefined;
111 |   do {
112 |     block = readUntil(rdr, ...quote);
113 |     if (!block) break;
114 |     result += block.value + block.next;
115 |     if (last(block.value) !== '\\') break;
116 |   } while (block);
117 |   return result;
118 | }
119 | 
120 | export function readQuotedUntil(rdr: Reader, ...chars: string[]): Chunk | undefined {
121 |   let result = '',
122 |     block: Chunk | undefined;
123 |   chars = ['"', "'", '@*'].concat(chars);
124 | 
125 |   while ((block = readUntil(rdr, ...chars))) {
126 |     result += block.value;
127 |     if (block.next === '"' || block.next === "'") {
128 |       result += block.next + readQuoted(rdr, block.next);
129 |     } else if (block.next === '@*') {
130 |       readUntil(rdr, '*@');
131 |     } else break;
132 |   }
133 | 
134 |   return Chunk.create(result, block?.next);
135 | }
136 | 
137 | export function readBlock(rdr: Reader, open: string, close: string, numOpen = 0): string {
138 |   const blockChars = [open, close];
139 |   let ret = '';
140 |   let block;
141 | 
142 |   while ((block = readUntil(rdr, ...blockChars))) {
143 |     ret += block.value;
144 | 
145 |     if (block.next === open) {
146 |       numOpen++;
147 |     } else if (block.next === close) {
148 |       numOpen--;
149 |     }
150 | 
151 |     if (numOpen === 0) {
152 |       ret += block.next;
153 |       return ret;
154 |     } else ret += block.next;
155 |   }
156 | 
157 |   return ret;
158 | }
159 | 
160 | export function last(str = ''): string {
161 |   return str.substr(str.length - 1);
162 | }
163 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | RazorJS
  2 | =======
  3 | 
  4 | A JavaScript implementation of the Razor view engine that aims to be simple and compatible for use both in the 
  5 | browser and in Node--simple enough for templating:
  6 | 
  7 |     Razor.compile('hello @model.name')({ name: 'world' }) == 'hello world'
  8 | 
  9 | As well as a Node view-engine:
 10 | 
 11 |     var http = require('http'), 
 12 |       url = require('url'),
 13 |       Razor = require('../bin/node/Razor.js');
 14 | 
 15 |     http.createServer(function (req, res) {
 16 |       var uri = url.parse(req.url),
 17 |         path = uri.pathname.substr(1) || 'index';
 18 | 
 19 |       Razor.view(path, function(template) {
 20 |         if(template) {
 21 |           template({ name: 'Andy Edinborough' }, function(html){
 22 |             res.writeHead(200, {'Content-Type': 'text/html'});
 23 |             res.end(html); 
 24 |           });
 25 |         } 
 26 | 
 27 |         else {
 28 |             res.writeHead(404, {'Content-Type': 'text/html'});
 29 |             res.end('<h1>Not Found</h1>');            
 30 |         }
 31 |       });
 32 | 
 33 |     }).listen(1337, "127.0.0.1");
 34 | 
 35 | Live Demo
 36 | ---------    
 37 | Try RazorJS in your browser now: http://jsbin.com/imihov/latest
 38 | 
 39 | Syntax
 40 | ------
 41 | 
 42 | <table>
 43 |   <tbody>
 44 |       <tr>
 45 |           <th valign="top">Description</th>
 46 |           <th valign="top">Code</th>
 47 |           <th valign="top">Notes</th>
 48 |       </tr>
 49 | 
 50 |       <tr>
 51 |           <td valign="top">Code Block</td>
 52 |           <td valign="top">
 53 |               <pre>
 54 | @{ 
 55 | 	var x = 123; 
 56 | 	var y = "because.";
 57 | }
 58 | </pre>
 59 |           </td>
 60 |           <td> </td>
 61 |       </tr>
 62 | 
 63 |       <tr>
 64 |           <td valign="top">Expression (Html Encoded)</td>
 65 |           <td valign="top">
 66 |               <pre>
 67 | &lt;span&gt;@model.message&lt;/span&gt;
 68 | </pre>
 69 |           </td>
 70 |           <td> </td>
 71 |       </tr>
 72 | 
 73 |       <tr>
 74 |           <td valign="top">Expression (Unencoded)</td>
 75 | 
 76 |           <td valign="top">
 77 |               <pre>
 78 | &lt;span&gt;
 79 | 	@html.raw(model.message)
 80 | &lt;/span&gt;
 81 | </pre>
 82 |           </td>
 83 |           <td> </td>
 84 |       </tr>
 85 | 
 86 |       <tr>
 87 |           <td valign="top">Combining Text and markup</td>
 88 | 
 89 |           <td valign="top">
 90 |               <pre>
 91 | @{ 
 92 | 	model.items.forEach(function(item) {
 93 | 		&lt;span&gt;@item.Prop&lt;/span&gt; 
 94 | 	}); 
 95 | }
 96 | </pre>
 97 |           </td>
 98 |           <td> </td>
 99 |       </tr>
100 | 
101 |       <tr>
102 |           <td valign="top">Mixing code and Plain text</td>
103 | 
104 |           <td valign="top">
105 |               <pre>
106 | @if (foo) {
107 | 	&lt;text&gt;Plain Text&lt;/text&gt; 
108 | }
109 | </pre>
110 |           </td>
111 |           <td> </td>
112 |       </tr>
113 | 
114 |       <tr>
115 |           <td valign="top">Mixing code and plain text
116 |           (alternate)</td>
117 | 
118 |           <td valign="top">
119 |               <pre>
120 | @if (foo) {
121 | 	@:Plain Text is @bar
122 | }
123 | </pre>
124 |           </td>
125 |           <td> </td>
126 |       </tr>
127 | 
128 |       <tr>
129 |           <td valign="top">Email Addresses</td>
130 | 
131 |           <td valign="top">
132 |               <pre>
133 | Hi test@example.com
134 | </pre>
135 |           </td>
136 | 
137 |           <td valign="top">Razor recognizes basic email
138 |           format and is smart enough not to treat the @ as a code
139 |           delimiter</td>
140 |       </tr>
141 | 
142 |       <tr>
143 |           <td valign="top">Explicit Expression</td>
144 | 
145 |           <td valign="top">
146 |               <pre>
147 | &lt;span&gt;ISBN@(isbnNumber)&lt;/span&gt;
148 | </pre>
149 |           </td>
150 | 
151 |           <td valign="top">In this case, we need to be
152 |           explicit about the expression by using parentheses.</td>
153 |       </tr>
154 | 
155 |       <tr>
156 |           <td valign="top">Escaping the @ sign</td>
157 | 
158 |           <td valign="top">
159 |               <pre>
160 | &lt;span&gt;In Razor, you use the 
161 | @@foo to display the value 
162 | of foo&lt;/span&gt;
163 | </pre>
164 |           </td>
165 | 
166 |           <td valign="top">@@ renders a single @ in the
167 |           response.</td>
168 |       </tr>
169 | 
170 |       <tr>
171 |           <td valign="top">Server side Comment</td>
172 | 
173 |           <td valign="top">
174 |               <pre>
175 | @*
176 | 	This is a server side 
177 | 	multiline comment 
178 | *@
179 | </pre>
180 |           </td>
181 |           <td> </td>
182 |       </tr>
183 | 
184 |       <tr>
185 |           <td valign="top">Mixing expressions and text</td>
186 | 
187 |           <td valign="top">
188 |               <pre>
189 | Hello @title. @name.
190 | </pre>
191 |           </td>
192 |           <td> </td>
193 |       </tr>
194 | 
195 |       <tr>
196 |         <td valign="top">Partials </td>
197 |         <td>
198 |             <pre>
199 | @html.renderPartial('another-view')
200 | </pre>              
201 |         </td>
202 |       </tr>
203 | 
204 |       <tr>
205 |         <td valign="top">Layouts </td>
206 |         <td>
207 |             <strong>View</strong>
208 |             <pre>
209 | @{ this.layout = '_layout'; } 
210 | 
211 | @section my_section(){
212 |   @:hi!
213 | }             
214 | </pre>              
215 |             <strong>Layout</strong>
216 |             <pre>
217 |   @this.renderBody()
218 |   @this.renderSection('my_section')
219 | </pre>              
220 |         </td>
221 |       </tr>
222 | 	</tbody>
223 | </table>            
224 | 
225 | *shamelessly stolen from @haacked (http://haacked.com/archive/2011/01/06/razor-syntax-quick-reference.aspx) and modified for RazorJS*
226 | 


--------------------------------------------------------------------------------
/tests/Example.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 | 
 5 | </head>
 6 | <body>
 7 |   <div id="notices"></div>
 8 |   
 9 |   <script src="Razor.js"></script>
10 |   <script type="application/x-razor-js" data-view-id="notice">
11 |     @* this view is for displaying notices *@
12 |     <div class="notice@(model.icon || model.userID ? ' has-icon': '')" data-id="@model.id">
13 |       @if(model.icon) { 
14 |         <img class="notice-icon" src="@model.icon" />
15 |       } else if (model.userID) {
16 |         <img class="notice-icon" src="http://tracky.com/content/icon/user/@(model.userID)[48].png" />
17 |       }
18 |       <div class="content">
19 |         <span class="paragraph">@model.message</span>
20 |         <div class="meta">@showDate()</div>
21 |       </div>
22 |       @if (model.buttons){
23 |         <div class="buttons"></div>
24 |       }
25 |     </div>
26 |     
27 |     @helper showDate() {
28 |       if(model.date){
29 |         <time data-date="@model.date"> </time>
30 |       }
31 |     }
32 |   </script>
33 |   
34 |   <script>
35 |     var view = Razor.view('notice'),
36 |       container = document.getElementById('notices'),
37 |       models = [
38 |         { userID: 1, message: 'commented "Wat?!"', date: Date.now() }
39 |       ];
40 |     
41 |     models.forEach(function(model){
42 |       var div = document.createElement('div');
43 |       div.innerHTML = view(model);
44 |       container.appendChild(div);
45 |     });  
46 |   </script>
47 | </body>
48 | </html>


--------------------------------------------------------------------------------
/tests/async-test.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 | 
 5 | </head>
 6 | <body> 
 7 | 
 8 |   <script src="http://code.jquery.com/jquery-latest.js"></script>
 9 |   <script src="../bin/browser/Razor.js"></script>
10 | 
11 |   <script>
12 |   	Razor.Cmd.prototype.toString = (function(toString) {
13 |   		return function(){
14 |   			if(this.type === 1) return 'this.asyncWrite(function(){ return (' + this.code + ');})';
15 |   			return toString.apply(this);
16 |   		};
17 |   	})(Razor.Cmd.prototype.toString);
18 | 
19 |   	Razor.basePage.asyncWrite = function(delegate) {
20 | 			var page = this, model = page.model, writer = page.writer, 
21 | 				asyncs = writer.asyncs || (writer.asyncs = []);
22 | 			if(writer.isDeferred === undefined) {
23 | 				writer.isDeferred = typeof model.done === 'function';
24 | 			}
25 | 			if(writer.isDeferred) {
26 | 				var id = asyncs.length;
27 | 				asyncs.push(delegate);
28 | 				writer.push(page.html.raw('<nobr data-async-id="'+id+'">'));
29 | 			} else {
30 | 				page.write(delegate());
31 | 			}
32 | 		};
33 | 		function processAsyncs(elm, page, model) {
34 | 			var writer = page.writer, asyncs = writer.asyncs;
35 | 			$.each(model, function(k,v) { 
36 | 				page.model[k] = v; 
37 | 			});
38 | 			elm.find('nobr[data-async-id]').each(function(){
39 | 				var nobr = $(this), i = nobr.attr('data-async-id') >>> 0;
40 | 				$(this).replaceWith(asyncs[i]());
41 | 			});
42 | 		}
43 | 
44 |   	function equals(value, shouldBe, message) {
45 |   		if(value != shouldBe) throw message; 
46 |   	}
47 |   	var view = Razor.compile('Today is: @model.date');
48 |   	var model = { date: 'Tuesday'};
49 | 
50 |   	equals(view(model), 'Today is: Tuesday', 'normal view works');
51 | 
52 |   	var page = {writer:[]};
53 |   	var dfd = $.Deferred();
54 |   	var div = $('<div>').html(view(dfd, page));
55 |   	dfd.done(function(m){
56 |   		processAsyncs(div, page, m);
57 |   	});
58 |   	div.appendTo('body');
59 |   	setTimeout(function(){
60 |   		dfd.resolve(model);
61 | 	  	equals(div.html(), 'Today is: Tuesday', 'O_o holy crap it worked');
62 |   	}, 1e3)
63 | 
64 |   </script>
65 | </body>
66 | </html>


--------------------------------------------------------------------------------
/tests/encoding.js:
--------------------------------------------------------------------------------
 1 | var Razor = require('../bin/node/razor.js');
 2 | exports.encoding = function(test){	
 3 | 	var equal = test.equal;
 4 | 	var encode = new Razor.HtmlHelper().encode;
 5 | 	
 6 | 	equal(encode('<test>') + '', '&lt;test&gt;', 'encodes');
 7 | 	equal(encode(encode('<test>')) + '', '&lt;test&gt;', 'won\'t double-encode');
 8 | 	equal(Razor.compile('hello @html.raw("<test>")')(), 'hello <test>', 'won\'t encode for html.raw()');
 9 | 	
10 | 	test.done();
11 | };


--------------------------------------------------------------------------------
/tests/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 | 	<link href="http://code.jquery.com/qunit/qunit-git.css" rel="stylesheet" />
  5 | 	<style>
  6 | 		body {
  7 | 			font-family: sans-serif;
  8 | 		}
  9 | 		pre {
 10 | 			background: #f3f3f3;
 11 | 			margin: 5px;
 12 | 			padding: 5px;
 13 | 		}
 14 | 		h3 {
 15 | 			padding: 0;
 16 | 			margin: 1em 0 0 0;
 17 | 		}
 18 | 	</style>
 19 | </head>
 20 | <body>
 21 | 	<h1 id="qunit-header">Razor</h1>
 22 | 	<h2 id="qunit-banner"></h2>
 23 | 	<div id="qunit-testrunner-toolbar"></div>
 24 | 	<h2 id="qunit-userAgent"></h2>
 25 | 	<ol id="qunit-tests"></ol>
 26 | 
 27 | 	<script src="http://code.jquery.com/jquery-latest.js"></script>
 28 | 	<script src="http://code.jquery.com/qunit/qunit-git.js"></script>
 29 | 	<script src="../bin/browser/Razor.js"></script>
 30 | 
 31 | 	<h2>Views</h2>
 32 | 
 33 | 	<script>
 34 | 		if (!String.prototype.trim)
 35 | 			String.prototype.trim = function () {
 36 | 				return this.replace(/^\s+|\s+$/g, '');
 37 | 			}; 
 38 | 
 39 | 		test('Views', function () {
 40 | 			equal(Razor.view('test-page-w-layout')().trim().split(/\s+/g).join('\n'), '<a>test!</a>\n<a>body!</a>', 'layouts');
 41 | 			equal(Razor.view('basic-test')({ name: 'world' }).trim(), 'Hello world', 'basic "hello world"');
 42 | 			equal(Razor.view('test-partial')({ name: 'world' }).trim(), 'Hello world', 'renderPartial');
 43 | 			equal(Razor.view('test-helper')({}).trim(), '<div>Hello world</div>', 'complex helper');
 44 | 			equal(Razor.view('test-less-than')({ id: -1 }).trim(), '<div>Ok!</div>', 'view contains "<"');
 45 | 		});  
 46 |  
 47 | 	</script>
 48 | 	
 49 | <script type="application/x-razor-js" data-view-id="basic-test">  
 50 | 	Hello @model.name
 51 | </script>
 52 | <script type="application/x-razor-js" data-view-id="test-less-than">
 53 | 	@if(model.id < 0) {
 54 | 		<div>Ok!</div>
 55 | 	}
 56 | </script>
 57 | <script type="application/x-razor-js" data-view-id="test-helper">
 58 | 	@helper test(name){
 59 | 		name = name || 'world';
 60 | 		<div>Hello @name</div>
 61 | 	}
 62 | 	@test(model.name)
 63 | </script> 
 64 | <script type="application/x-razor-js" data-view-id="test-partial">
 65 | 	@html.renderPartial('basic-test', model)
 66 | </script>
 67 | 
 68 | <script type="application/x-razor-js" data-view-id="test-layout">
 69 | 	@page.renderSection('test')
 70 | 	@page.renderBody()
 71 | </script>
 72 | <script type="application/x-razor-js" data-view-id="test-page-w-layout">
 73 | 	@{
 74 | 		page.layout = 'test-layout';
 75 | 	}
 76 | 	<a>body!</a>
 77 | 	@section test(){
 78 | 		<a>test!</a>
 79 | 	}
 80 | </script>
 81 | 
 82 | <script>
 83 | 	(function () {
 84 | 		if(navigator.userAgent.indexOf('PhantomJS') > -1)
 85 | 			return;
 86 | 
 87 | 		$('script[data-view-id]').each(function(){
 88 | 			var self = $(this),
 89 | 				html = self.html().split('\t').join('  ');
 90 | 			html = html.substr(html.indexOf('\n') + 1);
 91 | 			$('<pre class="brush: razor">').text(html).insertAfter(self);
 92 | 			$('<h3>').text(self.data('view-id')).insertAfter(self);
 93 | 		});
 94 | 
 95 | 		document.write('<link href="http://alexgorbatchev.com/pub/sh/3_0_83/styles/shCore.css" rel="stylesheet" />');
 96 | 		document.write('<link href="http://alexgorbatchev.com/pub/sh/3_0_83/styles/shThemeDefault.css" rel="stylesheet" />');
 97 | 		document.write('<script src="http://alexgorbatchev.com/pub/sh/3_0_83/scripts/shCore.js"></sc'+'ript>');
 98 | 		document.write('<script src="shBrushRazor.js"></sc'+'ript>');
 99 | 		document.write('<script src="http://alexgorbatchev.com/pub/sh/3_0_83/scripts/shBrushXml.js"></sc'+'ript>');
100 | 		
101 | 		setTimeout(function retry(){
102 | 			var sh = window.SyntaxHighlighter;
103 | 			if(
104 | 					!sh ||
105 | 					!sh.brushes.Xml ||
106 | 					!sh.brushes.Razor
107 | 				) return void setTimeout(retry, 100);
108 | 
109 | 			sh.highlight();
110 | 		}, 1);
111 | 	})();
112 | </script>
113 | </body>
114 | </html>
115 | 


--------------------------------------------------------------------------------
/tests/node.js:
--------------------------------------------------------------------------------
 1 | var Razor = require('../bin/node/razor.js');
 2 | 
 3 | function parseHtml(html, cb){
 4 | 	var htmlparser = require('htmlparser'),
 5 | 		select = require('soupselect').select,
 6 | 		parser = new htmlparser.Parser(new htmlparser.DefaultHandler(function(err, dom) {
 7 | 			cb(function(selector) {
 8 | 				return select(dom, selector);
 9 | 			});
10 | 		}));
11 | 	parser.parseComplete(html);
12 | }
13 | 
14 | exports.node = function(test){
15 | 	var equal = test.equal, ok = test.ok;
16 |  	test.expect(2);
17 | 	
18 | 	Razor.getViewFile = (function(getViewFile){
19 | 		return function(){
20 | 			var result = getViewFile.apply(this, arguments);
21 | 			result = './tests/' + result.replace(/^[\.\/]+/g, '');
22 | 			return result;
23 | 		};
24 | 	})(Razor.getViewFile);
25 | 
26 | 	
27 | 	Razor.view('index', function(view){
28 | 		view({ name: 'RazorJS' }, function(html){
29 | 			
30 | 			parseHtml(html, function($){
31 | 				equal($('meta').length, 1, '<meta>');
32 | 				equal($('strong')[0].children[0].data, 'RazorJS', '<strong>');
33 | 				test.done();
34 | 			});
35 | 			
36 | 		});
37 | 	});
38 | 	
39 | };


--------------------------------------------------------------------------------
/tests/parse.js:
--------------------------------------------------------------------------------
 1 | var Razor = require('../bin/node/razor.js');
 2 | 
 3 | exports.parse = function (test) {
 4 | 	var equal = test.equal, ok = test.ok;
 5 | 
 6 | 	equal(Razor.compile('@{ <a b=@0 c=@1> </a> }')().trim(), '<a b=0 c=1> </a>', 'multiple code snippets in a tag opener inside a code block');
 7 | 	equal(Razor.compile('test\\test')().trim(), 'test\\test', '\\ needs to be double-encoded');
 8 | 	equal(Razor.compile('@if(true) { if(true){ <a @(0>1?0:1) /> } }')().trim(), '<a 1 />', 'ternary inside tag inside nested if');
 9 | 	equal(Razor.compile('@if(true) { if(true){ <a @(0>1?0:1) /> <a> </a> } }')().trim(), '<a 1 /><a> </a>', 'ternary inside tag inside nested if followed by another tag');
10 | 	equal(Razor.compile('@{ model.items.forEach(function(x){ @x }); }')({ items: [0] }), '0', 'forEach');
11 | 	equal(Razor.compile('test')(), 'test', 'no razor');
12 | 	equal(Razor.compile('@@test')(), '@test', 'escaped @');
13 | 	equal(Razor.compile('test@test.com')(), 'test@test.com', 'email address');
14 | 	equal(Razor.compile('test@@@(model.test).com')({ test: 'test' }), 'test@test.com', 'explicit code');
15 | 	equal(Razor.compile('hello @model.name')({ name: 'world' }), 'hello world', 'model');
16 | 	equal(Razor.compile('hello @model.name[0]')({ name: 'world'.split('') }), 'hello w', 'model w/ indexers');
17 | 	equal(Razor.compile('hello @model[\'name\']')({ name: 'world' }), 'hello world', 'model w/ string indexers');
18 | 	equal(Razor.compile('hello @model.name("world")')({ name: function (n) { return n; } }), 'hello world', 'model w/ method');
19 | 	equal(Razor.compile('te@*FAIL*@st')(), 'test', 'comment');
20 | 	equal(Razor.compile('@if(model.name){ @model.name }')({ name: 'test' }), 'test', 'if statement');
21 | 	equal(Razor.compile('@if(!model.name){ @fail(); } else { @model.name; }')({ name: 'test' }), 'test', 'if-else statement');
22 | 	equal(Razor.compile('@if(true){ @:test }')().trim(), 'test', 'text-mode');
23 | 	equal(Razor.compile('@helper test(name){ @:Hi @name } @test("bob")')().trim(), 'Hi bob', 'helper');
24 | 	equal(Razor.compile('@if(true){ <div><div>nested</div></div>  }')().trim(), '<div><div>nested</div></div>', 'nested tags inside code');
25 | 	equal(Razor.compile('@{  }')().trim(), '', 'javascript code block');
26 | 	equal(Razor.compile('@switch(model.test){ case 0: <br/> break; }')({ test: 0 }).trim(), '<br/>', 'switch');
27 | 	equal(Razor.compile('@if(true){ <text>hi</text> }')().trim(), 'hi', 'using <text/>');
28 | 	equal(Razor.compile('@if(true){ if(false) { @:fail } else { @:win } }')().trim(), 'win', 'nested if');
29 | 	equal(Razor.compile('@if(true){ if(false) { @:fail } else { <div>Hi!</div> if(false) { } <div>Hi!</div> } }')().trim(), '<div>Hi!</div><div>Hi!</div>', 'nested if w/ html');
30 | 
31 | 	try {
32 | 		Razor.compile('@(');
33 | 		Razor.compile('@{');
34 | 	} catch (x) { }
35 | 	ok(true, 'Didn\'t crash');
36 | 
37 | 	equal(Razor.compile('@model.forEach(function(x){ @x })')([0]).trim(), '0', 'rendering from inside an inlined-function');
38 | 	
39 | 	test.done();
40 | };


--------------------------------------------------------------------------------
/tests/shBrushRazor.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * SyntaxHighlighter
 3 |  * http://alexgorbatchev.com/SyntaxHighlighter
 4 |  *
 5 |  * SyntaxHighlighter is donationware. If you are using it, please donate.
 6 |  * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
 7 |  *
 8 |  * @version
 9 |  * 3.0.83 (July 02 2010)
10 |  * 
11 |  * @copyright
12 |  * Copyright (C) 2004-2010 Alex Gorbatchev.
13 |  *
14 |  * @license
15 |  * Dual licensed under the MIT and GPL licenses.
16 |  */
17 | ;(function()
18 | {
19 | 	// CommonJS
20 | 	typeof(require) != 'undefined' ? SyntaxHighlighter = require('shCore').SyntaxHighlighter : null;
21 | 
22 | 	function Brush()
23 | 	{
24 | 		function process(match, regexInfo)
25 | 		{
26 | 			var constructor = SyntaxHighlighter.Match,
27 | 				code = match[0],
28 | 				tag = new XRegExp('(&lt;|<)[\\s\\/\\?]*(?<name>[:\\w-\\.]+)', 'xg').exec(code),
29 | 				result = []
30 | 				;
31 | 		
32 | 			if (match.attributes != null) 
33 | 			{
34 | 				var attributes,
35 | 					regex = new XRegExp('(?<name> [\\w:\\-\\.]+)' +
36 | 										'\\s*=\\s*' +
37 | 										'(?<value> ".*?"|\'.*?\'|\\w+)',
38 | 										'xg');
39 | 
40 | 				while ((attributes = regex.exec(code)) != null) 
41 | 				{
42 | 					result.push(new constructor(attributes.name, match.index + attributes.index, 'color1'));
43 | 					result.push(new constructor(attributes.value, match.index + attributes.index + attributes[0].indexOf(attributes.value), 'string'));
44 | 				}
45 | 			}
46 | 
47 | 			if (tag != null)
48 | 				result.push(
49 | 					new constructor(tag.name, match.index + tag[0].indexOf(tag.name), 'keyword')
50 | 				);
51 | 
52 | 			return result;
53 | 		}
54 | 	
55 | 		this.regexList = [
56 | 			{ regex: new XRegExp('(\\&lt;|<)\\!\\[[\\w\\s]*?\\[(.|\\s)*?\\]\\](\\&gt;|>)', 'gm'),			css: 'color2' },	// <![ ... [ ... ]]>
57 | 			{ regex: SyntaxHighlighter.regexLib.xmlComments,												css: 'comments' },	// <!-- ... -->
58 | 			{ regex: /@\*[\s\S]*?\*@$/gm,                                                                   css: 'comments' },  // server side comments
59 | 			{ regex: new XRegExp('(&lt;|<)[\\s\\/\\?]*(\\w+)(?<attributes>.*?)[\\s\\/\\?]*(&gt;|>)', 'sg'), func: process },
60 | 			{ regex: new RegExp("(^|[^@])@(functions|helper|inherits|model|section)", 'gmi'),               css: 'keyword' }    // Razor-specific keywords
61 | 		];
62 | 	};
63 | 
64 | 	Brush.prototype	= new SyntaxHighlighter.Highlighter();
65 | 	Brush.aliases	= ['razor'];
66 | 
67 | 	SyntaxHighlighter.brushes.Razor = Brush;
68 | 
69 | 	// CommonJS
70 | 	typeof(exports) != 'undefined' ? exports.Brush = Brush : null;
71 | })();
72 | 


--------------------------------------------------------------------------------
/tests/views/_layout.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 | 	@renderSection('head')
 5 | </head>
 6 | <body>
 7 |   
 8 | 	@renderBody()
 9 | 
10 | </body>
11 | </html>


--------------------------------------------------------------------------------
/tests/views/_sub-layout.html:
--------------------------------------------------------------------------------
1 | @{ layout = '_layout'; }
2 | 
3 | @section head {
4 | 	@renderSection('head')
5 | }
6 | 
7 | @renderBody()
8 | 


--------------------------------------------------------------------------------
/tests/views/index.html:
--------------------------------------------------------------------------------
1 | @{
2 | 	layout = '_sub-layout';
3 | }
4 | 
5 | Hello <strong>@model.name</strong>!
6 | 
7 | @section head {
8 | 	<meta charset="utf-8"/>
9 | }


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["**/*.ts"],
 3 |   "exclude": ["node_modules", "**/*.test.ts"],
 4 |   "compilerOptions": {
 5 |     "target": "es6",
 6 |     "esModuleInterop": true,
 7 |     "module": "commonjs",
 8 |     "moduleResolution": "node",
 9 |     "skipLibCheck": true,
10 |     "noImplicitAny": true,
11 |     "outDir": "./dist",
12 |     "strictNullChecks": true,
13 |     "declaration": true
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------