public function read(DOMElement $e) {
$tn = end(explode(':',$e->tagName));
switch($tn) {
case 'function':
foreach($e->childNodes as $cnn) {
if (typeOf($cnn) == 'DOMElement') {
$cnt = end(explode(':',$cnn->tagName));
if ($cnt == 'from') {
$this->from[] = $cnn->nodeValue;
} elseif ($cnt == 'to') {
$this->to = $cnn->nodeValue;
} else {
printf("Warning: Didn't expect %s here\n", $cnn->nodeName);
}
}
}
printf(__astr("[\b{phprefactor}] Refactoring{%s} --> %s\n"), join(', ',$this->from), $this->to);
break;
default:
printf("I don't know what to do with %s!\n", $tn);
}
}
static function inspectArray($data)
{
$ret = '<table>';
foreach ($data as $key => $value) {
$ret .= '<tr><th>' . htmlentities($key) . ' <br><em style="font-size:10px; font-weight:normal">' . typeOf($value) . '</em></th><td>';
if (typeOf($value) == 'boolean') {
if ($value) {
$ret .= '<img src="data:image/gif;base64,R0lGODlhEwAHAIABAAAAAP///yH5BAEKAAEALAAAAAATAAcAAAIajI+ZwMFgoHMt2imhPNn2x0XVt1zZuSkqUgAAOw==" alt="true">';
} else {
$ret .= '<img src="data:image/gif;base64,R0lGODlhFwAHAIABAAAAAP///yH5BAEKAAEALAAAAAAXAAcAAAIejI+pB20eAGqSPnblxczp2nmQFlkkdpJfWY3QAi8FADs=" alt="false">';
}
} else {
if (is_array($value) || is_a($value, 'StdClass')) {
$ret .= self::inspectArray((array) $value);
} else {
if ($value === null) {
$ret .= '<img src="data:image/gif;base64,R0lGODdhEwAHAKECAAAAAPj4/////////ywAAAAAEwAHAAACHYSPmWIB/KKBkznIKI0iTwlKXuR8B9aUXdYprlsAADs=" alt="null">';
} else {
$ret .= htmlentities($value);
}
}
}
$ret .= '</td></tr>';
}
$ret .= '</table>';
return $ret;
}
/**
* Escapes (secures) data for output.<br>
*
* <p>Array values are converted to space-separated value string lists.
* > A useful use case for an array attribute is the `class` attribute.
*
* Object values generate either:
* - a space-separated list of keys who's corresponding value is truthy;
* - a semicolon-separated list of key:value elements if at least one value is a string.
*
* Boolean values will generate the string "true" or "false".
*
* NULL is converted to an empty string.
*
* Strings are HTML-encoded.
*
* @param mixed $o
* @return string
*/
function e($o)
{
switch (gettype($o)) {
case 'string':
break;
case 'boolean':
return $o ? 'true' : 'false';
case 'integer':
case 'double':
return strval($o);
case 'array':
$at = [];
$s = ' ';
foreach ($o as $k => $v) {
if (!is_string($v) && !is_numeric($v)) {
throw new \InvalidArgumentException("Can't output an array with values of type " . gettype($v));
}
if (is_numeric($k)) {
$at[] = $v;
} else {
$at[] = "{$k}:{$v}";
$s = ';';
}
}
$o = implode($s, $at);
break;
case 'NULL':
return '';
default:
return typeOf($o);
}
return htmlentities($o, ENT_QUOTES, 'UTF-8', false);
}
public function testShouldFormatManyAccordingToConvertMethod()
{
$items = ['foo', 'bar', 'baz'];
$formatter = new MockFormatter();
$result = $formatter->formatMany($items);
assertThat('The result of `formatMany` should be an array of arrays.', $result, everyItem(is(typeOf('array'))));
assertThat('The result should be the same size as the number of items passed to `formatMany`.', $result, is(arrayWithSize(count($items))));
assertThat('The result should be correctly formatted.', $result, is(anArray([['count' => 1], ['count' => 2], ['count' => 3]])));
}
public function addAnimator($property, ILpfAnimator $animator, $frstart, $frend)
{
if (arr::hasKey($this->_properties, $property)) {
$this->_animators[$property][] = array('animator' => $animator, 'framestart' => $frstart, 'frameend' => $frend);
console::writeLn("Attached animator: %s => %s", typeOf($animator), $property);
} else {
logger::warning("Animator attached to nonexisting property %s of object %s", $property, (string) $this->_object);
}
}
/**
* @brief Recursive decoder
* @private
*
* @param String $json The JSON data to process
* @return Mixed The parsed data
*/
private static function decodeRecursive($json)
{
$arr = (array) $json;
foreach ($arr as $k => $v) {
if (typeOf($v) == 'stdClass' || typeOf($v) == 'array') {
$arr[$k] = (array) self::decodeRecursive($v);
}
}
return $arr;
}
/**
* @Then the SpikeApi Request Time should be very recent
*/
public function theRequestTimeShouldBeVeryRecent()
{
$now = time();
$data = json_decode($this->response);
$actual = $data->request_time;
assertThat($actual, typeOf('integer'));
#assertInternalType('integer', $actual);
// we need to allow some fuzz-time, a few seconds should be OK
assertThat("request time should be close", $now, closeTo($actual, 3));
// We give it a little fuzz to allow for potential clock drift between machines
}
/**
* @param Any? $value a value or null
*/
function mixedValueSummary($value, $valueIfEmpty = null, $returnKind = false)
{
$valueToReturn = $value ? $value : (isset($valueIfEmpty) ? $valueIfEmpty : $value);
if (!$returnKind) {
return $valueToReturn;
} else {
$r = array();
$r['kind'] = typeOf($valueToReturn);
$r['value'] = $valueToReturn;
return $r;
}
}
function exception(Exception $e)
{
if (ob_get_length() != false) {
@ob_end_clean();
}
$et = typeOf($e);
if ($et == 'FileNotFoundException' || $et == 'NavigationException') {
response::setStatus(404);
header('HTTP/1.1 404 Not Found', true);
printf("<h1>404: Not Found</h1>");
return;
}
if ($et == 'HttpException') {
response::setStatus($e->getCode());
$code = $e->getMessage();
list($code) = explode(':', $code);
$code = str_replace('Error ', '', $code);
$msg = HttpException::getHttpMessage($code);
header('HTTP/1.1 ' . $code . ' ' . $msg . ' ' . $msg);
printf("<h1>%s: %s</h1>\n<pre>%s</pre>", $code, $msg, $msg);
return;
}
response::setStatus(500);
logger::emerg("Unhandled exception: (%s) %s in %s:%d", get_class($e), $e->getMessage(), str_replace(BASE_PATH, '', $e->getFile()), $e->getLine());
header('HTTP/1.1 501 Server Error', true);
$id = uniqid();
$dbg = sprintf("Unhandled exception: (%s) %s\n in %s:%d", get_class($e), $e->getMessage(), str_replace(SYS_PATH, '', $e->getFile()), $e->getLine()) . Console::backtrace(0, $e->getTrace(), true) . "\n" . "Loaded modules:\n" . ModuleManager::debug() . "\n" . request::getDebugInformation();
logger::emerg($dbg);
if (config::get('lepton.mvc.exception.log', false) == true) {
$logfile = config::get('lepton.mvc.exception.logfile', "/tmp/" . $_SERVER['HTTP_HOST'] . "-debug.log");
$log = "=== Unhandled Exception ===\n\n" . $dbg . "\n";
$lf = @fopen($logfile, "a+");
if ($lf) {
fputs($lf, $log);
fclose($lf);
}
}
$ico_error = resource::get('warning.png');
header('content-type: text/html; charset=utf-8');
echo '<html><head><title>Unhandled Exception</title>' . self::$css . self::$js . '</head><body>' . '<div id="box"><div id="left"><img src="' . $ico_error . '" width="32" height="32"></div><div id="main">' . '<h1>An Unhandled Exception Occured</h1>' . '<hr noshade>' . '<p>This means that something didn\'t go quite go as planned. This could be ' . 'caused by one of several reasons, so please be patient and try ' . 'again in a little while.</p>';
if (config::get('lepton.mvc.exception.feedback', false) == true) {
echo '<p>The administrator of the website has been notified about this error. You ' . 'can help us find and fix the problem by writing a line or two about what you were doing when this ' . 'error occured.</p>';
echo '<p id="feedbacklink"><a href="javascript:doFeedback();">If you would like to assist us with more information, please click here</a>.</p>';
echo '<div id="feedback" style="display:none;"><p>Describe in a few short lines what you were doing right before you encountered this error:</p><form action="/errorevent.feedback/' . $id . '" method="post"><div><textarea name="text" style="width:100%; height:50px;"></textarea></div><div style="padding-top:5px; text-align:right;"><input type="button" value=" Close " onclick="closeFeedback();"> <input type="submit" value=" Submit Feedback "></div></form></div>';
}
if (config::get('lepton.mvc.exception.showdebug', false) == true) {
echo '<hr noshade>' . '<a href="javascript:toggleAdvanced();">Details »</a>' . '<pre id="advanced" style="display:none; height:300px;">' . $dbg . '</pre>';
}
echo '<div>' . '</body></html>';
}
/**
* @param $file
*
* @return array
*
* @throws \Stefanius\LaravelFixtures\Exception\FileNotFoundException
*/
public function loadYmlData($file)
{
if (is_null($file)) {
throw new \InvalidArgumentException(sprintf('The argument has to be a string. NULL given.'));
}
if (!is_string($file)) {
throw new \InvalidArgumentException(sprintf('The argument has to be a string. %s given.', typeOf($file)));
}
$ymlFilename = sprintf($this->fixtureDataPath . DIRECTORY_SEPARATOR . '%s.yml', $file);
if (!file_exists($ymlFilename)) {
throw new FileNotFoundException($ymlFilename);
}
return Yaml::parse(file_get_contents($ymlFilename));
}
public function testShouldFormatTraversableAccordingToConvertMethod()
{
$items = ['foo', 'bar', 'baz'];
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result of `formatTraversable` should be a Generator.', $result, is(anInstanceOf('Generator')));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('Every item in the result should be an array.', iterator_to_array($result), everyItem(is(typeOf('array'))));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result should be the same size as the number of items passed to `formatTraversable`.', $result, is(traversableWithSize(count($items))));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result should be correctly formatted.', iterator_to_array($result), is(anArray([['count' => 1], ['count' => 2], ['count' => 3]])));
}
/**
* Extracts and escapes text from the given value, for outputting to the HTTP client.
*
* <p>Note: this returns escaped text, except if the given argument is a {@see RawText} instance, in which case it
* returns raw text.
*
* @param string|RawText $s
* @return string
*/
function _e($s)
{
if (!is_scalar($s)) {
if (is_null($s)) {
return '';
}
if ($s instanceof RawText) {
return $s->toString();
}
if ($s instanceof RenderableInterface) {
$s = $s->getRendering();
} elseif (is_object($s) && method_exists($s, '__toString')) {
$s = (string) $s;
} else {
if (is_iterable($s)) {
return iteratorOf($s)->current();
}
return sprintf('[%s]', typeOf($s));
}
}
return htmlentities($s, ENT_QUOTES, 'UTF-8', false);
}
/**
* @internal
* @param mixed $arg
* @return string
*/
public static function formatErrorArg($arg)
{
if (is_object($arg)) {
switch (get_class($arg)) {
case \ReflectionMethod::class:
/** @var \ReflectionMethod $arg */
return sprintf('ReflectionMethod<%s::$s>', $arg->getDeclaringClass()->getName(), $arg->getName());
case \ReflectionFunction::class:
/** @var \ReflectionFunction $arg */
return sprintf('ReflectionFunction<function at %s line %d>', $arg->getFileName(), $arg->getStartLine());
case \ReflectionParameter::class:
/** @var \ReflectionParameter $arg */
return sprintf('ReflectionParameter<$%s>', $arg->getName());
default:
return typeOf($arg);
}
}
if (is_array($arg)) {
return sprintf('[%s]', implode(',', map($arg, [__CLASS__, 'formatErrorArg'])));
}
return str_replace('\\\\', '\\', var_export($arg, true));
}
function __inspect_recurs($data, $head = '')
{
$maxlenk = 30;
$maxlent = 8;
foreach ($data as $k => $v) {
if (strlen($k) > $maxlenk) {
$maxlenk = strlen($k);
}
if (strlen(typeOf($v)) > $maxlent) {
$maxlent = strlen(typeOf($v));
}
}
$maxlent += 2;
$itemcount = count($data);
$idx = 0;
foreach ($data as $k => $v) {
$idx++;
if (typeOf($v) == 'array' || typeOf($v) == 'stdClass') {
$ttl = $head . $k . ' ';
console::writeLn($ttl);
$myend = '|_';
$nhead = $head;
if ($idx++ > 0) {
$nhead = substr($head, 0, strlen($head) - 1) . ' ';
}
self::__inspect_recurs($v, $nhead . $myend);
} else {
switch (typeOf($v)) {
case 'boolean':
$sv = $v ? 'true' : 'false';
break;
default:
$sv = '"' . $v . '"';
}
console::writeLn('%s = %s', $head . sprintf('%s<%s>', $k, typeOf($v)), $sv);
}
}
}
/**
* @brief Run the application. Invoked by Lepton.
* Will parse the arguments and make sure everything is in order.
*
*/
function run()
{
global $argc, $argv;
if (isset($this->arguments)) {
if (is_string($this->arguments)) {
$strargs = $this->arguments;
$longargs = array();
} elseif (is_array($this->arguments)) {
$strargs = '';
$longargs = array();
foreach ($this->arguments as $arg) {
$strargs .= $arg[0];
// Scope is the : or ::
$scope = substr($arg[0], 1);
$longargs[] = $arg[1] . $scope;
}
} elseif (typeOf($this->arguments) == 'AppArgumentList') {
$args = $this->arguments->getData();
$strargs = '';
$longargs = array();
foreach ($args as $arg) {
$strargs .= $arg[0];
// Scope is the : or ::
$scope = substr($arg[0], 1);
$longargs[] = $arg[1] . $scope;
}
} else {
console::warn('Application->$arguments is set but format is not understood');
}
list($args, $params) = $this->parseArguments($strargs, $longargs);
foreach ($args as $arg => $val) {
if (in_array($arg, $longargs)) {
foreach ($args as $argsrc => $v) {
if ($argsrc == $arg) {
$args[$argsrc[0]] = $val;
$olarg = $argsrc[0];
}
}
} else {
foreach ($args as $argsrc => $v) {
if ($argsrc == $arg) {
$arg[$argsrc] = $val;
$olarg = $argsrc[0];
// Do any matching we need here
}
}
}
}
$this->_args = $args;
$this->_params = $params;
}
if (isset($args['h'])) {
if (method_exists($this, 'usage')) {
$this->usage();
}
return 1;
}
return $this->main($argc, $argv);
}
function CountItems()
{
global $db;
$cat = $db->query('SELECT ID,type,access,sc FROM ' . PRE . 'cats')->fetchAll(3);
//FETCH_NUM
$ile = count($cat);
if ($ile > 0) {
#Dla każdej kategorii policz liczbę zawartości
for ($i = 0; $i < $ile; ++$i) {
$id = $cat[$i][0];
$num[$id] = dbCount(typeOf($cat[$i][1]) . ' WHERE cat=' . $id . ' AND access=1');
#ID kategorii nadrzędnej
$sub[$id] = $cat[$i][3];
#Tablica będzie zawierać ilość kategorii w podkategoriach
$total[$id] = $num[$id];
}
for ($i = 0; $i < $ile; $i++) {
#Jeżeli dostępna - znajdź podkategorie i dolicz ilość zawartości
if ($cat[$i][2] != 2 && $cat[$i][2] != 3) {
$x = $cat[$i][3];
#Nadkategoria
while ($x != 0 && is_numeric($x)) {
$total[$x] += $total[$cat[$i][0]];
$x = $sub[$x];
}
}
}
#Zapisz ilość dla każdej kategorii
$q = $db->prepare('UPDATE ' . PRE . 'cats SET num=?, nums=? WHERE ID=?');
foreach ($total as $k => $x) {
if (is_numeric($x) && is_numeric($num[$k])) {
$q->execute(array($num[$k], $x, $k));
}
}
}
}
/**
* Performs the actual routing.
*
* @param mixed $routable
* @param ServerRequestInterface $request
* @param ResponseInterface $response
* @param callable $next
* @return ResponseInterface
*/
function route($routable, ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
if (is_null($routable)) {
return $next();
}
if (is_callable($routable)) {
if ($routable instanceof FactoryRoutable) {
$instance = $this->runFactory($routable);
return $this->route($instance, $request, $response, $next);
} else {
$response = $this->callHandler($routable, $request, $response, $next);
}
} else {
if ($routable instanceof \IteratorAggregate) {
$routable = $routable->getIterator();
} elseif (is_array($routable)) {
$routable = new \ArrayIterator($routable);
}
if ($routable instanceof Iterator) {
$response = $this->iteration_start($routable, $request, $response, $next, ++self::$stackCounter);
} elseif (is_string($routable)) {
$routable = $this->injector->make($routable);
if (is_callable($routable)) {
$response = $this->callHandler($routable, $request, $response, $next);
} else {
throw new \RuntimeException(sprintf("Instances of class <span class=class>%s</span> are not routable.", Debug::getType($routable)));
}
} else {
throw new \RuntimeException(sprintf("Invalid routable type <span class=type>%s</span>.", typeOf($routable)));
}
}
return $response;
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', typeOf('boolean'), null);
$this->assertMismatchDescription('was an integer <5>', typeOf('float'), 5);
}
/**
* For internal use.
*
* @param Component $component
* @param bool $deep
* @throws ComponentException
*/
private static function _inspect(Component $component, $deep = true)
{
if (self::$recursionMap->contains($component)) {
echo "<i>recursion</i>";
return;
}
self::$recursionMap->attach($component);
$COLOR_BIND = '#5AA';
$COLOR_CONST = '#5A5';
$COLOR_INFO = '#CCC';
$COLOR_PROP = '#B00';
$COLOR_TAG = '#000;font-weight:bold';
$COLOR_TYPE = '#55A';
$COLOR_VALUE = '#333';
$COLOR_SHADOW_DOM = '#5AA;font-weight:bold';
$Q = "<i style='color:#CCC'>\"</i>";
$tag = $component->getTagName();
$hasContent = false;
echo "<div class=__component><span style='color:{$COLOR_TAG}'><{$tag}</span>";
$isDoc = $component instanceof DocumentFragment;
if (!$component->parent && !$isDoc) {
echo " <span style='color:{$COLOR_INFO}'>(detached)</span>";
}
$type = typeOf($component) . ' #' . Debug::objectId($component);
echo "<span class='icon hint--rounded hint--right' data-hint='Component:\n{$type}'><i class='fa fa-info-circle'></i></span>";
$type1 = str_pad('#' . Debug::objectId($component->context), 4, ' ', STR_PAD_LEFT);
$type2 = str_pad('#' . Debug::objectId($component->getDataBinder()), 4, ' ', STR_PAD_LEFT);
$type3 = str_pad('#' . Debug::objectId($component->getViewModel()), 4, ' ', STR_PAD_LEFT);
$type4 = str_pad('#' . Debug::objectId($component->getDataBinder()->getViewModel()), 4, ' ', STR_PAD_LEFT);
$type5 = str_pad('#' . Debug::objectId($component->getDataBinder()->getProps()), 4, ' ', STR_PAD_LEFT);
echo "<span class='icon hint--rounded hint--bottom' data-hint='Context: {$type1} Data binder: {$type2}\nView model: {$type3} Binder view model: {$type4}\nProperties: {$type5}'><i class='fa fa-database'></i></span>";
// Handle text node
if ($component instanceof Text) {
echo "<span style='color:{$COLOR_TAG}'>></span><div style='margin:0 0 0 15px'>";
try {
if ($component->isBound('value')) {
/** @var Expression $exp */
$exp = $component->getBinding('value');
$exp = self::inspectString((string) $exp);
echo "<span style='color:{$COLOR_BIND}'>{$exp}</span> = ";
$v = self::getBindingValue('value', $component, $error);
if ($error) {
echo $v;
return;
}
if (!is_string($v)) {
echo Debug::typeInfoOf($v);
return;
}
} else {
$v = $component->props->value;
}
$v = strlen(trim($v)) ? HtmlSyntaxHighlighter::highlight($v) : "<i>'{$v}'</i>";
echo $v;
} finally {
echo "</div><span style='color:{$COLOR_TAG}'></{$tag}><br></span></div>";
}
return;
}
// Handle other node types
if ($component instanceof DocumentFragment) {
self::inspectViewModel($component);
}
if ($component->supportsProperties()) {
/** @var ComponentProperties $propsObj */
$propsObj = $component->props;
if ($propsObj) {
$props = $propsObj->getAll();
} else {
$props = null;
}
if ($props) {
ksort($props);
}
if ($props) {
$type = typeOf($propsObj);
$tid = Debug::objectId($propsObj);
echo "<span class='icon hint--rounded hint--right' data-hint='Properties: #{$tid}\n{$type}'><i class='fa fa-list'></i></span>";
echo "<table class='__console-table' style='color:{$COLOR_VALUE}'>";
// Display all scalar properties.
foreach ($props as $k => $v) {
$t = $component->props->getTypeOf($k);
$isModified = $component->props->isModified($k);
$modifStyle = $isModified ? ' class=__modified' : ' class=__original';
if ($t != type::content && $t != type::collection && $t != type::metadata) {
$tn = $component->props->getTypeNameOf($k);
echo "<tr{$modifStyle}><td style='color:{$COLOR_PROP}'>{$k}<td><i style='color:{$COLOR_TYPE}'>{$tn}</i><td>";
// Display data-binding
if ($component->isBound($k)) {
/** @var Expression $exp */
$exp = $component->getBinding($k);
$exp = self::inspectString((string) $exp);
echo "<span style='color:{$COLOR_BIND}'>{$exp}</span> = ";
$v = self::getBindingValue($k, $component, $error);
if ($error) {
break;
}
}
if (is_null($v)) {
echo "<i style='color:{$COLOR_INFO}'>null</i>";
} else {
switch ($t) {
case type::bool:
echo "<i style='color:{$COLOR_CONST}'>" . ($v ? 'true' : 'false') . '</i>';
break;
case type::id:
echo "{$Q}{$v}{$Q}";
break;
case type::number:
echo $v;
break;
case type::string:
echo "{$Q}<span style='white-space: pre-wrap'>" . self::inspectString(strval($v)) . "</span>{$Q}";
break;
default:
if (is_object($v)) {
echo sprintf("<i style='color:{$COLOR_CONST}'>%s</i>", Debug::typeInfoOf($v));
} elseif (is_array($v)) {
echo sprintf("<i style='color:{$COLOR_CONST}'>array(%d)</i>", count($v));
} else {
$v = _e($v);
echo "{$Q}{$v}{$Q}";
}
}
}
}
}
// Display all slot properties.
foreach ($props as $k => $v) {
$t = $component->props->getTypeOf($k);
if ($t == type::content || $t == type::collection || $t == type::metadata) {
$tn = $component->props->getTypeNameOf($k);
$isModified = $component->props->isModified($k);
$modifStyle = $isModified ? ' style="background:#FFE"' : ' style="opacity:0.5"';
echo "<tr{$modifStyle}><td style='color:{$COLOR_PROP}'>{$k}<td><i style='color:{$COLOR_TYPE}'>{$tn}</i><td>";
/** @var Expression $exp */
$exp = $component->getBinding($k);
if (isset($exp)) {
$exp = self::inspectString((string) $exp);
echo "<span style='color:{$COLOR_BIND}'>{$exp}</span> = ";
$v = self::getBindingValue($k, $component, $error);
if ($error) {
echo $v;
break;
}
}
if ($v && ($v instanceof Component || is_array($v))) {
switch ($t) {
case type::content:
if ($v) {
echo "<tr><td><td colspan=2>";
self::_inspect($v, $deep);
} else {
echo "<i style='color:{$COLOR_INFO}'>null</i>";
}
break;
case type::metadata:
if ($v) {
echo "<tr><td><td colspan=2>";
self::_inspect($v, $deep);
} else {
echo "<i style='color:{$COLOR_INFO}'>null</i>";
}
break;
case type::collection:
echo "of <i style='color:{$COLOR_TYPE}'>", $component->props->getRelatedTypeNameOf($k), '</i>';
if ($v) {
echo "<tr><td><td colspan=2>";
self::_inspectSet($v, true);
} else {
echo " = <i style='color:{$COLOR_INFO}'>[]</i>";
}
break;
}
} else {
if (is_array($v)) {
echo "<i style='color:{$COLOR_INFO}'>[]</i>";
} else {
if (isset($v)) {
printf("<b style='color:red'>WRONG TYPE: %s</b>", Debug::typeInfoOf($v));
} else {
echo "<i style='color:{$COLOR_INFO}'>null</i>";
}
}
}
echo '</tr>';
}
}
echo "</table>";
}
}
// If deep inspection is enabled, recursively inspect all children components.
if ($deep) {
$content = $shadowDOM = null;
if ($component->hasChildren()) {
$content = $component->getChildren();
}
if ($component instanceof CompositeComponent) {
$shadowDOM = $component->provideShadowDOM();
}
if ($content || $shadowDOM) {
echo "<span style='color:{$COLOR_TAG}'>></span><div style=\"margin:0 0 0 15px\">";
if ($content) {
self::_inspectSet($content, $deep);
}
if ($shadowDOM) {
echo "<span style='color:{$COLOR_SHADOW_DOM}'><Shadow DOM></span><div style=\"margin:0 0 0 15px\">";
self::_inspect($shadowDOM, $deep);
echo "</div><span style='color:{$COLOR_SHADOW_DOM}'></Shadow DOM></span>";
}
echo '</div>';
$hasContent = true;
}
}
echo "<span style='color:{$COLOR_TAG}'>" . ($hasContent ? "</{$tag}><br>" : "/><br>") . "</span></div>";
}
function esc_sql($value, $colType = null) {
if (is_number($value)) return $value;
if (typeOf($value) === 'NULL') return 'NULL';
return app('db')->getPdo()->quote($value);
}
/**
* @brief Return the type of the request object
*
* @return string The type of request object
*/
function getType()
{
return typeOf($this);
}
public function __construct($label, $key, Array $items = null, Array $options = null) {
$this->label = $label;
$this->setKey($key);
// Here we will do a little check to see if the array we are passed is
// indexed with a key ( $k => $v ), or if it's simply an array of arrays
// i.e. a recordset from a database query. If this is the case, we will
// go over the list and massage it to be indexed with a key.
if (count($items)>0) {
if (typeOf($items[0]) == 'array') {
$newarr = array();
// Repopulate the list with keys properly assigned
foreach($items as $item) {
$newarr[$item[0]] = $item[1];
}
// And update the item list with our newly populated one
$items = $newarr;
}
// Now we update the main list
$this->items = $items;
}
$this->options = arr::defaults($options, array(
'class' => 'wf-row'
));
}
public function decomposeArray($x = null)
{
$type = typeOf($x);
//pkdebug("TYPE: $type");
if (!$x) {
return '';
}
if (!is_array($x)) {
if (is_scalar($x) || is_object($x) && method_exists($x, '__toString')) {
return $x . $this->separator;
}
return '';
}
$str = $this->separator;
foreach ($x as $y) {
$str .= $this->decomposeArray($y) . $this->separator;
}
return $str;
}
public static function like($pattern, $string)
{
if (typeOf($pattern) == 'array') {
foreach ($pattern as $pat) {
if (fnmatch($pat, $string, FNM_CASEFOLD)) {
return true;
}
}
return false;
} else {
return fnmatch($pattern, $string, FNM_CASEFOLD);
}
}
/** Return an Eloquent Query Builder Instance
* Builds a basic chained "AND WHERE..." query from the instance 'querySets" array.
* The query set is an associative array of <tt>what=>[crit, val]</tt>, where
* 'what' is either a field/column name, OR the root of a custom query method,
* which has to be defined in the implementing classes, presumably a trait
* shared by the Controller/SearchModel. Looks first for field name, then
* method name, defined as <tt>$this->customQuery{What}($crit,$val)</tt>
*
* One advantage to searching on a model instance - you can also use
* and specify model methods as comparison criteria for stuff that's hard in
* DB. Can also take parameters. The Query will first execute the query it
* can on the DB - then from the return, filter on the instances using
* the methods.
*
* (Ex: <tt>$this->customQueryAsset_debt_ratio($query,$crit, $val)</tt>:
* <pre>
* [
* 'fieldName1'=>['crit'=>$crit1, 'val'=>$val1],
* 'fieldName2'=>['crit'=>$crit2, 'val'=>$val2],
* 'methodName1'=>['crit'=>$crit3, 'val'=>$val3],
* 'methodName2'=>['crit'=>$crit4, 'val'=>$val4, 'param'=>$param],
* ....]
* </pre>
*
* @param $targetModel - A PkModel CLASS, NOT instance.
* @return Eloquent Builder
* */
public function buildQueryOnModel($targetModel = null, $querySets=null) {
if (!$targetModel) $targetModel = static::getTargetModel();
if (empty($targetModel)) throw new \Exception("No model to build query on");
$targetFieldNames = $targetModel::getStaticAttributeNames();
//pkdebug("TargetFieldNames:", $targetFieldNames);
if ($querySets === null) {
if (!empty($this->querySets)) $querySets = $this->querySets;
else $querySets = $this->buildQuerySets();
}
#Sets are keyed by 'root' or 'baseName', with a definition array. If the
#root key matches an attribute name on the model, that's what we search
#against. If not, try to figure out what the query is on/for/to.
#
#The definition array might contain a sub-definition array -
#$sets[$root]['def']['attribute'] - which could be : 'property',
#'target_method' (a method to call on the target Model), or 'self_method'
#(a method defined in this model/trait.) - with $baseName the method or property
#name. It could also contain other fields, like as parameters to methods
#
#In fact, it's totally appropriate for a persistent query to consist entirely
#of methods and NO model/table fields.
//pkdebug("Query Sets:", $sets);
$query = $targetModel::query();
if (empty($querySets)) return $query;
//pkdebug("NOT empty SETS!");
//pkdebug("QuerySets:", $querySets);
//pkdebug("My PkMatchObjs:", $this->matchObjs);
foreach ($querySets as $root => $critset) {
$toq = typeOf($query);
//pkdebug("ROOT: [$root] SET:", $critset, "queryT: $toq");
if ($root == '0') continue;
//if ($root==='assetdebtratio') pkdebug("ADR: QT: ".typeOf($query)."..");
//pkdebug("ROOT: [ $root ] ADR: QT: ".typeOf($query)."..");
//if (!$critset['crit'] || ($critset['crit'] == '0') || static::emptyVal($critset['val'])) continue;
if (static::emptyCrit($critset['crit']) || static::emptyVal($critset['val']))
continue;
//pkdebug("ROOT: [ $root ] ADR: QT: ".typeOf($query)."..");
//pkdebug("root is:", $root, "critset:", $critset);
if (in_array($root, $targetFieldNames)) {
if (is_array($critset['val'])) {
if ($critset['crit'] === 'IN') {
$query = $query->whereIn($root, array_values($critset['val']));
continue;
} else if ($critset['crit'] === 'NOTIN') {
$query = $query->whereNotIn($root, array_values($critset['val']));
continue;
} else if ($critset['crit'] === 'BETWEEN') {
// $max = is_int(keyVal('max',$critset['val'])) ? keyVal('max',$critset['val']) : PHP_INT_MAX;
// pkdebug("ROOT: [ $root ] ADR: QT: ".typeOf($query)."..");
// $min = is_int(keyVal('min',$critset['val'])) ? keyVal('min',$critset['val']) : -PHP_INT_MAX;
$min = to_int(keyVal('minval', $critset['val']), -PHP_INT_MAX);
$max = to_int(keyVal('maxval', $critset['val']), PHP_INT_MAX);
//pkdebug('Orig Val Arr:', $critset['val'], "MIN:", $min, "MAX", $max);
$query = $query->whereBetween($root, [$min, $max]);
continue;
} else {
continue;
}
}
//pkdebug("QT: ".typeOf($query)."..");
$query = $query->where($root, $critset['crit'], $critset['val']);
} else if (method_exists($this, 'customQuery' . $root)) {
$customQueryMethod = 'customQuery' . $root;
$query = $this->$customQueryMethod($query, $critset['crit'], $critset['val'], $critset['param']);
}
}
return $query;
}
public function content($content = '', $raw = false)
{
if ($content === null) {
$this[] = null;
return $this;
}
if (is_array($content)) {
foreach ($content as $item) {
$this->content($item);
}
return $this;
}
if ($content instanceof self || $content instanceof PkHtmlRenderer || $content instanceof \Illuminate\Support\HtmlString) {
$this[] = $content;
return $this;
}
if (is_string($content)) {
if (!$raw) {
$content = hpure($content);
}
$this[] = $content;
return $this;
} else {
$type = typeOf($content);
throw new \Exception("Unhandled Content Type: [{$type}], val: " . print_r($content, 1));
}
return $this;
}
/**
* Returns the value converted to a the data type required by the specified property.
*
* @param string $name
* @param mixed $v
* @return bool|float|int|null|string|\Traversable
* @throws ComponentException
*/
function typecastPropertyValue($name, $v)
{
if ($this->isScalar($name) && $this->isEnum($name)) {
$this->validateEnum($name, $v);
}
$type = $this->getTypeOf($name);
if ($type && !type::validate($type, $v)) {
throw new ComponentException($this->component, sprintf("%s is not a valid value for the <kbd>{$name}</kbd> property, which is of type <kbd>%s</kbd>", is_scalar($v) ? sprintf("The %s<kbd>%s</kbd>", typeOf($v), var_export($v, true)) : sprintf("A value of PHP type <kbd>%s</kbd>", typeOf($v)), type::getNameOf($type)));
}
// A special case for content type properties:
// Convert a content property specified as attribute=string to a format equivalent to the one generated by
// <subtag>string</subtag>
if ($type == type::content && is_string($v)) {
$content = new Metadata($this->component->context, $name, type::metadata);
$content->setChildren([Text::from($this->component->context, $v)]);
return $content;
}
return type::typecast($type, $v);
}
/**
* @brief Retrieve the access matrix for the subject.
*
* The matrix will contain all the roles as well as effective modifiers
* applied including groups as well as the default roles.
*
* @param IAclObject $object The object to for which the access is queried
* @param IAclSubject $subject The subject whos access is being queried
* @return Array The access matrix
*/
static function getAccessMatrix(IAclObject $object, IAclSubject $subject)
{
// Get the object uuids
$ouuid = $object->getObjectUuid();
$roles = $object->getObjectRoles();
// Get the uuid and groups from the subject
$sgroups = $subject->getSubjectGroups();
$suuid = $subject->getSubjectUuid();
// Create database connection
$db = new DatabaseConnection();
$matrix = array();
// Determine and label the default roles for the object
$matrix[] = array('label' => sprintf('%s <%s>', typeOf($object), $ouuid), 'type' => self::TYP_OBJECT, 'roles' => $roles);
// Compile a role list and save the effective roles
$rlist = array();
foreach ($roles as $role => $def) {
$rlist[] = $role;
}
$effective = $roles;
// Determine and label the roles for the subjects groups
foreach ($sgroups as $group) {
$guuid = $group->getSubjectUuid();
$groles = acl::getExplicitAccessRecord($guuid, $ouuid, $rlist);
$matrix[] = array('label' => sprintf('%s <%s>', (string) $group, $guuid), 'type' => self::TYP_GROUP, 'roles' => $groles);
foreach ($effective as $role => $val) {
if ($groles[$role] === self::ACL_DENY) {
$effective[$role] = self::ACL_DENY;
} elseif ($groles[$role] === self::ACL_ALLOW) {
$effective[$role] = self::ACL_ALLOW;
}
}
}
// Determine and label the roles for the subject
$sroles = acl::getExplicitAccessRecord($suuid, $ouuid, $rlist);
$matrix[] = array('label' => sprintf('%s <%s>', (string) $subject, $suuid), 'type' => self::TYP_SUBJECT, 'roles' => $sroles);
foreach ($effective as $role => $val) {
if ($sroles[$role] === self::ACL_DENY) {
$effective[$role] = self::ACL_DENY;
} elseif ($sroles[$role] === self::ACL_ALLOW) {
$effective[$role] = self::ACL_ALLOW;
}
}
// Finally assemble the effective permissions
$matrix[] = array('label' => sprintf('%s <%s>', (string) $subject, $suuid), 'type' => self::TYP_EFFECTIVE, 'roles' => $effective);
// Return result
return $matrix;
}
/**
* Generate HTML CONTENT element of type $tag
* Change to allow $content to be assoc array with same params as args
* EXPERIMENT: Try Using Raw Count to prevent filtering of input els.
* @param string $tag - the HTML tag - required
* @param scalar|array|null $content
* @param string|array|null $attributes
* @param boolean $raw - default true
* @return html string
*/
public function tagged($tag, $content = null, $attributes = null, $raw = false)
{
$ctype = typeOf($content);
//if (! is_simple($content)) pkdebug("Type of Content: [$ctype]");
$attributes = $this->cleanAttributes($attributes);
if ($content === true || $content === $this) {
#That's RENDEROPEN === TRUE
$spaces = $this->spaceDepth();
$size = $this->addTagStack([$tag => ['raw' => $raw]]);
return $this->rawcontent("{$spaces}<{$tag} " . PkHtml::attributes($attributes) . ">\n");
} else {
if ($content === false) {
##Nest the elements
$spaces = $this->spaceDepth();
$size = $this->addDepthTagStack($tag);
return $this->rawcontent("{$spaces}<{$tag} " . $this->attributes($attributes) . ">\n");
} else {
#Trust that text already wrapped in PhHtmlRenderer has already been filtered
//if (!$raw && !static::getRawCount() && !($content instanceOf PkHtmlRenderer)) {
//$this[]=$this->spaceDepth()."<$tag ".PkHtml::attributes($attributes).">
$this->rawcontent($this->spaceDepth() . "<{$tag} " . PkHtml::attributes($attributes) . ">\n");
if (is_array($content)) {
foreach ($content as $citem) {
$this->content($citem, $raw);
}
} else {
$this->content($content, $raw);
}
$this->rawcontent($this->spaceDepth() . "</{$tag}>\n");
return $this;
}
}
}
/**
* @param mixed $v
* @return string
*/
function filter_type($v)
{
return typeOf($v);
}
