File: /var/www/vhosts/uyarreklam.com.tr/httpdocs/AbstractServiceProvider.php.tar
wp-content/plugins/woocommerce/src/Internal/DependencyManagement/AbstractServiceProvider.php 0000644 00000015611 15154665250 0036675 0 ustar 00 var/www/vhosts/uyarreklam.com.tr/httpdocs <?php
/**
* AbstractServiceProvider class file.
*/
namespace Automattic\WooCommerce\Internal\DependencyManagement;
use Automattic\WooCommerce\Vendor\League\Container\Argument\RawArgument;
use Automattic\WooCommerce\Vendor\League\Container\Definition\DefinitionInterface;
use Automattic\WooCommerce\Vendor\League\Container\ServiceProvider\AbstractServiceProvider as BaseServiceProvider;
/**
* Base class for the service providers used to register classes in the container.
*
* See the documentation of the original class this one is based on (https://container.thephpleague.com/3.x/service-providers)
* for basic usage details. What this class adds is:
*
* - The `add_with_auto_arguments` method that allows to register classes without having to specify the injection method arguments.
* - The `share_with_auto_arguments` method, sibling of the above.
* - Convenience `add` and `share` methods that are just proxies for the same methods in `$this->getContainer()`.
*/
abstract class AbstractServiceProvider extends BaseServiceProvider {
/**
* Register a class in the container and use reflection to guess the injection method arguments.
*
* WARNING: this method uses reflection, so please have performance in mind when using it.
*
* @param string $class_name Class name to register.
* @param mixed $concrete The concrete to register. Can be a shared instance, a factory callback, or a class name.
* @param bool $shared Whether to register the class as shared (`get` always returns the same instance) or not.
*
* @return DefinitionInterface The generated container definition.
*
* @throws ContainerException Error when reflecting the class, or class injection method is not public, or an argument has no valid type hint.
*/
protected function add_with_auto_arguments( string $class_name, $concrete = null, bool $shared = false ) : DefinitionInterface {
$definition = new Definition( $class_name, $concrete );
$function = $this->reflect_class_or_callable( $class_name, $concrete );
if ( ! is_null( $function ) ) {
$arguments = $function->getParameters();
foreach ( $arguments as $argument ) {
if ( $argument->isDefaultValueAvailable() ) {
$default_value = $argument->getDefaultValue();
$definition->addArgument( new RawArgument( $default_value ) );
} else {
$argument_class = $this->get_class( $argument );
if ( is_null( $argument_class ) ) {
throw new ContainerException( "Argument '{$argument->getName()}' of class '$class_name' doesn't have a type hint or has one that doesn't specify a class." );
}
$definition->addArgument( $argument_class->name );
}
}
}
// Register the definition only after being sure that no exception will be thrown.
$this->getContainer()->add( $definition->getAlias(), $definition, $shared );
return $definition;
}
/**
* Gets the class of a parameter.
*
* This method is a replacement for ReflectionParameter::getClass,
* which is deprecated as of PHP 8.
*
* @param \ReflectionParameter $parameter The parameter to get the class for.
*
* @return \ReflectionClass|null The class of the parameter, or null if it hasn't any.
*/
private function get_class( \ReflectionParameter $parameter ) {
return $parameter->getType() && ! $parameter->getType()->isBuiltin()
? new \ReflectionClass( $parameter->getType()->getName() )
: null;
}
/**
* Check if a combination of class name and concrete is valid for registration.
* Also return the class injection method if the concrete is either a class name or null (then use the supplied class name).
*
* @param string $class_name The class name to check.
* @param mixed $concrete The concrete to check.
*
* @return \ReflectionFunctionAbstract|null A reflection instance for the $class_name injection method or $concrete injection method or callable; null otherwise.
* @throws ContainerException Class has a private injection method, can't reflect class, or the concrete is invalid.
*/
private function reflect_class_or_callable( string $class_name, $concrete ) {
if ( ! isset( $concrete ) || is_string( $concrete ) && class_exists( $concrete ) ) {
$class = $concrete ?? $class_name;
if ( ! method_exists( $class, Definition::INJECTION_METHOD ) ) {
return null;
}
$method = new \ReflectionMethod( $class, Definition::INJECTION_METHOD );
$missing_modifiers = array();
if ( ! $method->isFinal() ) {
$missing_modifiers[] = 'final';
}
if ( ! $method->isPublic() ) {
$missing_modifiers[] = 'public';
}
if ( ! empty( $missing_modifiers ) ) {
throw new ContainerException( "Method '" . Definition::INJECTION_METHOD . "' of class '$class' isn't '" . implode( ' ', $missing_modifiers ) . "', instances can't be created." );
}
return $method;
} elseif ( is_callable( $concrete ) ) {
try {
return new \ReflectionFunction( $concrete );
} catch ( \ReflectionException $ex ) {
throw new ContainerException( "Error when reflecting callable: {$ex->getMessage()}" );
}
}
return null;
}
/**
* Register a class in the container and use reflection to guess the injection method arguments.
* The class is registered as shared, so `get` on the container always returns the same instance.
*
* WARNING: this method uses reflection, so please have performance in mind when using it.
*
* @param string $class_name Class name to register.
* @param mixed $concrete The concrete to register. Can be a shared instance, a factory callback, or a class name.
*
* @return DefinitionInterface The generated container definition.
*
* @throws ContainerException Error when reflecting the class, or class injection method is not public, or an argument has no valid type hint.
*/
protected function share_with_auto_arguments( string $class_name, $concrete = null ) : DefinitionInterface {
return $this->add_with_auto_arguments( $class_name, $concrete, true );
}
/**
* Register an entry in the container.
*
* @param string $id Entry id (typically a class or interface name).
* @param mixed|null $concrete Concrete entity to register under that id, null for automatic creation.
* @param bool|null $shared Whether to register the class as shared (`get` always returns the same instance) or not.
*
* @return DefinitionInterface The generated container definition.
*/
protected function add( string $id, $concrete = null, bool $shared = null ) : DefinitionInterface {
return $this->getContainer()->add( $id, $concrete, $shared );
}
/**
* Register a shared entry in the container (`get` always returns the same instance).
*
* @param string $id Entry id (typically a class or interface name).
* @param mixed|null $concrete Concrete entity to register under that id, null for automatic creation.
*
* @return DefinitionInterface The generated container definition.
*/
protected function share( string $id, $concrete = null ) : DefinitionInterface {
return $this->add( $id, $concrete, true );
}
}
plugins/woocommerce/lib/packages/League/Container/ServiceProvider/AbstractServiceProvider.php 0000644 00000001605 15155565220 0041035 0 ustar 00 var/www/vhosts/uyarreklam.com.tr/httpdocs/wp-content <?php declare(strict_types=1);
namespace Automattic\WooCommerce\Vendor\League\Container\ServiceProvider;
use Automattic\WooCommerce\Vendor\League\Container\ContainerAwareTrait;
abstract class AbstractServiceProvider implements ServiceProviderInterface
{
use ContainerAwareTrait;
/**
* @var array
*/
protected $provides = [];
/**
* @var string
*/
protected $identifier;
/**
* {@inheritdoc}
*/
public function provides(string $alias) : bool
{
return in_array($alias, $this->provides, true);
}
/**
* {@inheritdoc}
*/
public function setIdentifier(string $id) : ServiceProviderInterface
{
$this->identifier = $id;
return $this;
}
/**
* {@inheritdoc}
*/
public function getIdentifier() : string
{
return $this->identifier ?? get_class($this);
}
}
plugins/google-listings-and-ads/src/Internal/DependencyManagement/AbstractServiceProvider.php 0000644 00000007741 15155631446 0040777 0 ustar 00 var/www/vhosts/uyarreklam.com.tr/httpdocs/wp-content <?php
declare( strict_types=1 );
namespace Automattic\WooCommerce\GoogleListingsAndAds\Internal\DependencyManagement;
use Automattic\WooCommerce\GoogleListingsAndAds\Infrastructure\Conditional;
use Automattic\WooCommerce\GoogleListingsAndAds\Vendor\League\Container\Definition\DefinitionInterface;
use Automattic\WooCommerce\GoogleListingsAndAds\Vendor\League\Container\ServiceProvider\AbstractServiceProvider as LeagueProvider;
/**
* Class AbstractServiceProvider
*
* @package Automattic\WooCommerce\GoogleListingsAndAds\Internal\DependencyManagement
*/
abstract class AbstractServiceProvider extends LeagueProvider {
/**
* Array of classes provided by this container.
*
* Keys should be the class name, and the value can be anything (like `true`).
*
* @var array
*/
protected $provides = [];
/**
* Returns a boolean if checking whether this provider provides a specific
* service or returns an array of provided services if no argument passed.
*
* @param string $service
*
* @return boolean
*/
public function provides( string $service ): bool {
return array_key_exists( $service, $this->provides );
}
/**
* Use the register method to register items with the container via the
* protected $this->container property or the `getContainer` method
* from the ContainerAwareTrait.
*
* @return void
*/
public function register(): void {
foreach ( $this->provides as $class => $provided ) {
$this->share( $class );
}
}
/**
* Add an interface to the container.
*
* @param string $interface_name The interface to add.
* @param string|null $concrete (Optional) The concrete class.
*
* @return DefinitionInterface
*/
protected function share_concrete( string $interface_name, $concrete = null ): DefinitionInterface {
return $this->getContainer()->addShared( $interface_name, $concrete );
}
/**
* Share a class and add interfaces as tags.
*
* @param string $class_name The class name to add.
* @param mixed ...$arguments Constructor arguments for the class.
*
* @return DefinitionInterface
*/
protected function share_with_tags( string $class_name, ...$arguments ): DefinitionInterface {
$definition = $this->share( $class_name, ...$arguments );
foreach ( class_implements( $class_name ) as $interface_name ) {
$definition->addTag( $interface_name );
}
return $definition;
}
/**
* Share a class.
*
* Shared classes will always return the same instance of the class when the class is requested
* from the container.
*
* @param string $class_name The class name to add.
* @param mixed ...$arguments Constructor arguments for the class.
*
* @return DefinitionInterface
*/
protected function share( string $class_name, ...$arguments ): DefinitionInterface {
return $this->getContainer()->addShared( $class_name )->addArguments( $arguments );
}
/**
* Add a class.
*
* Classes will return a new instance of the class when the class is requested from the container.
*
* @param string $class_name The class name to add.
* @param mixed ...$arguments Constructor arguments for the class.
*
* @return DefinitionInterface
*/
protected function add( string $class_name, ...$arguments ): DefinitionInterface {
return $this->getContainer()->add( $class_name )->addArguments( $arguments );
}
/**
* Maybe share a class and add interfaces as tags.
*
* This will also check any classes that implement the Conditional interface and only add them if
* they are needed.
*
* @param string $class_name The class name to add.
* @param mixed ...$arguments Constructor arguments for the class.
*/
protected function conditionally_share_with_tags( string $class_name, ...$arguments ) {
$implements = class_implements( $class_name );
if ( array_key_exists( Conditional::class, $implements ) ) {
/** @var Conditional $class */
if ( ! $class_name::is_needed() ) {
return;
}
}
$this->provides[ $class_name ] = true;
$this->share_with_tags( $class_name, ...$arguments );
}
}