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.

[KodeZwerg]

Hallo Stahli!

Erstmal bin ich etwas durcheinander mit dem was Du schreibt.

Zitat:

das Units sortiert

Wie meinst Du das, sortiert? Was wird da sortiert?

Zitat:

Code ergänzt

Noch mehr Fragezeichen, was genau passiert da?

Frage und Bitte,
da YouTube hier gesperrt ist, könntest Du Bitte zwei Bilder anfügen um Vorher -> Nachher effekt zu Demonstrieren?

Ps: Ich hätte da auch etwas was mir in der IDE in Bezug auf Units fehlt oder ich habe es einfach noch nicht entdeckt.
Man kann ja intern für die IDE Hilfstexte an Methoden knüpfen.
Beispiel ///<summary></summary> oder ///<returns></returns> usw.
Solche Angaben meine ich, dafür einen IDE-Editor integrieren, das wär ein feature was mir fehlt.

[stahli]

Vorher/Nachher ist schwierig, da man die gesamte Unit sehen muss.

Die Codevervollständigung ist m.E. umfangreicher und komfortabler als die von Delphi.
Man muss weniger schreiben und es wird mehr vervollständigt.
Auch Member benutzter Interfaces werden automatisch in Klassen übernommen.
Mal ein Beispiel einer einfachen Klasse:



Original:

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Classes, Vcl.Graphics, System.Types, System.UITypes;

const

  aConst = 100;

type

  TClass1 = class
  private
    procedure PrivProc; virtual;  
  public
    constructor Create; virtual;
    destructor Destroy; override;
  public
    procedure Execute(NewVal: String); virtual;
    function TestFunc(var Val1: Integer): Boolean;
    prop PropString: string;
    prop PropInteger: Integer rf wn;
    prop PropBoolean: Boolean rn vi pv;
    prop PropByte: Byte sc;
    prop PropWord: Word rf wn;
    prop PropString2: string pc vi;
  end;

implementation

end.

Ergebnis:

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Classes, Vcl.Graphics, System.Types, System.UITypes;

const

  aConst = 100;

type

  TClass1 = class
  private
    fPropString: string;
    fPropInteger: Integer;
    fPropBoolean: Boolean;
    fPropByte: Byte;
    fPropWord: Word;
    fPropString2: string;
    procedure PrivProc; virtual;
    function _get_PropString: string;
    procedure _set_PropString(aValue: string);
    procedure _set_PropBoolean(var aValue: Boolean); virtual;
    function _get_PropByte: Byte; stdcall;
    procedure _set_PropByte(aValue: Byte); stdcall;
    function _get_PropString2: string; virtual;
    procedure _set_PropString2(const aValue: string); virtual;
  public
    constructor Create; virtual;
    destructor Destroy; override;
    procedure Execute(NewVal: String); virtual;
    function TestFunc(var Val1: Integer) Boolean
    property PropString: string read _get_PropString write _set_PropString;
    property PropInteger: Integer read fPropInteger;
    property PropBoolean: Boolean write _set_PropBoolean;
    property PropByte: Byte read _get_PropByte write _set_PropByte;
    property PropWord: Word read fPropWord;
    property PropString2: string read _get_PropString2 write _set_PropString2;
  end;

implementation

{ TClass1 }

constructor TClass1.Create;
begin

end;

destructor TClass1.Destroy;
begin

end

procedure TClass1.PrivProc;
begin
  ?;
end

function TClass1._get_PropString: string;
begin
  Result := fPropString;
end

procedure TClass1._set_PropString(aValue: string);
begin
  if (fPropString <> aValue) then
  begin
    fPropString := aValue;
  end;
end

procedure TClass1._set_PropBoolean(var aValue: Boolean);
begin
  if (fPropBoolean <> aValue) then
  begin
    fPropBoolean := aValue;
  end;
end

function TClass1._get_PropByte: Byte;
begin
  Result := fPropByte;
end

procedure TClass1._set_PropByte(aValue: Byte);
begin
  if (fPropByte <> aValue) then
  begin
    fPropByte := aValue;
  end;
end

function TClass1._get_PropString2: string;
begin
  Result := fPropString2;
end

procedure TClass1._set_PropString2(const aValue: string);
begin
  if (fPropString2 <> aValue) then
  begin
    fPropString2 := aValue;
  end;
end

procedure TClass1.Execute(NewVal: String);
begin
  ?;
end

function TClass1.TestFunc(var Val1: Integer): Boolean;
begin
  Result := ?;
end

end.

Zur Interface-Unterstützung wäre noch mehr zu sagen. Da verweise ich mal auf den vorherigen Thread: https://www.delphipraxis.net/193733-...stuetzung.html bzw. auf das Video.



Weiterhin wird der Code im Implementationsteil so sortiert, wie er in den Klassendeklarationen angeordnet ist. Die Reihenfolge ist also oben wie unten immer identisch. (Ausnahme sind standardmäßig contructor und destructor, die im Implementationsteil immer als erstes kommen.)
Bei Umsortierungen und Formatierungen werden gesetzte Haltepunkte und Bookmarks im Code immer beibehalten.



Die Codeformatierung habe ich noch nicht umgesetzt.
Ich habe aber z.B. vor, verkettete Anweisungen zu berücksichtigen (wenn die neue Zeile mit einem Punkt beginnt und Methoden eines Objektes oder Interfaces aufrufen) und z.B. read und write von aufeinanderfolgenden Properties untereinander auszurichten.



Um das richtig einzuordnen, ist sicherlich sinnvoll, mal das Video anzuschauen.
Aus meiner Sicht löst das eigentlich genau das, was mir an Delphi schon lange auf die Nerven ging - abgesehen davon, dass es noch nicht ganz fertig ist. Daher bin ich überrascht, dass es da so wenig Resonanz gab bisher.

Ich dachte, es lag vielleicht an dem bisherigen Schwerpunkt auf Interfaces, so dass es die Leute vielleicht übersehen haben, die (noch) nicht mit Interfaces arbeiten. Daher der neue Thread.


PS: Einen Metadateneditor habe ich nicht vor. Da bringen aber aktuelle Delphi IDEs m.E. ja auch schon etwas mit.

[Uwe Raabe]

Zitat von KodeZwerg:

Ps: Ich hätte da auch etwas was mir in der IDE in Bezug auf Units fehlt oder ich habe es einfach noch nicht entdeckt.
Man kann ja intern für die IDE Hilfstexte an Methoden knüpfen.
Beispiel ///<summary></summary> oder ///<returns></returns> usw.
Solche Angaben meine ich, dafür einen IDE-Editor integrieren, das wär ein feature was mir fehlt.

Das gibt's schon: Documentation Insight

[KodeZwerg]

@stahli: Danke nochmal fürs Erklären was Du so vor hast, habs nun verstanden!

ot

Zitat von Uwe Raabe:

Das gibt's schon: Documentation Insight

Danke, das was ich da sehe ist genau was ich wollte, nur ohne die Eigentliche Programm funktionalität. Vielleicht finde ich ja so etwas auch einzeln. Danke auf jedenfall für Antwort!
/ot

[himitsu]

Ein Documentation-Insight Embarcadero-Edition (Light-Variante) gab es für paar Jahre kostenlos in der IDE, aber der Herstelle wollte es nicht mehr, womit man es sich nun nur noch kaufen kann.

Einen Editor dafür gab es von Embarcadero noch nie ... nur den vom Documentation-Insight.
Es gibt aber schon immer die Code-Templates, auch wenn die nicht so "schön" intuitiv sind.

Im Delphi gibt es standardmäßig nur das Help-Insight, was ein Minimum an Funktionalität bietet. (das kann man durch das große Documentation-Insight ersetzen)

[Luckie]

Deine automatische Codevervollständigung erstellt Code, der sich nicht kompilieren lass. Hier zum Beispiel: Result := ?; . Das würde ich nicht machen. Zum einem leässt es sich nicht testweise kompilieren und zum anderen zeigt ErrorInsight dann immer Fehler an und man ist verwirrt, weil man an den Stellen ja noch nichts gemacht hat. Auch bringt das wohl manchmal den ErrorInsight durcheinander.

[TurboMagic]

Zitat von KodeZwerg:

Ps: Ich hätte da auch etwas was mir in der IDE in Bezug auf Units fehlt oder ich habe es einfach noch nicht entdeckt.
Man kann ja intern für die IDE Hilfstexte an Methoden knüpfen.
Beispiel ///<summary></summary> oder ///<returns></returns> usw.
Solche Angaben meine ich, dafür einen IDE-Editor integrieren, das wär ein feature was mir fehlt.

Schon mal Strg-J im Editor gedrückt, dann s gedrückt und "summary" aus der Liste mittels Enter
ausgewählt (ggf. vorher mittels Cursor runter hinscrollen)?

[KodeZwerg]

Zitat von TurboMagic:

Zitat von KodeZwerg:

Ps: Ich hätte da auch etwas was mir in der IDE in Bezug auf Units fehlt oder ich habe es einfach noch nicht entdeckt.
Man kann ja intern für die IDE Hilfstexte an Methoden knüpfen.
Beispiel ///<summary></summary> oder ///<returns></returns> usw.
Solche Angaben meine ich, dafür einen IDE-Editor integrieren, das wär ein feature was mir fehlt.

Schon mal Strg-J im Editor gedrückt, dann s gedrückt und "summary" aus der Liste mittels Enter
ausgewählt (ggf. vorher mittels Cursor runter hinscrollen)?

Wenn ich CTRL-J drücke, erstellt der eine Neue Funktion.
Drücke ich dann "s" wird der Name der Funktion mit "s" ersetzt.
Obwohl Du nur einen Satz geschrieben hast kann ich es nicht nachvollziehen.

[EWeiss]

Zitat:

Wo hast du dir denn das mit den Unterstrichen für Setter und Getter abgeguckt? Das sieht ja gruselig aus.

Die Region für Getter und Setter [Getter-Setter] in den Interfaces zu erstellen sieht gut aus Damit ist das Interface gut überschaubar.
Habe es in meiner LiB(API) auch addiert

gruss