Awesome-claude-code create-template-method

Generates Template Method pattern for PHP 8.4. Creates abstract algorithm skeleton with customizable steps, allowing subclasses to override specific parts without changing structure. Includes unit tests.

install

source · Clone the upstream repo

git clone https://github.com/dykyi-roman/awesome-claude-code

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/dykyi-roman/awesome-claude-code "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/create-template-method" ~/.claude/skills/dykyi-roman-awesome-claude-code-create-template-method && rm -rf "$T"

manifest: skills/create-template-method/SKILL.md

source content

Template Method Pattern Generator

Creates Template Method pattern infrastructure for algorithm skeletons with customizable steps.

When to Use

Scenario	Example
Common algorithm structure	Data import/export with format variations
Controlled extension points	Report generation with customizable sections
Code reuse across variants	Order processing with type-specific steps
Invariant parts protection	Template rendering with hooks

Component Characteristics

Abstract Template Class

Defines algorithm skeleton
Implements invariant steps
Declares abstract/hook methods
Calls methods in sequence

Concrete Implementations

Override specific steps
Provide algorithm variants
Inherit common behavior
Maintain overall structure

Hook Methods

Optional override points
Default empty implementation
Allow customization
Don't break flow

Generation Process

Step 1: Generate Abstract Template

Path:

src/Domain/{BoundedContext}/Template/

```
Abstract{Name}Template.php
```
— Algorithm skeleton with template method

Step 2: Generate Concrete Templates

Path:

src/Domain/{BoundedContext}/Template/

src/Application/{BoundedContext}/

```
{Variant1}{Name}Template.php
```
— First variant implementation
```
{Variant2}{Name}Template.php
```
— Second variant implementation
```
{Variant3}{Name}Template.php
```
— Third variant implementation

Step 3: Generate Support Classes (Optional)

Path:

src/Domain/{BoundedContext}/ValueObject/

```
{Name}Result.php
```
— Result value object
```
{Name}Config.php
```
— Configuration value object

Step 4: Generate Tests

```
{Variant}{Name}TemplateTest.php
```
— Individual template tests
```
Abstract{Name}TemplateTest.php
```
— Template skeleton tests

File Placement

Component	Path
Abstract Template	`src/Domain/{BoundedContext}/Template/`
Concrete Templates (Domain logic)	`src/Domain/{BoundedContext}/Template/`
Concrete Templates (App logic)	`src/Application/{BoundedContext}/`
Unit Tests	`tests/Unit/Domain/{BoundedContext}/Template/`

Naming Conventions

Component	Pattern	Example
Abstract	`Abstract{Name}Template`	`AbstractDataImporterTemplate`
Concrete	`{Variant}{Name}Template`	`CsvDataImporterTemplate`
Template Method	`execute()` or `process()`	`execute()`
Hook Method	`before{Step}()` , `after{Step}()`	`beforeValidation()`
Test	`{ClassName}Test`	`CsvDataImporterTemplateTest`

Quick Template Reference

Abstract Template

abstract readonly class Abstract{Name}Template
{
    public function execute({InputType} $input): {OutputType}
    {
        $this->validate($input);
        $data = $this->extract($input);
        $transformed = $this->transform($data);
        $result = $this->load($transformed);
        $this->afterLoad($result);

        return $result;
    }

    abstract protected function extract({InputType} $input): array;
    abstract protected function transform(array $data): array;

    protected function validate({InputType} $input): void
    {
        // Default validation
    }

    protected function afterLoad({OutputType} $result): void
    {
        // Hook method - optional override
    }
}

Concrete Template

final readonly class {Variant}{Name}Template extends Abstract{Name}Template
{
    protected function extract({InputType} $input): array
    {
        // Variant-specific extraction
    }

    protected function transform(array $data): array
    {
        // Variant-specific transformation
    }
}

Usage Example

// Create templates for different formats
$csvImporter = new CsvDataImporterTemplate();
$jsonImporter = new JsonDataImporterTemplate();
$xmlImporter = new XmlDataImporterTemplate();

// Use same interface
$result = $csvImporter->execute($fileContent);

Common Template Method Variants

Domain	Variants
Data Import	CSV, JSON, XML, Excel
Report Generation	PDF, Excel, HTML, Email
Order Processing	Standard, Express, International
Document Rendering	Markdown, LaTeX, HTML
Payment Flow	Card, Bank Transfer, Digital Wallet

Anti-patterns to Avoid

Anti-pattern	Problem	Solution
Too many abstract methods	Hard to implement	Use hook methods with defaults
Public template steps	Breaks encapsulation	Make steps protected/private
Mutable state	Side effects	Use readonly classes, pass data
Deep inheritance	Complexity	Limit to 2-3 levels max
Breaking LSP	Inconsistent behavior	Maintain contract in overrides

References

For complete PHP templates and examples, see:

```
references/templates.md
```
— Abstract Template, Concrete Template, Hook Methods templates
```
references/examples.md
```
— DataImporter, ReportGenerator, OrderProcessor with tests