Tem razão, mas nesse caso o efeito é o mesmo, certo?
E de qualquer forma, prefiro mesmo “simular herança” com delegação do que usar herança de verdade. :twisted:
É basicamente o que venho utilizando hoje para contornar. O problema é que preciso avaliar em elo menos 3 bindings: do closure, da classe que recebe o closure e top-level. Conseguir o primeiro é complicado, a menos qu você faça a gambi que o Kung posto de passar self no método 
gambi essa minha que é melhor que a gambi de incluir o modulo! 
Tem algum jeito de pegar o call stack atual em Ruby como tem em Java?
Estamos discutindo qual gamiarra é melhor
CQD
Tem isso, mas não serve:
http://ruby-doc.org/core/classes/Kernel.html#M005955
Do jeito que você quer não conheço…
:thumbup: O assunto continua sendo Ruby, mas posso dizer que você tem tamanha imaginação para canditado a “blue-collar”.
:idea: “Em relação a querer aprender ou ter conhecimento isso vai da vontade e busca da investigação ao saber de cada um”
“Apostila Ruby on Rails fique avontade para abrir sua mente”
Ruby on Rails
http://linorg.ciagri.usp.br/ftp/pub/webdev/rails-tutorial.pdf
Tem isso, mas não serve:
http://ruby-doc.org/core/classes/Kernel.html#M005955
Do jeito que você quer não conheço…[/quote]
O povo do rubinius tava fazendo algo no sentido de permitir stack walk arbitrário, sendo possível Não sei se é possível capturar com contexto de um frame, entretanto.
Tem isso, mas não serve:
http://ruby-doc.org/core/classes/Kernel.html#M005955
Do jeito que você quer não conheço…[/quote]
Realmente, não serve não.
Que triste 
Gujeiros,
será que vocês poderiam citar referências bibliográficas para entendermos esse papo todo? Não, não quero nenhum livro dos Deitel. E nem precisa ser um Head First Metaprogramming. Pode mandar algo mais bizarro.
Acabei de me avaliar como white-and-yellow-collar! :roll:
[quote=TheMask]Gujeiros,
será que vocês poderiam citar referências bibliográficas para entendermos esse papo todo? Não, não quero nenhum livro dos Deitel. E nem precisa ser um Head First Metaprogramming. Pode mandar algo mais bizarro.
Acabei de me avaliar como white-and-yellow-collar! :roll: [/quote]
Procure pelo assunto no lambda the ultimate e no citeseer. Boa leitura.
[quote=TheMask]Gujeiros,
será que vocês poderiam citar referências bibliográficas para entendermos esse papo todo? Não, não quero nenhum livro dos Deitel. E nem precisa ser um Head First Metaprogramming. Pode mandar algo mais bizarro.
Acabei de me avaliar como white-and-yellow-collar! :roll: [/quote]
Ruby for Rails do David Black também é uma boa leitura e aborda coisas interessantes sobre metaprogramação aplicada no rails.
Eu ainda não entendi direito o que você está tentando fazer, vc procura algo como se os contextos fossem se sobrepondo numa pilha ou uma “herança de escopo”, mas ainda não entendi o que isso tem a ver com monkey patching.
O que eu pensei foi em passar o contexto que tem o método que vc qr acessar por variável.
[code]class A
def initialize
@abc =122
end
def hehe
B.new.huhuhu {|context| p @abc; puts context.bwawawawawa}
end
end
class B
def huhuhu(&block)
yield self
end
def bwawawawawa
’risada maquiavelica’
end
end
A.new.hehe
[/code]
O seu exemplo é basicamente aq mesma coisa do do Kung, com a direção invertida. Ainda é uma gambiarra e apesar de solucionar o exemplo (1)cria ainda mais sintaxe acidental e (2)não resolve todos os casos, e se eu quiser ter três níveis? Níveis arbitrários? A pergunta é: como resolver isso sem mexer no bloco nem na invocacão do método?
O problema é que se eu não tenho mecanismo de binding decente eu crio muitos métodos em classes existentes, como no caso que citei do Selenium onde uma classe de domínio teve que incluir um módulo do SeleniumRC. No fim do dia você acaba tendo métodos em Fixnum que ó são usados em um canto escuso de uma biblioteca que você importou. Um bom exemplo é o problema que o RSpec cria aodefinir métodos em Object. Se fosse possível definir métodos apenas dentro do bloco it() ele não precisaria poluir todo o namespace com metodos que só fazem sentido nele.
Com a ênfase em DSLs em Ruby pode-se esperar ainda mais oluição, cada DSL implementa sua gambiarra para ter uma sintaxe diferenciada e no final seu Fixnum vai estar assoviando, chupando cana e se chamando Roberta Close.
Phillip, que tal colocar as operações que vc quer adicionar nas classes (limitando o escopo) em um módulo e sobrescrever o append_features (http://ruby-doc.org/core/classes/Module.html#M001659):
module DSLExtensions
def ... end
def append_features(mod)
#guarda as modificacoes em algum lugar para desfazer depois!
end
end
def novo_escopo(&blk)
Fixnum.send(:include, DSLExtensions)
instance_eval(&blk)
remove_extensions_from(Fixnum)
endGambi forte. Não sei se é pior que passar o contexto pai como variável…
E eu faço a mesma besteira que o Rails faz e fico com uma thread só?
Nah, a outra gambiarra pelo menos era tread-safe
é, mas a outra tb não resolve o problema do “scoped monkey patching”!
operacao do
1.so_pode_ter_esse_metodo_aqui
end(e acabaram as minhas idéias)
(por enquanto)
A conclusão é que se eu tivesse a solução para isso, já estaria tão famoso quanto o Phillip!
São dois problemas. Um é a falta de opções de binding, fazendo com que eu tenha quea alterar classes (adicionar métodos em inteiros) quando o que eu queria era simplesmente que um método estivesse disponivel em um contexto qualquer. Outro é o fato de que se eu alterar uma classe (como consequência do primeiro ou não) eu altero ela em todo o sistemas.
Será que JRuby não consegue resolver o seundo problema com classloaders diferentes? Não tenho idéia, não sei como o JRuby funciona… LOOOOOOOOOOOOOOUUUUUDS!!!
[quote=pcalcado]São dois problemas. Um é a falta de opções de binding, fazendo com que eu tenha quea alterar classes (adicionar métodos em inteiros) quando o que eu queria era simplesmente que um método estivesse disponivel em um contexto qualquer. Outro é o fato de que se eu alterar uma classe (como consequência do primeiro ou não) eu altero ela em todo o sistemas.
Será que JRuby não consegue resolver o seundo problema com classloaders diferentes? Não tenho idéia, não sei como o JRuby funciona… LOOOOOOOOOOOOOOUUUUUDS!!![/quote]
Acho que usando 2 instancias, uma para a aplicação e outra para a DSL, com call by value, iow serializa todos argumentos, provavelmente funciona.