Avec des caractères génériques dans Ruby

Je voudrais écrire une fonction d'utilité/module qui va donner de simples générique/glob correspondant à cordes. La raison pour laquelle je ne suis pas en utilisant des expressions régulières, c'est que l'utilisateur sera celui qui aura finissent par fournir des modèles pour correspondre à l'aide d'une sorte de fichier de configuration. Je ne pouvais pas trouver un tel joyau stable - essayé joker, mais il avait des problèmes de paramétrage.

La fonctionnalité, je suis à la recherche est simple. Par exemple, pour les modèles suivants, voici les correspondances:

pattern | test-string         | match
========|=====================|====================
*hn     | john, johnny, hanna | true , false, false     # wildcard  , similar to /hn$/i
*hn*    | john, johnny, hanna | true , true , false     # like /hn/i
hn      | john, johnny, hanna | false, false, false     # /^hn$/i
*h*n*   | john, johnny, hanna | true , true , true
etc...

J'aimerais que ce soit aussi efficace que possible. J'ai pensé à la création d'regexes à partir de la structure des chaînes, mais qui semblait plutôt inefficace à faire au moment de l'exécution. Toutes les suggestions sur cette mise en œuvre? merci.

MODIFIER: je suis en utilisant ruby 1.8.7

OriginalL'auteur sa125 | 2011-06-23

  1. 13

    Je ne vois pas pourquoi vous pensez qu'il serait inefficace. Des prédictions au sujet de ces sortes de choses sont notoirement peu fiables, vous devez décider que c'est trop lent avant d'aller vous pencher en arrière pour trouver un moyen plus rapide. Et puis, vous devriez profil pour s'assurer que c'est là que réside le problème (d'ailleurs il y a une moyenne de 3-4x boost de vitesse de commutation à 1,9)

    De toute façon, il devrait être assez facile à faire, quelque chose comme:

    class Globber 
  def self.parse_to_regex(str)
    escaped = Regexp.escape(str).gsub('\*','.*?')
    Regexp.new "^#{escaped}$", Regexp::IGNORECASE
  end

  def initialize(str)
    @regex = self.class.parse_to_regex str
  end

  def =~(str)
    !!(str =~ @regex)
  end
end


glob_strs = {
  '*hn'    => [['john', true, ], ['johnny', false,], ['hanna', false]],
  '*hn*'   => [['john', true, ], ['johnny', true, ], ['hanna', false]],
  'hn'     => [['john', false,], ['johnny', false,], ['hanna', false]],
  '*h*n*'  => [['john', true, ], ['johnny', true, ], ['hanna', true ]],
}

puts glob_strs.all? { |to_glob, examples|
  examples.all? do |to_match, expectation|
    result = Globber.new(to_glob) =~ to_match
    result == expectation
  end
}
# >> true
    Je pense que dans le cas de '*hn' par exemple, il a besoin de 'john is awesome' pour retourner vrai aussi, et avec /.*hn$/ aura pas de match
    Ne semble pas être la voie à des boules de travail sur mon ordinateur (Mac OSX Leopard) gist.github.com/1041942
    Je suppose que joker, c'est plus précis que glob pour mon but - pour le cas sur '*hn' j'aimerais tout ce qui est avant et le motif de match, et rien après; donc true pour 'john', false pour 'john is ..'. merci
    Qui est en harmonie avec cette solution.

    OriginalL'auteur Joshua Cheek

  2. 1
    def create_regex(pattern)
 if pattern[0,1] != '*'
    pattern = '[^\w\^]' + pattern
 end
 if pattern[-1,1] != '*'
    pattern = pattern + '[^\w$]'
 end
 return Regexp.new( pattern.gsub(/\*/, '.*?') )
end

    Ce methoid doit retourner votre regexp

    PS: il n'est pas testé 😀

    fait des modifications - merci de remarquer les erreurs de syntaxe - trop de perl/php 😀

    OriginalL'auteur Tudor Constantin