jcubic's questions

Encontrei um problema estranho. Eu queria criar uma página de índice simples para o domínio, onde usei apenas a tag "subdomain". Quero ter uma lista de domínios na ultag, mas queria uma fonte monoespaçada, então coloquei tudo na tag "pre":

h1 { margin: 0 }
ul { margin-block: 0 }

<pre>
<h1>example.com</h1>
<ul>
  <li><a href="https://sub.example.com">sub.example.com</a></li>
</ul>
</pre>

Mas isso o torna ulmuito alto, posso corrigir o problema configurando display: flex-o como ul. Mas quero saber por que isso está acontecendo. Tudo com HTML e CSS deve ser determinístico e acontecer por um motivo. Verifiquei line-heighta configuração como , 1emmas isso não resolveu o problema.

Por que a tag ulinterna preé tão grande? Observe também que h1 é irrelevante aqui.

Testei isso no Brave e no Firefox e funciona da mesma forma. É um bug ou um comportamento esperado? Não vejo esse efeito no Epiphany e no Safari.

Nesta resposta Posso usar o valor auto com a propriedade calc()? o autor diz que auto não é um valor válido para a calc()expressão.

Ok, tudo bem. Mas o problema que tenho é que tenho uma propriedade CSS personalizada que quero dar um valor padrão que cancelará o calc().

O que eu tenho é este CSS:

.terminal {
    --terminal-line: calc(var(--size, 1) * (16px / var(--pixel-density, 1)) + 1px / var(--pixel-density, 1));
    height: auto;
    /* force size when user add --rows */
    height: calc((var(--terminal-line) * var(--rows)) + (var(--padding, 10) * 2px));
}

@property --rows {
    syntax: '<number>';
    inherits: true;
}

e a propriedade personalizada não existe initial-valuee, de acordo com o Google Dev Tools, ela não está realmente registrada. Então, adicionei isto:

@property --rows {
    syntax: '<number> | auto';
    inherits: true;
    initial-value: auto;
}

Isso parece funcionar como eu quero (testado no Firefox e no Chrome). Mas o problema é o Chrome Dev Tools.

É assim que a propriedade se parece:

Parece que a altura é aplicada. Efeito similar está no Firefox:

Então a questão é: qual é o valor real da propriedade height quando calc()é inválida? É autoda regra strike through ou algum outro padrão quando o valor é inválido? O que é isso? Quero ter certeza de que meu código está correto.

Com o git, você pode substituir o diff por uma ferramenta de comparação personalizada, como o difftastic, usando um arquivo de configuração global do git.

Existe uma maneira de fazer o mesmo com o grep? Você pode ter uma ferramenta grep diferente para o git, como ripgrep ou ugrep ?

É difícil encontrar alguma coisa, pois a maioria dos resultados da pesquisa mostra como usar o grep. Quando eu uso o replace, ele mostra como substituir o texto dentro do código e não como substituir o próprio grep.

Estou com um problema com minha gramática PEG em PHP que usa php-peg (o projeto tem um fork mais recente que é publicado no packagist). Meu projeto é uma bifurcação de um analisador de expressão que desejo substituir por um analisador gerado que seja muito mais fácil de modificar.

Tudo funciona bem até agora, mas tenho problemas para adicionar multiplicação implícita que faz parte dos recursos originais do projeto.

Se parece com isso:

8(5/2)

deveria multiplicar implicitamente 8 pela fração.

Minha gramática até agora tem muitos recursos, mas eu só quero saber como adicionar multiplicação implícita a um exemplo básico de calculadora parecido com este:

Number: /[0-9]+/
Value: Number > | '(' > Expr > ')' >
    function Number( &$result, $sub ) {
        $result['val'] = $sub['text'] ;
    }
    function Expr( &$result, $sub ) {
        $result['val'] = $sub['val'] ;
    }

Times: '*' > operand:Value >
Div: '/' > operand:Value >
Product: Value > ( Times | Div ) *
    function Value( &$result, $sub ) {
        $result['val'] = $sub['val'] ;
    }
    function Times( &$result, $sub ) {
        $result['val'] *= $sub['operand']['val'] ;
    }
    function Div( &$result, $sub ) {
        $result['val'] /= $sub['operand']['val'] ;
    }

Plus: '+' > operand:Product >
Minus: '-' > operand:Product >
Sum: Product > ( Plus | Minus ) *
    function Product( &$result, $sub ) {
        $result['val'] = $sub['val'] ;
    }
    function Plus( &$result, $sub ) {
        $result['val'] += $sub['operand']['val'] ;
    }
    function Minus( &$result, $sub ) {
        $result['val'] -= $sub['operand']['val'] ;
    }

Expr: Sum
    function Sum( &$result, $sub ) {
        $result['val'] = $sub['val'] ;
    }

Localizado no diretório de exemplos de projetos .

Criei um projeto de exemplo de calculadora básica no GitHub.

Eu tenho uma biblioteca e não percebi que ela estava emitindo avisos de suspensão de uso até que alguém criou um problema no GitHub. Eu habilitei:

error_reporting(E_ALL);

E corrigiu todos os avisos de depreciação. Mas a questão é: você pode fazer com que o código sempre falhe (penso em testes unitários) se houver avisos de descontinuação? Eu estava pensando em adicionar ob_buffer com uma expressão regular para testar se não há avisos e gerar um erro. Mas isso exigiria algum código que não ficaria bonito.

Existe uma maneira fácil de alternar algumas opções para tornar os avisos erros reais? Então o teste unitário não passa e o código sempre falha? Quero que meu código seja à prova de futuro e não falhe quando o PHP decidir substituir a obsolescência por um erro real.