_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2500 | Reporter.on | train | public function on() : self
{
$this->handler->setErrorHandler();
$this->handler->setExceptionHandler();
$this->handler->setFatalHandler();
return $this;
} | php | {
"resource": ""
} |
q2501 | Driver.start | train | public function start($type = '*firefox', $startUrl = 'http://localhost')
{
if (null !== $this->sessionId) {
throw new Exception("Session already started");
}
$response = $this->doExecute('getNewBrowserSession', $type, $startUrl);
if (preg_match('/^OK,(.*)$/', $response, $vars)) {
$this->sessionId = $vars[1];
} else {
throw new Exception("Invalid response from server : $response");
}
} | php | {
"resource": ""
} |
q2502 | Driver.getString | train | public function getString($command, $target = null, $value = null)
{
$result = $this->doExecute($command, $target, $value);
if (!preg_match('/^OK,/', $result)) {
throw new Exception("Unexpected response from Selenium server : ".$result);
}
return strlen($result) > 3 ? substr($result, 3) : '';
} | php | {
"resource": ""
} |
q2503 | Driver.getStringArray | train | public function getStringArray($command, $target = null, $value = null)
{
$string = $this->getString($command, $target, $value);
$results = preg_split('/(?<!\\\),/', $string);
foreach ($results as &$result) {
$result = str_replace('\,', ',', $result);
}
return $results;
} | php | {
"resource": ""
} |
q2504 | Driver.getNumber | train | public function getNumber($command, $target = null, $value = null)
{
$string = $this->getString($command, $target, $value);
return (int) $string;
} | php | {
"resource": ""
} |
q2505 | Driver.getBoolean | train | public function getBoolean($command, $target = null, $value = null)
{
$string = $this->getString($command, $target, $value);
return $string == 'true';
} | php | {
"resource": ""
} |
q2506 | Driver.stop | train | public function stop()
{
if (null === $this->sessionId) {
throw new Exception("Session not started");
}
$this->doExecute('testComplete');
$this->sessionId = null;
} | php | {
"resource": ""
} |
q2507 | Driver.doExecute | train | protected function doExecute($command, $target = null, $value = null)
{
$postFields = array();
$query = array('cmd' => $command);
if ($target !== null) {
$postFields[1] = $target;
}
if ($value !== null) {
$postFields[2] = $value;
}
if (null !== $this->sessionId) {
$query['sessionId'] = $this->sessionId;
}
$query = http_build_query($query);
$url = $this->url.'?'.$query;
//open connection
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, count($postFields));
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postFields));
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($ch);
$curlErrno = curl_errno($ch);
curl_close($ch);
if ($curlErrno > 0) {
throw new Exception("Unable to connect ! ");
}
if (false === $result) {
throw new Exception("Connection refused");
}
return $result;
} | php | {
"resource": ""
} |
q2508 | StacktraceFormatterTrait.unpackThrowables | train | private function unpackThrowables($throwable)
{
if (!$throwable instanceof Throwable) {
return [];
}
$throwables = [$throwable];
while ($throwable = $throwable->getPrevious()) {
$throwables[] = $throwable;
}
return $throwables;
} | php | {
"resource": ""
} |
q2509 | RenderViewHelper.renderStatic | train | public static function renderStatic(array $arguments, Closure $renderChildrenClosure, RenderingContextInterface $renderingContext)
{
/** @var FieldViewHelperService $fieldService */
$fieldService = Core::instantiate(FieldViewHelperService::class);
if (false === $fieldService->fieldContextExists()) {
throw ContextNotFoundException::slotRenderViewHelperFieldContextNotFound();
}
/** @var SlotViewHelperService $slotService */
$slotService = Core::instantiate(SlotViewHelperService::class);
$slotName = $arguments['slot'];
$result = '';
if ($slotService->hasSlot($slotName)) {
$currentVariables = version_compare(VersionNumberUtility::getCurrentTypo3Version(), '8.0.0', '<')
? $renderingContext->getTemplateVariableContainer()->getAll()
: $renderingContext->getVariableProvider()->getAll();
ArrayUtility::mergeRecursiveWithOverrule($currentVariables, $arguments['arguments']);
$slotService->addTemplateVariables($slotName, $currentVariables);
$slotClosure = $slotService->getSlotClosure($slotName);
$result = $slotClosure();
$slotService->restoreTemplateVariables($slotName);
}
return $result;
} | php | {
"resource": ""
} |
q2510 | ExceptionHandler.handle | train | public function handle($throwable)
{
if ($throwable instanceof Exception) {
$response = $this->handler->handleException($this->defaultRequest, $this->defaultResponse, $throwable);
} elseif ($throwable instanceof Throwable) {
$response = $this->handler->handleThrowable($this->defaultRequest, $this->defaultResponse, $throwable);
} else {
return false;
}
if ($response instanceof ResponseInterface) {
$this->renderResponse($response);
return true;
} else {
return false;
}
} | php | {
"resource": ""
} |
q2511 | FieldViewHelper.storeViewDataLegacy | train | protected function storeViewDataLegacy()
{
$originalArguments = [];
$variableProvider = $this->getVariableProvider();
foreach (self::$reservedVariablesNames as $key) {
if ($variableProvider->exists($key)) {
$originalArguments[$key] = $variableProvider->get($key);
}
}
$viewHelperVariableContainer = $this->renderingContext->getViewHelperVariableContainer();
$currentView = $viewHelperVariableContainer->getView();
return function (array $templateArguments) use ($originalArguments, $variableProvider, $viewHelperVariableContainer, $currentView) {
$viewHelperVariableContainer->setView($currentView);
/*
* Cleaning up the variables in the provider: the original
* values are restored to make the provider like it was before
* the field rendering started.
*/
foreach ($variableProvider->getAllIdentifiers() as $identifier) {
if (array_key_exists($identifier, $templateArguments)) {
$variableProvider->remove($identifier);
}
}
foreach ($originalArguments as $key => $value) {
if ($variableProvider->exists($key)) {
$variableProvider->remove($key);
}
$variableProvider->add($key, $value);
}
};
} | php | {
"resource": ""
} |
q2512 | FieldViewHelper.injectFieldInService | train | protected function injectFieldInService($fieldName)
{
$formObject = $this->formService->getFormObject();
$formConfiguration = $formObject->getConfiguration();
if (false === is_string($fieldName)) {
throw InvalidArgumentTypeException::fieldViewHelperInvalidTypeNameArgument();
} elseif (false === $formConfiguration->hasField($fieldName)) {
throw PropertyNotAccessibleException::fieldViewHelperFieldNotAccessibleInForm($formObject, $fieldName);
}
$this->fieldService->setCurrentField($formConfiguration->getField($fieldName));
} | php | {
"resource": ""
} |
q2513 | FieldViewHelper.getLayout | train | protected function getLayout(View $viewConfiguration)
{
$layout = $this->arguments['layout'];
if (false === is_string($layout)) {
throw InvalidArgumentTypeException::invalidTypeNameArgumentFieldViewHelper($layout);
}
list($layoutName, $templateName) = GeneralUtility::trimExplode('.', $layout);
if (empty($templateName)) {
$templateName = 'default';
}
if (empty($layoutName)) {
throw InvalidArgumentValueException::fieldViewHelperEmptyLayout();
}
if (false === $viewConfiguration->hasLayout($layoutName)) {
throw EntryNotFoundException::fieldViewHelperLayoutNotFound($layout);
}
if (false === $viewConfiguration->getLayout($layoutName)->hasItem($templateName)) {
throw EntryNotFoundException::fieldViewHelperLayoutItemNotFound($layout, $templateName);
}
return $viewConfiguration->getLayout($layoutName)->getItem($templateName);
} | php | {
"resource": ""
} |
q2514 | FieldViewHelper.getTemplateArguments | train | protected function getTemplateArguments()
{
$templateArguments = $this->arguments['arguments'] ?: [];
ArrayUtility::mergeRecursiveWithOverrule($templateArguments, $this->fieldService->getFieldOptions());
return $templateArguments;
} | php | {
"resource": ""
} |
q2515 | Convert.valueToBytes | train | public static function valueToBytes($value): int
{
if (is_int($value)) {
return $value;
}
$value = trim($value);
// Native PHP check for digits in string
if (ctype_digit(ltrim($value, '-'))) {
return (int)$value;
}
$signed = (substr($value, 0, 1) === '-') ? -1 : 1;
// Kilobytes
if (preg_match('/(\d+)K$/i', $value, $matches)) {
return (int)($matches[1] * $signed * 1024);
}
// Megabytes
if (preg_match('/(\d+)M$/i', $value, $matches)) {
return (int)($matches[1] * $signed * 1024 * 1024);
}
// Gigabytes
if (preg_match('/(\d+)G$/i', $value, $matches)) {
return (int)($matches[1] * $signed * 1024 * 1024 * 1024);
}
throw new InvalidArgumentException("Failed to find K, M, or G in a non-integer value [$value]");
} | php | {
"resource": ""
} |
q2516 | Convert.objectToArray | train | public static function objectToArray($source): array
{
$result = [];
if (is_array($source)) {
return $source;
}
if (!is_object($source)) {
return $result;
}
$json = json_encode($source);
if ($json === false) {
return $result;
}
$array = json_decode($json, true);
if ($array === null) {
return $result;
}
$result = $array;
return $result;
} | php | {
"resource": ""
} |
q2517 | Convert.dataToJson | train | public static function dataToJson(string $data, bool $lint = false): stdClass
{
if ($lint) {
$linter = new JsonParser();
$linter->parse($data);
}
$data = json_decode($data);
if ($data === null) {
throw new InvalidArgumentException("Failed to decode json");
}
return (object)$data;
} | php | {
"resource": ""
} |
q2518 | URI.getQueryParam | train | public function getQueryParam(UriInterface $uri, $param)
{
if (!$query = $uri->getQuery()) {
return null;
}
parse_str($query, $params);
if (!array_key_exists($param, $params)) {
return null;
}
return $params[$param];
} | php | {
"resource": ""
} |
q2519 | URI.uriFor | train | public function uriFor($route, array $params = [], array $query = [])
{
if (!$route) {
return '';
}
return $this->router->relativePathFor($route, $params, $query);
} | php | {
"resource": ""
} |
q2520 | URI.absoluteURIFor | train | public function absoluteURIFor(UriInterface $uri, $route, array $params = [], array $query = [])
{
$path = $this->uriFor($route, $params);
return (string) $uri
->withUserInfo('')
->withPath($path)
->withQuery(http_build_query($query))
->withFragment('');
} | php | {
"resource": ""
} |
q2521 | FormBuilder.getTypeObject | train | private function getTypeObject($type, $args)
{
/* @var AbstractType $object */
if ($type instanceof AbstractType) {
$object = $type;
} else {
$class = $this->getTypeClass($type);
if (!\class_exists($class)) {
$class = TextType::class;
}
$object = new $class($args, $this);
}
return $object;
} | php | {
"resource": ""
} |
q2522 | BehavioursManager.applyBehaviourOnFormInstance | train | public function applyBehaviourOnFormInstance(FormObject $formObject)
{
if ($formObject->hasForm()) {
$formInstance = $formObject->getForm();
foreach ($formObject->getConfiguration()->getFields() as $fieldName => $field) {
if (ObjectAccess::isPropertyGettable($formInstance, $fieldName)
&& ObjectAccess::isPropertySettable($formInstance, $fieldName)
) {
$propertyValue = ObjectAccess::getProperty($formInstance, $fieldName);
foreach ($field->getBehaviours() as $behaviour) {
/** @var AbstractBehaviour $behaviourInstance */
$behaviourInstance = GeneralUtility::makeInstance($behaviour->getClassName());
// Applying the behaviour on the field's value.
$propertyValue = $behaviourInstance->applyBehaviour($propertyValue);
}
ObjectAccess::setProperty($formInstance, $fieldName, $propertyValue);
}
}
}
} | php | {
"resource": ""
} |
q2523 | ConditionFactory.registerCondition | train | public function registerCondition($name, $className)
{
if (false === is_string($name)) {
throw InvalidArgumentTypeException::conditionNameNotString($name);
}
if (false === class_exists($className)) {
throw ClassNotFoundException::conditionClassNameNotFound($name, $className);
}
if (false === in_array(ConditionItemInterface::class, class_implements($className))) {
throw InvalidArgumentTypeException::conditionClassNameNotValid($className);
}
$this->conditions[$name] = $className;
return $this;
} | php | {
"resource": ""
} |
q2524 | ConditionFactory.registerDefaultConditions | train | public function registerDefaultConditions()
{
if (false === $this->defaultConditionsWereRegistered) {
$this->defaultConditionsWereRegistered = true;
$this->registerCondition(
FieldHasValueCondition::CONDITION_NAME,
FieldHasValueCondition::class
)->registerCondition(
FieldHasErrorCondition::CONDITION_NAME,
FieldHasErrorCondition::class
)->registerCondition(
FieldIsValidCondition::CONDITION_NAME,
FieldIsValidCondition::class
)->registerCondition(
FieldIsEmptyCondition::CONDITION_NAME,
FieldIsEmptyCondition::class
)->registerCondition(
FieldIsFilledCondition::CONDITION_IDENTIFIER,
FieldIsFilledCondition::class
)->registerCondition(
FieldCountValuesCondition::CONDITION_IDENTIFIER,
FieldCountValuesCondition::class
);
}
} | php | {
"resource": ""
} |
q2525 | TypoScriptService.getFormConfiguration | train | public function getFormConfiguration($formClassName)
{
$formzConfiguration = $this->getExtensionConfiguration();
return (isset($formzConfiguration['forms'][$formClassName]))
? $formzConfiguration['forms'][$formClassName]
: [];
} | php | {
"resource": ""
} |
q2526 | TypoScriptService.getExtensionConfiguration | train | protected function getExtensionConfiguration()
{
$cacheInstance = CacheService::get()->getCacheInstance();
$hash = $this->getContextHash();
if ($cacheInstance->has($hash)) {
$result = $cacheInstance->get($hash);
} else {
$result = $this->getFullConfiguration();
$result = (ArrayUtility::isValidPath($result, self::EXTENSION_CONFIGURATION_PATH, '.'))
? ArrayUtility::getValueByPath($result, self::EXTENSION_CONFIGURATION_PATH, '.')
: [];
if (ArrayUtility::isValidPath($result, 'settings.typoScriptIncluded', '.')) {
$cacheInstance->set($hash, $result);
}
}
return $result;
} | php | {
"resource": ""
} |
q2527 | TypoScriptService.getFullConfiguration | train | protected function getFullConfiguration()
{
$contextHash = $this->getContextHash();
if (false === array_key_exists($contextHash, $this->configuration)) {
$typoScriptArray = ($this->environmentService->isEnvironmentInFrontendMode())
? $this->getFrontendTypoScriptConfiguration()
: $this->getBackendTypoScriptConfiguration();
$this->configuration[$contextHash] = $this->typoScriptService->convertTypoScriptArrayToPlainArray($typoScriptArray);
}
return $this->configuration[$contextHash];
} | php | {
"resource": ""
} |
q2528 | Generator.generate | train | public function generate(
ContainerConfiguration $config,
ConfigCache $dump
): ContainerInterface {
$this->compiler->compile($config, $dump, $this);
return $this->loadContainer($config, $dump);
} | php | {
"resource": ""
} |
q2529 | HtmlToJson.toJson | train | public function toJson($html)
{
// Strip white space between tags to prevent creation of empty #text nodes
$html = preg_replace('~>\s+<~', '><', $html);
$document = new \DOMDocument();
// Load UTF-8 HTML hack (from http://bit.ly/pVDyCt)
$document->loadHTML('<?xml encoding="UTF-8">' . $html);
$document->encoding = 'UTF-8';
// fetch the body of the document. All html is stored in there
$body = $document->getElementsByTagName("body")->item(0);
$data = array();
// loop trough the child nodes and convert them
if ($body) {
foreach ($body->childNodes as $node) {
$data[] = $this->convert($node);
}
}
return json_encode(array('data' => $data));
} | php | {
"resource": ""
} |
q2530 | HtmlToJson.convert | train | private function convert(\DOMElement $node)
{
foreach ($this->converters as $converter) {
if ($converter->matches($node)) {
return $converter->toJson($node);
}
}
} | php | {
"resource": ""
} |
q2531 | AbstractActivation.getConditions | train | public function getConditions()
{
$conditionList = $this->withFirstParent(
Form::class,
function (Form $formConfiguration) {
return $formConfiguration->getConditionList();
}
);
$conditionList = ($conditionList) ?: [];
ArrayUtility::mergeRecursiveWithOverrule($conditionList, $this->conditions);
return $conditionList;
} | php | {
"resource": ""
} |
q2532 | AbstractActivation.getCondition | train | public function getCondition($name)
{
if (false === $this->hasCondition($name)) {
throw EntryNotFoundException::activationConditionNotFound($name);
}
$items = $this->getConditions();
return $items[$name];
} | php | {
"resource": ""
} |
q2533 | FormService.getFormWithErrors | train | public static function getFormWithErrors($formClassName)
{
GeneralUtility::logDeprecatedFunction();
return (isset(self::$formWithErrors[$formClassName]))
? self::$formWithErrors[$formClassName]
: null;
} | php | {
"resource": ""
} |
q2534 | ConditionParser.getNodeRecursive | train | protected function getNodeRecursive()
{
while (false === empty($this->scope->getExpression())) {
$currentExpression = $this->scope->getExpression();
$this->processToken($currentExpression[0]);
$this->processLogicalAndNode();
}
$this->processLastLogicalOperatorNode();
$node = $this->scope->getNode();
unset($this->scope);
return $node;
} | php | {
"resource": ""
} |
q2535 | ConditionParser.processToken | train | protected function processToken($token)
{
switch ($token) {
case ')':
$this->processTokenClosingParenthesis();
break;
case '(':
$this->processTokenOpeningParenthesis();
break;
case self::LOGICAL_OR:
case self::LOGICAL_AND:
$this->processTokenLogicalOperator($token);
break;
default:
$this->processTokenCondition($token);
break;
}
return $this;
} | php | {
"resource": ""
} |
q2536 | ConditionParser.processTokenOpeningParenthesis | train | protected function processTokenOpeningParenthesis()
{
$groupNode = $this->getGroupNode($this->scope->getExpression());
$scopeSave = $this->scope;
$expression = array_slice($scopeSave->getExpression(), count($groupNode) + 2);
$scopeSave->setExpression($expression);
$this->scope = $this->getNewScope();
$this->scope->setExpression($groupNode);
$node = $this->getNodeRecursive();
$this->scope = $scopeSave;
$this->scope->setNode($node);
} | php | {
"resource": ""
} |
q2537 | ConditionParser.processTokenLogicalOperator | train | protected function processTokenLogicalOperator($operator)
{
if (null === $this->scope->getNode()) {
$this->addError('Logical operator must be preceded by a valid operation.', self::ERROR_CODE_LOGICAL_OPERATOR_PRECEDED);
} else {
if (self::LOGICAL_OR === $operator) {
if (null !== $this->scope->getLastOrNode()) {
/*
* If a `or` node was already registered, we create a new
* boolean node to join the two nodes.
*/
$node = new BooleanNode($this->scope->getLastOrNode(), $this->scope->getNode(), $operator);
$this->scope->setNode($node);
}
$this->scope->setLastOrNode($this->scope->getNode());
} else {
$this->scope
->setCurrentLeftNode($this->scope->getNode())
->deleteNode();
}
$this->scope
->setCurrentOperator($operator)
->shiftExpression();
}
} | php | {
"resource": ""
} |
q2538 | ConditionParser.processTokenCondition | train | protected function processTokenCondition($condition)
{
if (false === $this->condition->hasCondition($condition)) {
$this->addError('The condition "' . $condition . '" does not exist.', self::ERROR_CODE_CONDITION_NOT_FOUND);
} else {
$node = new ConditionNode($condition, $this->condition->getCondition($condition));
$this->scope
->setNode($node)
->shiftExpression();
}
} | php | {
"resource": ""
} |
q2539 | ConditionParser.processLogicalAndNode | train | protected function processLogicalAndNode()
{
if (null !== $this->scope->getCurrentLeftNode()
&& null !== $this->scope->getNode()
&& null !== $this->scope->getCurrentOperator()
) {
$node = new BooleanNode($this->scope->getCurrentLeftNode(), $this->scope->getNode(), $this->scope->getCurrentOperator());
$this->scope
->setNode($node)
->deleteCurrentLeftNode()
->deleteCurrentOperator();
}
return $this;
} | php | {
"resource": ""
} |
q2540 | ConditionParser.processLastLogicalOperatorNode | train | protected function processLastLogicalOperatorNode()
{
if (null !== $this->scope->getCurrentLeftNode()) {
$this->addError('Logical operator must be followed by a valid operation.', self::ERROR_CODE_LOGICAL_OPERATOR_FOLLOWED);
} elseif (null !== $this->scope->getLastOrNode()) {
$node = new BooleanNode($this->scope->getLastOrNode(), $this->scope->getNode(), self::LOGICAL_OR);
$this->scope->setNode($node);
}
return $this;
} | php | {
"resource": ""
} |
q2541 | ConditionParser.getGroupNodeClosingIndex | train | protected function getGroupNodeClosingIndex(array $expression)
{
$parenthesis = 1;
$index = 0;
while ($parenthesis > 0) {
$index++;
if ($index > count($expression)) {
$this->addError('Parenthesis not correctly closed.', self::ERROR_CODE_CLOSING_PARENTHESIS_NOT_FOUND);
}
if ('(' === $expression[$index]) {
$parenthesis++;
} elseif (')' === $expression[$index]) {
$parenthesis--;
}
}
return $index;
} | php | {
"resource": ""
} |
q2542 | Salt.getSalt | train | public static function getSalt(): string
{
$result = '';
try {
$result = static::readSaltFromFile();
} catch (InvalidArgumentException $e) {
Log::warning("Failed to read salt from file");
}
if ($result) {
return $result;
}
try {
$salt = static::generateSalt();
static::writeSaltToFile($salt);
$result = static::readSaltFromFile();
} catch (InvalidArgumentException $e) {
throw new InvalidArgumentException("Failed to regenerate and save new salt: " . $e->getMessage(), 0, $e);
}
Log::warning("New salt is generated and stored. Users might need to logout and clean their cookies.");
return $result;
} | php | {
"resource": ""
} |
q2543 | Salt.readSaltFromFile | train | protected static function readSaltFromFile(): string
{
Utility::validatePath(static::$saltFile);
$result = file_get_contents(static::$saltFile);
$result = $result ?: '';
static::validateSalt($result);
return $result;
} | php | {
"resource": ""
} |
q2544 | Salt.writeSaltToFile | train | protected static function writeSaltToFile(string $salt): void
{
static::validateSalt($salt);
$result = @file_put_contents(static::$saltFile, $salt);
if (($result === false) || ($result <> strlen($salt))) {
throw new InvalidArgumentException("Failed to write salt to file [" . static::$saltFile . "]");
}
} | php | {
"resource": ""
} |
q2545 | Salt.validateSalt | train | protected static function validateSalt(string $salt): void
{
if (!ctype_print($salt)) {
throw new InvalidArgumentException("Salt is not a printable string");
}
static::validateSaltMinLength();
$saltLength = strlen($salt);
if ($saltLength < static::$saltMinLength) {
throw new InvalidArgumentException("Salt length of $saltLength characters is less than expected " . static::$saltMinLength);
}
} | php | {
"resource": ""
} |
q2546 | Salt.generateSalt | train | protected static function generateSalt(): string
{
$result = '';
static::validateSaltMinLength();
$pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$poolSize = strlen($pool);
for ($i = 0; $i < static::$saltMinLength; $i++) {
$result .= $pool[rand(0, $poolSize - 1)];
}
return $result;
} | php | {
"resource": ""
} |
q2547 | Client.getBrowser | train | public function getBrowser($startPage, $type = '*firefox')
{
$url = 'http://'.$this->host.':'.$this->port.'/selenium-server/driver/';
$driver = new Driver($url, $this->timeout);
$class = $this->browserClass;
return new $class($driver, $startPage, $type);
} | php | {
"resource": ""
} |
q2548 | MySQL.describeTable | train | public function describeTable($table)
{
if (!$this->connection->expr('show tables like []', [$table])->get()) {
return []; // no such table
}
$result = [];
foreach ($this->connection->expr('describe {}', [$table]) as $row) {
$row2 = [];
$row2['name'] = $row['Field'];
$row2['pk'] = $row['Key'] == 'PRI';
$row2['type'] = preg_replace('/\(.*/', '', $row['Type']);
$result[] = $row2;
}
return $result;
} | php | {
"resource": ""
} |
q2549 | FormObjectHash.getHash | train | public function getHash()
{
if (null === $this->hash) {
$this->hash = $this->calculateHash();
}
return $this->hash;
} | php | {
"resource": ""
} |
q2550 | ErrorHandler.register | train | public function register($handledErrors = E_ALL)
{
$errHandler = [$this, 'handleError'];
$exHandler = [$this, 'handleException'];
$handledErrors = is_int($handledErrors) ? $handledErrors : E_ALL;
set_error_handler($errHandler, $handledErrors);
set_exception_handler($exHandler);
return $this;
} | php | {
"resource": ""
} |
q2551 | ErrorHandler.registerShutdown | train | public function registerShutdown()
{
if (self::$reservedMemory === null) {
self::$reservedMemory = str_repeat('x', 10240);
register_shutdown_function(__CLASS__ . '::handleFatalError');
}
self::$exceptionHandler = [$this, 'handleException'];
return $this;
} | php | {
"resource": ""
} |
q2552 | ConditionProcessorFactory.fetchProcessorInstanceFromCache | train | protected function fetchProcessorInstanceFromCache($cacheIdentifier, FormObject $formObject)
{
$cacheInstance = CacheService::get()->getCacheInstance();
/** @var ConditionProcessor $instance */
if ($cacheInstance->has($cacheIdentifier)) {
$instance = $cacheInstance->get($cacheIdentifier);
$instance->attachFormObject($formObject);
} else {
$instance = $this->getNewProcessorInstance($formObject);
$instance->calculateAllTrees();
$cacheInstance->set($cacheIdentifier, $instance);
}
return $instance;
} | php | {
"resource": ""
} |
q2553 | GoogleRecaptcha.verify | train | public function verify($response)
{
$result = $this->getVerificationResult($response);
if ($result['success']) {
return true;
}
if (!empty($result['error-codes'])) {
$this->errors = $result['error-codes'];
}
return false;
} | php | {
"resource": ""
} |
q2554 | GoogleRecaptcha.getScriptSrc | train | protected function getScriptSrc($onloadCallbackName)
{
$url = static::SCRIPT_URL;
$queryArgs = [];
\parse_str(\parse_url($url, PHP_URL_QUERY), $queryArgs);
$queryArgs['onload'] = $onloadCallbackName;
$queryArgs['render'] = 'explicit';
$url = \sprintf('%s?%s', \strtok($url, '?'), \http_build_query($queryArgs));
return $url;
} | php | {
"resource": ""
} |
q2555 | NegotiatingContentHandler.getContentTypeHandler | train | private function getContentTypeHandler(ServerRequestInterface $request)
{
$acceptHeader = $request->getHeaderLine('Accept');
$acceptedTypes = explode(',', $acceptHeader);
foreach ($this->handlers as $contentType => $handler) {
if ($this->doesTypeMatch($acceptedTypes, $contentType)) {
return $handler;
}
}
return reset($this->handlers);
} | php | {
"resource": ""
} |
q2556 | FootprintBehavior.beforeSave | train | public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options): void
{
if (! is_callable($this->getConfig('callback'))) {
return;
}
$user = call_user_func($this->getConfig('callback'));
if (empty($user['id'])) {
return;
}
// Set created_by only if that field is not set during entity creation
if ($entity->isNew() && empty($entity->get($this->getConfig('created_by')))) {
$entity->set($this->getConfig('created_by'), $user['id']);
}
// Set modified_by if that field is not set during update
$userId = $entity->isDirty($this->getConfig('modified_by')) && !empty($this->getConfig('modified_by')) ? $entity->get($this->getConfig('modified_by')) : $user['id'];
$entity->set($this->getConfig('modified_by'), $userId);
} | php | {
"resource": ""
} |
q2557 | BuilderAbstract.build | train | public function build(InputSettings $settings)
{
$this->settings = $settings;
$this->setElement();
$this->setValidator();
$this->setLabel();
$this->setDefault();
$this->setAttributes();
$this->setData();
$this->setAdditionalOptions();
return $this->getElement();
} | php | {
"resource": ""
} |
q2558 | BuilderAbstract.initElement | train | public function initElement()
{
if(is_null($this->settings)) {
$this->settings = new InputSettings();
}
return $this->build($this->settings);
} | php | {
"resource": ""
} |
q2559 | BuilderAbstract.setLabel | train | public function setLabel()
{
if($this->settings->getValue(InputSettings::LABEL_PARAM)) {
$this->element->setLabel($this->settings->getValue(InputSettings::LABEL_PARAM));
} else {
$this->element->setLabel(preg_replace('/.*\\\/', '', get_class($this)));
}
} | php | {
"resource": ""
} |
q2560 | BuilderAbstract.setDefault | train | public function setDefault()
{
if($this->settings->getValue(InputSettings::DEFAULTS_PARAM)) {
$this->element->setDefault($this->settings->getValue(InputSettings::DEFAULTS_PARAM));
}
} | php | {
"resource": ""
} |
q2561 | BuilderAbstract.setAttributes | train | public function setAttributes()
{
if($this->settings->getValue(InputSettings::PLACEHOLDER_PARAM)) {
$this->element->setAttribute('placeholder', $this->settings->getValue(InputSettings::PLACEHOLDER_PARAM));
}
} | php | {
"resource": ""
} |
q2562 | DoctrineWriter.getNewInstance | train | protected function getNewInstance()
{
$className = $this->objectMetadata->getName();
if (class_exists($className) === false) {
throw new \RuntimeException('Unable to create new instance of ' . $className);
}
return new $className;
} | php | {
"resource": ""
} |
q2563 | DoctrineWriter.setValue | train | protected function setValue($object, $value, $setter)
{
if (method_exists($object, $setter)) {
$object->$setter($value);
}
} | php | {
"resource": ""
} |
q2564 | AssetHandlerFactory.getAssetHandler | train | public function getAssetHandler($className)
{
if (false === array_key_exists($className, $this->instances)) {
if (false === class_exists($className)) {
throw ClassNotFoundException::wrongAssetHandlerClassName($className);
}
$instance = GeneralUtility::makeInstance($className, $this);
if (false === $instance instanceof AbstractAssetHandler) {
throw InvalidArgumentTypeException::wrongAssetHandlerType(get_class($instance));
}
$this->instances[$className] = $instance;
}
return $this->instances[$className];
} | php | {
"resource": ""
} |
q2565 | FormInitializationJavaScriptAssetHandler.getFormInitializationJavaScriptCode | train | public function getFormInitializationJavaScriptCode()
{
$formName = GeneralUtility::quoteJSvalue($this->getFormObject()->getName());
$formConfigurationJson = $this->handleFormConfiguration($this->getFormConfiguration());
$javaScriptCode = <<<JS
(function() {
Fz.Form.register($formName, $formConfigurationJson);
})();
JS;
return $javaScriptCode;
} | php | {
"resource": ""
} |
q2566 | FormInitializationJavaScriptAssetHandler.getFormConfiguration | train | protected function getFormConfiguration()
{
$formConfigurationArray = $this->getFormObject()->getConfiguration()->toArray();
$this->removeFieldsValidationConfiguration($formConfigurationArray)
->addClassNameProperty($formConfigurationArray);
return ArrayService::get()->arrayToJavaScriptJson($formConfigurationArray);
} | php | {
"resource": ""
} |
q2567 | FormInitializationJavaScriptAssetHandler.removeFieldsValidationConfiguration | train | protected function removeFieldsValidationConfiguration(array &$formConfiguration)
{
foreach ($formConfiguration['fields'] as $fieldName => $fieldConfiguration) {
if (true === isset($fieldConfiguration['validation'])) {
unset($fieldConfiguration['validation']);
unset($fieldConfiguration['activation']);
$formConfiguration['fields'][$fieldName] = $fieldConfiguration;
}
}
return $this;
} | php | {
"resource": ""
} |
q2568 | FormzLocalizationJavaScriptAssetHandler.getJavaScriptCode | train | public function getJavaScriptCode()
{
$realTranslations = [];
$translationsBinding = [];
foreach ($this->translations as $key => $value) {
$hash = HashService::get()->getHash($value);
$realTranslations[$hash] = $value;
$translationsBinding[$key] = $hash;
}
$jsonRealTranslations = $this->handleRealTranslations(ArrayService::get()->arrayToJavaScriptJson($realTranslations));
$jsonTranslationsBinding = $this->handleTranslationsBinding(ArrayService::get()->arrayToJavaScriptJson($translationsBinding));
return <<<JS
Fz.Localization.addLocalization($jsonRealTranslations, $jsonTranslationsBinding);
JS;
} | php | {
"resource": ""
} |
q2569 | FormzLocalizationJavaScriptAssetHandler.getTranslationKeysForFieldValidation | train | public function getTranslationKeysForFieldValidation(Field $field, $validationName)
{
$result = [];
if (true === $field->hasValidation($validationName)) {
$key = $field->getName() . '-' . $validationName;
$this->storeTranslationsForFieldValidation($field);
$result = $this->translationKeysForFieldValidation[$key];
}
return $result;
} | php | {
"resource": ""
} |
q2570 | FormzLocalizationJavaScriptAssetHandler.injectTranslationsForFormFieldsValidation | train | public function injectTranslationsForFormFieldsValidation()
{
$formConfiguration = $this->getFormObject()->getConfiguration();
foreach ($formConfiguration->getFields() as $field) {
$this->storeTranslationsForFieldValidation($field);
}
return $this;
} | php | {
"resource": ""
} |
q2571 | FormzLocalizationJavaScriptAssetHandler.storeTranslationsForFieldValidation | train | protected function storeTranslationsForFieldValidation(Field $field)
{
if (false === $this->translationsForFieldValidationWereInjected($field)) {
$fieldName = $field->getName();
foreach ($field->getValidation() as $validationName => $validation) {
$messages = ValidatorService::get()->getValidatorMessages($validation->getClassName(), $validation->getMessages());
foreach ($messages as $key => $message) {
$message = MessageService::get()->parseMessageArray($message, ['{0}', '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', '{9}', '{10}']);
$localizationKey = $this->getIdentifierForFieldValidationName($field, $validationName, $key);
$this->addTranslation($localizationKey, $message);
$messages[$key] = $localizationKey;
}
$this->translationKeysForFieldValidation[$fieldName . '-' . $validationName] = $messages;
$key = $this->getFormObject()->getClassName() . '-' . $field->getName();
$this->injectedTranslationKeysForFieldValidation[$key] = true;
}
}
return $this;
} | php | {
"resource": ""
} |
q2572 | FormzLocalizationJavaScriptAssetHandler.translationsForFieldValidationWereInjected | train | protected function translationsForFieldValidationWereInjected(Field $field)
{
$key = $this->getFormObject()->getClassName() . '-' . $field->getName();
return true === isset($this->injectedTranslationKeysForFieldValidation[$key]);
} | php | {
"resource": ""
} |
q2573 | Configuration.getConfigurationObjectServices | train | public static function getConfigurationObjectServices()
{
return ServiceFactory::getInstance()
->attach(ServiceInterface::SERVICE_CACHE)
->with(ServiceInterface::SERVICE_CACHE)
->setOption(CacheService::OPTION_CACHE_NAME, InternalCacheService::CONFIGURATION_OBJECT_CACHE_IDENTIFIER)
->setOption(CacheService::OPTION_CACHE_BACKEND, InternalCacheService::get()->getBackendCache())
->attach(ServiceInterface::SERVICE_PARENTS)
->attach(ServiceInterface::SERVICE_DATA_PRE_PROCESSOR)
->attach(ServiceInterface::SERVICE_MIXED_TYPES);
} | php | {
"resource": ""
} |
q2574 | Configuration.addForm | train | public function addForm(FormObject $form)
{
if (true === $this->hasForm($form->getClassName(), $form->getName())) {
throw DuplicateEntryException::formWasAlreadyRegistered($form);
}
$form->getConfiguration()->setParents([$this]);
$this->forms[$form->getClassName()][$form->getName()] = $form;
} | php | {
"resource": ""
} |
q2575 | Configuration.calculateHash | train | public function calculateHash()
{
$fullArray = $this->toArray();
$configurationArray = [
'view' => $fullArray['view'],
'settings' => $fullArray['settings']
];
$this->hash = HashService::get()->getHash(serialize($configurationArray));
} | php | {
"resource": ""
} |
q2576 | MethodBuilder.buildCode | train | public function buildCode()
{
$code = '';
if ($this->documentation) {
$code .= ' /**'."\n";
$code .= ' * '.str_replace("\n", "\n * ", wordwrap($this->documentation, 73))."\n";
$code .= ' */'."\n";
}
$code .= ' public function '.$this->name.'('.implode(', ', $this->parameters).')'."\n";
$code .= ' {'."\n";
$code .= ' '.str_replace("\n", "\n ", $this->body)."\n";
$code .= ' }';
// Trim trailing whitespaces
$code = preg_replace('/[ ]+$/m', '', $code);
return $code;
} | php | {
"resource": ""
} |
q2577 | Taxonomy.createVocabulary | train | public function createVocabulary($name) {
if ($this->vocabulary->where('name', $name)->count()) {
throw new Exceptions\VocabularyExistsException();
}
return $this->vocabulary->create(['name' => $name]);
} | php | {
"resource": ""
} |
q2578 | Taxonomy.getVocabularyByNameAsArray | train | public function getVocabularyByNameAsArray($name) {
$vocabulary = $this->vocabulary->where('name', $name)->first();
if (!is_null($vocabulary)) {
return $vocabulary->terms->pluck('name', 'id')->toArray();
}
return [];
} | php | {
"resource": ""
} |
q2579 | Taxonomy.getVocabularyByNameOptionsArray | train | public function getVocabularyByNameOptionsArray($name) {
$vocabulary = $this->vocabulary->where('name', $name)->first();
if (is_null($vocabulary)) {
return [];
}
$parents = $this->term->whereParent(0)
->whereVocabularyId($vocabulary->id)
->orderBy('weight', 'ASC')
->get();
$options = [];
foreach ($parents as $parent) {
$options[$parent->id] = $parent->name;
$this->recurse_children($parent, $options);
}
return $options;
} | php | {
"resource": ""
} |
q2580 | Taxonomy.recurse_children | train | private function recurse_children($parent, &$options, $depth = 1) {
$parent->childrens->map(function($child) use (&$options, $depth) {
$options[$child->id] = str_repeat('-', $depth) .' '. $child->name;
if ($child->childrens) {
$this->recurse_children($child, $options, $depth+1);
}
});
} | php | {
"resource": ""
} |
q2581 | Taxonomy.deleteVocabularyByName | train | public function deleteVocabularyByName($name) {
$vocabulary = $this->vocabulary->where('name', $name)->first();
if (!is_null($vocabulary)) {
return $vocabulary->delete();
}
return FALSE;
} | php | {
"resource": ""
} |
q2582 | Taxonomy.createTerm | train | public function createTerm($vid, $name, $parent = 0, $weight = 0) {
$vocabulary = $this->vocabulary->findOrFail($vid);
$term = [
'name' => $name,
'vocabulary_id' => $vid,
'parent' => $parent,
'weight' => $weight,
];
return $this->term->create($term);
} | php | {
"resource": ""
} |
q2583 | ConditionIsValidValidator.isValid | train | public function isValid($condition)
{
$conditionTree = ConditionParser::get()
->parse($condition);
if (true === $conditionTree->getValidationResult()->hasErrors()) {
$errorMessage = $this->translateErrorMessage(
'validator.form.condition_is_valid.error',
'formz',
[
$condition->getExpression(),
$conditionTree->getValidationResult()->getFirstError()->getMessage()
]
);
$this->addError($errorMessage, self::ERROR_CODE);
}
} | php | {
"resource": ""
} |
q2584 | InjectorServiceProvider.alias | train | protected function alias($aliasKey, $serviceKey)
{
// Bound as a factory to ALWAYS pass through to underlying definition.
$this->bindFactory(
$aliasKey,
function (Container $app) use ($serviceKey) {
return $app[$serviceKey];
}
);
} | php | {
"resource": ""
} |
q2585 | InjectorServiceProvider.autoBind | train | protected function autoBind($className, callable $parameterFactory = null)
{
$this->bind(
$className,
$this->closureFactory->createAutoWireClosure($className, $parameterFactory)
);
} | php | {
"resource": ""
} |
q2586 | InjectorServiceProvider.autoBindFactory | train | protected function autoBindFactory($className, callable $parameterFactory = null)
{
$this->bindFactory(
$className,
$this->closureFactory->createAutoWireClosure($className, $parameterFactory)
);
} | php | {
"resource": ""
} |
q2587 | Injector.create | train | public function create($className, $parameters = [])
{
$reflectionClass = new \ReflectionClass($className);
if (!$reflectionClass->hasMethod("__construct")) {
//This class doesn't have a constructor
return $reflectionClass->newInstanceWithoutConstructor();
}
if (!$reflectionClass->getMethod('__construct')->isPublic()) {
throw new InjectorInvocationException(
"Injector failed to create $className - constructor isn't public." .
" Do you need to use a static factory method instead?"
);
}
try {
$parameters = $this->buildParameterArray(
$this->inspector->getSignatureByReflectionClass($reflectionClass, "__construct"),
$parameters
);
return $reflectionClass->newInstanceArgs($parameters);
} catch (MissingRequiredParameterException $e) {
throw new InjectorInvocationException(
"Can't create $className " .
" - __construct() missing parameter '" . $e->getParameterString() . "'" .
" could not be found. Either register it as a service or pass it to create via parameters."
);
} catch (InjectorInvocationException $e) {
//Wrap the exception stack for recursive calls to aid debugging
throw new InjectorInvocationException(
$e->getMessage() .
PHP_EOL . " => (Called when creating $className)"
);
}
} | php | {
"resource": ""
} |
q2588 | Injector.canAutoCreate | train | public function canAutoCreate($className)
{
foreach ($this->autoCreateWhiteList as $regex) {
if (preg_match($regex, $className)) {
return true;
}
}
return false;
} | php | {
"resource": ""
} |
q2589 | Injector.buildParameterArray | train | private function buildParameterArray($methodSignature, $providedParameters)
{
$parameters = [];
foreach ($methodSignature as $position => $parameterData) {
if (!isset($parameterData['variadic'])) {
$parameters[$position] = $this->resolveParameter($position, $parameterData, $providedParameters);
} else {
// variadic parameter must be the last one, so
// the rest of the provided paramters should be piped
// into it to mimic native php behaviour
foreach ($providedParameters as $variadicParameter) {
$parameters[] = $variadicParameter;
}
}
}
return $parameters;
} | php | {
"resource": ""
} |
q2590 | ParameterInspector.getSignatureByReflectionClass | train | public function getSignatureByReflectionClass(\ReflectionClass $reflectionClass, $methodName)
{
$className = $reflectionClass->getName();
return $this->getMethodSignature($className, $methodName, $reflectionClass);
} | php | {
"resource": ""
} |
q2591 | BindingClosureFactory.createAutoWireClosure | train | public function createAutoWireClosure($className, callable $parameterFactory = null)
{
return function (Container $app) use ($className, $parameterFactory) {
$parameters = $parameterFactory ? $parameterFactory($app) : [];
return $this->injector->create($className, $parameters);
};
} | php | {
"resource": ""
} |
q2592 | BindingClosureFactory.createProxy | train | private function createProxy($className, callable $serviceFactory, Container $app)
{
return $this->proxyFactory->createProxy(
$className,
function (&$wrappedObject, $proxy, $method, $parameters, &$initializer) use (
$className,
$serviceFactory,
$app
) {
$wrappedObject = $serviceFactory($app);
$initializer = null;
return true;
}
);
} | php | {
"resource": ""
} |
q2593 | Packages.classmap | train | public function classmap()
{
$path = $this->composerPath . $this->classmapName;
$i = 0;
if (is_file($path)) {
$data = include $path;
foreach ($data as $key => $value) {
if (false === empty($value)) {
$this->libs[addcslashes($key, '\\')] = $value;
$i++;
}
}
$this->log[] = 'Imported ' . $i . ' classes from classmap';
return $i;
}
$this->log[] = 'Warn: classmap not found';
return false;
} | php | {
"resource": ""
} |
q2594 | Packages.psr0 | train | public function psr0()
{
$i = $this->load($this->composerPath . $this->psrZeroName);
if ($i !== false) {
$this->log[] = 'Imported ' . $i . ' classes from psr0';
return $i;
}
$this->log[] = 'Warn: psr0 not found';
return false;
} | php | {
"resource": ""
} |
q2595 | Packages.psr4 | train | public function psr4()
{
$i = $this->load($this->composerPath . $this->psrFourName);
if ($i !== false) {
$this->log[] = 'Imported ' . $i . ' classes from psr4';
return $i;
}
$this->log[] = 'Warn: psr4 not found';
return false;
} | php | {
"resource": ""
} |
q2596 | Packages.save | train | public function save($path)
{
if (count($this->libs) === 0) {
return false;
}
$handle = fopen($path, 'w');
if ($handle === false) {
throw new \InvalidArgumentException('This path is not writabled: ' . $path);
}
$first = true;
$eol = chr(10);
fwrite($handle, '<?php' . $eol . 'return array(');
foreach ($this->libs as $key => $value) {
$value = self::relativePath($value);
fwrite($handle, ($first ? '' : ',') . $eol . " '" . $key . "' => '" . $value . "'");
$first = false;
}
fwrite($handle, $eol . ');' . $eol);
fclose($handle);
return true;
} | php | {
"resource": ""
} |
q2597 | Packages.version | train | public static function version($name)
{
$file = INPHINIT_ROOT . 'composer.lock';
$data = is_file($file) ? json_decode(file_get_contents($file)) : false;
if (empty($data->packages)) {
return false;
}
$version = false;
foreach ($data->packages as $package) {
if ($package->name === $name) {
$version = $package->version;
break;
}
}
$data = null;
return $version;
} | php | {
"resource": ""
} |
q2598 | ObjectArrayStorage.get | train | public function get($object) : array
{
$values = $this->storage->get($object);
return ($values === null) ? [] : $values;
} | php | {
"resource": ""
} |
q2599 | ObjectArrayStorage.add | train | public function add($object, $value) : void
{
$values = $this->get($object);
$values[] = $value;
$this->storage->set($object, $values);
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.