introduction

J'ai été accro au langage J ces derniers temps, mais malheureusement, les points forts de la syntaxe de Qiita ne prennent pas en charge J: qiitan-cry:. ~~ J est un langage particulièrement laid, donc je pense que cela motivera à la fois l'auteur et le lecteur à avoir des points forts de la syntaxe.

J'ai donc décidé de le mettre en œuvre moi-même. Je garderai cette trace ici.

Cela peut être utile lors de l'implémentation de surlignages de syntaxe dans d'autres langues, ou le langage J peut être trop différent des autres langues pour être très utile.

Procédure approximative

Les points forts de la syntaxe de Qiita utilisent actuellement une bibliothèque Ruby appelée Rouge. Je voulais ajouter des points forts J en envoyant une pull request à cette bibliothèque.

Après avoir bifurqué Rouge, commencez par consulter le guide de développement lexer (https://rouge-ruby.github.io/docs/file.LexerDevelopment.html).

Tout d'abord, ajoutez le fichier qui définit le lexer et la spécification.

`lib/rouge/lexers/j.rb`


# -*- coding: utf-8 -*- #
# frozen_string_literal: true

module Rouge
  module Lexers
    class J < RegexLexer
      title 'J'
      desc "The J programming language (www.jsoftware.com)"
      tag 'j'
      filenames '*.ijs', '*.ijt'

      #Écrivez l'implémentation lexer ici
    end
  end
end

`spec/lexers/j_spec.rb`


# -*- coding: utf-8 -*- #
# frozen_string_literal: true

describe Rouge::Lexers::J do
  let(:subject) { Rouge::Lexers::J.new }

  describe 'guessing' do
    include Support::Guessing

    it 'guesses by filename' do
      assert_guess :filename => 'foo.ijs'
      assert_guess :filename => 'foo.ijt'
    end
  end

  describe 'lexing' do
    include Support::Lexing

    #Écrivez un test ici
  end
end

En plus de cela, vous avez besoin de lib / rouge / demos / j et spec / visual / samples / j, mais vous pouvez commencer avec un fichier vide.

Après cela, effectuez les étapes suivantes en parallèle. Il est plus rapide de regarder le code réel que de l'expliquer avec des mots, donc je ne vais pas l'expliquer en détail. Si vous regardez lexer, une langue que vous connaissez / utilisez souvent, vous le découvrirez probablement.

écrire une spécification

Si vous savez écrire RSpec, vous ne devriez pas avoir de problèmes [^ 1].

Utilisez ʻassert_tokens_equal` pour les tests.

assert_tokens_equal "code",Jeton 1,Jeton 2, ...

Les jetons sont représentés par une paire de «[nom, texte]». Voir List (https://github.com/rouge-ruby/rouge/wiki/List-of-tokens) pour les noms des jetons.

En fait, il semble que de nombreux langages aient peu de spécifications écrites, donc * il n'est peut-être pas nécessaire d'écrire trop en détail *.

Écrire lexer

DSL (EDSL) est également utilisé pour décrire lexer.

symbole d'état faire
expression régulière de règle,jeton
  ...
end

Les détails ne sont pas expliqués ici. Si vous ne comprenez pas, il peut être utile de regarder lexer dans d'autres langues [^ 2].

Rédiger un échantillon visuel / une démo

L'exemple visuel (spec / visual / samples / j) est un fichier texte qui vous permet de vérifier visuellement la mise en évidence correcte. Il peut s'agir d'un programme d'une certaine taille ou simplement d'une liste de jetons.

demo (lib / rouge / demos / j) est un code court qui apparaît dans rouge.jneen.net.

tester

Comme indiqué dans le README, les spécifications sont testées à l'aide de rake. L'échantillon visuel est vérifié en exécutant rackup. (localhost: 9292 montre une démo et localhost: 9292 / j montre un exemple visuel.)

Points à retenir

Il semble que le contenu écrit ici soit complètement incompréhensible pour ceux qui ne connaissent pas le langage J.

La chose la plus importante pour mettre en évidence le code de J est que ** tous les symboles ne doivent pas être traités comme des opérateurs **. Si vous ne pouvez pas colorer les symboles, la signification des surlignages de la syntaxe sera réduite de moitié.

J'ai donc décidé de traiter le verbe comme une fonction (Name.Function) et l'adverbe / conjonction comme un opérateur (ʻOperator`). Cela rend les expressions comme «>: @ i.» plus faciles à lire.

Il y a encore une chose à faire pour la lisibilité. Lorsque la partie définition d'une définition explicite est un littéral de chaîne (par exemple, dyad: 'x + y'), l'intérieur du littéral est mis en évidence comme une expression.

en conclusion

En fait, c'est la première fois que j'écris correctement Ruby, mais je pense que c'était étonnamment facile à écrire [^ 3]. Il était facile de pouvoir déboguer visuellement.

J'ai envoyé une pull request à Rouge et elle a été fusionnée avec succès: tada:. Il est inclus dans la version v3.24.0 récemment publiée (Demo).

Tout ce que j'ai à faire est d'attendre que Qiita réponde. : qiitan:

De côté

Extrait des commentaires sur la version Rouge v3.24.0:

Cette version a deux nouveaux lexers: un pour les e-mails * (...) * et un pour J (pourquoi pas un autre langage commençant par J?).

~~ Après tout, J est traité comme un langage matériel …… ~~

[^ 1]: Minitest est en fait utilisé, mais le style d'écriture de base est le même. [^ 2]: De toute évidence, la copie n'est pas bonne. [^ 3]: J'ai l'impression que je viens d'écrire EDSL sur Ruby plutôt que sur Ruby.

[RUBY] Qiita n'a pas de points forts de la syntaxe du langage J, je l'ai donc implémenté moi-même