regex avançado

Preciso humildemente da ajuda dos Regexers :D

Para substituir o conteúdo de uma string qualquer para branco, eu uso esta função:
“‘isto é uma string’”.gsub(/[^‘“]*/,’‘) #=> "’’"</p> <p>

Agora, não sei se é possível fazer com conteudo dos métodos.

1) Eu não sei como negar palavras em regex. Apenas sei usando classes de caracter [].

2) O problema é que métodos podem ter vários sublocos, e isto vai provavelmente deixar o regex um pouco mais complicado.

Eu atualmente implementei a solução usando stacks.
Quando encontra do/def, incrementa stack. Quando encontra end, subtrai stack.

Se no final de tudo stack for 0, então sei que todo aquele pedaço de código era do método.

Alguém?

Use retrovisores e grupos para fazer uma reanálise com os matches anteriores.

Vixi Shairon… o_O Gringolou…

Antonio, se entendi bem vc quer substituir o conteúdo dos métodos por vazio, é isso? Ou dar match no conteúdo do método?

Seria interessante pegar o conteúdo, Ronie …

Dexa eu explicar direitinho o que estou fazendo.

Eu tenho um projeto no qual eu tenho que dar require em trocentos arquivos. Não apenas isso, os arquivos tem uma certa ordem para serem carregados e eles são removidos, adicionados e renomeados frequentemente. Dir.glob obviamente ajuda a navegar nos arquivos mas não ajuda em nada a encontrar as dependências entre eles.

Por exemplo
a.rb
class A <textarea name='code' class='ruby'>class A < B; end</p> <p>

b.rb
class B; end</p> <p>

se tentar carregar a.rb antes de b.rb, ruby vai se queixar (e com razão).

A idéia para solucionar esse problema, é resolver essas dependêncis. Em 99% das vezes, o que causa dependências, são as constantes que o ruby tenta interpretar em tempo de avaliação estática. Ademais, constantes definidas dentros de métodos serão apenas avaliadas em tempo de execução e isso, não interessa pro require que estou fazendo.

Então, fiz uma função chamada require2 para lidar com esse problema.

Não vou dar mais detalhes do algoritmo porque dai comeca a complicar um pouco. Enfim, esta tudo funcionando bunitinho … exceto que eu não gosto de usar stacks para ignorar o corpo do método.

A idéia é pegar um arquivo simples assim:

e transformá-lo em:

Quando os arquivo estão limpos assim, eu posso mais facilmente aplicar as funções para localização de dependência.

A questão é como fazer um regex para isso, como disse, stacks deixou o código um pouco POG.

Olha, em tese expressões regulares não fazem esse tipo de coisa. Somente o Perl e o .NET existem construções para você pegar expressões regulares recursivas. Pelo menos, em Ruby não achei.

Por outro lado, na prática dá, mas não é bonito, nem legível. A idéia básica é que existe um limite no número de recursões que você vai pegar, então, ao invés de fazer recursivamente, nós declaramos explicitamente o número de recursões.

Para nenhum nível de recursão (nossa construção básica) fica assim:

Agora vamos complicar um pouco, vamos adicionar um nível de recursão:

Mais um nível:

Agora, pra finalizar, podemos fazer uma classe pra criar a expressão pra gente:

Baum… acho que assim funciona, mas não testei para todos os casos.

Antonio,

Você pode fazer negação em re utilizando (?!). Exemplo tirado do Programming Ruby 2nd edition:

A solução mais simples é utilizar Kernel#autoload, mas como eu não se qual é o propósito do código, vou apresentar duas outras alternativas.

Uma coisa que você pode fazer que é bem interessante e na minha opinião mais simples é ao invés de percorrer os arquivos com regexp, apenas carregue-os e utilize um grafo pare resolver as dependências ;)

Se o seu loader fizer assim não dará certo:

Supondo que você esteja percorrendo diversos arquivos atrás do Dir.

A primeira solução é simples mas tem vários revés.
Na segunda, posteriormente você percorre o grafo conforme suas dependências forem supridas

Outra solução, ao invés de filtar o que você não quer, filtre o que você quer, procurando por:

Depois carregue os arquivos. Me parece mais simples.

Ronie, realmente regexz deixam essa situação complexa. Mesmo assim, obrigado pela explicação e pelos códigos :D

Daniel, obrigado pelas sugestões também. Mas a coisa é um pouco mais complexa. Kernel.autoload seria quase a mesma coisa dos requires e ainda assim não resolveria porque a maioria dos arquivos são criados sem ordem e padrão…

A primeira solução que fiz há muitooo tempo atras foi dar um require com Dir.glob e resgatar todos NameError, e fazer o procedimento novamente até resolver todas as dependências. O problema disso é que existem alguns arquivos que tem funções além de definições. Por exemplo:

Essa solução vai ficar sempre inserindo registro toda vez que o arquivo for lido para resolver dependência. Funciona bem com definições de classes porque elas, em sua maioria não trabalham diretamente manipulando dado, mas não com arquivos que possuam algum código que manipule-os (como acima).

Usar const_missing é a mesma coisa do NameError. E muito provavelmente algum gem já deve ter tomado controle desse ‘callback’.

O único modo que pensei até agora e que pelo menos ta funcionando até agora(fica dificil imaginar todos cenários) é fazer pré-avaliação do modo como descrevi no post anterior.

Vlw

Antonio, se seu problema é pegar o nome da classe e o include, vc não precisaria do “end”, bastaria só pegar a declaração da classe, não seria?

Alguma coisa do tipo:
/class\s+(\w+)\s+(<textarea name='code' class='ruby'>/class\s+(\w+)\s+(< \w+)?(\s+include\s+([\w,]+))?/m</p> <p>

Pelo menos a parte estática da coisa resolveria.

Outra idéia: Pegue todas as constantes do código (tudo que começa com uma Letra maiúscula) e veja se existem arquivos pra ele, se existem, dê require, senão, ignore.

Acho que ruby2ruby seria uma boa solução para a parte dos gatos com regexp :).