ruby-mine

David Brady hat einen Mandelbrot Einzeiler geschrieben:

60.times{|a|puts((0..240).map{|b|x=y=i=0;until(x*x+y*y>4||i==99);x,y,i=x*x-y*y+b/120.0-1.5,2*x*y+a/30.0-1,i+1;end;i==99?'#':'.'}*'');}

Ich liebe Code der das Layout hinrichtet. Wobei sich streitet lässt, ob ein Stück Code mit mehr als 80 Zeichen wirklich noch ein Einzeiler ist.

Optimierte Version von Jan:

60.times{|a|puts (0..240).map{|b|x=y=i=0;x,y=x*x-y*y+b/120.0-1.5,2*x*y+a/30.0-1until x*x+y*y>4||98<i+=1;i>98?'#':'.'}*''}

Seit ein paar Tagen gibt es eine neue Hookmethode mit dem Namen respond_to_missing? im Rubytrunk.

Und sie sind doch ähnlicher als gedacht…

Es ist zwar noch eine ganze Weile bis Weihnachten, aber eins ist sicher: Ruby 1.9.2 kommt. Und mit ihm ein Herzenswunsch Yehuda Katz's, der es wegen später Einreichung nicht mehr in 1.9.1 geschafft hat, aber im trunk vorhanden ist: Proc#parameters. Einen kleinen Spass, den man sich damit leisten kann, findet ihr unter dem Link.

(Deutsche Übersetzung; Original auf murfy.de.)

Ich bin gerade dabei, den Java Scanner für CodeRay (Ticket #42 ^^) zu schreiben, und dachte, es wäre nett, eine Liste von eingebauten Typen zu haben, um sie hervorzuheben – wie String oder IllegalStateException. Ich wusste, dass TextMate recht gute Unterstützung für Java bietet, also schaute ich mir das Bundle genauer an.

Tatsächlich, irgendein schlauer Kerl hat dort einen ziemlich langen regulären Ausdruck in die Tokendefinitionen geschrieben:

support-type-built-ins-java = {
  name = 'support.type.built-ins.java';
  match = '\b(R(GBImageFilter|MI(S(ocketFactory|e(curity(Manager|Exception)|
    rver(SocketFactory|Impl(_Stub)?)?))|C(onnect(ion(Impl(_Stub)?)?|
    or(Server)?)|l(ientSocketFactory|assLoader(Spi)?))|IIOPServerImpl|
    JRMPServerImpl|FailureHandler)|SA(MultiPrimePrivateCrtKey(Spec)?|
    ...und so weiter über mehrere Bildschirmseiten...

Offenbar haben sie eine lange Liste von Typen in eine minimale Regexp umgewandelt, sicher mit Hilfe eine Scripts. Das war nicht ganz das, wonach ich gesucht hatte. Wie komme ich jetzt an die ursprüngliche Liste?

Wann hast Du das letzte mal die Bibliothek benchmark aus der Ruby Standardbibliothek benutzt? Kannst Du Dich noch erinnern, wie die Methoden heißen, die man braucht, um einen Benchmarkbericht zu erzeugen?

Ich muss jedes mal neu in der API-Dokumentation nachschauen, weil die Bibliothek für mich nicht gerade intuitiv ist, so dass ich die Benutzung immer wieder vergesse. Aber dem kann man ja Abhilfe schaffen…

...wenn’s auch kompliziert geht?

Quines sind bekanntermassen Programme die ihren eigenen Quelltext ausgeben.

Aber jetzt gibts was neues: Quines der 3. Ordnung. sigfpe hat ein kleines Haskell-Programm entwickelt:

q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']
main=q "q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']" "def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'" "def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end"

Führt man dieses Programm aus, erhält man ein Python-Programm:

def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'
q("def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'","def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']")

… welches wiederum ein Ruby-Programm produziert:

def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end
q("def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']","def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'")

Und dieses Ruby-Programm produziert wieder das Haskell-Programm. Toll, oder?

Jawohl :)

class Feeling

  def ~
    p :drunk
  end

  def !
    p :alert
  end

  def -@
    p :bad
  end

  def +@
    p :good
  end

end

feeling = Feeling.new

-feeling  # => :bad
+feeling  # => :good
!feeling  # => :alert
~feeling  # => :drunk
# >> :bad
# >> :good
# >> :alert
# >> :drunk

Der Fachmann/Die Fachmassaigiraffe sieht hier mehrere Dinge:

• Der !-Operator ist jetzt dynamisch und kann neu definiert werden. (Ebenso != und !~.)
• Unäre Methoden lassen sich auch ohne @-Suffix definieren, wenn sie keine binäre Schwestermethode haben.
• p gibt seine Argumente nicht nur aus, sondern auch zurück (statt nil.)
• CodeRay braucht mal wieder ein Update.
• Ich benutze TextMate ;-)
• In 12 Tagen kommt Ruby 1.9!

matz sagt:

For good news, I have no big change left.

Laurent Sansonetti ist der Herr der bei Apple für Ruby verantwortlich ist. Neben dem Ruby Interpreter kümmert er sich auch um so sachen wie RubyCocoa, einer Ruby-ObjectiveC-Bridge, mit der man native OS X Programme in Ruby schreiben kann.

Und jetzt hat er RubyInject veröffentlicht.

Rails hat Symbol#to_proc populär gemacht. So sehr dass es sogar Teil von Ruby 1.9 werden wird.

'x+1'.to_proc[2] # => 3
'x+2*y'.to_proc[2, 3] # => 8

%w[dsf fgdg fg].map(&:capitalize)

%w[dsf fgdg fg].map(&'.capitalize')

(1..5).map &'*2' # => [2, 4, 6, 8, 10]

(1..5).inject &'+' # => 15

Endlich kann man auch Musik beim Programmieren hören ;-)

Dass man Methoden in Ruby auch groß schreiben darf, ist ja allgemein bekannt. Es gibt sogar Methoden wie Array, die genauso heißen wie eine Konstante. Die Namensräume von Konstanten und Methoden sind also getrennt.

Doch wie geht defined? damit um? Erkennt es, dass es zwei Objekte mit demselben Namen gibt?

# Ruby 1.8/1.9
Foo = 'Konstante'
def Foo
  'Methode'
end

Foo  # => "Konstante"
Foo()  # => "Methode"

defined? Foo  # => "constant"
defined? Foo()  # => "method"

Also: Wenn man eine großgeschriebene Methode auf Existenz testen will, muss man Klammern dahinter setzen.

Ein kleines Ruby-Script soll aktiven phpBB-Neutzern dabei helfen, schnell und einfach über Neuigkeiten informiert zu werden. Eine Lösung von murphy speziell für Thunderbird und MacOS.

(nur zur Sicherheit:)

Vorsicht, dieser Code ist der Nachbau einer PHP-Sicherheitslücke. Bitte nicht benutzen!

Aus aktuellem Anlass eine Nachbesserung im Verhalten von require:

require 'open-uri'

module Kernel
  alias_method :require_old, :require

  def require params
    if params =~ /\A(ftp|http[s]?)/
      eval open(params).read
    else
      require_old params
    end
  end
end

Hier zum Test:

require 'http://www.ruby-mine.de/assets/2007/5/10/remote_1.rb' 
#=> i'm far away

Anhang von murphy

Vergiss nicht:

require 'cgi'
cgi = CGI.new
for name, value in cgi.params 
  eval("#{name}=#{value}")
end