UnitOptimizer

[stahli]

Ich bin dabei, ein Tool aufzubauen, das Units sortiert und Code ergänzt.

Es ist quasi eine Klassenvervollständigung, Codeformatierung und Codesortierung in einem.

Hier mal ein aktueller Zwischenstand als Video: https://youtu.be/cfKa3wuoEd0

Eine direkte Codeformatierung (Einrückung) habe ich noch nicht drin, will das aber auch noch ergänzen. Die anderen Features gehen für mich aber vor.

Die Abkürzung "prop" könnte man auch mit "property" ausschreiben lassen. Ebenso sind optional andere Voreinstellungen möglich, wenn dies gewünscht würde. Ich bin zunächst erst einmal von meinen Wünschen ausgegangen.

Ich würde das später sehr gern kommerziell anbieten, wenn es Nachfrage gibt.
Für öffentliche Tests ist es noch etwas früh. Dazu muss ich noch einiges ausbauen und ausbessern.
Sofern jemand Erfahrungen mit den OTA hat und daran mitarbeiten möchte, dann gebt Bescheid...



Ich hatte dazu schon einen Thread, der sich aber speziell auf die Interface-Unterstützung bezogen hatte. Da das Tool aber Units allgemein bearbeitet habe ich hier einen neuen Thread eröffnet.

[stahli]

Machen Code-Einrückungen in ähnlicher Art wie im Screenshot irgendwie Sinn?
Würde jemand so etwas nutzen wollen und nach welchen Kriterien?

Ich selbst bin da unschlüssig.

Aktuell kann ich z.B. alle Worte nach einen ":" untereinander ausrichten lassen - und zwar automatisch, solange ":" in aufeinander folgenden Zeilen vorkommen.

Ich könnte auch sagen, dass eine Ausrichtung nur erfolgen soll, wenn die X-Ausrichtung z.B. 4 Zeichen Unterschied nicht übersteigt.
Dann hätte man ggf. Blöcke von Ausrichtungen, gebündelt für ein paar Zeilen.
Ich weiß aber nicht, ob das übersichtlich wird. Vermutlich eher nicht.

[Aviator]

Ich hatte das auch mal eine Zeit lang so gemacht. Allerdings händisch. Irgendwann wurde es mir zu blöd, die Zeilen immer nachzurücken wenn mal eine Variable mit einem längeren Namen hinzugefügt wurde. Diese Arbeit würde zwar von deinem Unit Optimizer abgenommen, aber ich hatte damals noch einen anderen Punkt, warum ich es nicht mehr mache. Bei Methoden hatte ich das aber nie gemacht. Das passt in meinen Augen gar nicht.

Wenn Variablen im Namen etwas länger sind und zugleich in einer anderen Zeile bspw. nur eine Zählervariable (wie i, j, k, ...) steht, dann ist der Abstand zwischen Variablennamen und Datentyp sehr groß. Somit kann man beim lesen relativ leicht in der Zeile verrutschen, was das Lesen von SourceCode im Endeffekt schwieriger macht anstatt leichter.

Also wenn du das einfügen wolltest, dann auf jeden Fall einstellbar/als Option. Dann kannst du, wie von dir vorgeschlagen, auch noch einstellen lassen, bis zu welcher Anzahl von Leerzeichen überhaupt eine solche Ausrichtung erfolgen soll.

So viel von mir dazu.

[DieDolly]

Zitat:

Also wenn du das einfügen wolltest, dann auf jeden Fall einstellbar/als Option.

Im Prinzip wäre es wünschenswert, wenn alles irgendwie mit einer Option versehen würde.
So kann jeder sich die Formatierungen aktivieren, die gewünscht sind.

[hsg]

Bei Typdeklaration mache ich so etwas nicht, allerdings bei der Variablendeklaration schon sehr gerne, da ich so optisch besser die Namen der Variablen erkennen kann. Allerdings benutze ich sehr selten die Auflistung von Variablen gleichen Types (var i,j,k : integer), sondern schreibe sie lieber untereinander in eigene Zeilen:

Code:

var
   i:  Integer; 
   j:  Integer;

An einer anderen Stelle könntest du mir sehr viel Arbeit abnehmen :
Ich schreibe bei mehreren Zuweisungen untereinander das := immer in der gleichen Spalte, das ganze sieht dann ungefähr so aus:

Code:

   oWnd                 := TMeineFensterklasse.create( self ); 
   oWnd.Property1      := irgendEinWert;
   oWnd.AndereProp      := einAndererWert;

Für mich ist das optisch einfach besser lesbar. Ich erkenne sofort, wo Zuweisungen stehen und wem da was zugewiesen wird. Hab's mir durch eine andere Programmiersprache angewöhnt, die auch noch selbst die Groß- und Kleinschreibung von Feldern zum Teil selbst übernommen hat.

[Ralf Kaiser]

Zitat von hsg:

Ich schreibe bei mehreren Zuweisungen untereinander das := immer in der gleichen Spalte, das ganze sieht dann ungefähr so aus:

Code:

   oWnd                 := TMeineFensterklasse.create( self ); 
   oWnd.Property1      := irgendEinWert;
   oWnd.AndereProp      := einAndererWert;

Für mich ist das optisch einfach besser lesbar. Ich erkenne sofort, wo Zuweisungen stehen und wem da was zugewiesen wird. Hab's mir durch eine andere Programmiersprache angewöhnt, die auch noch selbst die Groß- und Kleinschreibung von Feldern zum Teil selbst übernommen hat.

Was ist wenn du mal im gesamten Code nach Stellen wie oWnd := TMeineFensterklasse.create( self ); suchen willst? Bei so einer Formatierung weißt du nie, wie viele Leerzeichen da benutzt werden und musst anfangen mit RegExpressions zu suchen!

[stahli]

Danke Euch!

Ich werde für verschiedene Abschnitte (const, var, Klassendeklaration, Code usw.) einige Optionen anbieten.

Intern arbeite ich mit benannten "Tabs". Bei Propertys z.B. mit "Tab 'read'" und "Tab 'write'".
Der Formatierer schiebt die dann untereinander.

Ich kann noch einen Toleranzwert zuweisen, so dass man variieren kann zwischen etwa:

Code:

   oWnd                        := TMeineFensterklasse.create(self ); 
   oWnd.Property1              := irgendEinWert;
   I                           := 1;
   J                           := 2;
   oWnd.AndereProp             := einAndererWert;
   oWnd.NochGanzVollAndereProp := einAndererWert;

und

Code:

   oWnd      := TMeineFensterklasse.create(self ); 
   oWnd.Prop := irgendEinWert;
   I := 1;
   J := 2;
   oWnd.AnderePropLang         := einAndererWert;
   oWnd.NochGanzVollAndereProp := einAndererWert;

und

Code:

   oWnd      := TMeineFensterklasse.create(self ); 
   oWnd.Prop := irgendEinWert;
   I         := 1;
   J         := 2;
   oWnd.AnderePropLang         := einAndererWert;
   oWnd.NochGanzVollAndereProp := einAndererWert;

Wobei man dann halt auch mal damit leben muss, dass man subjektiv an der einen oder anderen Stelle doch lieber eine andere Einrückung hätte. Aber dann muss man halt für sich passende Durchschnittswerte finden...


@Ralf Kaiser

Ein sehr guter Einwand!
Vielleicht könnte man Emba dazu bewegen, bei Suchen Leerzeichen zu ignorieren oder immer auf eines zu kürzen.
Keine Ahnung ob das machbar wäre.

[dataspider]

Zitat von Ralf Kaiser:

Zitat von hsg:

Ich schreibe bei mehreren Zuweisungen untereinander das := immer in der gleichen Spalte, das ganze sieht dann ungefähr so aus:

Code:

   oWnd                 := TMeineFensterklasse.create( self ); 
   oWnd.Property1      := irgendEinWert;
   oWnd.AndereProp      := einAndererWert;

Für mich ist das optisch einfach besser lesbar. Ich erkenne sofort, wo Zuweisungen stehen und wem da was zugewiesen wird. Hab's mir durch eine andere Programmiersprache angewöhnt, die auch noch selbst die Groß- und Kleinschreibung von Feldern zum Teil selbst übernommen hat.

Was ist wenn du mal im gesamten Code nach Stellen wie oWnd := TMeineFensterklasse.create( self ); suchen willst? Bei so einer Formatierung weißt du nie, wie viele Leerzeichen da benutzt werden und musst anfangen mit RegExpressions zu suchen!

Und wenn mal bei der 100. Zeile der Bezeichner 1 Zeichen länger ist, rückst du die 99 andernen 1 Zeichen weiter...
Wenn man sonst nichts zu tun hat

Frank

[hsg]

Zitat von Ralf Kaiser:

Was ist wenn du mal im gesamten Code nach Stellen wie oWnd := TMeineFensterklasse.create( self ); suchen willst? Bei so einer Formatierung weißt du nie, wie viele Leerzeichen da benutzt werden und musst anfangen mit RegExpressions zu suchen!

Das ist korrekt, aber bisher habe ich auch nicht wirklich nach solchen Sachen gesucht. Eine Suche nach "TMeineFensterklasse.create" hat mir eigentlich in solchen Fällen gereicht

[DasWolf]

Zitat von dataspider:

Zitat von Ralf Kaiser:

Zitat von hsg:

Ich schreibe bei mehreren Zuweisungen untereinander das := immer in der gleichen Spalte, das ganze sieht dann ungefähr so aus:

Code:

   oWnd                 := TMeineFensterklasse.create( self ); 
   oWnd.Property1      := irgendEinWert;
   oWnd.AndereProp      := einAndererWert;

Für mich ist das optisch einfach besser lesbar. Ich erkenne sofort, wo Zuweisungen stehen und wem da was zugewiesen wird. Hab's mir durch eine andere Programmiersprache angewöhnt, die auch noch selbst die Groß- und Kleinschreibung von Feldern zum Teil selbst übernommen hat.

Was ist wenn du mal im gesamten Code nach Stellen wie oWnd := TMeineFensterklasse.create( self ); suchen willst? Bei so einer Formatierung weißt du nie, wie viele Leerzeichen da benutzt werden und musst anfangen mit RegExpressions zu suchen!

Und wenn mal bei der 100. Zeile der Bezeichner 1 Zeichen länger ist, rückst du die 99 andernen 1 Zeichen weiter...
Wenn man sonst nichts zu tun hat

Frank

Dann benutzt man Shift + Alt.
Ganz easy.

[TiGü]

Wer Quelltext nach Spalten ausrichtet, der schubst auch kleine Babyenten in den Teich!

Wo ist der Sinn darin?
Man liest von links nach rechts Zeile für Zeile.
Das ist doch keine Monatsbilanz oder dergleichen.
Je weiter a von b weg ist (a := b, a: b), desto mehr muss das Auge beim Lesen springen und man kann sich in der Zeile vertun.
Kein normaler Mensch würde auf diese Weise einen normalen deutschen/englischen/whatever Text lesen wollen, aber bei Quelltext soll das sinnvoll sein?