Metaprogrammierung mit Ruby

Metaprogrammierung Dario Rexin

Agenda • Was ist Metaprogrammierung • Ruby Object Model • Open Classes • Methoden in Ruby • Hooks in Ruby • Die Zukunft

Was ist Metaprogrammierung

Was ist Metaprogrammierung • Writing code, that writes code • Code zur Laufzeit des Programms generieren und evaluieren • Klassen und Strukturen zur Laufzeit verändern • Metaprogrammierung == Programmierung

Ruby Object Model

Ruby Object Model Foo

Ruby Object Model Object Foo

Ruby Object Model Kernel Object Foo

Ruby Object Model Kernel #Kernel Object #Object Foo #Foo

Open Classes

Open Classes • Klassen können jederzeit wieder geöffnet werden • Methoden/Variablen können hinzugefügt, überschrieben und entfernt werden

Beispiel class String def foo class String “foo” undef to_s end end end

Methoden in Ruby

Methoden in Ruby instance_eval remove_const instance_variable_get const_set eval deﬁne_method class_eval undef send instance_variable_set const_get alias_method

const • Object.const_get(:String) => String • Object.const_set(:Foo, Class.new) => Foo • Object.remove_const(:Foo) => Bar

const • Object.const_get(:String) => String • Object.const_set(:Foo, Class.new) => Foo • Object.remove_const(:Foo) => Bar #private

instance_variable • obj.instance_variable_set(:@foo, 8) • obj.instance_variable_get(:@foo) • obj.remove_instance_variable(:@foo)

instance_variable • obj.instance_variable_set(:@foo, 8) • obj.instance_variable_get(:@foo) • obj.remove_instance_variable(:@foo) #private

eval • evaluiert String im aktuellen Kontext • Zugriff auf alle Variablen/Methoden möglich • mit Bedacht einsetzen

eval while(true) do input = gets.sub(/n/, '') eval("puts Object.const_get ('#{input}'.to_sym).methods") end

eval input == String

eval input == String Output: try_convert allocate new superclass ...

eval input == String');puts Dir.glob('/*/**');#

eval input == String');puts Dir.glob('/*/**');# Output: ... /Applications/Address Book.app /Applications/App Store.app /Applications/AppCleaner.app /Applications/Automator.app /Applications/Caffeine.app ...

May I touch your privates?

May I touch your privates? Object.instance_eval do remove_const(:Bar) end

May I touch your privates? Object.instance_eval do private_methods.each do |m| public m end end

deﬁne_method • fügt dem Objekt eine neue Methode hinzu • Parameter: name, &block • Block-Parameter: *args

Hooks in Ruby

Hooks in Ruby • method_added / _removed • method_missing • Module#included

method_added • Aufruf beim Hinzufügen einer Methode • Parameter: name • nützlich, wenn man eine Methode mit einer anderen umschließen möchte

Beispiel class Foo def self.method_added name alias_method “__old_#{name}__”, name deﬁne_method name do |*args| puts “called #{name}” self.send(“__old_#{name}__”, *args) end end end

method_missing • Aufruf, wenn keine Methode gefunden wird • Parameter: name, *args • dynamische Methoden erstellen • wird in vielen Libraries benutzt

Beispiel class Hash def method_missing name, *args return super(name, *args) unless self.include? (name) self[name] end end

Beispiel class Hash def method_missing name, *args return super(name, *args) unless self.include? (name) self[name] end end {:foo => :bar}.foo # => :bar

Module#included • Aufruf, wenn Modul inkludiert wird • Parameter: Klasse, welche das Modul inkludiert

Beispiel module Foo def self.included base base.extend(ClassMethods) end module ClassMethods #... end end

Die Zukunft

Die Zukunft • reﬁnements • machen Monkey Patching sicherer • nur im Scope gültig

Beispiel MyGreatMoneyGem: MyMuchBetterMoneyGem: class Fixnum class Fixnum def euro def euro “#{self} €” Euro.new(self) end end # usw. # usw. end end

Lösung MyGreatMoneyGem: MyMuchBetterMoneyGem: module MGMG module MMBMG reﬁne Fixnum do reﬁne Fixnum do def euro def euro “#{self}€” Euro.new(self) end end # usw. # usw. end end end end

Anwendung class ThisClass class ThatClass using MGMG using MMBMG def self.do_sth def self.do_sth 5.euro 5.euro end end end end MGMG.do_sth # => 5€ MGMG.do_sth # => #<Euro: 0x0......>

Scopes using A #global module Foo using B #modulweit class Bar using C #klassenweit def baz using D #nur innerhalb der Methode end end end

Kein local rebinding class Foo def bar module Mod baz reﬁne Foo do end def baz “no baz” def baz end “baz” end end end end

Kein local rebinding using Mod Foo.new.baz # => “no baz” Foo.new.bar # => “baz”

Danke für die Aufmerksamkeit

Links • http://yehudakatz.com/2010/11/30/ruby-2-0- refinements-in-practice/ • http://www.rubyinside.com/ruby-refinements-an- overview-of-a-new-proposed-ruby- feature-3978.html • http://timeless.judofyr.net/refinements-in-ruby

Metaprogrammierung mit Ruby

by Dario Rexin on Jan 13, 2011

Accessibility

Tags

Upload Details

Usage Rights

1 Embed 1

Statistics

Metaprogrammierung mit Ruby — Presentation Transcript