Initial commit

Author: e2d2-dev

README.md

@@ -0,0 +1,39 @@
+# Introduction
+Adds and removes traits & interfaces from classes in one command.
+
+# Installation
+Install package.
+```bash
+composer require e2d2-dev/modify-classes
+```
+
+# Usage
+It automatically detects if it is an interface or a trait. You can add or remove one or many in one step.
+Don't forget to use save.
+
+## Add
+   ```php
+   use Betta\ModifyClasses\Modifier;
+   
+   // add one
+   Modifier::make(Your::class)->add(YourInterface::class)->save()
+   
+   // add many
+   Modifier::make(Your::class)->addMany([
+        YourInterface::class,
+        YourSecondIntfaceOrTrait::class,
+   ])->save()
+   ```
+## Remove
+   ```php
+   use Betta\ModifyClasses\Modifier;
+   
+   // add one
+   Modifier::make(Your::class)->remove(YourInterface::class)->save()
+   
+   // add many
+   Modifier::make(Your::class)->removeMany([
+        YourInterface::class,
+        YourSecondIntfaceOrTrait::class,
+   ])->save()
+   ```

composer.json

@@ -0,0 +1,13 @@
+{
+	"name": "e2d2-dev/modify-classes",
+	"description": "",
+	"type": "library",
+	"license": "MIT",
+	"require": {},
+	"autoload": {
+		"psr-4": {
+			"Betta\\ModifyClasses\\": "src/"
+		}
+	},
+	"minimum-stability": "stable"
+}

src/Concerns/CanInject.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns;
+
+trait CanInject
+{
+    use HasInjectables;
+
+    public function addMany(array $injectables): static
+    {
+        foreach ($injectables as $injectable) {
+            $this->add($injectable);
+        }
+        return $this;
+    }
+
+    public function add(string $injectable): static
+    {
+        $this->injectable = $injectable;
+        $this->injectableType();
+        $this->handleInjectable();
+        $this->reset();
+
+        return $this;
+    }
+
+    protected function injectAfter($needle, $inject): void
+    {
+        $this->buffer = str($this->buffer)
+            ->before($needle)
+            ->append($needle)
+            ->append($inject)
+            ->append(
+                str($this->buffer)->after($needle)
+            );
+    }
+
+    protected function handleInjectable(): void
+    {
+        match ($this->getInjectableType()) {
+            'interface' => $this->injectInterface(),
+            'trait' => $this->injectTrait(),
+        };
+    }
+
+    protected function injectUse(): void
+    {
+        $use = "use {$this->getInjectableName()}";
+
+        if ($this->buffer->contains($use)) {
+            $name = $this->getInjectableName();
+            $replace = $this->buffer
+                ->after($this->getRawDescriptor()->toString())
+                ->before($name)
+                ->afterLast("\n")
+                ->append($name)
+                ->toString();
+
+            $this->buffer = $this->buffer->replace($replace, "\t$use");
+
+            return;
+        }
+
+        $replace = $this->buffer->after(
+            $this->getRawDescriptor()->toString()
+        )->after('{');
+
+        $this->buffer = $this->buffer->replace($replace, $replace->prepend("\n\t$use;"));
+    }
+}

src/Concerns/CanRemove.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns;
+
+trait CanRemove
+{
+    protected ?string $removeable = null;
+    protected ?string $removeableType = null;
+
+    public function removeMany(array $injectables): static
+    {
+        foreach ($injectables as $injectable) {
+            $this->remove($injectable);
+        }
+        return $this;
+    }
+
+    public function remove(string $removeable): static
+    {
+        $this->removeable = $removeable;
+        $this->removeableType();
+        $this->handleRemoveable();
+        $this->reset();
+
+        return $this;
+    }
+
+    protected function getRemoveable(): ?string
+    {
+        return $this->removeable;
+    }
+
+    protected function getRemoveableName(): string
+    {
+        return class_basename($this->getRemoveable());
+    }
+
+    protected function removeInterface(): void
+    {
+        if (! $this->hasInterface()) {
+            return;
+        }
+        $this->injectDescriptor();
+        $this->removeImport($this->getRemoveable());
+    }
+
+    protected function hasInterface(): bool
+    {
+        return $this->getImplements()->filter(fn ($interface) => $interface === $this->getRemoveable())->isNotEmpty();
+    }
+
+    protected function removeTrait(): void
+    {
+        $this->removeImport($this->getRemoveable());
+        $this->removeUse();
+    }
+
+    protected function removeUse(): void
+    {
+        collect([
+            "use {$this->getRemoveable()};",
+            "use {$this->getRemoveableName()};",
+        ])->each(fn ($line) => $this->buffer = $this->buffer->remove($line));
+    }
+
+    protected function handleRemoveable(): void
+    {
+        match ($this->getRemoveableType()) {
+            'interface' => $this->removeInterface(),
+            'trait' => $this->removeTrait(),
+        };
+    }
+
+    public function getRemoveableType(): ?string
+    {
+        return $this->removeableType;
+    }
+
+    protected function removeableType(): void
+    {
+        $this->removeableType = $this->getType($this->removeable);
+    }
+}

src/Concerns/CanReset.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns;
+
+trait CanReset
+{
+    protected function reset(): void
+    {
+        $this->injectable = null;
+        $this->injectableType = null;
+        $this->removeable = null;
+        $this->removeableType = null;
+    }
+}

src/Concerns/Class/CanExtend.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns\Class;
+
+trait CanExtend
+{
+    protected ?string $extendsName;
+
+    protected ?string $extendsClass;
+
+    protected function getExtendsName(): ?string
+    {
+        return $this->extendsName ??= ! $this->classExtends()
+            ? null
+            : $this->getDescriptor()
+                ->after('extends')
+                ->before('implements')
+                ->trim();
+    }
+
+    protected function classExtends(): ?string
+    {
+        return $this->getDescriptor()->contains('extends');
+    }
+
+    protected function getExtendsClass(): ?string
+    {
+        return $this->extendsClass ??= $this->getImportedClass($this->getExtendsName());
+    }
+}

src/Concerns/Class/CanImplement.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns\Class;
+
+use Illuminate\Support\Collection;
+
+trait CanImplement
+{
+    protected Collection $implements;
+
+    protected function getImplements(): Collection
+    {
+        return $this->implements ??= ! $this->getDescriptor()->contains('implements')
+            ? collect() :
+                $this->getDescriptor()
+                    ->after('implements')
+                    ->trim()
+                    ->remove(' ')
+                    ->explode(',')
+                    ->mapWithKeys(fn (string $item) => [$item => $this->getImportedClass($item)]);
+    }
+
+    protected function hasImplements(): bool
+    {
+        return $this->getImplements()->isNotEmpty();
+    }
+}

src/Concerns/Class/HasDescriptor.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns\Class;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Stringable;
+
+trait HasDescriptor
+{
+    protected Stringable $descriptor;
+
+    protected function getDescriptor(): Stringable
+    {
+        return $this->descriptor ??= $this->getRawDescriptor()
+            ->before('//')
+            ->before('/*')
+            ->trim()
+            ->trim("\n")
+            ->trim("\t");
+    }
+
+    protected function getRawDescriptor(): Stringable
+    {
+        return $this->buffer
+            ->after("class {$this->getClassBasename()}")
+            ->ltrim()
+            ->before("\n{");
+    }
+
+    protected function injectDescriptor(): void
+    {
+        $replace = $this->getRawDescriptor();
+
+        if ($replace->contains('//')) {
+            $replace = $replace->before('//')->rtrim();
+        }
+
+        $this->buffer = $this->buffer->replace(
+            $replace->toString(),
+            $this->constructDescriptor()
+        );
+    }
+
+    protected function constructDescriptor(): string
+    {
+        $result = [];
+
+        if ($this->getExtendsName()) {
+            $result[] = "extends {$this->getExtendsName()}";
+        }
+
+        $implements = $this->constructImplements();
+
+        if ($implements->count()) {
+            $result[] = 'implements '.$implements->implode(', ');
+        }
+
+        return implode(' ', $result);
+    }
+
+    protected function constructImplements(): Collection
+    {
+        return $this->getImplements()
+            ->reject(fn ($interface) => $interface === $this->getRemoveable())
+            ->flip()
+            ->push(
+                class_basename($this->getInjectable())
+            )
+            ->filter()
+            ->values()
+            ->unique();
+    }
+}

src/Concerns/Class/HasImported.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Betta\ModifyClasses\Concerns\Class;
+
+use Illuminate\Support\Stringable;
+
+trait HasImported
+{
+    protected function getClassImportLine(string $name): Stringable
+    {
+        return $this->buffer
+            ->after($this->getClassNamespace().';')
+            ->trim()
+            ->before('class ')
+            ->beforeLast("\n")
+            ->explode('use ')
+            ->filter(fn ($line) => str($line)->afterLast('\\')->contains($name))
+            ->map(fn ($line) => str($line)->remove(';')->trim())
+            ->first();
+    }
+
+    protected function getImportedClass(string $name): string
+    {
+        return match (true) {
+            class_exists($name) => $name,
+            $this->importedIsAlias($name) => $this->getClassImportLine($name)->before(' as ')->trim()->toString(),
+            default => $this->getClassImportLine($name)->toString(),
+        };
+    }
+
+    protected function importedIsAlias(string $name): bool
+    {
+        return $this->getClassImportLine($name)->contains(' as ');
+    }
+}