vendor/mpociot/pipeline/src/Pipeline.php line 102

Open in your IDE?
  1. <?php
  3. namespace Mpociot\Pipeline;
  5. use Closure;
  7. class Pipeline
  8. {
  10. /**
  11. * The object being passed through the pipeline.
  12. *
  13. * @var mixed
  14. */
  15. protected $passable;
  17. /**
  18. * The array of class pipes.
  19. *
  20. * @var array
  21. */
  22. protected $pipes = [];
  24. /**
  25. * The additional parameters.
  26. *
  27. * @var array
  28. */
  29. protected $parameters = [];
  31. /**
  32. * The method to call on each pipe.
  33. *
  34. * @var string
  35. */
  36. protected $method = 'handle';
  38. /**
  39. * Set the object being sent through the pipeline.
  40. *
  41. * @param mixed $passable
  42. * @return $this
  43. */
  44. public function send(...$passable)
  45. {
  46. $this->passable = $passable;
  48. return $this;
  49. }
  51. /**
  52. * Set the array of pipes.
  53. *
  54. * @param array|mixed $pipes
  55. * @return $this
  56. */
  57. public function through($pipes)
  58. {
  59. $this->pipes = is_array($pipes) ? $pipes : func_get_args();
  61. return $this;
  62. }
  64. /**
  65. * Set the method to call on the pipes.
  66. *
  67. * @param string $method
  68. * @return $this
  69. */
  70. public function via($method)
  71. {
  72. $this->method = $method;
  74. return $this;
  75. }
  77. /**
  78. * Set the additional parameters to send
  79. *
  80. * @param mixed $parameters
  81. * @return $this
  82. */
  83. public function with(...$parameters)
  84. {
  85. $this->parameters = $parameters;
  87. return $this;
  88. }
  90. /**
  91. * Run the pipeline with a final destination callback.
  92. *
  93. * @param \Closure $destination
  94. * @return mixed
  95. */
  96. public function then(Closure $destination)
  97. {
  98. $pipeline = array_reduce(
  99. array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
  100. );
  102. return call_user_func_array($pipeline, $this->passable);
  103. }
  105. /**
  106. * Get the final piece of the Closure onion.
  107. *
  108. * @param \Closure $destination
  109. * @return \Closure
  110. */
  111. protected function prepareDestination(Closure $destination)
  112. {
  113. return function () use ($destination) {
  114. return call_user_func_array($destination, func_get_args());
  115. };
  116. }
  118. /**
  119. * Get a Closure that represents a slice of the application onion.
  120. *
  121. * @return \Closure
  122. */
  123. protected function carry()
  124. {
  125. return function ($stack, $pipe) {
  126. return function () use ($stack, $pipe) {
  127. $passable = func_get_args();
  128. $passable[] = $stack;
  129. $passable = array_merge($passable, $this->parameters);
  131. if (is_callable($pipe)) {
  132. // If the pipe is an instance of a Closure, we will just call it directly but
  133. // otherwise we'll resolve the pipes out of the container and call it with
  134. // the appropriate method and arguments, returning the results back out.
  135. return call_user_func_array($pipe, $passable);
  136. } elseif (! is_object($pipe)) {
  137. list($name, $parameters) = $this->parsePipeString($pipe);
  138. // If the pipe is a string we will parse the string and resolve the class out
  139. // of the dependency injection container. We can then build a callable and
  140. // execute the pipe function giving in the parameters that are required.
  141. $pipe = new $name();
  142. $parameters = array_merge($passable, $parameters);
  143. } else {
  144. // If the pipe is already an object we'll just make a callable and pass it to
  145. // the pipe as-is. There is no need to do any extra parsing and formatting
  146. // since the object we're given was already a fully instantiated object.
  147. $parameters = $passable;
  148. }
  150. return method_exists($pipe, $this->method)
  151. ? call_user_func_array([$pipe, $this->method], $parameters)
  152. : $pipe(...$parameters);
  153. };
  154. };
  155. }
  157. /**
  158. * Parse full pipe string to get name and parameters.
  159. *
  160. * @param string $pipe
  161. * @return array
  162. */
  163. protected function parsePipeString($pipe)
  164. {
  165. list($name, $parameters) = array_pad(explode(':', $pipe, 2), 2, []);
  167. if (is_string($parameters)) {
  168. $parameters = explode(',', $parameters);
  169. }
  171. return [$name, $parameters];
  172. }
  173. }