PHPackages cerbero/enum - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Utility & Helpers](/categories/utility) 4. / 5. cerbero/enum ActiveLibrary[Utility & Helpers](/categories/utility) cerbero/enum ============ Zero-dependencies package to supercharge enum functionalities. 2.3.5(5mo ago)359207.5kโ†“15.4%32MITPHPPHP ^8.1CI passing Since Jul 12Pushed 5mo ago6 watchersCompare [ Source](https://github.com/cerbero90/enum)[ Packagist](https://packagist.org/packages/cerbero/enum)[ Docs](https://github.com/cerbero90/enum)[ GitHub Sponsors](https://github.com/cerbero90)[ RSS](/packages/cerbero-enum/feed)WikiDiscussions develop Synced 1mo ago READMEChangelogDependencies (4)Versions (13)Used By (2) ๐ŸŽฒ Enum ====== [](#-enum) [![Author](https://camo.githubusercontent.com/03d9f58e6572fecfcf84799a8c87025dffcbc1c384734566c8415b359142fc7c/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f617574686f722d6365726265726f39302d626c75653f6c6f676f3d78267374796c653d666f722d7468652d6261646765266c6f676f53697a653d6175746f)](https://x.com/cerbero90)[![PHP Version](https://camo.githubusercontent.com/952fd372ab97113e9a794bbf9a5d80cbe5e4e96f098c869d152e785574efdb7c/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f6365726265726f2f656e756d3f636f6c6f723d253233373737424234266c6f676f3d706870267374796c653d666f722d7468652d6261646765266c6f676f53697a653d6175746f)](https://www.php.net)[![Latest Version](https://camo.githubusercontent.com/fdc69f21b6a3fab1a234833b8233f1193501bfc1a01c20743199250a16824286/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f6365726265726f2f656e756d2e7376673f6c6162656c3d76657273696f6e267374796c653d666f722d7468652d6261646765266c6f676f3d766974657373266c6f676f436f6c6f723d666666266c6f676f53697a653d6175746f)](https://packagist.org/packages/cerbero/enum)[![Software License](https://camo.githubusercontent.com/9ea7157111981e64ce15546f9a0acc7710430886a175c7c143eec8b6b26da197/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d626c75652e7376673f7374796c653d666f722d7468652d6261646765266c6f676f3d6c65726e61266c6f676f436f6c6f723d666666266c6f676f53697a653d6175746f)](LICENSE.md)[![Build Status](https://camo.githubusercontent.com/3fddc6e03eeb0d5e1a9844c656f8fbd15867c87d007321f95677d89cdafd931f/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f6365726265726f39302f656e756d2f6275696c642e796d6c3f6272616e63683d6d6173746572267374796c653d666f722d7468652d6261646765266c6f676f3d676974687562266c6f676f53697a653d6175746f)](https://github.com/cerbero90/enum/actions?query=workflow%3Abuild)[![Code Quality](https://camo.githubusercontent.com/758a0f2489334ef608e65914832a242275eb5902644346dfae4e2b43cfcc7f91/68747470733a2f2f696d672e736869656c64732e696f2f636f646163792f67726164652f34326437326166303963353534303731626538633763626436356335376537393f7374796c653d666f722d7468652d6261646765266c6f676f3d636f64616379266c6f676f53697a653d6175746f)](https://app.codacy.com/gh/cerbero90/enum/dashboard)[![Coverage](https://camo.githubusercontent.com/6385df045c4f632f8ae4756f06ab2110c341b05c58a5f7b917a6529a3b697dc0/68747470733a2f2f696d672e736869656c64732e696f2f636f646163792f636f7665726167652f34326437326166303963353534303731626538633763626436356335376537393f7374796c653d666f722d7468652d6261646765266c6f676f3d636f64616379266c6f676f53697a653d6175746f)](https://app.codacy.com/gh/cerbero90/enum/dashboard)[![PHPStan Level](https://camo.githubusercontent.com/047424e0daa5f9eb89165511c840728f3626285cc1c865418f2367831b7f510c/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068707374616e2d6d61782d737563636573733f7374796c653d666f722d7468652d6261646765266c6f676f3d646174613a696d6167652f706e673b6261736536342c6956424f5277304b47676f414141414e53556845556741414143414141414167434159414141427a656e72304141414762306c455156523432753158653142555a52532f79344b67386f6952334643434255795345535a4252436961426e6d45734f7a65537a73672b4b7859594f3964454566744e52715a6a78343046525a6b5470716d4f7a3553324c73586c455a42636961746b516e484447596147644679314570474d486c2f702f5064466c7432726b354f2b4a396e356e412f767466356e6564336c6e6c49537052686166426c4c524c4843744a475672422f5a4244736177326c55717a526547414334364473745459666e534347556a61614476677841436f366a337655656e4e64496d65525871646e575635617a3572726e7a655a7a6e6a384a2b4535467473636c68663373344a3443532f6f52783542766f6e385a553635464759517841776366383561374365527a2b4334315448656a75657964435a3741414b33346e7776336b48502f6f554b644f4c344b373235386646374375643432374f3438525165476b49474a37374e38665a716c726366525034642f78393057516648584c65427439645472536c776c33563635796e574c4d315345413271624e51636b626534586d77773130486d79337368696430434d636d6c454a745344736c35565a42646641674d7649337575522b6d6f4a714e364c61786d70734f42654c43446d546966434239325263516d6241554a767471414c63357351723870383667594243634664427139774f696e374e5161783665776c423672714c5a486632334650313079336c6a36754a74454267324878695643747a64335345774d4243696f364e6839757a5a344f2f764c774f5a344f554e4d324e79494750467276757a42472f2f6c5250732b5651326b316b692b65506b64383462736b7a375946705967697a457a3838503876507a596666753364445330674a4e545531515856304e71616d70524b31574977676669453471684f7969673072432b7043764b3851556f4d4c37754a564841356b635155703344537071576a6333642f4479386f4b696f694c6f367571436f614568754862314b765430394141684246706257346c4f70794d797949425153436d6f55514c517a676e694e767a2b6f624232485332527742674536644f7843794a6f676d4e6b503275315772687734514a30332b69477252395845643343544e426e366543626f3430775044774d645856314246314456473571694574626f78535550364a37312b44334e775541684c4f4952517a6d376c6e6e68595576375146762f79445a2f4c6d3575624b3244564939695a386252384a4474454235376c4e7a454e514e364f6a6f49476c70616249565a7359614d544f2b6872696b525241314a786d5358396845372f734a745679463338744b735543565a7842687a396a49337747542f514a6c41447a50417958726e6a306b496e7a47485143524d794f672f65643275486a784975453454675951487132444c4a71756d617368592b6c6e734d433447564335646f365856754b396c2b34536b4e38792b47665965564a6e32672b2b553751796750543064426759474944765435386d6e46355051636a433833507a5346396648375331745a47456841515a514f54384a61413331376f496b4d366a533875564c53447a4f517167323355682b4d6c6b4f66303047673063503334632b7676373455527a4d396e34316762792f7276766b63374f54686c415455334e4347594a5558743451614c75545977426354534f426d6a315244374434547369783442794f6a5a52462f7a677570444562675a336a346c792f71656b704e44306f35615134344853344f416773567174493167545a4f303149624730615031626b6e6e7843445576417248692b42306c4a536c7a676c5446594f3275644633516c39544372486e356f45497265487036516c5255464a53556c4a43717169705357566c4a38764c79434759494653374853337a476138376d76346c636a4c774c6c53746c4c544b59595555416c76726c444763573435774b785858366171485a4e75744d2b316f51424846546577414b6b6f48342b7671436a3438505941475335796235616d6a4e6f4f2b435532534c35334e4b70444430767848486d4f4a6972374c357855765a676d307573325231343253634f4979567159766c70575534586f4849503844584c32622b776a6457655868365532466a6d49494b6d625741595046524d75733632682f676549766a4f51596c707544797351724c4c364765723439486757386a7176585568493755764462396961535444714874794974694635537577356577462f4e6438564a367a6c68736e30366245687758344e79664376754745655270546d68346d6b47363879447079757a42394555636a553561776241676e63506c4165536441514552307a436e647a715662655843347144734d70764745594258526e734478344e33417566314643546a5449615674592f51546d643049386242566d316b656a45756255664f30317671496d6e336334395837717065714939696e4967746270784b3359724b66494a43742b4f6556326e665556465234636134456b56454e794137676b59634d66423152354d4d6d785a37657a2f324b463553534e3179562b3135385550734a54305a4263493262524c744958476f5975354665724f55694a65314f66734c335845574834336c324b532b694a46392b53344670634e6773632b6a3863543848346f31626650672f716b4c743530754a31527a644d7347673055717766454e313134507762314374575447672b59395535436c4b397837785557493742493556515670304156635133625a6b51686d6e45676448684b794e535a65313663727442496c63377349623663524c6674325043676f4b476a696a4244746a72415137613345644d73787a4952666c414649685062366d48596d5977582b57426c505167736b6867567279794a4351794e79424c73425164513666677351687974364d534f4f73575a37676248387745546d67524b41696a61744e4c384e676d30787834744c6373707330577a7834616c306a586c493430422f413370613134344d447453674141414141456c46546b5375516d4343266c6f676f53697a653d6175746f)](https://phpstan.org/)[![Total Downloads](https://camo.githubusercontent.com/4633b2ad8e22d9af9a8250d7d0eaed42ebf17f4e2c2345c2c482f91e60b666bd/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f6365726265726f2f656e756d2e7376673f7374796c653d666f722d7468652d6261646765266c6f676f3d7061636b6167697374266c6f676f53697a653d6175746f)](https://packagist.org/packages/cerbero/enum) Zero-dependencies package to supercharge enum functionalities. Tip Need to supercharge enums in a Laravel application? Consider using [๐ŸŽฒ Laravel Enum](https://github.com/cerbero90/laravel-enum) instead. ๐Ÿ“ฆ Install --------- [](#-install) Via Composer: ``` composer require cerbero/enum ``` ๐Ÿ”ฎ Usage ------- [](#-usage) - [โš–๏ธ Comparison](#%EF%B8%8F-comparison) - [๐Ÿท๏ธ Meta](#%EF%B8%8F-meta) - [๐Ÿšฐ Hydration](#-hydration) - [๐ŸŽฒ Enum operations](#-enum-operations) - [๐Ÿงบ Cases collection](#-cases-collection) - [๐Ÿช„ Magic](#-magic) - [๐Ÿคณ Self-awareness](#-self-awareness) - [๐Ÿฆพ Console commands](#-console-commands) - [๐Ÿ—’๏ธ annotate](#%EF%B8%8F-annotate) - [๐Ÿ—๏ธ make](#%EF%B8%8F-make) - [๐Ÿ’™ ts](#-ts) To supercharge our enums with all the features provided by this package, we can let our enums use the `Enumerates` trait: ``` use Cerbero\Enum\Concerns\Enumerates; enum PureEnum { use Enumerates; case One; case Two; case Three; } enum BackedEnum: int { use Enumerates; case One = 1; case Two = 2; case Three = 3; } ``` ### โš–๏ธ Comparison [](#๏ธ-comparison) We can check whether an enum includes some names or values. Pure enums check for names and backed enums check for values: ``` PureEnum::has('One'); // true PureEnum::has('four'); // false PureEnum::doesntHave('One'); // false PureEnum::doesntHave('four'); // true BackedEnum::has(1); // true BackedEnum::has(4); // false BackedEnum::doesntHave(1); // false BackedEnum::doesntHave(4); // true ``` Otherwise we can check whether cases match a given name or value: ``` PureEnum::One->is('One'); // true PureEnum::One->is(1); // false PureEnum::One->is('four'); // false PureEnum::One->isNot('One'); // false PureEnum::One->isNot(1); // true PureEnum::One->isNot('four'); // true BackedEnum::One->is(1); // true BackedEnum::One->is('1'); // false BackedEnum::One->is(4); // false BackedEnum::One->isNot(1); // false BackedEnum::One->isNot('1'); // true BackedEnum::One->isNot(4); // true ``` Comparisons can also be performed against arrays: ``` PureEnum::One->in(['One', 'four']); // true PureEnum::One->in([1, 4]); // false PureEnum::One->notIn(['One', 'four']); // false PureEnum::One->notIn([1, 4]); // true BackedEnum::One->in([1, 4]); // true BackedEnum::One->in(['One', 'four']); // false BackedEnum::One->notIn([1, 4]); // false BackedEnum::One->notIn(['One', 'four']); // true ``` ### ๐Ÿท๏ธ Meta [](#๏ธ-meta) Meta add extra information to a case. Meta can be added by implementing a public non-static method and/or by attaching `#[Meta]` attributes to cases: ``` enum BackedEnum: int { use Enumerates; #[Meta(color: 'red', shape: 'triangle')] case One = 1; #[Meta(color: 'green', shape: 'square')] case Two = 2; #[Meta(color: 'blue', shape: 'circle')] case Three = 3; public function isOdd(): bool { return $this->value % 2 != 0; } } ``` The above enum defines 3 meta for each case: `color`, `shape` and `isOdd`. The `#[Meta]` attributes are ideal to declare static information, whilst public non-static methods are ideal to declare dynamic information. To access a case meta, we can simply call the method having the same name of the wanted meta: ``` BackedEnum::Two->color(); // green ``` Tip Our IDE can autocomplete meta methods thanks to the [`annotate` command](#%EF%B8%8F-annotate). `#[Meta]` attributes can also be attached to the enum itself to provide default values when a case does not declare its own meta values: ``` #[Meta(color: 'red', shape: 'triangle')] enum BackedEnum: int { use Enumerates; case One = 1; #[Meta(color: 'green', shape: 'square')] case Two = 2; case Three = 3; } ``` In the above example all cases have a `red` color and a `triangle` shape, except the case `Two` that overrides the default meta values. Meta can also be leveraged for the [hydration](#-hydration), [elaboration](#-enum-operations) and [collection](#-cases-collection) of cases. ### ๐Ÿšฐ Hydration [](#-hydration) An enum case can be instantiated from its own name, value (if backed) or [meta](#%EF%B8%8F-meta): ``` PureEnum::from('One'); // PureEnum::One PureEnum::from('four'); // throws ValueError PureEnum::tryFrom('One'); // PureEnum::One PureEnum::tryFrom('four'); // null PureEnum::fromName('One'); // PureEnum::One PureEnum::fromName('four'); // throws ValueError PureEnum::tryFromName('One'); // PureEnum::One PureEnum::tryFromName('four'); // null PureEnum::fromMeta('color', 'red'); // CasesCollection[PureEnum::One] PureEnum::fromMeta('color', 'purple'); // throws ValueError PureEnum::fromMeta('isOdd'); // CasesCollection[PureEnum::One, PureEnum::Three] PureEnum::fromMeta('shape', fn(string $shape) => in_array($shape, ['square', 'circle'])); // CasesCollection[PureEnum::One, PureEnum::Three] PureEnum::tryFromMeta('color', 'red'); // CasesCollection[PureEnum::One] PureEnum::tryFromMeta('color', 'purple'); // null PureEnum::tryFromMeta('isOdd'); // CasesCollection[PureEnum::One, PureEnum::Three] PureEnum::tryFromMeta('shape', fn(string $shape) => in_array($shape, ['square', 'circle'])); // CasesCollection[PureEnum::One, PureEnum::Three] BackedEnum::from(1); // BackedEnum::One BackedEnum::from('1'); // throws ValueError BackedEnum::tryFrom(1); // BackedEnum::One BackedEnum::tryFrom('1'); // null BackedEnum::fromName('One'); // BackedEnum::One BackedEnum::fromName('four'); // throws ValueError BackedEnum::tryFromName('One'); // BackedEnum::One BackedEnum::tryFromName('four'); // null BackedEnum::fromMeta('color', 'red'); // CasesCollection[BackedEnum::One] BackedEnum::fromMeta('color', 'purple'); // throws ValueError BackedEnum::fromMeta('isOdd'); // CasesCollection[PureEnum::One, PureEnum::Three] BackedEnum::fromMeta('shape', fn(string $shape) => in_array($shape, ['square', 'circle'])); // CasesCollection[BackedEnum::One, BackedEnum::Three] BackedEnum::tryFromMeta('color', 'red'); // CasesCollection[BackedEnum::One] BackedEnum::tryFromMeta('color', 'purple'); // null BackedEnum::tryFromMeta('isOdd'); // CasesCollection[PureEnum::One, PureEnum::Three] BackedEnum::tryFromMeta('shape', fn(string $shape) => in_array($shape, ['square', 'circle'])); // CasesCollection[BackedEnum::One, BackedEnum::Three] ``` Hydrating from meta can return multiple cases. To facilitate further processing, such cases are [collected into a `CasesCollection`](#-cases-collection). ### ๐ŸŽฒ Enum operations [](#-enum-operations) A number of operations can be performed against an enum to affect all its cases: ``` PureEnum::collect(); // CasesCollection[PureEnum::One, PureEnum::Two, PureEnum::Three] PureEnum::count(); // 3 PureEnum::first(); // PureEnum::One PureEnum::first(fn(PureEnum $case, int $key) => ! $case->isOdd()); // PureEnum::Two PureEnum::names(); // ['One', 'Two', 'Three'] PureEnum::values(); // [] PureEnum::pluck('name'); // ['One', 'Two', 'Three'] PureEnum::pluck('color'); // ['red', 'green', 'blue'] PureEnum::pluck(fn(PureEnum $case) => $case->isOdd()); // [true, false, true] PureEnum::pluck('color', 'shape'); // ['triangle' => 'red', 'square' => 'green', 'circle' => 'blue'] PureEnum::pluck(fn(PureEnum $case) => $case->isOdd(), fn(PureEnum $case) => $case->name); // ['One' => true, 'Two' => false, 'Three' => true] PureEnum::map(fn(PureEnum $case, int $key) => $case->name . $key); // ['One0', 'Two1', 'Three2'] PureEnum::keyByName(); // CasesCollection['One' => PureEnum::One, 'Two' => PureEnum::Two, 'Three' => PureEnum::Three] PureEnum::keyBy('color'); // CasesCollection['red' => PureEnum::One, 'green' => PureEnum::Two, 'blue' => PureEnum::Three] PureEnum::keyByValue(); // CasesCollection[] PureEnum::groupBy('color'); // ['red' => CasesCollection[PureEnum::One], 'green' => CasesCollection[PureEnum::Two], 'blue' => CasesCollection[PureEnum::Three]] PureEnum::filter('isOdd'); // CasesCollection[PureEnum::One, PureEnum::Three] PureEnum::filter(fn(PureEnum $case) => $case->isOdd()); // CasesCollection[PureEnum::One, PureEnum::Three] PureEnum::only('Two', 'Three'); // CasesCollection[PureEnum::Two, PureEnum::Three] PureEnum::except('Two', 'Three'); // CasesCollection[PureEnum::One] PureEnum::onlyValues(2, 3); // CasesCollection[] PureEnum::exceptValues(2, 3); // CasesCollection[] PureEnum::sort(); // CasesCollection[PureEnum::One, PureEnum::Three, PureEnum::Two] PureEnum::sortBy('color'); // CasesCollection[PureEnum::Three, PureEnum::Two, PureEnum::One] PureEnum::sortByValue(); // CasesCollection[] PureEnum::sortDesc(); // CasesCollection[PureEnum::Two, PureEnum::Three, PureEnum::One] PureEnum::sortByDesc(fn(PureEnum $case) => $case->color()); // CasesCollection[PureEnum::One, PureEnum::Two, PureEnum::Three] PureEnum::sortByDescValue(); // CasesCollection[] BackedEnum::collect(); // CasesCollection[BackedEnum::One, BackedEnum::Two, BackedEnum::Three] BackedEnum::count(); // 3 BackedEnum::first(); // BackedEnum::One BackedEnum::first(fn(BackedEnum $case, int $key) => ! $case->isOdd()); // BackedEnum::Two BackedEnum::names(); // ['One', 'Two', 'Three'] BackedEnum::values(); // [1, 2, 3] BackedEnum::pluck('value'); // [1, 2, 3] BackedEnum::pluck('color'); // ['red', 'green', 'blue'] BackedEnum::pluck(fn(BackedEnum $case) => $case->isOdd()); // [true, false, true] BackedEnum::pluck('color', 'shape'); // ['triangle' => 'red', 'square' => 'green', 'circle' => 'blue'] BackedEnum::pluck(fn(BackedEnum $case) => $case->isOdd(), fn(BackedEnum $case) => $case->name); // ['One' => true, 'Two' => false, 'Three' => true] BackedEnum::map(fn(BackedEnum $case, int $key) => $case->name . $key); // ['One0', 'Two1', 'Three2'] BackedEnum::keyByName(); // CasesCollection['One' => BackedEnum::One, 'Two' => BackedEnum::Two, 'Three' => BackedEnum::Three] BackedEnum::keyBy('color'); // CasesCollection['red' => BackedEnum::One, 'green' => BackedEnum::Two, 'blue' => BackedEnum::Three] BackedEnum::keyByValue(); // CasesCollection[1 => BackedEnum::One, 2 => BackedEnum::Two, 3 => BackedEnum::Three] BackedEnum::groupBy('color'); // ['red' => CasesCollection[BackedEnum::One], 'green' => CasesCollection[BackedEnum::Two], 'blue' => CasesCollection[BackedEnum::Three]] BackedEnum::filter('isOdd'); // CasesCollection[BackedEnum::One, BackedEnum::Three] BackedEnum::filter(fn(BackedEnum $case) => $case->isOdd()); // CasesCollection[BackedEnum::One, BackedEnum::Three] BackedEnum::only('Two', 'Three'); // CasesCollection[BackedEnum::Two, BackedEnum::Three] BackedEnum::except('Two', 'Three'); // CasesCollection[BackedEnum::One] BackedEnum::onlyValues(2, 3); // CasesCollection[] BackedEnum::exceptValues(2, 3); // CasesCollection['Two' => false, 'Three' => true] BackedEnum::sort(); // CasesCollection[BackedEnum::One, BackedEnum::Three, BackedEnum::Two] BackedEnum::sortBy('color'); // CasesCollection[BackedEnum::Three, BackedEnum::Two, BackedEnum::One] BackedEnum::sortByValue(); // CasesCollection[BackedEnum::One, BackedEnum::Two, BackedEnum::Three] BackedEnum::sortDesc(); // CasesCollection[BackedEnum::Two, BackedEnum::Three, BackedEnum::One] BackedEnum::sortByDescValue(); // CasesCollection[BackedEnum::Three, BackedEnum::Two, BackedEnum::One] BackedEnum::sortByDesc(fn(BackedEnum $case) => $case->color()); // CasesCollection[BackedEnum::One, BackedEnum::Two, BackedEnum::Three] ``` ### ๐Ÿงบ Cases collection [](#-cases-collection) When an [enum operation](#-enum-operations) can return multiple cases, they are collected into a `CasesCollection` which provides a fluent API to perform further operations on the set of cases: ``` PureEnum::filter('isOdd')->sortBy('color')->pluck('color', 'name'); // ['Three' => 'blue', 'One' => 'red'] ``` Cases can be collected by calling `collect()` or any other [enum operation](#-enum-operations) returning a `CasesCollection`: ``` PureEnum::collect(); // CasesCollection[PureEnum::One, PureEnum::Two, PureEnum::Three] BackedEnum::only('One', 'Two'); // CasesCollection[BackedEnum::One, BackedEnum::Two] ``` We can iterate a cases collection within any loop: ``` foreach (PureEnum::collect() as $case) { echo $case->name; } ``` All the [enum operations listed above](#-enum-operations) are also available when dealing with a collection of cases. ### ๐Ÿช„ Magic [](#-magic) Enums can implement magic methods to be invoked or to handle calls to inaccessible methods. By default when calling an inaccessible static method, the name or value of the case matching the missing method is returned: ``` PureEnum::One(); // 'One' BackedEnum::One(); // 1 ``` Tip Our IDE can autocomplete cases static methods thanks to the [`annotate` command](#%EF%B8%8F-annotate). We can also obtain the name or value of a case by simply invoking it: ``` $case = PureEnum::One; $case(); // 'One' $case = BackedEnum::One; $case(); // 1 ``` When calling an inaccessible method of a case, by default the value of the meta matching the missing method is returned: ``` PureEnum::One->color(); // 'red' BackedEnum::One->shape(); // 'triangle' ``` Tip Our IDE can autocomplete meta methods thanks to the [`annotate` command](#%EF%B8%8F-annotate). Depending on our needs, we can customize the default behavior of all enums in our application when invoking a case or calling inaccessible methods: ``` use Cerbero\Enum\Enums; use UnitEnum; // define the logic to run when calling an inaccessible method of an enum Enums::onStaticCall(function(string $enum, string $name, array $arguments) { // $enum is the fully qualified name of the enum that called the inaccessible method // $name is the inaccessible method name // $arguments are the parameters passed to the inaccessible method }); // define the logic to run when calling an inaccessible method of a case Enums::onCall(function(UnitEnum $case, string $name, array $arguments) { // $case is the instance of the case that called the inaccessible method // $name is the inaccessible method name // $arguments are the parameters passed to the inaccessible method }); // define the logic to run when invoking a case Enums::onInvoke(function(UnitEnum $case, mixed ...$arguments) { // $case is the instance of the case that is being invoked // $arguments are the parameters passed when invoking the case }); ``` ### ๐Ÿคณ Self-awareness [](#-self-awareness) Some internal methods are also available and can be useful for inspecting enums or auto-generating code: ``` PureEnum::isPure(); // true PureEnum::isBacked(); // false PureEnum::isBackedByInteger(); // false PureEnum::isBackedByString(); // false PureEnum::metaNames(); // ['color', 'shape', 'isOdd'] PureEnum::metaAttributeNames(); // ['color', 'shape'] PureEnum::One->resolveItem('name'); // 'One' PureEnum::One->resolveMeta('isOdd'); // true PureEnum::One->resolveMetaAttribute('color'); // 'red' PureEnum::One->value(); // 'One' BackedEnum::isPure(); // false BackedEnum::isBacked(); // true BackedEnum::isBackedByInteger(); // true BackedEnum::isBackedByString(); // false BackedEnum::metaNames(); // ['color', 'shape', 'isOdd'] BackedEnum::metaAttributeNames(); // ['color', 'shape'] BackedEnum::One->resolveItem('value'); // 1 BackedEnum::One->resolveMeta('isOdd'); // true BackedEnum::One->resolveMetaAttribute('color'); // 'red' BackedEnum::One->value(); // 1 ``` ### ๐Ÿฆพ Console commands [](#-console-commands) This package provides a handy binary, built to automate different tasks. To learn how to use it, we can simply run it: ``` ./vendor/bin/enum ``` For the console commands to work properly, the application base path is automatically guessed. However, in case of issues, we can manually set it by creating an `enums.php` file in the root of our app: ```