Lançamento do jq 1.7

 (github.com/jqlang)
3 pontos por GN⁺ 2023-09-07 | 1 comentários | Compartilhar no WhatsApp
  • As opções --argfile e os filtros leaf_paths e recurse_down, que estavam sem suporte, foram removidos
  • A imagem Docker agora é distribuída em ghcr.io/jqlang/jq em vez do Docker Hub
  • Os alvos de build de lançamento agora especificam várias arquiteturas para Linux, macOS, Windows e Docker
  • Foi adicionado --raw-output0, permitindo inserir bytes NUL entre as saídas; a saída de strings contendo NUL agora gera erro
  • No Windows, foi adicionada a opção --binary/-b, permitindo saída com fim de linha \n em vez de \r\n
  • Agora é possível definir a cor das chaves de objetos com JQ_COLORS, e a variável de ambiente NO_COLOR é respeitada para desativar a saída colorida
  • Foi corrigido o problema dos códigos de saída da opção --exit-code/-e: agora retorna 0 se o último valor de saída for verdadeiro, 1 se for false ou null, e 4 se não houver saída
  • Literais numéricos decimais agora são usados para preservar a precisão dos literais numéricos; operações de comparação respeitam essa precisão, mas operações aritméticas podem truncá-la
  • Foram adicionadas novas funções internas: pick(stream), debug(msgs), scan($re; $flags) e abs
  • Em instruções if, agora é possível omitir o ramo else, e um else omitido é tratado com o comportamento de .
  • halt e halt_error agora encerram imediatamente, sem continuar para a próxima entrada
  • Foram corrigidos problemas como saída JSON incorreta com números grandes em algumas plataformas, falha de segmentação ao usar libjq com threads e crash de assert em --jsonarg
  • CI, scan build, release e build do site passaram a usar GitHub Actions, e o OSS-Fuzz foi adicionado

Leituras relacionadas

1 comentários

 
GN⁺ 2023-09-07
Opiniões no Hacker News

  • Gosto muito do JQ porque ele é excelente
    Implementamos em Clojure um subconjunto do JQ para permitir que usuários processem/filtrem dados no nosso produto (uma ferramenta para Kafka baseada em JVM e navegador). Foi uma das tarefas mais divertidas entre os códigos que já escrevi e, como gosto de escrever gramáticas em si, também deixo um grande agradecimento ao Instaparse: https://github.com/Engelberg/instaparse
    Ao implementar, descobri que o JQ é LISP-2, o que me surpreendeu porque, só olhando a sintaxe, não parece ser: https://github.com/jqlang/jq/wiki/jq-Language-Description#:~...

    • Não consigo gostar de jq de jeito nenhum. Há muito jq nos scripts bash da base de código do meu trabalho, parte desse código foi escrita por mim, e eu até uso a contragosto quando é a melhor opção
      Mas me incomoda a sintaxe de consulta pouco intuitiva, o fato de precisar pesquisar a cada passo minúsculo e o resultado sair parecendo um feitiço difícil de decifrar para quem não é especialista em jq. Tenho uma rejeição instintiva a DSLs em geral que ficam embutidas dentro de strings, como htmx ou tailwind
      Ainda assim, reconheço que é um software bem-feito e que às vezes não há alternativa melhor. Para lidar com JSON no bash, ele também é a opção menos ruim, no sentido de ser muito melhor que um monstro feito de sed/awk/cut. Só que comandos jq enfiados no meio de scripts, sempre como strings indecifráveis, estão perto daquilo que eu não quero ver em código, junto com expressões regulares. Como alternativa, já tentei passar inline Python dentro de um heredoc via pipe, mas isso fica tão bagunçado quanto scripts jq
    • Também adicionei um parser/gramática de JQ ao editor/testador online de gramáticas LALR(1)/FLEX: https://mingodad.github.io/parsertl-playground/playground/
      Nos exemplos, selecione "Jq parser (partially working)" e clique em "Parse" para ver a árvore do parser para o código em "Input source". Feedback é sempre bem-vindo
    • Já existe uma implementação de JQ para a JVM. Não está 100% completa, mas é utilizável: https://github.com/eiiches/jackson-jq
    • jq é muito bom para permitir que usuários transformem seus próprios dados. Nós também usamos uma abordagem parecida, em que o usuário cria um endpoint de webhook de entrada, envia dados JSON arbitrários e configura mapeamentos úteis com testes de regressão e monitoramento
      jq simplifica a maioria dos casos (na prática, notação de ponto para JSON) e também viabiliza a cauda longa de casos complexos
    • Se o produto já estiver em um estado utilizável, eu adoraria testá-lo

  • Gosto de jq, mas também uso JMESPath (especialmente com a AWS CLI), yq (incluindo tomlq e xq) e dasel. É uma pena que hclq esteja praticamente morto
    https://jmespath.org/
    https://kislyuk.github.io/yq/
    https://github.com/TomWright/dasel
    https://hclq.sh/

    • Vamos tornar JSON passível de grep: https://github.com/tomnomnom/gron
      Uso jq há anos e sempre dou um jeito de montar o que preciso, mas ainda nunca achei intuitivo. Quando fica só um pouco mais complexo, é difícil chegar à solução sem ler a documentação por bastante tempo, e eu gostaria que fosse mais fácil de usar
    • A página do tutorial interativo do JMESPath é muito boa: https://jmespath.org/tutorial.html
      Ajudou quando eu estava aprendendo a sintaxe pela primeira vez, e ainda volto a ela quando esbarro em alguma sintaxe estranha
    • Criei uma pequena ferramenta para converter de vários formatos para vários formatos
      O principal uso é converter para JSON coisas como CSV, TOML e XML para então passar por pipe para o jq: https://github.com/sentriz/rsl
    • Como alternativas, também existem estas ferramentas
      https://github.com/kellyjonbrazil/jello
      https://github.com/wwkimball/yamlpath
    • Outra ótima alternativa é JSONPath, que é excelente, mas é uma pena que não tenha suporte e reconhecimento mais amplos
      Inspirada no XPath, ela é mais familiar do que uma DSL totalmente nova, e considero que seu recurso principal é a busca recursiva por chaves. Se você escrever people..address, ela encontra em qualquer lugar do JSON todas as chaves "address" abaixo de "people". É minha linguagem de parsing favorita para JSON, e também escrevi um texto apresentando como usá-la para fazer parsing de datasets JSON
      https://github.com/JSONPath-Plus/JSONPath
      https://scrapfly.io/blog/parse-json-jsonpath-python/

  • Se você usa jq só de vez em quando e precisa consultar a documentação toda vez, vale experimentar o gron. É JSON que dá para usar com grep
    https://github.com/tomnomnom/gron

    • Simples, mas parece muito útil
      Venho usando curl cheat.sh/jq há anos, e acho o cheat.sh como um todo um excelente material. Hoje em dia, provavelmente usaria algo como o ChatGPT
    • O design é realmente muito bem feito
      Também dá para fazer algo como gron | grep | sed | gron -u
    • Sempre sofri com a sintaxe do jq, mas fico impressionado toda vez com o quanto o ChatGPT consegue gerar bem o comando certo quando se fornece um JSON de exemplo

  • Um dos motivos pelos quais gosto de jq, ou consigo tolerá-lo, é a estabilidade. Scripts que escrevi anos atrás ainda funcionam exatamente igual hoje
    Por outro lado, o código que mantive para yq quebrava com frequência, à medida que o yq continuava melhorando de maneiras que não eram retrocompatíveis. Não investiguei com que frequência essas mudanças aconteceram, mas fui afetado várias vezes em lugares como scripts de CI, onde as versões das ferramentas básicas variam bastante e o ritmo de atualização também é diferente
    Por isso sempre fui grato aos mantenedores do jq por entenderem a importância da retrocompatibilidade. Espero que este anúncio não signifique que essa estabilidade era apenas um efeito colateral acidental da estagnação, e que, ao corrigirem a estagnação, sacrificarão a estabilidade

  • Além das ferramentas parecidas com jq, há duas ferramentas interessantes para usar junto com jq: jo e jc
    https://github.com/jpmens/jo
    https://github.com/kellyjonbrazil/jc

    • Também há jless e gron
      Ouvi falar do gron pela primeira vez aqui, mas acrescento por completude. Enquanto isso, JSON parece estar virando uma espécie de formato padrão de saída para ferramentas de CLI. O ideal seria todas as ferramentas de CLI oferecerem uma flag como --json, tornando o jc desnecessário
      https://jless.io/
      https://github.com/tomnomnom/gron

  • Post relacionado do mês passado, "First release of jq in 5 years": https://news.ycombinator.com/item?id=36951830
    Sou grande fã do jq e uso o tempo todo

  • Finalmente aconteceu
    Foi muito legal ver a comunidade se unir para recrutar novos mantenedores e reviver o projeto. Agradecimentos especiais, em particular, a @stedolan, @itchyny e @owenthereal, pelos nomes de usuário no GitHub

  • jq e miller são itens essenciais da minha caixa de ferramentas, junto com awk e vim
    https://github.com/johnkerl/miller

  • A nova função embutida pick(stream) adiciona a capacidade de emitir uma projeção de um objeto ou array de entrada
    jq -n '{"a": 1, "b": {"c": 2, "d": 3}, "e": 4} | pick(.a, .b.c, .x)'
    Isso é um verdadeiro salvador. Obrigado aos contribuidores

    • Se você não precisa se aprofundar, também dá para fazer assim
      $ jq -n '{"a": 1, "b": {"c": 2, "d": 3}, "e": 4} | {a, e}'
      {
      "a": 1,
      "e": 4
      }
    • Instalei do Git há alguns dias para usar esse recurso, e ele é muito útil
    • É um novo recurso realmente excelente. No momento, parece impossível fazer isso sem remontar o stream primeiro, então seria bom ter uma versão de pick que também funcionasse com dados em streaming

  • Também quero recomendar o jaq. É um clone do jq focado em correção, velocidade e simplicidade
    Ele implementa apenas um subconjunto do jq, mas tenho usado com bastante satisfação até agora: https://github.com/01mf02/jaq