Getting Started

Minimal Steps

Installation: Add the package to your Laravel project via Composer:
```
composer require --dev moox/devtools
```
This installs a curated set of dev tools including Pest, Larastan (PHPStan), Pint, and Livewire/Pest plugins.
First Use Case: Run your first Pest test to verify integration:
```
./vendor/bin/pest
```
If successful, you’ll see output like:
```
PASS  Tests/Unit/ExampleTest.php
✓ it works (0.1s)
```
Where to Look First:
- Pest Configuration: Check tests/Pest.php for plugin and preset settings.
- Larastan Rules: Inspect .larastan.neon in the project root for static analysis rules.
- Pint Rules: Review .pint.php for code formatting preferences.
- Blade Capture: Use {{ @capture }} in Blade templates for testing (documented in README.md if available).

Implementation Patterns

Daily Workflows

Testing with Pest:

Unit Tests: Place in tests/Unit/ with Pest’s fluent syntax:

test('user can be created', function () {
    $user = User::factory()->create();
    expect($user->email)->toBeValid();
});

Feature Tests: Use in tests/Feature/ with Laravel helpers:

test('GET /dashboard', function () {
    $response = $this->get('/dashboard');
    $response->assertStatus(200);
});

Livewire Tests: Leverage the included plugin:

test('livewire component renders', function () {
    Livewire::test(ProfileComponent::class)
        ->assertSee('Profile');
});

Static Analysis:

Run Larastan in CI/CD pipelines:

./vendor/bin/larastan analyse --level=5 app

Integrate with Git hooks for pre-commit checks:

./vendor/bin/larastan analyse --memory-limit=1G --error-format=json

Code Formatting:

Auto-format codebase:

./vendor/bin/pint --test  # Dry run
./vendor/bin/pint        # Apply fixes

Add to composer.json scripts:

"scripts": {
    "lint": "pint",
    "test": "pest"
}

Blade Testing:

Capture Blade output for assertions:

{{ @capture('header') }}
    <h1>{{ $title }}</h1>
{{ @endcapture }}

test('blade header', function () {
    BladeCapture::capture('header', ['title' => 'Test']);
    expect(BladeCapture::get('header'))->toContain('Test');
});

Integration Tips

Laravel Projects:
- Use pest-plugin-laravel for seamless Laravel integration (e.g., actingAs, assertDatabaseHas).
- Configure Testbench in phpunit.xml for legacy tests:
```
<testsuites>
    <testsuite name="Unit">
        <directory>./tests/Unit</directory>
    </testsuite>
</testsuites>
```

Livewire:

Test components with the included plugin:

test('livewire emits events', function () {
    Livewire::test(Counter::class)
        ->emit('increment')
        ->assertEmitted('increment');
});

CI/CD:

Example GitHub Actions workflow:

name: Laravel Tests
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-php@v3
        with:
          php-version: '8.2'
      - run: composer install --dev
      - run: ./vendor/bin/pest
      - run: ./vendor/bin/larastan analyse --level=5 app
      - run: ./vendor/bin/pint --test

Customization:
- Override default configurations by placing custom files in the project root (e.g., .pint.php, .larastan.neon).

Gotchas and Tips

Pitfalls

Version Lock-in:
- The meta-package pins specific versions of tools (e.g., Pest v4, Pint v1). Upgrading individual tools may require manual version overrides in composer.json.
- Fix: Use replace in composer.json to force a version:
```
"replace": {
    "pestphp/pest": "6.0"
}
```
Larastan Strictness:
- Default rules may flag false positives (e.g., Laravel magic methods). Customize .larastan.neon:
```
ignores = [
    'app/Helpers/*',
    'app/Models/Concerns/*'
]
```
Pest Plugin Conflicts:
- Plugins like pest-plugin-livewire may conflict with custom Pest configurations. Ensure tests/Pest.php is minimal:
```
uses(Tests\TestCase::class)->in('Feature');
uses(PestPluginLivewire::class)->in('Feature');
```
Blade Capture Limitations:
- The @capture directive requires Laravel’s Blade compiler. Gotcha: Fails in non-Laravel contexts (e.g., CLI scripts).
- Fix: Use BladeCapture::capture() in tests instead:
```
BladeCapture::capture('template', ['data' => $data]);
```

Testbench vs. Pest:

Mixing TestCase from Testbench and Pest can cause conflicts. Stick to one:

// Pest
use Tests\TestCase;
class MyTest extends TestCase { ... }

// Testbench (legacy)
use Orchestra\Testbench\TestCase;
class LegacyTest extends TestCase { ... }

Pint Presets:
- The default Pint preset may not match your team’s style. Customize .pint.php:
```
return Pint::laravel()->withRules([
    Pint\Rule\NoTrailingWhitespace::class,
]);
```

Debugging

Pest:
- Enable verbose output:
```
./vendor/bin/pest --debug
```
- Check for plugin loading errors in bootstrap/Pest.php.
Larastan:
- Generate a baseline for gradual adoption:
```
./vendor/bin/larastan baseline app
```
- Use --error-format=json for CI-friendly parsing.

Composer Conflicts:

Resolve dependency conflicts with:

composer why-not moox/devtools
composer why pestphp/pest

Extension Points

Custom Pest Plugins:
- Publish plugins to composer.json and register in tests/Pest.php:
```
uses(MyCustomPlugin::class)->in('Unit');
```

Larastan Rules:

Extend rules in .larastan.neon:

extends = [larastan/laravel.neon]
rules = [
    \Moox\CustomRule::class
]

Pint Rules:

Add custom rules to .pint.php:

return Pint::laravel()->withRules([
    Pint\Rule\NoTrailingWhitespace::class,
    Pint\Rule\LineEnding::class,
]);

Testbench Extensions:

Override providers in tests/CreatesApplication.php:

protected function getPackageProviders($app) {
    return [
        \Moox\YourPackage\ServiceProvider::class,
    ];
}

Git Hooks:

Add pre-commit checks in .git/hooks/pre-commit:

#!/bin/sh
./vendor/bin/pint --test || exit 1
./vendor/bin/larastan analyse --level=5 --error-format=json | jq -e '. >/dev/null' || exit 1

Devtools Laravel Package