vendor/illuminate/support/Traits/Macroable.php

   1 <?php
   2
   3 namespace Illuminate\Support\Traits;
   4
   5 use Closure;
   6 use ReflectionClass;
   7 use ReflectionMethod;
   8 use BadMethodCallException;
   9
  10 trait Macroable
  11 {
  12     /**
  13      * The registered string macros.
  14      *
  15      * @var array
  16      */
  17     protected static $macros = [];
  18
  19     /**
  20      * Register a custom macro.
  21      *
  22      * @param  string $name
  23      * @param  object|callable  $macro
  24      *
  25      * @return void
  26      */
  27     public static function macro($name, $macro)
  28     {
  29         static::$macros[$name] = $macro;
  30     }
  31
  32     /**
  33      * Mix another object into the class.
  34      *
  35      * @param  object  $mixin
  36      * @return void
  37      */
  38     public static function mixin($mixin)
  39     {
  40         $methods = (new ReflectionClass($mixin))->getMethods(
  41             ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
  42         );
  43
  44         foreach ($methods as $method) {
  45             $method->setAccessible(true);
  46
  47             static::macro($method->name, $method->invoke($mixin));
  48         }
  49     }
  50
  51     /**
  52      * Checks if macro is registered.
  53      *
  54      * @param  string  $name
  55      * @return bool
  56      */
  57     public static function hasMacro($name)
  58     {
  59         return isset(static::$macros[$name]);
  60     }
  61
  62     /**
  63      * Dynamically handle calls to the class.
  64      *
  65      * @param  string  $method
  66      * @param  array   $parameters
  67      * @return mixed
  68      *
  69      * @throws \BadMethodCallException
  70      */
  71     public static function __callStatic($method, $parameters)
  72     {
  73         if (! static::hasMacro($method)) {
  74             throw new BadMethodCallException("Method {$method} does not exist.");
  75         }
  76
  77         if (static::$macros[$method] instanceof Closure) {
  78             return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
  79         }
  80
  81         return call_user_func_array(static::$macros[$method], $parameters);
  82     }
  83
  84     /**
  85      * Dynamically handle calls to the class.
  86      *
  87      * @param  string  $method
  88      * @param  array   $parameters
  89      * @return mixed
  90      *
  91      * @throws \BadMethodCallException
  92      */
  93     public function __call($method, $parameters)
  94     {
  95         if (! static::hasMacro($method)) {
  96             throw new BadMethodCallException("Method {$method} does not exist.");
  97         }
  98
  99         $macro = static::$macros[$method];
 100
 101         if ($macro instanceof Closure) {
 102             return call_user_func_array($macro->bindTo($this, static::class), $parameters);
 103         }
 104
 105         return call_user_func_array($macro, $parameters);
 106     }
 107 }