Clone version_bumper and adopt to this project

Updated main README with:

• usage of TAsynCommand (general information)
• sample implementation (copy this topic to doc ver 1.0)
• sample execution (copy this topic to doc ver 1.0)

Build prototype test suite for TAsyncCommand. Problems:

• New to wait until thread will finish
• Move fThread into protected if it will be required

Cleanup

1. Change methods of TCommandAction: SetupSomething => WithSomething
2. Update documentation

Methods list:

• SetupCaption => WithCaption
• SetupCommand => WithCommand
• SetupShortCut => WithShortCut
• SetupEventOnUpdate => WithEventOnUpdate
• SetupEventAfterExecution => WithEventAfterExecution
• Inject => WithInjection

Remove release date from:

• Pattern.Command.pas

Change ReleaseVersion to Version in:

• Pattern.Command.pas

Add siganture to:

• TCommandAction.pas

Update sample project (folder samples) to Updated demo do new API

Read article and test with TActionCommand:

Runtime assigned action's ShortCut does not fire in custom component

https://stackoverflow.com/questions/27053769/runtime-assigned-actions-shortcut-does-not-fire-in-custom-component

actual:

TAsyncCommand = class (TCommand)
    procedure DoPrepare; override;
    procedure DoTeardown; override;

refactor to:

TAsyncCommand = class (TCommand)
    procedure WithEventBeforeStart(TProc)
    procedure WithEventAfterFinish(TProc)

(Review current documentation and add missing points)

List:

1. Section [TCommand memory management]
   • TBD: Describe advantages of management base on TComponent solution using owner.
2. Updated and expand TAsyncCommand documentation
   • Events list
   • sample
3. TCommandAction refactoring:
   • SetupCaption => WithCaption
   • SetupCommand => WithCommand
   • SetupShortCut => WithShortCut
   • SetupEventOnUpdate => WithEventOnUpdate
   • SetupEventAfterExecution => WithEventAfterExecution
   • Inject => WithInjection
4. TAsyncCommand events:
   • WithEventBeforeStart
   • WithEventAfterFinish
   • thread name for the debugging
     • fThread.NameThreadForDebugging('TAsyncCommand - '+Self.ClassName);
5. TAsyncCommand - OnUpdate with TTimer
   • WithEventOnProgress(aProc)
   • property ProgressInterval: integer;
   • function GetElapsedTime: TTimeSpan;
6. All Commands:
   • IsBusy function
   • GetElapsedTime / GetElapsedTimeMs
7. TAsyncCommand.Terminate

Select one o variant (A - E) from #1

Add:

TAsyncCommand.Terminate: boolean

Allow to inject inherited classes.

Remove command construction code from: TCommandVclFactory class:
move to TCommand class

1. Create command
   • TCommandVclFactory.CreateCommand<TMyCommand>(Owner,[injections...])
   • change to
   • TMyCommand.CreateAndInject(Owner,[injections...])
2. Execute command
   • TCommandVclFactory.ExecuteCommand<TMyCommand>([injections...]);
   • change to
   • TCommand.Execute<TMyCommand>([injections...]);

• TCommandFactoryTests =>
  • TFactoryNoInjectionTest
  • TFactoryWithInjectionTest

(maybe saperate units too) - now is too early IMHO

Allow to inject: integer, word, double, boolean,

SetupCaption => WithCaption
SetupCommand => WithCommand
SetupShortCut => WithShortCut
SetupEventOnUpdate => WithEventOnUpdate
SetupEventAfterExecution => WithEventAfterExecution
Inject => WithInjection

Update samples and doc

See #22 for more references

As a developer, I want to:

• Inject interfaces
• inject object which are implemented matched interface

Update properties in unit Tests.TCommandFactory
in class: TAdvancedCommand = class(TCommand)

• use base classes TStrings and TStream
• add isPrime method
• add Flag injection: ProcessNonPrimeNumbers: boolean

When

• getting metadata form TComponent based object with:

  TClassPropertyList.Create(AnyComponentObject);

Then

• Check TComponent standard published properties:
• Ignore all standard properties:
• in Delphi 10.3 there are two such properties:
  1. Name: TComponentName
  2. Tag: NativeInt

TAsyncCommand = class (TCommand)
    procedure WithEventOnProgress(TProc)
    property ProgressInterval: integer;
    function GetElapsedTime: TTimeSpan;

Add diagnostics to TAsyncCommand:

• uses System.Diagnostics
• fStopwatch: TStopwatch;

File: Readme.md

variant A

// function InjectProperty(const APropertyName String; Value:Variant): TInjectRec;
Button2.Action := TCommandVclFactory.CreateCommandAction<TButon2Command>(Self,
  'Run command: Button2', [InjectProperty('Memo', Memo1),
  InjectProperty('Edit', Edit1)]);

variant B

// TIjector = class
//    function InjectProperty(APropertyName, Value): TIjector;
Button2.Action := TCommandVclFactory.CreateCommandAction<TButon2Command>(Self,
   'Run command: Button2', TIjector.Create.InjectProperty('Memo', Memo1)
   .InjectProperty('Edit', Edit1));

variant C

Button2.Action := TCommandVclFactory.CreateCommandAction<TButon2Command>(Self,
   'Run command: Button2', ['Memo','Edit'], [Memo1,Edit1]);

variant D

Button2.Action := TCommandVclFactory.CreateCommandAction<TButon2Command>(Self,
  'Run command: Button2', [['property.Memo',Memo1],['Edit',Edit1]]);

function TAsyncCommand.Synchronize(aThreadMethod: TThreadMethod;

usage:

Synchronize(procedure
  begin
    fProgressBar.Position := i + 1;
  end);

procedure DoGuard; shouldn't be mandatory to implement in TCommand and in TAsyncCommand. Like in sample bellow:

type
  TSamapleCommand
  protected
    procedure DoExecute; override;
  end;

TAsyncCommand unit:

• Pattern.Command.pas ==> Pattern.AsyncCommand.pas

Extract:

• TDiceRollCommand and TAsyncDiceRollCommand to separate demo

DUnitxCommand.dpr ⇒ TestCommandPattern.dpr
Tests.TCommandFactory.pas ⇒ Tests.TCommand.pas

• class: TestCommndFactory_BasicCommand ⇒ TestBasicCommnd
• class: TestCommndFactory_StrigListCommand ⇒ TestStrigListCommnd
• class: TestCommndFactory_AdvancedCommand ⇒ TestAdvancedCommnd

See TODO in comment:

procedure TAsyncCommand.Execute;
begin
  DoGuard;
  DoPrepare;
  fIsWorking := True;
  TThread.CreateAnonymousThread(
    procedure
    begin
      DoExecute;
      // TODO: lock or critical section is required bellow (critical !!!)
      fIsWorking := True;
    end);
end;

Refactor component publised properties

• Separate class for analysing published TComponent properties
• add unit tests

Requires #5 to be closed

Check:

1. Expected System.EAssertionFailed exception if no required exection was provided (use TCommandStringList class)
2. Command with two TStringList published properties (some variants: eg. change injection order)
3. Command with two TStringList and TComponent published properties between

Allow to inject inherited class, example:

type
  TMyComponent = class(TComponent)
  strict private
    FStrings: TStrings;
  published
    property Strings: TStrings read FStrings write FStrings;
  end;

allow to inject:

  var aComponent := TMyComponent.Create(aOwner);
  var aStringList := TStringList.Create;
  TComponentInjector.InjectProperties(aComponent, [aStringList]);
  Assert (aComponent.Strings = aStringList);