Veröffentlichung der Programmiersprache Ruby 2.7.0

Nach einem Jahr Entwicklung veröffentlicht Release Ruby 2.7.0, eine dynamische, objektorientierte Programmiersprache, die sich durch eine hohe Effizienz in der Softwareentwicklung auszeichnet und die besten Merkmale von Perl, Java, Python, Smalltalk, Eiffel, Ada und Lisp integriert. Der Code des Projekts wird unter den Lizenzen BSD („2-clause BSDL“) und „Ruby“ veröffentlicht, die auf die neueste Version der GPL verweisen und vollständig mit der GPLv3 kompatibel sind. Ruby 2.7 ist die siebte größere Version, die im Rahmen des geplanten Entwicklungsprozesses vorbereitet wurde, der ein Jahr für die Vorbereitung funktionaler Verbesserungen und alle 2-3 Monate die Veröffentlichung von Korrekturen vorsieht.

Haupt Verbesserungen:

• Experimentell Unterstützung Mustervergleich (Pattern matching), das es ermöglicht, ein gegebenes Objekt zu durchlaufen und einen Wert zuzuweisen, wenn eine Übereinstimmung mit dem Muster vorliegt.

  case [0, [1, 2, 3]]
  in [a, [b, *c]]
  p a #=> 0
  p b #=> 1
  p c #=> [2, 3]
  end

  case {a: 0, b: 1}
  in {a: 0, x: 1}
  :unreachable
  in {a: 0, b: var}
  p var #=> 1
  end

• In der interaktiven Shell für Berechnungen, irb (REPL, Read-Eval-Print-Loop), wurde die Möglichkeit der mehrzeiligen Bearbeitung implementiert, ermöglicht durch eine readline-kompatible Bibliothek. reline, geschrieben in Ruby. Es wurde Unterstützung für rdoc integriert, die es ermöglicht, in irb auf die Dokumentation zu den angegebenen Klassen, Modulen und Methoden zuzugreifen. Der Code wird mit Syntax-Hervorhebung dargestellt, die über Binding#irb gezeigt wird, ebenso wie die Ergebnisse der Inspektion von Objekten der Basisklassen.
  
• Ein Compaction GC (Verdichtungs-Colektor) wurde hinzugefügt, der die Defragmentierung des Speicherbereichs durchführen kann. Dies behebt Probleme mit der Leistungseinbuße und dem erhöhten Speicherverbrauch aufgrund von Speicherfragmentierung, die bei der Ausführung mancher mehrthreadiger Ruby-Anwendungen auftreten kann. Zum Verpacken von Objekten im Heap wurde angeboten verwendet man die Methode GC.compact, die die Anzahl der genutzten Speicherseiten verringert und den Heap für Operationen optimiert.
  CoW (copy-on-write).
• Durchgeführt Vorbereitung auf die Trennung von Argumenten, die basierend auf ihrer Position in der Liste («def foo(a,b,c)») und den Schlüsselwörtern («def foo(key: val)») definiert sind. Die automatische Umwandlung von Argumenten basierend auf Schlüsselwörtern und Position ist veraltet und wird in der Ruby-Version 3.0 nicht mehr unterstützt. Insbesondere ist die Verwendung des letzten Arguments als Schlüsselwortparameter, die Übergabe von Argumenten basierend auf Schlüsselwörtern als letztem Hash-Parameter und die Trennung des letzten Arguments in positionale und Schlüsselparameter als veraltet erklärt worden.

  def foo(key: 42); end; foo({key: 42}) # gewarnt
  def foo(**kw); end; foo({key: 42}) # gewarnt
  def foo(key: 42); end; foo(**{key: 42}) # OK
  def foo(**kw); end; foo(**{key: 42}) # OK

  def foo(h, **kw); end; foo(key: 42) # gewarnt
  def foo(h, key: 42); end; foo(key: 42) # gewarnt
  def foo(h, **kw); end; foo({key: 42}) # OK
  def foo(h, key: 42); end; foo({key: 42}) # OK

  def foo(h={}, key: 42); end; foo(«key» => 43, key: 42) # gewarnt
  def foo(h={}, key: 42); end; foo({«key» => 43, key: 42}) # gewarnt
  def foo(h={}, key: 42); end; foo({«key» => 43}, key: 42) # OK

  def foo(opt={}); end; foo( key: 42 ) # OK

  def foo(h, **nil); end; foo(key: 1) # ArgumentError
  def foo(h, **nil); end; foo(**{key: 1}) # ArgumentError
  def foo(h, **nil); end; foo(«str» => 1) # ArgumentError
  def foo(h, **nil); end; foo({key: 1}) # OK
  def foo(h, **nil); end; foo({«str» => 1}) # OK

  h = {}; def foo(*a) a end; foo(**h) # []
  h = {}; def foo(a) a end; foo(**h) # {} und Warnung
  h = {}; def foo(*a) a end; foo(h) # [{}]
  h = {}; def foo(a) a end; foo(h) # {}

• Möglichkeit Verwendung von nummerierten Variablennamen als Standard für Blockparameter.

  [1, 2, 3].each { puts @1 } # analog zu [1, 2, 3].each { |i| puts i }

• Experimentelle Unterstützung von Bereichen ohne Startwert.

  ary[..3] # entsprechend ary[0..3]
  rel.where(sales: ..100)

• Die Methode Enumerable#tally wurde hinzugefügt, um zu zählen, wie oft jedes Element vorkommt.

  [„a“, „b“, „c“, „b“].tally
  #=> {«a»=>1, «b»=>2, «c»=>1}

• Der Aufruf einer privaten Methode mit dem Literal „self“ ist erlaubt.

  def foo
  end
  private :foo
  self.foo

• Die Methode Enumerator::Lazy#eager wurde hinzugefügt, um eine reguläre Enumeration aus einer „faulen“ (Enumerator::Lazy) Enumeration zu generieren.

  a = %w(foo bar baz)
  e = a.lazy.map {|x| x.upcase }.map {|x| x + „!“ }.eager
  p e.class #=> Enumerator
  p e.map {|x| x + „?“ } #=> [„FOO!?“, „BAR!?“, „BAZ!?“]

• Die Entwicklung des experimentellen JIT-Compilers wurde fortgesetzt, der die Leistung von Anwendungen in Ruby erheblich steigern kann. Der in Ruby vorgeschlagene JIT-Compiler schreibt zunächst den Code in C auf die Festplatte und ruft dann einen externen C-Compiler zur Generierung von Maschinenanweisungen auf (Unterstützung für GCC, Clang und Microsoft VC++ wird bereitgestellt). In der neuen Version wurde ein Verfahren zur Inline-Entfaltung bei Bedarf implementiert, die selektive Anwendung von Optimierungsmodi während der Kompilierung wurde sichergestellt, der Standardwert für „—jit-min-calls“ wurde von 5 auf 10000 erhöht und „—jit-max-cache“ von 1000 auf 100.
• Die Leistung von CGI.escapeHTML, Monitor und MonitorMixin wurde verbessert.
• In Module#name, true.to_s, false.to_s und nil.to_s wird sichergestellt, dass die Rückgabe der Zeichenfolge für das angegebene Objekt unverändert bleibt.
• Die Größe der von der Methode RubyVM::InstructionSequence#to_binary generierten Binärdateien wurde reduziert;
• Die Versionen der eingebetteten Komponenten wurden aktualisiert, einschließlich
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  StringScanner 1.0.3;
• Die Bibliotheken wurden aus der Grundausstattung in externe Gem-Pakete ausgelagert
  CMath (cmath gem),
  Scanf (scanf gem),
  Shell (shell gem),
  Synchronizer (sync gem),
  ThreadsWait (thwait gem),
  E2MM (e2mmap gem).
• Auf rubygems.org wurden die standardmäßig gelieferten Module der stdlib veröffentlicht:
  benchmark,
  cgi,
  delegate,
  getoptlong,
  net-pop,
  net-smtp,
  open3,
  pstore,
  singleton. Die Module monitor wurden nicht auf rubygems.org übertragen.
  observer,
  timeout,
  tracer,
  uri,
  yaml, die nur in ruby-core bereitgestellt werden.
• Zum Kompilieren von Ruby wird jetzt ein C-Compiler benötigt, der den C99-Standard unterstützt.

Quelle: opennet.ru