CPL
/
banboshi_V2
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
版博士V2.0程序
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
61 Commits
5 Branches
6.2 GiB
 
 
 
 
Branch: TongWei
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'TongWei'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/gogocode/test/G.find.test.js

1065 lines
29 KiB
Raw Permalink Blame History 

  1. const $ = require('../index');

  2. const config = require('./config');

  3. const jc1 = require('./code/simple1');

  4. const jc2 = require('./code/simple2');

  5. const jc5 = require('./code/simple5');

  6. const jc6 = require('./code/simple6');

  7. const tc1 = require('./code/simple-ts-1');

  8. const hc1 = require('./code/simple1.html');

  9. const hc2 = require('./code/simple2.html');

  10. const jTryout = require('./code/simple-tryout');

  11. const glob = require('glob');

  12. 

  13. const SIMPLE_CODE = `var a = 1;`;

  14. const CODE = `

  15. function test(c){

  16. 	let a = 1;

  17.   	let b = 2;

  18.   	return a + b + c;

  19. }

  20. test(11)`;

  21. const OBJECT_CODE = `

  22. const a = {

  23.     name: 'jerry',

  24.     age: 12

  25. }`;

  26. test('$.find: input is empty string should not throw error', () => {

  27.     expect(()=>{

  28.        const G = $(SIMPLE_CODE);

  29.        G.find('');

  30.     }).toThrow();

  31. })

  32. 

  33. test('$.find: input is empty string should not throw error', () => {

  34.     expect(()=>{

  35.        const G = $(SIMPLE_CODE);

  36.        const result = G.find('');

  37.     }).toThrow();

  38. })

  39. test('$.find: input is simple selector should not throw error', () => {

  40.     expect(()=>{

  41.        const G = $(SIMPLE_CODE);

  42.        G.find('var $_$ = $_$');

  43.     }).not.toThrow();

  44. })

  45. test('$.find: input is simple selector result should be ok', () => {

  46.     const G = $(SIMPLE_CODE);

  47.     result = G.find('var $_$ = $_$').generate();

  48.     expect(result).toBe('var a = 1;');

  49. })

  50. test('$.find: input is simple selector without $_$ should not throw error', () => {

  51.     expect(()=>{

  52.        const G = $(SIMPLE_CODE);

  53.        G.find('var a = 1;');

  54.     }).not.toThrow();

  55. })

  56. test('$.find: input is simple selector without $_$ result should be ok', () => {

  57.     const G = $(SIMPLE_CODE);

  58.     result = G.find('var a = 1;').generate();

  59.     expect(result).toBe('var a = 1;');

  60. })

  61. test('$.find: input is string array should not throw error', () => {

  62.     expect(()=>{

  63.        const G = $(CODE);

  64.        G.find(['let $_$ = $_$','test()']);

  65.     }).not.toThrow();

  66. })

  67. 

  68. test('$.find: input is string array result should be ok', () => {

  69.     const G = $(CODE);

  70.     const result = G.find(['let $_$ = $_$', 'test()']);

  71.     const code0 = $(result.eq(0).node).generate();

  72.     const code1 = $(result.eq(1).node).generate();

  73.     const code2 = $(result.eq(2).node).generate();

  74.     expect(code0 === 'let a = 1;' && code1 === 'let b = 2;' && code2 === 'test(11)').toBeTruthy();

  75. })

  76. test('$.find: result is return object', () => {

  77.     expect(()=>{

  78.        const G = $(CODE);

  79.        G.find('return $_$');

  80.     }).not.toThrow();

  81. })

  82. test('$.find: result is return object, result should be ok', () => {

  83.     const G = $(CODE);

  84.     const code = G.find('return $_$').generate();

  85.     expect(code).toBe('return a + b + c;')

  86. })

  87. test('$.find: input is string array ,only one selector, should not throw error', () => {

  88.     expect(()=>{

  89.        const G = $(CODE);

  90.        G.find(['var $_$ = $_$']);

  91.     }).not.toThrow();

  92. })

  93. test('$.find: input is string array ,only one selector, result should be ok', () => {

  94.     const G = $(CODE);

  95.     const result = G.find(['let $_$ = $_$']).generate();

  96.     expect(result).toBe('let a = 1;');

  97. })

  98. test('$.find: input is object  should not throw error', () => {

  99.     expect(()=>{

  100.        const G = $(jc1);

  101.        G.find({type: 'StringLiteral', value: '$_$'});

  102.     }).not.toThrow();

  103. })

  104. test('$.find: input is object result should be ok', () => {

  105.     const G = $(jc1);

  106.     const code = G.find({ type: 'StringLiteral', value: '$_$' }).generate();

  107.     expect(code).toBe("'../index'");

  108. })

  109. test('$.find: input is object array  should not throw error', () => {

  110.     expect(()=>{

  111.        const G = $(CODE);

  112.        G.find([{type: 'StringLiteral', value: '$_$'}, {type: 'Identifier', name: '$_$'}]);

  113.     }).not.toThrow();

  114. })

  115. test('$.find: find properties key should not throw error', () => {

  116.     expect(()=>{

  117.        const G = $(OBJECT_CODE);

  118.        G.find(`$_$:'jerry'`);

  119.     }).not.toThrow();

  120. })

  121. test('$.find: find properties key result should be ok', () => {

  122.     const G = $(OBJECT_CODE);

  123.     // todo support key: value

  124.     const code = G.find(`{ $_$ : 'jerry' }`).generate();

  125.     expect(code.indexOf(`name`) > -1).toBeTruthy();

  126. })

  127. test('$.find: find object ', () => {

  128.     expect(()=>{

  129.        const G = $(OBJECT_CODE);

  130.        G.find(`{$_$:'jerry'}`);

  131.     }).not.toThrow();

  132. })

  133. test('$.find: find object result should be ok', () => {

  134.     const G = $(OBJECT_CODE);

  135.     const code = G.find(`{$_$:'jerry'}`).generate();

  136.     expect(code.indexOf(`name: 'jerry',`) > -1).toBeTruthy();

  137. })

  138. test('$.find: find object result should be ok', () => {

  139.     const G = $(OBJECT_CODE);

  140.     const code = G.find(`{name:'jerry'}`).generate();

  141.     expect(code.indexOf(`name: 'jerry',`) > -1).toBeTruthy();

  142. })

  143. test('$.find: find properties value should not throw error', () => {

  144.     expect(()=>{

  145.        const G = $(OBJECT_CODE);

  146.        G.find(`name:$_$`);

  147.     }).not.toThrow();

  148. })

  149. test('$.find: find properties value result should be ok', () => {

  150.     const G = $(OBJECT_CODE);

  151.     const code = G.find(`{ name: $_$ }`).generate();

  152.     expect(code.indexOf(`jerry`) > -1).toBeTruthy();

  153. })

  154. test('$.find: simple tryout js code if condition result should be ok', () => {

  155.  

  156.     const code = $(jTryout).find('if ($_$){}')

  157.         .each(ast => {

  158.             ast.replace(`!Tryout.TRYOUT_SID_391`,`false`)

  159.             .replace(`Tryout.TRYOUT_SID_391`,'true')

  160.         })

  161.         .root()

  162.         .generate();

  163.     const result = code.indexOf(`if (!Tryout.TRYOUT_SID_391`) < 0 && code.indexOf(`if (Tryout.TRYOUT_SID_391`) < 0

  164.     expect(result).toBeTruthy();

  165. })

  166. test('$.find: simple js code if condition result should be ok', () => {

  167.     const match = $(`if (a && 1 || 0) { b } else { c; dosth() }`)

  168.     .find(`if ($_$1) { $_$2 } else { $_$3 }`)

  169.     .match;

  170.     const result = match['1'][0].value === 'a && 1 || 0' && 

  171.     match['2'][0].value === 'b' &&

  172.     match['3'][0].value === 'c'

  173.     expect(result).toBeTruthy();

  174. })

  175. test('$.find: replace function name', () => {

  176. 

  177.     const G = $(`const code = Page({

  178.         onShow() { },

  179.         data: { }

  180.       })`);

  181.     const code = G.find(`Page({ $_$() { }  })`)

  182.         .each(item => {

  183.             if (item.match[0][0].value == 'onShow') {

  184.                 item.match[0][0].node.name = 'render'

  185.             }

  186.         }).generate();

  187.     const result = code.indexOf(`render()`) > -1 && code.indexOf(`onShow()`) < 0;

  188.     expect(result).toBeTruthy();

  189. })

  190. test('$.find: find function name', () => {

  191.     expect(()=>{

  192.        const G = $(CODE);

  193.        G.find(`function $_$(c)`);

  194.     }).not.toThrow();

  195. })

  196. test('$.find: find function name result should be ok', () => {

  197.     const G = $(CODE);

  198.     //待定

  199.     const code = G.find(`function $_$(c) { $_$2 }`).match[0][0].value;

  200.     expect(code).toBe('test');

  201. })

  202. test('$.find: find arrow function name', () => {

  203.     const G = $(jc1);

  204.     const code = G.find(`()=>{}`).generate();

  205.     expect(code.indexOf(`console.log('this is arrow function' )`) > -1).toBeTruthy();

  206. })

  207. test('$.find: find object', () => {

  208.     expect(()=>{

  209.        const G = $(OBJECT_CODE);

  210.        G.find(`const a = $_$`);

  211.     }).not.toThrow();

  212. })

  213. test('$.find: find object result should be ok', () => {

  214.     const G = $(OBJECT_CODE);

  215.     const code = G.find(`const a = $_$`).generate();

  216.     expect(code.indexOf(`name: 'jerry',`) > -1).toBeTruthy();

  217. })

  218. test('$.find: find argument', () => {

  219.     expect(()=>{

  220.        const G = $(CODE);

  221.        G.find(`test($_$)`);

  222.     }).not.toThrow();

  223. })

  224. test('$.find: find argument result should be ok', () => {

  225.     const G = $(CODE);

  226.     const code = G.find(`test($_$)`).generate();

  227.     expect(code).toBe('test(11)');

  228. })

  229. test('$.find: find argument and body', () => {

  230.     expect(()=>{

  231.        const G = $(CODE);

  232.        G.find(`function test($_$){$_$}`);

  233.     }).not.toThrow();

  234. })

  235. test('$.find: find argument and body should be ok', () => {

  236.     const G = $(CODE);

  237.     const code = G.find(`function test($_$){$_$}`).generate();

  238.     expect(code.indexOf('function test(c){') > -1 &&

  239.         code.indexOf('let a = 1;') > -1

  240.     ).toBeTruthy()

  241. })

  242. test('$.find: find in function should be ok', () => {

  243.     const G = $(CODE);

  244.     const code = G.find(`function $_$() {

  245.         let a = 1;

  246.       }`).generate();

  247.     expect(code.indexOf('function test(c){') > -1 &&

  248.         code.indexOf('let a = 1;') > -1

  249.     ).toBeTruthy()

  250. })

  251. test('$.find: find in function should be ok', () => {

  252.     let has = false;

  253.     const G = $(CODE);

  254.     G.find(`function $_$() {  }`)

  255.     .each(item => {

  256.         if(item.has('let a = 1;')){

  257.             has = true;

  258.         }

  259.     })

  260.     expect(has).toBeTruthy();

  261. })

  262. test('$.find: find function should be ok', () => {

  263.     let has = false;

  264.     const G = $(CODE);

  265.     G.find(`$_$()`)

  266.         .each(item => {

  267.             has = true;

  268.         })

  269.     expect(has).toBeTruthy();

  270. })

  271. test('$.find: find function should be ok', () => {

  272.     let has = false;

  273.     const G = $(jc1);

  274.     G.find(`parent().$_$()`)

  275.         .each(item => {

  276.             has = true;

  277.         })

  278.     expect(has).toBeTruthy();

  279. })

  280. test('$.find: find function should be ok', () => {

  281.     let has = false;

  282.     const G = $(CODE);

  283.     G.find(`test()`)

  284.         .each(item => {

  285.            has = true;

  286.         })

  287.     expect(has).toBeTruthy();

  288. })

  289. test('$.find: find "for" code should be ok', () => {

  290.     const G = $(jc2);

  291.     const code = G.find(`for($_$1;$_$2;$_$3){$_$4}`).generate();

  292.     expect(code.indexOf('for (let i = 0; i < array.length; i++) {') > -1 &&

  293.         code.indexOf('const element = array[i];') > -1

  294.     ).toBeTruthy()

  295. })

  296. test('$.find: find "for" code should be ok', () => {

  297.     const G = $(jc2);

  298.     const match = G.find(`for($_$1;$_$2;$_$3){$_$2}`).match;

  299.     expect(match['1'].length === 1 && match['2'].length === 2 && match['3'].length === 1).toBeTruthy();

  300. })

  301. // test('$.find: find in "switch" code should be ok', () => {

  302. //     const G = $(jc2);

  303. //     const code = G.find(`switch ($_$) {$_$}`).generate();

  304. //     expect(code.indexOf('switch (a)') > -1 &&

  305. //         code.indexOf(' case 1:') > -1

  306. //     ).toBeTruthy()

  307. // })

  308. // TODO

  309. test('$.find: find in "catch" code should be ok', () => {

  310.     const G = $(jc2);

  311.     const code = G.find(`try {$_$} catch (e) {$_$}`).generate();

  312.     expect(code.indexOf('try') > -1 &&

  313.         code.indexOf(' catch') > -1

  314.     ).toBeTruthy()

  315. })

  316. // test('$.find: find in "catch" code should be ok', () => {

  317. //     //  如何处理非完整try catch 语句？？

  318. //     const G = $(jc2);

  319. //     const code = G.find(`try {$_$} `).generate();

  320. //     expect(code.indexOf('try') > -1 

  321. //     ).toBeTruthy()

  322. // })

  323. // TODO

  324. 

  325. // test('$.find: find in "catch" code should be ok', () => {

  326. //      //  如何处理非完整try catch 语句？？

  327. //     const G = $(jc2);

  328. //     const code = G.find(`catch (e) {$_$}`).generate();

  329. //     expect(code.indexOf('try') > -1 

  330. //     ).toBeTruthy()

  331. // })

  332. test('$.find: find super in ts',()=>{

  333.     const nodes = [];

  334.     const code = $(tc1)

  335.         .find(`super($_$,$_$,$_$)`, { ignoreSequence: true })

  336.         .each(item => {

  337.             item.after('console.log("super")')

  338.         }).root().generate();

  339.     $(code).find(`console.log("super")`).each(item => {

  340.         nodes.push(item);

  341.     })

  342.     const result = nodes.length === 1 &&

  343.     nodes[0].siblings().generate().indexOf(`super(options.baseWidth, options.baseHeight, options);`) > -1;

  344.     expect(result).toBeTruthy();

  345.  })

  346. test('$.find: find constructor in ts', () => {

  347.     const nodes = [];

  348.     const code = $(tc1)

  349.         .find(`constructor($_$){}`)

  350.         .append('body', 'console.log("constructor")')

  351.         .root()

  352.         .generate();

  353.     $(code).find(`console.log("constructor")`).each(item => {

  354.         nodes.push(item);

  355.     })

  356.     const result = nodes.length === 1

  357.     expect(result).toBeTruthy();

  358. })

  359. test('$.find: find all',()=>{

  360.    const nodes = [];

  361.     $(jc1)

  362.         .find('$_$')

  363.         .each(item => {

  364.             nodes.push(item);

  365.         })

  366.   expect(nodes.length > 0).toBeTruthy();

  367. })

  368. test('$.find: find h',()=>{

  369.     const nodes = [];

  370.      $(jc1)

  371.          .find('h')

  372.          .each(item => {

  373.              nodes.push(item);

  374.          })

  375.    expect(nodes.length > 0).toBeTruthy();

  376.  })

  377. test('$.find: 获取表达式中的变量', () => {

  378.     const members = [];

  379.     $(`(a.b.c && b) || (c && d)`)

  380.         .find('$_$')

  381.         .each(item => {

  382.             if (item.parent().node.type == 'MemberExpression' && item.parent(1).node.type != 'MemberExpression') {

  383.                 // 输出a.b.c整体 而不是a \ b \ c

  384.                 members.push(item.parent().generate())

  385.             } else if (item.parent().node.type != 'MemberExpression') {

  386.                 // 输出独立的变量

  387.                 members.push(item.generate())

  388.             }

  389.         })

  390.     expect(members[0] === 'a.b.c' &&

  391.         members[1] === 'b' &&

  392.         members[2] === 'c' &&

  393.         members[3] === 'd'

  394.     ).toBeTruthy();

  395. })

  396. test('$.find: find string', () => {

  397.     const nodes = [];

  398.     $(jc1)

  399.         .find(`'$_$'`)

  400.         .each(item => {

  401.             nodes.push(item);

  402.         })

  403.   expect(nodes[0].generate() === `'../index'`).toBeTruthy();

  404. })

  405. test('$.find: find string', () => {

  406.     const nodes = [];

  407.     $(jc1)

  408.         .find(`'this is string'`)

  409.         .each(item => {

  410.             nodes.push(item);

  411.         })

  412.   expect(nodes[0].generate() === `'this is string'`).toBeTruthy();

  413. })

  414. test('$.find: find 获取赋值语句', () => {

  415.     const matchList = [];

  416.     $(jc1)

  417.         .find(`$_$1 = $_$2`)

  418.         .each(item => {

  419.             matchList.push(item.match[1]);

  420.         })

  421.   expect(matchList[0][0].value === `a`).toBeTruthy();

  422. })

  423. 

  424. test('$.find: find 获取赋值语句', () => {

  425.     const matchList = [];

  426.     $(jc1)

  427.     .find('a = $_$')

  428.     .each(item => {

  429.         matchList.push(item.match[0])

  430.      })

  431.   expect(matchList[0][0].value).toBe(3);

  432. })

  433. test('$.find: find 获取赋值语句', () => {

  434.     const matchList = [];

  435.     $(jc1)

  436.     .find('car.color = $_$')

  437.     .each(item => {

  438.         matchList.push(item.match[0])

  439.      })

  440.   expect(matchList[0][0].value).toBe('green');

  441. })

  442. test('$.find: find 获取赋值语句', () => {

  443.     const matchList = [];

  444.     $(jc1)

  445.     .find('$_$1.color = $_$2')

  446.     .each(item => {

  447.         matchList.push(item.match['1'])

  448.      })

  449.   expect(matchList[0][0].value).toBe('car');

  450. })

  451. test('$.find: find 获取赋值语句 arr', () => {

  452.     const matchList = [];

  453.     $(jc1)

  454.     .find('$_$ = [1, 2]')

  455.     .each(item => {

  456.         matchList.push(item.match[0])

  457.      })

  458.   expect(matchList[0][0].value).toBe('arr');

  459. })

  460. test('$.find: 在某作用域里面获取变量定义', () => {

  461.     const matchList = [];

  462.     const code = $(jc1)

  463.     .find(`const obj = { name: 'test' };`)

  464.     .parent().generate();

  465. const compareCode = $(

  466. `{

  467.     function test(){

  468.         let a = 1;

  469.     }

  470.     const obj = { name: 'test' };

  471. }`).generate();

  472.   expect(code).toBe(compareCode);

  473. })

  474. test('$.find: class define use $_$', () => {

  475.     const code = $(jc5)

  476.     .find('class $_$ {}').generate();

  477.     const result = code.indexOf('class Car {') > -1;

  478.     expect(result).toBeTruthy();

  479. })

  480. test('$.find: class define', () => {

  481.     const code = $(jc5)

  482.     .find('class Car {}').generate();

  483.     const result = code.indexOf('class Car {') > -1;

  484.     expect(result).toBeTruthy();

  485. })

  486. test('$.find: class define', () => {

  487.     const match = $(jc5)

  488.         .find(`class Car {

  489.         color = $_$c;

  490.         size = $_$s;

  491.       }`).match;

  492.     const result = match['c'][0].value === 'red' && match['s'][0].value === 12;

  493.     expect(result).toBeTruthy();

  494. })

  495. test('$.find: ts type define', () => {

  496.     let find = false;

  497.     $(jc6)

  498.         .find('CheckBoxProps')		// 找到的有可能是变量名，也有可能是类型定义

  499.         .each(item => {

  500.             if (item.parent().node.type == 'TSTypeReference') {

  501.                 find = true;

  502.             }

  503.         })

  504.     expect(find).toBeTruthy();

  505. })

  506. test('$.find: ts type define', () => {

  507.     const match = $(jc6)

  508.         .find('let $_$1:CheckBoxProps = $_$2')		

  509.         .match;

  510.     const result = match['1'][0].value === 'cbp' && match['2'][0].value === '{\n  checked: true,\n  width: 100\n}';

  511.     expect(result).toBeTruthy();

  512. })

  513. test('$.find: ts type define in function', () => {

  514.     const match = $(jc6)

  515.         .find('($_$: CheckBoxProps) => {}')		

  516.         .match;

  517.     const result = match[0][0].value === 'props' ;

  518.     expect(result).toBeTruthy();

  519. })

  520. test('$.find: find import ', () => {

  521.     const match = $(jc2)

  522.         .find(`import $_$1 from '$_$2'`)		

  523.         .match;

  524.     const result = match['1'][0].value === 'moment' ;

  525.     expect(result).toBeTruthy();

  526. })

  527. test('$.find: find import ', () => {

  528.     const match = $(jc1)

  529.         .find(`export $_$ from '@path/sth'`)		

  530.         .match;

  531.     const result = match[0][0].value === 'sth' ;

  532.     expect(result).toBeTruthy();

  533. })

  534. 

  535. test('$.find: render property', () => {

  536.     const match = $(`const a = {

  537.         render: function() {}

  538.       }`)

  539.         .find('render: function() {}')		

  540.     const result = !!match[0];

  541.     expect(result).toBeTruthy();

  542. })

  543. 

  544. test('$.find: find 模拟解构赋值 ', () => {

  545.     // 找到const {a,b = {b1},c = 3} = d; 转为const a = d.a, b = d.b || {b1}, c = d.c || 3;

  546. 

  547.     const code = $(`const {a,b = {b1},c = 3} = d`)

  548.         .find('const { $_$1 = $_$2 } = $_$3')

  549.         .each(item => {

  550.             const keyList = item.match[1].filter((item, i) => i % 2 == 0)

  551.             const obj = item.match[3][0].value

  552.             const newkeyList = keyList.map((key, i) => {

  553.                 let dec = `${key.value} = ${obj}.${key.value}`

  554.                 if (item.match[2][i].value != key.value) {

  555.                     dec += ('||' + item.match[2][i].value)

  556.                 }

  557.                 return dec

  558.             })

  559.             item.replaceBy(`const ${newkeyList.join(', ')}`)

  560.         })

  561.         .root()

  562.         .generate()

  563.     const result = code.indexOf('const a = d.a, b = d.b||{b1}, c = d.c||3') > -1;

  564.     expect(result).toBeTruthy();

  565. })

  566. test('$.find: simple1 html code', () => {

  567.     expect(() => {

  568.         const G = $(hc1, config.html).find('<span>$_$</span>');

  569.     }).not.toThrow();

  570. })

  571. test('$.find: simple1 html code input is object result should be ok', () => {

  572.     const G = $(hc1, config.html);

  573.     // 选择器构造 抛出异常报错

  574.     const code = G.find({ nodeType: 'text', content: G.expando }).generate();

  575.     //待定

  576.     expect(code).toBe("\n");

  577. })

  578. 

  579. test('$.find: simple1 html code input is object result should be ok', () => {

  580.     const G = $(hc1, config.html);

  581.     // 选择器构造 抛出异常报错

  582.     const code = G.find({ nodeType: 'tag', content: G.expando }).generate();

  583.     //待定

  584.     expect(code.indexOf('<html>') > -1).toBeTruthy();

  585. })

  586. 

  587. test('$.find: simple1 html code result should be ok', () => {

  588.     const G = $(hc1, config.html).find('<span>');

  589.     const code = G.generate();

  590.     expect(code).toBe('<span>test</span>')

  591. })

  592. test('$.find: simple1 html code use $_$ result should be ok', () => {

  593.     const G = $(hc1, config.html).find('<span>$_$</span>');

  594.     const code = G.generate();

  595.     expect(code).toBe('<span>test</span>')

  596. })

  597. test('$.find: simple1 html code use full tag result should be ok', () => {

  598.     const G = $(hc1, config.html).find('<span>test</span>');

  599.     const code = G.generate();

  600.     expect(code).toBe('<span>test</span>')

  601. })

  602. test('$.find: simple1 html code find attr value', () => {

  603.     const G = $(hc1, config.html).find('<div id=$_$>');

  604.     const match = G.match;

  605.     expect(match[0][0].value).toBe('1');

  606. })

  607. test('$.find: simple1 html code find attr key', () => {

  608.     const G = $(hc1, config.html).find('<div $_$="1">');

  609.     const match = G.match;

  610.     expect(match[0][0].value).toBe('id');

  611. })

  612. test('$.find: simple1 html code find DOCTYPE ', () => {

  613.     const G = $(hc1, config.html).find('<!DOCTYPE html>');

  614.     const match = G.match;

  615.     // 无$_$ 无match返回也合理

  616.     // expect(match[0].value).toBe('');

  617. })

  618. test('$.find: script code result should be ok', () => {

  619.     const G = $(hc1, config.html);

  620.     const result = G.find('<script>$_$</script>');

  621.     const match = result.match;

  622.     expect(match[0][0].value).toBe(` var a = '1';`);

  623. })

  624. test('$.find: style code result should be ok', () => {

  625.     const G = $(hc1, config.html);

  626.     const result = G.find('<style>$_$</style>');

  627.     const match = result.match;

  628.     expect(match.indexOf('color: #000;') > -1).toBeTruthy();

  629. })

  630. test('$.find: comment code result should be ok', () => {

  631.     const G = $(hc1, config.html);

  632.     const result = G.find('<!-- $_$ -->');

  633.     const match = result.match;

  634.     expect(match).toBe(` comment test `);

  635. })

  636. test('$.find: replace html tag result should be ok', () => {

  637. 

  638.     const G = $(hc1, config.html);

  639.     

  640.     const code = G.find('<form $_$>$_$</form>').each((ast)=>{

  641.         ast.node.content.name = 'mx-form'

  642.     }).root().generate();

  643.     

  644.     expect(code.indexOf('<form') < 0 && code.indexOf('<mx-form') > -1).toBeTruthy();

  645. 

  646. })

  647. 

  648. test('$.find: find script tag content', () => {

  649.     const G = $(hc2, config.html);

  650.     let appScriptCount = 0;

  651.     const AST = G.find('<script>$_$</script>').each(function (ast) {

  652.         //找到两个script标签有内容，实际上应该只有一个

  653.         if (ast.match) {

  654.             appScriptCount++;

  655.         }

  656.     });

  657.     expect(appScriptCount).toBe(1);

  658. })

  659. 

  660. test('$.find: find objproperty', () => {

  661.     const AST = $(

  662.         `

  663.         import Vue from 'vue';

  664.         export default {

  665.             name: 'cd',

  666.             props: {

  667.               msg: String,

  668.             },

  669.             directives: {

  670.               highlight: {

  671.                 bind(el, binding, vnode) {

  672.                   el.style.background = binding.value;

  673.                 },

  674.                 inserted(el, binding) {

  675.                   el.parentNode.style.border = \`1px solid \${binding.value}\`;

  676.                 }

  677.               },

  678.             },

  679.           };`

  680.     ).find(`

  681.     directives: {

  682.       $_$1: {

  683.         bind($_$2, $_$3, $_$4) {

  684.           $$$1

  685.         },

  686.       },

  687.     }

  688.     `)

  689.     expect(AST).toBeTruthy();

  690. })

  691. 

  692. test('$.find: find comments 1', () => {

  693.     const res = $(`// c3

  694.     aaaa

  695.     // c1

  696.     var a = 1;

  697.     // c2

  698.     function x () {

  699.         // c3

  700.         // c3

  701.         i++

  702.         // c3

  703.         // c4

  704.         /* sdsd

  705. 

  706.         sdads

  707.         */

  708.        // c3

  709.     }

  710.     // c3`)

  711.     .find('// $_$')

  712.     .each(item => {

  713.         item.value.value += '>>>>>'

  714.     })

  715.     .root()

  716.     .generate()

  717.     expect(res.match('>>>>')).toBeTruthy();

  718. })

  719. 

  720. test('$.find: find comments 1', () => {

  721.     const res = $(`

  722.     // c1

  723.     var a = 1;

  724.     // c2

  725.     function x () {

  726.         i++

  727.         // c3

  728.         /* sdsd

  729. 

  730.         sdads

  731.         */

  732.     }`)

  733.     .find('/* $_$ */')

  734.     .each(item => {

  735.         item.value.value += '>>>>>'

  736.     })

  737.     .find('// $_$')

  738.     .each(item => {

  739.         item.value.value += '<<<<<'

  740.     })

  741.     .root()

  742.     .generate()

  743.     expect(res.match('>>>>')).toBeTruthy();

  744. })

  745. 

  746. test('$.find: html close tag', () => {

  747.     const G = $(`<hhh>222

  748.         <hhh>111</hhh>

  749.         <hhh/>

  750.         <hhh/>

  751.         <hhh>333</hhh>

  752.     </hhh>`, config.html);

  753.     const result = G.find(['<hhh></hhh>', '<hhh/>']);

  754.     expect(result.length == 5).toBeTruthy();

  755. })

  756. 

  757. test('$.find: should not find vue template',()=>{

  758.     const code = `

  759.     <script>

  760.     import Vue from "vue";

  761.     export default {

  762.     };

  763.     </script>`;

  764.     const has = $(code, config.vue)

  765.         .find('<template></template>').length > 0;

  766.     expect(has).not.toBeTruthy()

  767. })

  768. 

  769. 

  770. test('$.find: should not find vue script', () => {

  771.     const code = `

  772.     <template>

  773.     <div class="context-menu-list">

  774.       <slot></slot>

  775.     </div>

  776.   </template>`;

  777.     const has = $(code, config.vue)

  778.         .find('<script></script>').length > 0;

  779.     expect(has).not.toBeTruthy()

  780. })

  781. 

  782. test('$.find: should not find vue script', () => {

  783.     const code = `

  784.     <template>

  785.     <div class="context-menu-list">

  786.       <slot></slot>

  787.     </div>

  788.   </template>`;

  789.     const res = $(code, config.vue)

  790.         .find('<script></script>')

  791.         .root()

  792.         .generate();

  793.     expect(res.match('template')).toBeTruthy()

  794. })

  795. 

  796. test('$.find: find import', () => {

  797.     const code = `

  798.     import foo from './foo'

  799.     import { MuxButton, MuxSelect } from '@alife/mux-components'

  800.     import lodash, { add } from 'lodash'

  801.     import Antd from 'antd'`;

  802. 

  803.     console.log(`import $$$1, {$$$2} from '$_$1'`)

  804.     $(code)

  805.         .find(`import $$$1, {$$$2} from '$_$1'`)

  806.         .each(item => console.log(item.generate()));

  807. 

  808.     console.log(`import $$$1 from '$_$1'`)

  809.     $(code)

  810.         .find(`import $$$1 from '$_$1'`)

  811.         .each(item => console.log(item.generate()));

  812. 

  813.     console.log(`import { $$$1 } from '$_$1'`)

  814.     $(code)

  815.         .find(`import { $$$1 } from '$_$1'`)

  816.         .each(item => console.log(item.generate()));

  817. 

  818.     expect(true).toBeTruthy()

  819. })

  820. 

  821. test('$.find: find import', () => {

  822.     const res = $(`

  823. $t('s')

  824. $t('sss')

  825. 's'`)

  826.     .replace('$t($_$)', (match => {

  827.       if (match[0][0].value == 's') {

  828.         return `global.$t($_$)`

  829.       } else return null

  830.     }))

  831.     .root()

  832.     .generate()

  833. 

  834.     expect(res.match(`global`)).toBeTruthy()

  835. })

  836. 

  837. test('$.find: find script setup', () => {

  838.     const res = $(`

  839.     <script setup>

  840.     const a = inject('global')

  841.     </script>

  842.     <template>

  843.     </template>`, { parseOptions: { language: 'vue' }})

  844.         .find('<script setup></script>')

  845.         .find(`const $_$1 = inject('global')`)

  846.         .generate()

  847. 

  848.     expect(res.match('global')).toBeTruthy()

  849. })

  850. 

  851. test('$.find: find script setup', () => {

  852.     const res = $(`

  853.     <script setup>

  854.     </script>

  855.     <template>

  856.         <div a="1" b="s">

  857.             <div c="1222" b="s">

  858.                 

  859.             </div>

  860.         </div>

  861.     </template>`, { parseOptions: { language: 'vue' }})

  862.         .find('<template></template>')

  863.         .find(`<$_$1 $$$></$_$1>`)

  864.         .each(item => {

  865.             item.match['$$$$'].forEach(attr => {

  866.                 if (attr.value.content == 's') {

  867.                     attr.value.content = 'handle("s")'

  868.                 }

  869.             })

  870.         })

  871.         .generate()

  872. 

  873.     expect(res.match('handle')).toBeTruthy()

  874. })

  875. 

  876. test('$.find: match typeAnnotation', () => {

  877.     const res = $(`

  878.         export default async (

  879.             data: Request<{ msg: string }>

  880.         ): Promise<string> => {

  881. 

  882.             return data.msg

  883.         }

  884.     `)

  885.         .find(`export default async ($$$1): $_$2 => { $$$3 }`)

  886.         .match[2]

  887. 

  888.     expect(res[0].type == 'TSTypeReference').toBeTruthy()

  889. })

  890. 

  891. test('$.find: match typeAnnotation', () => {

  892.     const res = $(`

  893.         export default async (

  894.             data: Request<{ msg: string }>

  895.         ): Promise<string> => {

  896. 

  897.             return data.msg

  898.         }

  899.     `)

  900.         .find(`export default async ($$$1): $_$1<$_$2> => { $$$3 }`)

  901.         .match

  902. 

  903.     expect(res[1][0] && res[2][0]).toBeTruthy()

  904. })

  905. 

  906. test('$.find: match Vue.createApp', () => {

  907.     const find = $(`

  908.     import App from './App';

  909.     window.$vueApp.use();

  910.     const app = window.$vueApp = Vue.createApp(App).mount('#app');

  911.     window.$vueApp.config.globalProperties.routerAppend = (path, pathToAppend) => {

  912.         return path + (path.endsWith('/') ? '' : '/') + pathToAppend; };

  913.     

  914.     `)

  915.         .find(`Vue.createApp(App).mount('#app')`)

  916. 

  917. 

  918.     expect(find.length > 0).toBeTruthy()

  919. })

  920. 

  921. test('$.find: match typeAnnotation', () => {

  922.     const res = $(`const c = () => x;

  923.     const d = function () {

  924.         console.log('ddd');

  925.     }`)

  926.     .find(`() => $_$`)

  927. 

  928.     expect(res.match[0][0].value == 'x').toBeTruthy()

  929. })

  930. 

  931. test('$.find: replace html tag result should be ok', () => {

  932.     const res = $(`

  933.     var e;

  934.         var a = 1, b=2, d, c=3;

  935. 

  936.         function xxx(){

  937.             return a = 5, b=6, c=7, 8;

  938.         }

  939. 

  940.         if(a=5,b=6,c=7,d){

  941.             

  942.         }

  943.     `)

  944.     .find(`var $_$1 = $_$2`)

  945.     .each(item => {

  946.         item.match

  947.     })

  948.     expect(!!res).toBeTruthy();

  949. 

  950. })

  951. 

  952. test('$.find: match string', () => {

  953.     let res = '';

  954.     $('`/aa/bb/${cc}/cccccc/${s}`')

  955.         .find('`$_$1\${$_$2}`')

  956.         .each(item => {

  957.             res = item.match[1].length + item.match[2].length

  958.         })

  959.     expect(res == 5).toBeTruthy()

  960. })

  961. 

  962. 

  963. test('$.find: $$$ match ObjectMethod', () => {

  964.     let res =

  965.     $(`

  966.     Component({

  967.         mixins: [],

  968.         methods: {

  969.             b() {

  970.     

  971.             }

  972.         }

  973.     });

  974.     `)

  975.     .find(`Component({

  976.         $$$1,

  977.         methods: { $$$2 }

  978.       })`)

  979.     expect(res.length == 1).toBeTruthy()

  980. })

  981. 

  982. test('$.find: match string', () => {

  983.     let res = $(`function a () {

  984.         function b () {

  985. 

  986.         }

  987.     }

  988.     function c() {

  989. 

  990.     }`)

  991.         .find('function $_$() {}')

  992.     expect(res.length == 3).toBeTruthy()

  993. })

  994. 

  995. test('$.find: match string', () => {

  996.     let res = $(`{function a () {

  997.         function b () {

  998. 

  999.         }

  1000.     }

  1001.     function c() {

  1002. 

  1003.     }}`)

  1004.         .find('function $_$() {}', { deep: 'n' })

  1005.     expect(res.length == 2).toBeTruthy()

  1006. })

  1007. 

  1008. test('$.find: match string', () => {

  1009.     let res = $(`<div>

  1010.         <p v-if=""></p>

  1011.     </div>`, { parseOptions: { language: 'html'}})

  1012.         .find(`

  1013.         <p></p>`)

  1014.     expect(res.length == 1).toBeTruthy()

  1015. })

  1016. 

  1017. test('$.find: match string', () => {

  1018.     let res = $(`<script attr="5" data="10" ></script> `, { parseOptions: { language: 'html'}})

  1019.         .find(`<script attr="$_$1" $$$1></script>`)

  1020.     expect(res.match[1] && res.match['$$$1']).toBeTruthy()

  1021. })

  1022. 

  1023. // test('$.find: match string', () => {

  1024. //     let res = $(`const car1 = {

  1025. //         size: 'small',

  1026. //         color: 'red',

  1027. //         init(a, b) {

  1028.           

  1029. //         }

  1030. //       } `)

  1031. //         .find(`{

  1032. //             init() {}

  1033. //           }`)

  1034. //     expect(res.length == 1).toBeTruthy()

  1035. // })

  1036. 

  1037. test('$.find: match string', () => {

  1038.     let res = $(`const car1 = {

  1039.         size: 'small',

  1040.         color: 'red',

  1041.         init(a, b) {

  1042.           

  1043.         }

  1044.       } `)

  1045.         .find(`{

  1046.             color: 'red'

  1047.           }`)

  1048.     expect(res.length == 1).toBeTruthy()

  1049. })

  1050. 

  1051. 

  1052. test('$.find: match string', () => {

  1053.     let res = $(`import 'foo.css';

  1054.     import { a } from 'bar';

  1055.     import b from 'baz';

  1056.     import c, { d } from 'far';`)

  1057.         .find(`import { $$$ } from '$_$';`)

  1058.     expect(res.length == 2).toBeTruthy()

  1059. })

  1060. 

  1061. test('$.find: match string', () => {

  1062.     let res = $(`import 'foo.css';`)

  1063.         .find(`import { $$$ } from '$_$';`)

  1064.     expect(res.length == 0).toBeTruthy()

  1065. })