mirrors/TiddlyWiki5
1
0
Fork 0
mirror of https://github.com/Jermolene/TiddlyWiki5 synced 2024-11-01 07:36:18 +00:00
Code Issues Releases Wiki Activity
823bcd7999
TiddlyWiki5/editions/test/tiddlers/tests/test-html-parser.js

236 lines
14 KiB
JavaScript
Raw Normal View History

Some tests for the HTML tag parser Getting ready for some improvements
2013-06-10 20:07:42 +00:00
/*\
title: test-html-parser.js
type: application/javascript
tags: [[$:/tags/test-spec]]
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
Tests for the internal components of the HTML tag parser
Some tests for the HTML tag parser Getting ready for some improvements
2013-06-10 20:07:42 +00:00
\*/
(function(){
/*jslint node: true, browser: true */
/*global $tw: false */
"use strict";
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
function FakeParser() {
}
$tw.utils.extend(FakeParser.prototype,require("$:/core/modules/parsers/wikiparser/rules/html.js"));
describe("HTML tag new parser tests", function() {
var parser = new FakeParser();
it("should parse whitespace", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseWhiteSpace("p ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseWhiteSpace("p ",1)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'whitespace', start : 1, end : 3 }
);
});
it("should parse string tokens", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseTokenString("p= ",0,"=")).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseTokenString("p= ",1,"=")).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'token', value : '=', start : 1, end : 2 }
);
});
it("should parse regexp tokens", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseTokenRegExp("p=' ",0,/(=(?:'|"))/)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseTokenRegExp("p=' ",1,/(=(?:'|"))/g).match[0]).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
'=\''
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseTokenRegExp("p=blah ",2,/([^\s>]+)/g).match[0]).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
'blah'
);
});
it("should parse string literals", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseStringLiteral("p='blah' ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseStringLiteral("p='blah' ",2)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 2, value : 'blah', end : 8 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseStringLiteral("p='' ",2)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 2, value : '', end : 4 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseStringLiteral("p=\"blah' ",2)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseStringLiteral("p=\"\" ",2)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 2, value : '', end : 4 }
);
});
it("should parse macro parameters", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("me",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'me', end : 2 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("me:one",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'one', name : 'me', end : 6 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("me:'one two three'",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'one two three', name : 'me', end : 18 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("'one two three'",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'one two three', end : 15 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("me:[[one two three]]",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'one two three', name : 'me', end : 20 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("[[one two three]]",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'macro-parameter', start : 0, value : 'one two three', end : 17 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroParameter("myparam>",0)).toEqual(
Wikirules now use better macrocall parser (#5451) * wikirules now use better macrocall parser Before, wikirules would use a deficient macrocall parser which couldn't handle certain types of arguments. Now it uses the same one that the widget parser uses. Less code! * style changes and removing weird switch statement That switch statement made more sense in an earlier iteration. * comment improvements * oops, wikirule macrocalls could do ONE thing better * '=' wasn't allowed for widget macros, but why? Now they're allowed for both widget macros and macrocall macros.
2021-01-29 13:26:31 +00:00
{ type : 'macro-parameter', start : 0, value : 'myparam>', end : 8 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
});
it("should parse macro invocations", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ ], name : 'mymacro', end : 11 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro one two three>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ { type : 'macro-parameter', start : 9, value : 'one', end : 13 }, { type : 'macro-parameter', start : 13, value : 'two', end : 17 }, { type : 'macro-parameter', start : 17, value : 'three', end : 23 } ], name : 'mymacro', end : 25 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro p:one q:two three>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ { type : 'macro-parameter', start : 9, value : 'one', name : 'p', end : 15 }, { type : 'macro-parameter', start : 15, value : 'two', name : 'q', end : 21 }, { type : 'macro-parameter', start : 21, value : 'three', end : 27 } ], name : 'mymacro', end : 29 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro 'one two three'>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ { type : 'macro-parameter', start : 9, value : 'one two three', end : 25 } ], name : 'mymacro', end : 27 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<mymacro r:'one two three'>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ { type : 'macro-parameter', start : 9, value : 'one two three', name : 'r', end : 27 } ], name : 'mymacro', end : 29 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseMacroInvocation("<<myMacro one:two three:'four and five'>>",0)).toEqual(
Extend the HTML rendering mechanism to support attributes specified as macro invocations
2013-06-18 14:37:19 +00:00
{ type : 'macrocall', start : 0, params : [ { type : 'macro-parameter', start : 9, value : 'two', name : 'one', end : 17 }, { type : 'macro-parameter', start : 17, value : 'four and five', name : 'three', end : 39 } ], name : 'myMacro', end : 41 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
});
it("should parse HTML attributes", function() {
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p='blah' ",1)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
null
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p='blah' ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 8 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p=\"blah\" ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 8 }
);
Allow newlines within filtered transclusions (#6421) * Allow newlines within filtered transclusions * Docs
2022-02-21 15:28:21 +00:00
expect($tw.utils.parseAttribute("p=\"bl\nah\" ",0)).toEqual(
{ type : 'string', start : 0, name : 'p', value : 'bl\nah', end : 9 }
);
expect($tw.utils.parseAttribute("p={{{blah}}} ",0)).toEqual(
{ type : 'filtered', start : 0, name : 'p', filter : 'blah', end : 12 }
);
expect($tw.utils.parseAttribute("p={{{bl\nah}}} ",0)).toEqual(
{ type : 'filtered', start : 0, name : 'p', filter : 'bl\nah', end : 13 }
);
expect($tw.utils.parseAttribute("p={{{ [{$:/layout}] }}} ",0)).toEqual(
{ type : 'filtered', start : 0, name : 'p', filter : ' [{$:/layout}] ', end : 23 }
);
expect($tw.utils.parseAttribute("p={{blah}} ",0)).toEqual(
{ type : 'indirect', start : 0, name : 'p', textReference : 'blah', end : 10 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p=blah ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 6 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p =blah ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 7 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p= blah ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 7 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p = blah ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', start : 0, name : 'p', value : 'blah', end : 8 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute("p = >blah ",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', value : 'true', start : 0, name : 'p', end : 4 }
);
Fix html parser tests
2014-04-17 13:43:24 +00:00
expect($tw.utils.parseAttribute(" attrib1>",0)).toEqual(
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
{ type : 'string', value : 'true', start : 0, name : 'attrib1', end : 8 }
);
Adds Text substitution support in widget attributes and new operator (#7526) * feat: new text substitution support, first pass * fix: use the widget method instead of evaluating a filter * revert to earlier implementation that emulates macro syntax * fix: capitalize comments * feat: add support for triple backticks for substituted attributes * docs: added docs for substitute operator * chore: more docs tweaks * docs: substituted attributes, refactored docs for widget attributes * docs: fixed typo * docs: more examples for substituted attributes * docs: updated prior documentation on concatenating text and variables * docs: documentation corrections * Update editions/tw5.com/tiddlers/filters/examples/substitute Operator (Examples).tid Co-authored-by: btheado <brian.theado@gmail.com> --------- Co-authored-by: btheado <brian.theado@gmail.com>
2023-06-24 13:57:15 +00:00
expect($tw.utils.parseAttribute("p=`blah` ",1)).toEqual(null);
expect($tw.utils.parseAttribute("p=`blah` ",0)).toEqual(
{ start: 0, name: 'p', type: 'substituted', rawValue: 'blah', end: 8 }
);
expect($tw.utils.parseAttribute("p=```blah``` ",0)).toEqual(
{ start: 0, name: 'p', type: 'substituted', rawValue: 'blah', end: 12 }
);
expect($tw.utils.parseAttribute("p=`Hello \"There\"`",0)).toEqual(
{ start: 0, name: 'p', type: 'substituted', rawValue: 'Hello "There"', end: 17 }
);
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
});
it("should parse HTML tags", function() {
expect(parser.parseTag("<mytag>",1)).toEqual(
null
);
expect(parser.parseTag("</mytag>",0)).toEqual(
null
);
expect(parser.parseTag("<mytag>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 0, attributes : { }, orderedAttributes: [ ], tag : 'mytag', end : 7 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<mytag attrib1>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 0, attributes : { attrib1 : { type : 'string', value : 'true', start : 6, name : 'attrib1', end : 14 } }, orderedAttributes: [ { start: 6, name: 'attrib1', type: 'string', value: 'true', end: 14 } ], tag : 'mytag', end : 15 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<mytag attrib1/>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 0, attributes : { attrib1 : { type : 'string', value : 'true', start : 6, name : 'attrib1', end : 14 } }, orderedAttributes: [ { start: 6, name: 'attrib1', type: 'string', value: 'true', end: 14 } ], tag : 'mytag', isSelfClosing : true, end : 16 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<$view field=\"title\" format=\"link\"/>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'view', start : 0, attributes : { field : { start : 6, name : 'field', type : 'string', value : 'title', end : 20 }, format : { start : 20, name : 'format', type : 'string', value : 'link', end : 34 } }, orderedAttributes: [ { start: 6, name: 'field', type: 'string', value: 'title', end: 20 }, { start: 20, name: 'format', type: 'string', value: 'link', end: 34 } ], tag : '$view', isSelfClosing : true, end : 36 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<mytag attrib1='something'>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 0, attributes : { attrib1 : { type : 'string', start : 6, name : 'attrib1', value : 'something', end : 26 } }, orderedAttributes: [ { start: 6, name: 'attrib1', type: 'string', value: 'something', end: 26 } ], tag : 'mytag', end : 27 }
);
expect(parser.parseTag("<mytag attrib1 attrib1='something'>",0)).toEqual(
{ type : 'element', start : 0, attributes : { attrib1 : { type : 'string', start : 15, name : 'attrib1', value : 'something', end : 34 } }, orderedAttributes: [ { start: 6, name: 'attrib1', type: 'string', value: 'true', end: 15 }, { start: 15, name: 'attrib1', type: 'string', value: 'something', end: 34 } ], tag : 'mytag', end : 35 }
);
expect(parser.parseTag("<mytag attrib1 attrib1='something' attrib1='else'>",0)).toEqual(
{ type : 'element', start : 0, attributes : { attrib1 : { type : 'string', start : 34, name : 'attrib1', value : 'else', end : 49 } }, orderedAttributes: [ { start: 6, name: 'attrib1', type: 'string', value: 'true', end: 15 }, { start: 15, name: 'attrib1', type: 'string', value: 'something', end: 34 }, { start: 34, name: 'attrib1', type: 'string', value: 'else', end: 49 } ], tag : 'mytag', end : 50 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<$mytag attrib1='something' attrib2=else thing>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'mytag', start : 0, attributes : { attrib1 : { type : 'string', start : 7, name : 'attrib1', value : 'something', end : 27 }, attrib2 : { type : 'string', start : 27, name : 'attrib2', value : 'else', end : 40 }, thing : { type : 'string', start : 40, name : 'thing', value : 'true', end : 46 } }, orderedAttributes: [ { start: 7, name: 'attrib1', type: 'string', value: 'something', end: 27 }, { start: 27, name: 'attrib2', type: 'string', value: 'else', end: 40 }, { start: 40, name: 'thing', type: 'string', value: 'true', end: 46 } ], tag : '$mytag', end : 47 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("< $mytag attrib1='something' attrib2=else thing>",0)).toEqual(
null
);
expect(parser.parseTag("<$mytag attrib3=<<myMacro one:two three:'four and five'>>>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'mytag', start : 0, attributes : { attrib3 : { type : 'macro', start : 7, name : 'attrib3', value : { type : 'macrocall', start : 16, params : [ { type : 'macro-parameter', start : 25, value : 'two', name : 'one', end : 33 }, { type : 'macro-parameter', start : 33, value : 'four and five', name : 'three', end : 55 } ], name : 'myMacro', end : 57 }, end : 57 } }, orderedAttributes: [ { type : 'macro', start : 7, name : 'attrib3', value : { type : 'macrocall', start : 16, params : [ { type : 'macro-parameter', start : 25, value : 'two', name : 'one', end : 33 }, { type : 'macro-parameter', start : 33, value : 'four and five', name : 'three', end : 55 } ], name : 'myMacro', end : 57 }, end : 57 } ], tag : '$mytag', end : 58 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.parseTag("<$mytag attrib1='something' attrib2=else thing attrib3=<<myMacro one:two three:'four and five'>>>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'mytag', start : 0, attributes : { attrib1 : { type : 'string', start : 7, name : 'attrib1', value : 'something', end : 27 }, attrib2 : { type : 'string', start : 27, name : 'attrib2', value : 'else', end : 40 }, thing : { type : 'string', start : 40, name : 'thing', value : 'true', end : 47 }, attrib3 : { type : 'macro', start : 47, name : 'attrib3', value : { type : 'macrocall', start : 55, params : [ { type : 'macro-parameter', start : 64, value : 'two', name : 'one', end : 72 }, { type : 'macro-parameter', start : 72, value : 'four and five', name : 'three', end : 94 } ], name : 'myMacro', end : 96 }, end : 96 } }, orderedAttributes: [ { type : 'string', start : 7, name : 'attrib1', value : 'something', end : 27 }, { type : 'string', start : 27, name : 'attrib2', value : 'else', end : 40 }, { type : 'string', start : 40, name : 'thing', value : 'true', end : 47 }, { type : 'macro', start : 47, name : 'attrib3', value : { type : 'macrocall', start : 55, params : [ { type : 'macro-parameter', start : 64, value : 'two', name : 'one', end : 72 }, { type : 'macro-parameter', start : 72, value : 'four and five', name : 'three', end : 94 } ], name : 'myMacro', end : 96 }, end : 96 } ], tag : '$mytag', end : 97 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
});
it("should find and parse HTML tags", function() {
expect(parser.findNextTag("<something <mytag>",1)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 11, attributes : { }, orderedAttributes: [ ], tag : 'mytag', end : 18 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.findNextTag("something else </mytag>",0)).toEqual(
null
);
expect(parser.findNextTag("<<some other stuff>> <mytag>",0)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 1, attributes : { other : { type : 'string', value : 'true', start : 6, name : 'other', end : 13 }, stuff : { type : 'string', value : 'true', start : 13, name : 'stuff', end : 18 } }, orderedAttributes: [ { type : 'string', value : 'true', start : 6, name : 'other', end : 13 }, { type : 'string', value : 'true', start : 13, name : 'stuff', end : 18 } ], tag : 'some', end : 19 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
expect(parser.findNextTag("<<some other stuff>> <mytag>",2)).toEqual(
Extend HTML tag parser to maintain an ordered array of attribute names (#6132) * Extend HTML tag parser to maintain an ordered array of attribute names * Add some tests for repeated attributes * Record entire attribute in orderedAttributes array so that we can work with duplicated attributes
2021-10-27 10:35:12 +00:00
{ type : 'element', start : 21, attributes : { }, orderedAttributes: [ ], tag : 'mytag', end : 28 }
Refactor the HTML element parser The purpose is to allow attributes to be specified as macro invocations. For example `<div myattr=<<mymacro param1 param3>>>`. The parser needed sprucing up in order to copy with the nesting of angle brackets. The refactoring has been done with an eye on using the same technique in the filter expression parser (which is pretty messy at the moment -- it throws exceptions for syntax errors, which is bad). Later I'm hoping to extend the technique to create a more flexible table parser.
2013-06-15 14:12:05 +00:00
);
});
});
Some tests for the HTML tag parser Getting ready for some improvements
2013-06-10 20:07:42 +00:00
})();
Reference in New Issue Copy Permalink