Une expérience : code source en français / An experiment: source code in French

etrais.rb

# -*- coding: utf-8 -*-

# Ceci n'est pas une entrée. :-) Cette expression rationelle ( ou «
# regulière », si on préfère l'anglicisme ) correspond à quelques entrées
# fausses.
FAUSSES_ENTRÉES =
  /^10 Natural|(13|19) Creating|15 Nouns|21 Adjectives|2[235] Verbs|24 Use|26 Adverbs/

# Valides parties du discours trouvées dans ce dictionnaire.
PARTIES_DU_DISCOURS = {}
%w{adj adj(f) adj(pl) adjf adji adji(pl) adv conj det intj nadj nadj(f)
   nadj(pl) nadjpl nf nf(pl) nfpl nm nm(pl) nmfi nmi nmpl prep
   pro v xxx}.each do |partie|
  PARTIES_DU_DISCOURS[partie] = true
end

# Parties du discours qui correspondent à un genre.
MASCULIN = {}
%w{nm nm(pl) nmi nmpl}.each {|p| MASCULIN[p] = true }
FÉMININ = {}
%w{adj(f) nadj(f) nf nf(pl) nfpl}.each {|p| FÉMININ[p] = true }

# Meurs en donnant un message et l'index de l'entrée actuelle.
def meurs(index, message)
  STDERR.puts "Entrée #{index} : #{message}"
  exit 1
end

open('freq_dict.txt', 'r') do |dictionnaire|

  # Cherche le debut.
  while true
    ligne = dictionnaire.gets.chomp
    if ligne =~ /^range count /
      break
    end
  end

  # Cherche la prochaine entrée.  Ils ressemblent la suivante :
  #
  #   1 le det, pro the; him, her, it, them
  #
  #   • vive la politique, vive l'amour – long live politics, long live love
  #
  #   89 | 2359662
  prochaine_entrée = 1
  dictionnaire.each_line do |ligne|
    ligne.chomp!

    # Essaye de décomposer chaque ligne comme une entrée.
    if ligne =~ /^(\d+) ((?:[[:word:]]|[-'?])+) ([^, ]+(?:, ?[^, ]+)*) (.*)/
      index = $1
      mot = $2
      partie_du_discours = $3
      définition_anglaise = $4

      # Est-ce que c'est l'entrée que l'on attend ?
      if index.to_i == prochaine_entrée
        prochaine_entrée += 1

        # Éxtrais et valide chaque partie du discours.
        parties_du_discours = partie_du_discours.gsub(/ /, '').split(/,/)
        parties_du_discours.each do |partie|
          unless PARTIES_DU_DISCOURS[partie]
            meurs(index, "Invalide partie du discours : #{partie}")
          end
        end

        # Éxtrais les autres champs.
        unless dictionnaire.gets.chomp.empty?
          meurs(index, "Attendu ligne blanche")
        end
        exemples = dictionnaire.gets.chomp
        if exemples =~ /^• ([^–]+)– ?(.+)/
          exemple_anglais = $1.chomp
          exemple_français = $2
        else
          meurs(index, "Impossible à décomposer : #{exemples}")
        end
        unless dictionnaire.gets.chomp.empty?
          meurs(index, "Attendu ligne blanche")
        end

        # Affiche tous nos champs comme TSV.
        champs =
          [index, mot, parties_du_discours.join(','), définition_anglaise,
           exemple_français, exemple_anglais]

        # Analyse le genre.
        masculin = parties_du_discours.any? {|p| MASCULIN[p] }
        féminin = parties_du_discours.any? {|p| FÉMININ[p] }
        if masculin && féminin
          masculin_féminin = true
          masculin = false
          féminin = false
        end
        #puts "#{mot}\t#{parties_du_discours.join(',')}\t#{définition_anglaise}" if masculin_féminin

        puts champs.join("\t")
      elsif ligne =~ FAUSSES_ENTRÉES
        # Ignore cette soi-distante entrée.
      else
        STDERR.puts "Attendu à « #{prochaine_entrée} », trouvé : « #{ligne} »"
        exit 1
      end

      # Ça y'est ! C'est le fin.
      break if prochaine_entrée > 5000
    end
  end

  # Pour déboguer les parties du discours, décommentez ceci :
  #parties_du_discours.keys.sort.each {|partie| STDERR.puts partie }
end