Adding New Methods and Properties
PHP Houdini also allows you to complete methods and properties that don’t exist at all on the dynamic class.
The methods for doing so are addNewMethods()
and addNewProperties()
.
Adding New Methods
To add new methods, you call addNewMethods
after overrideClass
and then you must specify an available source for the new methods.
Sources include constants, properties, or methods of the same class or another class.
Note
The autocompleted methods have zero arguments. This is ideal for configuring getter methods.
In the future, there may be a way to configure the arguments for each dynamic method. Please contact us
at support@profoundinventions.com
if you would like to request this feature.
Here’s an example that completes methods from all the protected properties in a class, and
transforms them from snake_case
to camelCase
. The return type of the method
is set from the type of the value of the corresponding property:
<?php
namespace Houdini\Config\V1;
use YourNamespace\YourDynamicClass;
use SomeOtherNamespace\SomeOtherClass;
houdini()->overrideClass(YourDynamicClass::class)
->addNewMethods()
->fromAllPropertiesOfTheSameClass()
->filter( AccessFilter::isProtected() )
->transform( NameTransform::camelCase() )
Adding New Properties
Here’s an example that completes the same as the previous example for methods, but generates properties instead of methods:
<?php
namespace Houdini\Config\V1;
use YourNamespace\YourDynamicClass;
use SomeOtherNamespace\SomeOtherClass;
houdini()->overrideClass(YourDynamicClass::class)
->addNewProperties()
->fromAllPropertiesOfTheSameClass()
->filter( AccessFilter::isProtected() )
->transform( NameTransform::camelCase() )
Available Sources
The sources for methods or properties are configured with another method call with the return value of
addNewMethods()
and addNewProperties()
.
This gives you flexibility to generate completion from any many combinations of methods, properties, and constants.
Here’s a list of all the available sources.
fromAllMethodsOfTheSameClass()
Use all methods of the same class that you’re overriding in
overrideClass
as a source.fromAllMethodsOfAnotherClass(string $className)
Use all methods of the class specified by
$className
as a source.fromAllPropertiesOfTheSameClass()
Use all properties of the same class that you’re overriding in
overrideClass
as a source.fromAllPropertiesOfAnotherClass(string $className)
Use all properties of the class specified by
$className
as a source.fromPropertyOfTheSameClass(string $propertyName)
Use a single property with the name of
$propertyName
of the same class that you’re overriding inoverrideClass
as a source.fromAllConstantsOfTheSameClass()
Use all contants of the same class that you’re overriding in
overrideClass
as a source.fromAllConstantsOfAnotherClass(string $className)
Use all constants of the class specified by
$className
as a source.fromConstantOfTheSameClass(string $constantName)
Use a single constant with the name of
$constantName
of the same class that you’re overriding inoverrideClass
as a source.
Using Static Properties and Methods
By default, methods and properties are added in instance context. This means you can only access them as instance methods, and not as static methods or properties.
You can specify autocompleting in one context or another using the useContext
method, and
then specifying which context with Context::isStatic()
or Context::isInstance()
.
Here’s an example that adds completion for the MyCLabs Enum
library. To use that library, you extend an Enum
class provided by the library that
allows you to access a static method that corresponds to constants on the enum class. This example
will add completion for those enums as static methods:
<?php
namespace Houdini\Config\V1;
use MyCLabs\Enum\Enum;
houdini()->overrideClass(Enum::class)
->addNewMethods()
->fromAllConstantsOfTheSameClass()
->useContext( Context::isStatic() );
This example will add completion for all Enum classes in your project that
extend MyCLabs\Enum\Enum
- you don’t need to specify each one individually.
Swapping contexts
Note you can also autocomplete a static property or method from a non-static property
or method, or vice versa. If you want to do this,
you use the fromContext()
method to specify whether the source is a static or instance method,
and then the toContext()
method to specify the context for the autocompleted property or method.
Effectively, useContext(Context::isStatic()
is equivalent to
fromContext(Context::isStatic())->toContext(Context::isStatic())
Note
Constants are always treated as static. So, when completing from a constant,
fromContext(Context::isInstance())
will have no effect.
Configuring the Name and Type
You can also configure how the name or the type are determined.
Configuring the Name
You can configure the name using a few different methods:
useTheSameName()
This will use the same name as the source for a method or property.
useValueAsTheName()
This will use the default value of the property or constant as the name of the property or method. Not available if the source is a method, which doesn’t have a value.
useTypeAsTheName()
Use the fully-qualified type (so the constant or property type, or for a method, the return type) as the name. For names that start with a backslash, they won’t be legal names in PHP, but you can use
transform()
to change that by replacing the backslashes with something else (for example, underscores).
Configuring the Type
The types of properties and methods are also configurable using methods:
useTheSameType
This uses the same type as the source. This is the default.
useValueAsTheType
This uses the value of the constant or field as the type. For example if a property looks like
protected $foo = 'string'
, this method will make the type to bestring
for the method or property generated from that.Not available when the source is a method, which can’t have a value.
useNameAsTheType
This uses the name of the method, property, or constant as the type.
useCustomType(string $type)
This uses a custom type that you pass as a parameter.
Go to the next step to learn about adding methods or properties from specialized patterns of arrays.