tor-browser

suggestions.test.js (5773B)

---

import { schema } from 'prosemirror-schema-basic';
import { triggerCharacter } from './suggestions';

const CUR = '\u2038';

function createPosition(text) {
 const position = text.indexOf(CUR) + 1;
 const stripped = text.replace(CUR, '');

 expect(position).toBeGreaterThan(0);
 expect(position).toBeLessThanOrEqual(stripped.length + 1);

 const doc = schema.node('doc', null, [
   schema.node('paragraph', null, [
     schema.text(stripped),
   ]),
 ]);

 return doc.resolve(position);
}

function mention(text) {
 const $position = createPosition(text);

 return triggerCharacter('@', { allowSpaces: true })($position);
}

function tag(text) {
 const $position = createPosition(text);

 return triggerCharacter('#', { allowSpaces: false })($position);
}

describe('the triggerCharacter matcher', () => {
 it('will match when cursor is immediately after a node', () => {
   const doc = schema.node('doc', null, [
     schema.node('paragraph', null, [
       schema.node('hard_break'),
       schema.text('@mention'),
     ]),
   ]);

   const $position = doc.resolve(3);
   const result = triggerCharacter('@', { allowSpaces: true })($position);

   expect(result).toMatchObject({
     text: '@mention',
   });
 });

 describe(`for tags`, () => {
   it(`won't match "${CUR}#"`, () => {
     const text = `${CUR}#`;

     expect(tag(text)).toBeUndefined();
   });

   it(`will match "#${CUR}"`, () => {
     const text = `#${CUR}`;

     expect(tag(text)).toMatchObject({
       text: '#',
     });
   });

   it(`won't match "${CUR}#tag"`, () => {
     const text = `${CUR}#tag`;

     expect(tag(text)).toBeUndefined();
   });

   it(`will match "#${CUR}tag"`, () => {
     const text = `#${CUR}tag`;

     expect(tag(text)).toMatchObject({
       text: '#tag',
       range: { from: 1, to: 5 },
     });
   });

   it(`will match "#tag-with-dashes${CUR}"`, () => {
     const text = `#tag-with-dashes${CUR}`;

     expect(tag(text)).toMatchObject({
       text: '#tag-with-dashes',
     });
   });

   it(`won't match "#tag with spaces${CUR}"`, () => {
     const text = `#tag with spaces${CUR}`;

     expect(tag(text)).toBeUndefined();
   });

   it(`won't match "#tag#with#hashes${CUR}"`, () => {
     const text = `#tag#with#hashes${CUR}`;

     expect(tag(text)).toBeUndefined();
   });

   it(`will match "#multiple${CUR} #tags #separately"`, () => {
     const text = `#multiple${CUR} #tags #separately`;

     expect(tag(text)).toMatchObject({
       text: '#multiple',
     });
   });

   it(`will match "#multiple #tags${CUR} #separately"`, () => {
     const text = `#multiple #tags${CUR} #separately`;

     expect(tag(text)).toMatchObject({
       text: '#tags',
     });
   });

   it(`will match "#multiple #tags #separately${CUR}"`, () => {
     const text = `#multiple #tags #separately${CUR}`;

     expect(tag(text)).toMatchObject({
       text: '#separately',
     });
   });

   it(`won't match "#multiple ${CUR}#tags" when cursor is outside`, () => {
     const text = `#multiple ${CUR}#tags`;

     expect(tag(text)).toBeUndefined();
   });
 });

 describe('for mentions', () => {
   it(`won't match "${CUR}@"`, () => {
     const text = `${CUR}@`;

     expect(mention(text)).toBeUndefined();
   });

   it(`will match "@${CUR}"`, () => {
     const text = `@${CUR}`;

     expect(mention(text)).toMatchObject({
       text: '@',
     });
   });

   it(`won't match "${CUR}@mention"`, () => {
     const text = `${CUR}@mention`;

     expect(mention(text)).toBeUndefined();
   });

   it(`will match "@${CUR}mention"`, () => {
     const text = `@${CUR}mention`;

     expect(mention(text)).toMatchObject({
       text: '@mention',
       range: { from: 1, to: 9 },
     });
   });

   it(`will match "@m${CUR}ention"`, () => {
     const text = `@m${CUR}ention`;

     expect(mention(text)).toMatchObject({
       text: '@mention',
     });
   });

   it(`will match "@mention${CUR}"`, () => {
     const text = `@mention${CUR}`;

     expect(mention(text)).toMatchObject({
       text: '@mention',
     });
   });

   it(`will match "@mention ${CUR}"`, () => {
     const text = `@mention ${CUR}`;

     expect(mention(text)).toMatchObject({
       text: '@mention ',
     });
   });

   it(`will match "@mentions with${CUR} spaces"`, () => {
     const text = `@mentions with${CUR} spaces`;

     expect(mention(text)).toMatchObject({
       text: '@mentions with spaces',
     });
   });

   it(`will match "@${CUR}mentions with spaces"`, () => {
     const text = `@${CUR}mentions with spaces`;

     expect(mention(text)).toMatchObject({
       text: '@mentions with spaces',
     });
   });

   it(`will match "@multiple ${CUR}@mentions"`, () => {
     const text = `@multiple ${CUR}@mentions`;

     expect(mention(text)).toMatchObject({
       text: '@multiple ',
     });
   });

   it(`will match "@multiple @${CUR}mentions"`, () => {
     const text = `@multiple @${CUR}mentions`;

     expect(mention(text)).toMatchObject({
       text: '@mentions',
     });
   });

   it(`will match "mentions with text @${CUR}before them"`, () => {
     const text = `mentions with text @${CUR}before them`;

     expect(mention(text)).toMatchObject({
       text: '@before them',
     });
   });

   it(`will match "@${CUR}mentioned@email.address"`, () => {
     const text = `@${CUR}mentioned@email.address`;

     expect(mention(text)).toMatchObject({
       text: '@mentioned@email.address',
     });
   });

   it(`won't match "normal@${CUR}email.address"`, () => {
     const text = `normal@${CUR}email.address`;

     expect(mention(text)).toBeUndefined();
   });
 });
});