PHP code example of grifart / scaffolder

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

grifart / scaffolder example snippets

  

  use Grifart\ClassScaffolder\Capabilities;
  use function Grifart\ClassScaffolder\Definition\definitionOf;
  use Grifart\ClassScaffolder\Definition\Types;

  return [
      definitionOf(Article::class, withFields: [
          'id' => 'int',
          'title' => 'string',
          'content' => 'string',
          'tags' => Types\listOf('string'),
      ])
          ->withField('archivedAt', Types\nullable(\DateTime::class))
          ->with(
              Capabilities\constructorWithPromotedProperties(),
              Capabilities\getters(),
          )
  ];
  

  

  /**
   * Do not edit. This is generated file. Modify definition file instead.
   */

  declare(strict_types=1);

  final class Article
  {
      /**
       * @param string[] $tags
       */
      public function __construct(
          private int $id,
          private string $title,
          private string $content,
          private array $tags,
          private ?\DateTime $archivedAt,
      ) {
      }


      public function getId(): int
      {
          return $this->id;
      }


      public function getTitle(): string
      {
          return $this->title;
      }


      public function getContent(): string
      {
          return $this->content;
      }


      /**
       * @return string[]
       */
      public function getTags(): array
      {
          return $this->tags;
      }


      public function getArchivedAt(): ?\DateTime
      {
          return $this->archivedAt;
      }
  }
  

    use Grifart\ClassScaffolder\Capabilities;
    use Grifart\ClassScaffolder\Definition\definitionOf;
    use Grifart\ClassScaffolder\Definition\Types;

    return [
        definitionOf(Article::class, withFields: [
            'id' => 'int',
            'title' => 'string',
            'content' => 'string',
            'tags' => Types\listOf('string'),
        ])
            ->withField('archivedAt', Types\nullable(\DateTime::class))
            ->with(
                Capabilities\constructorWithPromotedProperties(),
                Capabilities\getters(),
            )
    ];

  $definition->withField('field', 'string')
  

  private string $field;
  

  $definition->withField('field', \Iterator::class)
  

  private Iterator $field;
  

  $otherDefinition = definitionOf(OtherClass::class);
  $definition->withField('field', $otherDefinition);
  

  private OtherClass $field;
  

  $definition->withField('field', Types\nullable('string'))
  

  private ?string $field;
  

  $definition->withField('field', Types\listOf('string'))
  

  /** @var string[] */
  private array $field;
  

  $definition->withField('field', Types\collection(Collection::class, UserId::class, User::class))
  

  /** @var Collection<UserId, User> */
  private Collection $field;
  

  $definition->withField('field', Types\generic(\SerializedValue::class, User::class))
  

  /** @var SerializedValue<User> */
  private SerializedValue $field;
  

  $definition->withField('field', Types\arrayShape(['key' => 'string', 'optional?' => 'int']))
  

  /** @var array{key: string, optional?: int} */
  private array $field;
  

  $definition->withField('field', Types\tuple('string', Types\nullable('int')))
  

  /** @var array{string, int|null} */
  private array $field;
  

  $definition->withField('field', Types\union('int', 'string'))
             ->withField('other', Types\intersection(\Traversable::class, \Countable::class))
  

  private int|string $field;
  private Traversable&Countable $other;
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\properties())
  

  final class Foo
  {
      private string $field;
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\properties())
      ->with(Capabilities\initializingConstructor())
  

  final class Foo
  {
      private string $field;

      public function __construct(string $field)
      {
          $this->field = $field;
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
  

  final class Foo
  {
      public function __construct(private string $field)
      {
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\readonlyProperties())
  

  final class Foo
  {
      public function __construct(public readonly string $field)
      {
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\privatizedConstructor())
  

  final class Foo
  {
      private function __construct(private string $field)
      {
      }
  }
  

  definitionOf(FooEvent::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\privatizedConstructor())
      ->with(Capabilities\namedConstructor('occurred'))
  

  final class FooEvent
  {
      private function __construct(private string $field)
      {
      }

      public static function occurred(string $field): self
      {
          return new self($field);
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\getters())
  

  final class Foo
  {
      public function __construct(private string $field)
      {
      }

      public function getField(): string
      {
          return $this->field;
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\setters())
  

  final class Foo
  {
      public function __construct(private string $field)
      {
      }

      public function setField(string $field): void
      {
          $this->field = $field;
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\constructorWithPromotedProperties())
      ->with(Capabilities\getters())
  

  final class Foo
  {
      public function __construct(private string $field)
      {
      }

      public function withField(string $field): self
      {
          $self = clone $this;
          $self->field = $field;
          return $self;
      }
  }
  

  definitionOf(Foo::class)
      ->withField('field', 'string')
      ->with(Capabilities\implementedInterface(\IteratorAggregate::class))
  

  final class Foo implements IteratorAggregate
  {
  }
  

return [
    definitionOf(Name::class, withFields: [
        'firstName' => 'string',
        'lastName' => 'string',
    ])
        ->with(Capabilities\constructorWithPromotedProperties())
        ->with(Capabilities\getters()),
];

/**
 * Do not edit. This is generated file. Modify definition file instead.
 */

declare(strict_types=1);

final class Name
{
    public function __construct(
        private string $firstName,
        private string $lastName,
    ) {
    }
    
    
    public function getFirstName(): string{
        return $this->firstName;
    }


    public function getLastName(): string{
        return $this->lastName;
    }
}

#[\Grifart\ClassScaffolder\Preserve]
public function getFullName(): string
{
    return $this->firstName . ' ' . $this->lastName;
}

$definition->with(Capabilities\preservedAnnotatedMethods())

use Grifart\ClassScaffolder\Capabilities\Capability;
use Grifart\ClassScaffolder\ClassInNamespace;
use Grifart\ClassScaffolder\Definition\ClassDefinition;

final class GetFullNameMethod implements Capability
{
    public function applyTo(
        ClassDefinition $definition, // lets you access the list of defined fields
        ClassInNamespace $draft,     // this is the prescription of the newly generated class
        ?ClassInNamespace $current,  // this describes the original class if it already exists
    ): void
    {
        $draft->getClassType()->addMethod('getFullName')
            ->setReturnType('string')
            ->addBody('return $this->firstName . " " . $this->lastName;');
    }
}

> ->with(new class implements Capability {
>   function applyTo() { /* the transformation */ }
> });
> 

use Grifart\ClassScaffolder\Capabilities;
use Grifart\ClassScaffolder\Definition\ClassDefinition;
use function Grifart\ClassScaffolder\Definition\definitionOf;

function valueObject(string $className): ClassDefinition
{
    return definitionOf($className)
        ->with(Capabilities\constructorWithPromotedProperties())
        ->with(Capabilities\getters());
}

return [
    $tag = valueObject(Tag::class)
        ->withField('name', 'string'),

    valueObject(Article::class)
        ->withField('id', 'int')
        ->withField('title', 'string')
        ->withField('content', 'string')
        ->withField('tags', listOf($tag))
        ->withField('archivedAt', nullable(\DateTime::class)),
];

sh
  composer exec scaffolder scaffold .definition.php
  

sh
  php bin/console grifart:scaffolder:scaffold .definition.php