Get best of the week

Colorir textos em html e React

É fácil adicionar marcação ao texto com as mãos. Você pode marcar o texto aqui em Habré e copiá-lo para o site. Você pode fazer uma pesquisa com uma substituição no Notepad ++ ou no Atom.

Se for 1 texto. Se houver muitos textos, desejo ter uma ferramenta para extrair fragmentos de texto com tags html ou gerar código-fonte para o React. No Python, isso não é difícil (algumas linhas de código por cor).



Se você conhece Python e expressões regulares, siga o link.

Existem exemplos e códigos-fonte. Sob katom, uma descrição detalhada.

Marcação de texto, por exemplo, colorindo o código-fonte Javascript


Considere a função:

def jsToHtml(s):

Na entrada, o texto de origem retorna html.

Definimos as variáveis ​​que definem os atributos dos blocos. No exemplo, os estilos são usados ​​para maior clareza; no futuro, é mais lógico substituí-los por classes.

comm = 'style="color: red;"' #   
blue = 'style="color: blue;"' # 
...

Marcação.

A primeira coisa a fazer é escapar dos caracteres '&', '<', '>'

s = s.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')

'&' é escapado para exibir as combinações de letras '& lt;', '& gt;' e outros '& ...;', Os

caracteres '<' e '>' são escapados para não entrar em conflito com as tags.

Você pode proteger muitas coisas, mas, na minha opinião, no utf-8 isso é suficiente.

Algoritmo de marcação:

  • Tomamos um reformulação e procuramos por todos os fragmentos de texto que o satisfazem.
  • Recortamos cada fragmento, adicionamos marcações a ele e salvamos o fragmento marcado em uma matriz (ao mesmo tempo, salve o texto original: será útil).
  • Em seu lugar, insira o esboço com o número.
  • E assim para todas as cores.
  • Quando tudo estiver pintado, substitua os stubs por fragmentos coloridos da matriz.

O stub deve ser único, mas em nosso texto não existe um único caractere '<' e nem um único '>'.

Fazendo um esboço:

f'<{i}>'

onde i é o número do esboço. Definitivamente, não existe tal coisa no texto.

O que fazer se já houver um esboço dentro do fragmento.

Por exemplo, no texto de origem, havia linhas:

`  :   /*     */ `
/* , `     ` */

Opções 2:

  1. Ignorar. Nesse caso, a sequência terá uma cor dupla.
  2. Encontre stubs aninhados e substitua-os pelo texto original (não marcado).

Nós criamos uma função que implementa tudo isso (10 linhas de código, 10 linhas de comentário):

def oneRe(reStr, s, attr, ls, multiColor=False):
    '''
        s  ,          ls,
           (<0>, <1> ...<1528>...).
          .
    
    reStr - re
    s - 
    attr -  style/class/etc
    ls -   
    multiColor=False,     
    '''
    for block in set(re.findall(reStr, s)):
        toArr = block
        if not multiColor: #  multiColor==False,   
            for prev in set(re.findall(r'<[\d]+>', block)): #  : <0> ... <21>
                iPrev = int(prev[1:-1], 10)                #     
                toArr = toArr.replace(prev, ls[iPrev][1])  #   '<0> qwe <21>'  (<0>,<21>)  . 
        ls.append([f'<span {attr}>{toArr}</span>', toArr]) #     ls 2 :     
        s = s.replace(block, f'<{len(ls)-1}>')
    return s

Esta é uma demonstração: a marcação da expressão regular pode estar incorreta, caracteres de escape (\ ', \ ") não são processados.

Para referência: expression:

s = s.replace(/A + B/g, 'A - B');

Os editores do Notepad ++ e Atom têm cores diferentes.

Agora que existe um Re , a coloração dos fragmentos é feita com simplicidade. Um exemplo para colorir as linhas entre apóstrofos e aspas:

s = oneRe(r"'[\s\S]*?'", s, green, ls, multiColor=False) #    ''   ls
s = oneRe(r'"[\s\S]*?"', s, green, ls, multiColor=False) #    ""   ls

Um exemplo de coloração mais complexa. Precisa de js para colorir expressões em várias linhas
`    ${A + B}  ${A - B}`


for mStr in set(re.findall(r'`[\s\S]+?`', s)): #    
    newFstr = mStr
    for val in set(re.findall(r"\$\{[\s\S]+?\}", mStr)):
        ls.append([f'<span {darkRed}>{val}</span>', val])
        newFstr = newFstr.replace(val, f'<{i}>')
        i += 1
    s = s.replace(mStr, newFstr)
    
s = oneRe(r'`[\s\S]+?`', s, green, ls, multiColor=True) #    ``   ls

primeiro encontramos as multi-

strings : re.findall (r`` [\ s \ S] +? '', s) retorna uma lista de blocos de texto entre caracteres de aspas.

Cada bloco contém espaços ou não espaços ([\ s \ S], ou seja, qualquer coisa).

Comprimento do bloco 1 ou mais (+).

Sem ganância ("?" Significa que não há símbolo "` "dentro do bloco).

Copie o bloco encontrado (variável mStr ) para a variável newFstr .
Encontramos nos sub-blocos as expressões $ {...}.

re.findall (r "\ $ \ {[\ s] *? \}", mStr) retorna uma lista desses sub-blocos. Nós salvamos a marcação na matriz ls e substituímos o sub-bloco pelo stub na variável newFstr .
Quando os sub-blocos acabarem, substitua na string original svalor do bloco original para novo.

O conjunto não é supérfluo. Se findall retornar vários blocos idênticos, ao processar o primeiro bloco no código-fonte, todos os blocos idênticos serão substituídos por stubs de uma só vez. Ao processar o segundo mesmo bloco, ele não estará mais no texto de origem. O conjunto remove a duplicação.

Arquivo JsToHtml.py
# -*- coding: utf-8 -*- 
'''
AON 2020

'''

import re

# *** *** ***

def oneRe(reStr, s, attr, ls, multiColor=False):
    '''
        s  ,          ls,
           (<0>, <1> ...<1528>...).
          .
    
    reStr - re
    s - 
    attr -  style/class/etc
    ls -   
    multiColor=False,     
    '''
    i = len(ls) #   
    for block in set(re.findall(reStr, s)):
        toArr = block
        if not multiColor: #  multiColor==False,   
            for prev in set(re.findall(r'<[\d]+>', block)): #  : <0> ... <21>
                iPrev = int(prev[1:-1], 10)                 #     
                toArr = toArr.replace(prev, ls[iPrev][1])   #   '<0> qwe <21>'  (<0>,<21>)  . 
        ls.append([f'<span {attr}>{toArr}</span>', toArr])  #     ls 2 :     
        s = s.replace(block, f'<{i}>')              #       
        i += 1
    return s

# *** *** ***

def operColor(s, ls, color):
    '''
     .
      ,       ,  
    '''
    i = len(ls)
    for c in ['&lt;=', '&gt;=', '=&lt;', '=&gt;', '&lt;', '&gt;', '&amp;&amp;', '&amp;',
              '===', '!==', '==', '!=', '+=', '-=', '++', '--', '||']:
        ls.append([f'<span {color}>{c}</span>',0])
        s = s.replace(c, f'<{i}>')
        i += 1
    for c in '!|=+-?:,.[](){}%*/':
        ls.append([f'<span {color}>{c}</span>',0])
        s = s.replace(c, f'<{i}>')
        i += 1
    return s

# *** *** ***

def jsToHtml(s):
    '''
      .
     ,        <span>.
    '''

    black = '''style="font-family: 'Courier New', monospace;
        background: #fff; 
        color: black;
        font-weight: bold;
        border: 1px solid #ddd;
        padding: 5px;
        text-align: left;
        white-space: pre;"'''
    comm = 'style="color: red;"'
    green = 'style="color: green; font-style: italic;"'
    blue = 'style="color: blue;"'
    red2 = 'style="color: #840;"'

    s = s.replace('&', '&amp;').replace('<', &'&lt;').replace('>', '&gt;')   #   '&', '<', '>'

    ls = []

    i = 0
    for mStr in set(re.findall(r'`[\s\S]+?`', s)): #    
        newFstr = mStr
        for val in set(re.findall(r"\$\{[\s\S]+?\}", mStr)):
            ls.append([f'<span {darkRed}>{val}</span>', val])
            newFstr =newFstr.replace(val, f'<{i}>')
            i += 1
        s = s.replace(mStr, newFstr)
        
    s = oneRe(r'`[\s\S]+?`', s, green, ls, multiColor=True) #    ``   ls
    s = oneRe(r"'[\s\S]*?'", s, green, ls, multiColor=False) #    ''   ls
    s = oneRe(r'"[\s\S]*?"', s, green, ls, multiColor=False) #    ""   ls
    s = oneRe(r'/[\s\S].*?/g\b', s, green, ls, multiColor=False) #    re-   ls
    s = oneRe(r'/[\s\S].*?/\.', s, green, ls, multiColor=False) #    re-   ls
    s = oneRe(r'/\*[\s\S]+?\*/', s, comm, ls, multiColor=False) #    /*  */   ls (  - )
    s = oneRe(r'//[\s\S]*?\n', s, comm, ls, multiColor=False) #    //    ls (  - )

    i = len(ls)

    #    
    for c in ['new', 'JSON', 'Promise', 'then', 'catch', 'let', 'const', 'var', 'true', 'false', 'class', 'from', 'import', 'set', 'list', 'for', 'in', 'if', 'else', 'return', 'null']:
        ls.append([f'<span {blue}>{c}</span>',0])
        s = re.sub (r'\b%s\b' % c, f'<{i}>', s)
        i += 1

    #     
    for c in ['window', 'doc', 'cmd', 'init','init2', 'recalc', 'hide', 'readOnly', 'validate']:
        ls.append([f'<span {darkRed}>{c}</span>',0])
        s = re.sub (r'\b%s\b' % c, f'<{i}>', s)
        i += 1

    s = operColor(s, ls, darkBlue) #    

    for j in range(len(ls), 0, -1):  #  , , ,    
        s = s.replace(f'<{j-1}>', ls[j-1][0])

    return f'<div {black}>{s}</div>'

# *** *** ***


Html em React


Converta html em React code source em htmltoreact.com . Há também um link para o GitHub.

Isso não me agradou: em primeiro lugar, não forma exatamente o que eu preciso e, em segundo lugar, como arrastarei esse milagre para o meu servidor.

Eu escrevi o meu.

Instale a biblioteca lxml (pip install lxml ou pip3 install lxml).

Nós importamos:

from xml.dom.minidom import parseString
from lxml import html, etree

Converta texto html em texto xhtml. É quase a mesma coisa, mas todas as tags estão fechadas.

doc = html.fromstring(htmlText)
ht = etree.tostring(doc, encoding='utf-8').decode()

O parsim xhtml resultante para a casa na árvore usando a mini-casa.

dom = parseString(ht)

Criamos uma função que salta recursivamente sobre os nós e gera o resultado na forma do código-fonte React.

Após chamar parseString, a árvore dom é um nó pai que possui nós filhos que têm filhos etc.

Cada nó é um dicionário que contém sua descrição:

  • nodeName - nome do nó, sequência
  • childNodes - nós filhos, lista
  • atributos- atributos, dicionário
  • Um nó chamado #text possui nodeValue (string)

Exemplo:

<div class="A" style="color: red;">Red of course,<br> </div>

Após as transformações, obtemos:
{ 'nodeName':'div',
  'attributes': {'style': 'color: red;', 'class': 'A'},
  'childNodes': [
    {'nodeName':'#text', 'nodeValue': 'Red of course,'},
    {'nodeName':'br'},
    {'nodeName':'#text', 'nodeValue': ''},
  ],
}

Converter o dom em uma string é fácil (existe uma impressão), ao gerar o código React, substituí a classe por className e refiz o atributo style.

Nos nós de texto, '{', '}', '<', '>' são escapados.

Arquivo HtmlToReact.py
# -*- coding: utf-8 -*- 
# -*- coding: utf-8 -*- 

from xml.dom.minidom import parseString
from lxml import html, etree

# *** *** ***

_react = ''

def htmlToReact(buf):
    '''
    buf - html-
     ReactJS- 
    '''
    global _react
    _react = ''

    try:
        r = re.search('<[\\s\\S]+>', buf)
        if r:
            doc = html.fromstring(r.group(0))
            ht = etree.tostring(doc, encoding='utf-8').decode()
            xHtmlToReact(parseString(ht).childNodes[0], '')
            return _react
        else:
            return '<empty/>'
    except Exception as ex:
        s = f'htmlToReact: \n{ex}'
        print(s)
        return s

# *** *** ***

def sU(a, c):
    '''
    xlink:show   ->  xlinkShow
    font-weight  ->  fontWeight
    '''
    l, _, r = a.partition(c)
    return ( (l + r[0].upper() + r[1:]) if r else a).strip()

# *** *** ***

def xHtmlToReact(n, shift='\n    '):
    '''
       -
      ,        upperCase
       global  _react
    '''
    global _react

    if n.nodeName.lower() in ['head', 'script']:
        return
    
    _react += shift + '<' + n.nodeName.lower()
    if n.attributes:
        for k, v in n.attributes.items():
            if k == 'style':
                style = ''
                for s in v.split(';'):
                    if s.strip():
                        l, _, r = s.partition(':')
                        style += f'''{sU(l, '-')}: "{r.strip()}", '''
                if style:
                    _react += ' style={{' + style + '}}'
            elif k == 'class':
                _react += f' className="{v}"'
            else:
                kk = k.replace('xlink:href', 'href') # deprcated
                _react += f''' {sU( sU(kk, ':'), '-' )}="{v}"'''
        
    _react += '>'
    if n.childNodes:
        for child in n.childNodes:
            if  child.nodeName == '#text':
                tx = child.nodeValue
                for x in ['{', '}', '<', '>']:
                    tx = tx.replace(x, '{"' + x + '"_{_')
                tx = tx.replace('_{_', '}')
                if tx[-1] == ' ':
                    tx = tx[:-1] + '\xa0'
                _react += tx.replace('\n', '<br/>')
            else:
                xHtmlToReact(child)
                
    _react += f'{shift}</{n.nodeName.lower()}>'

# *** *** ***


Exemplos e código fonte aqui.

PS Em Habré, a coloração do código Python (e talvez outros) não é o ideal. Se a string python tiver a string & amp; , é exibido como & . Nos meus códigos, ajustei para que parecesse certo. Se Habr corrigir um erro, meus textos se cruzarão.

More articles:


All Articles