/**
* return the array values that match the search regex
*
* @param array|Traversable $data
* the collection of input strings to check
* @param string $searchRegex
* the regex to match
* @return array
* returns the elements of $data that match the regex
* will be an empty array if no matches found
*/
public static function againstTraversable($data, $searchRegex)
{
// robustness!
RequireTraversable::checkMixed($data, E4xx_UnsupportedType::class);
RequirePcreRegex::check($searchRegex, E4xx_InvalidPcreRegex::class);
return self::matchArray($data, $searchRegex);
}
/**
* return the array values that do not contain the search string
*
* @param array|Traversable $data
* the collection of input strings to check
* @param string $searchString
* the string to search for
* @return array
* returns the elements of $data that do not contain $searchString
* will be an empty array if no matches found
*/
public static function againstTraversable($data, $searchString)
{
// robustness!
RequireTraversable::checkMixed($data, E4xx_UnsupportedType::class);
RequireStringy::checkMixed($searchString, E4xx_UnsupportedType::class);
return self::matchArray($data, $searchString);
}
/**
* expand a list of ranges
*
* @param array|Traversable $data
* the list of ranges to expand
* @return array
* the expanded ranges
*/
public static function fromTraversable($data)
{
// robustness!
RequireTraversable::checkMixed($data, E4xx_UnsupportedType::class);
$retval = [];
foreach ($data as $key => $range) {
$retval[$key] = self::fromString($range);
}
return $retval;
}
/**
* our constructor
*
* @param array<ComparisonExpression> $rangeExpressions
* the list of comparison expressions that make up this version range
*/
public function __construct($rangeExpressions)
{
// robustness
RequireTraversable::check($rangeExpressions, E4xx_UnsupportedType::class);
$this->rangeExpressions = [];
foreach ($rangeExpressions as $rangeExpression) {
RequireObjectOfType::check($rangeExpression, ComparisonExpression::class, E4xx_UnsupportedType::class);
$this->rangeExpressions[] = $rangeExpression;
}
}
/**
* write an array of data to the stream
*
* @param array $data
* the data to write to the stream
* @return void
*/
public function writeArray($data)
{
// robustness!
RequireTraversable::check($data, E4xx_UnsupportedType::class);
foreach ($data as $item) {
// we do not know what $item is, so send it to our generic
// write method
$this->write($item);
}
}
/**
* merge their array into our array
*
* @param array &$ours
* the array that we want to merge into
* @param array|Traversable $theirs
* the array that we want to merge from
* @return void
*/
public static function fromArray(&$ours, $theirs)
{
// robustness!
RequireIndexable::check($ours, E4xx_UnsupportedType::class);
RequireTraversable::check($theirs, E4xx_UnsupportedType::class);
// copy from them to us
foreach ($theirs as $key => $value) {
self::mergeKeyIntoArray($ours, $key, $value);
}
// all done
}
/**
* create an escaped string from a collection of command + args
*
* @param array|Traversable $data
* the data to escape
* @return string
* the command to execute
*/
public static function fromArray($data)
{
// robustness!
RequireTraversable::checkMixed($data);
// escape everything
$retval = [];
foreach ($data as $part) {
$retval[] = escapeshellarg((string) $part);
}
// all done
return implode(' ', $retval);
}
public function __construct($command, $returnCode, $output)
{
// robustness!
RequireTraversable::checkMixed($command, E4xx_UnsupportedType::class);
RequireNumeric::check($returnCode, E4xx_UnsupportedType::class);
RequireStringy::checkMixed($output, E4xx_UnsupportedType::class);
$this->setCommand($command);
$this->setReturnCode($returnCode);
$this->setOutput($output);
// all done
$this->makeReadOnly();
}
/**
* run a CLI command using the popen() interface
*
* @param array|Traversable $command
* the command to execute
* @param int|null $timeout
* how long before we force the command to close?
* @param string|null $cwd
* the folder to run the command inside
* @param EventStream $eventStream
* helper to send events to
* @return ProcessResult
* the result of executing the command
*/
public static function run($command, $timeout = null, $cwd = null, EventStream $eventStream = null)
{
// robustness
RequireTraversable::checkMixed($command, E4xx_UnsupportedType::class);
RequireTimeoutOrNull::check($timeout);
RequireAbsoluteFolderOrNull::check($cwd);
$eventStream = GuaranteeEventStream::from($eventStream);
return self::runCommand($command, $timeout, $cwd, $eventStream);
}
/**
* @covers ::check
* @covers ::checkMixed
* @dataProvider provideNonTraversables
* @expectedException GanbaroDigital\Reflection\Exceptions\E4xx_UnsupportedType
*/
public function testRejectsNonTraversablesWhenCalledStatically($item)
{
// ----------------------------------------------------------------
// setup your test
// ----------------------------------------------------------------
// perform the change
RequireTraversable::check($item);
}
/**
* extract the columns from an array of strings
*
* @param array|Traversable $data
* the data to be filtered
* @param string $columnNos
* the columns to be extracted
* @param string $columnSeparator
* the column delimiter
* @return array
* a list of the filtered strings
*/
public static function fromTraversable($data, $columnNos, $columnSeparator)
{
// robustness!
RequireTraversable::checkMixed($data, E4xx_UnsupportedType::class);
RequireStringy::checkMixed($columnNos, E4xx_UnsupportedType::class);
RequireStringy::checkMixed($columnSeparator, E4xx_UnsupportedType::class);
$colsToMatch = array_flip(ExpandRange::from($columnNos));
return self::filterArray($data, $columnSeparator, $colsToMatch);
}
