/**
* Creates a PHP parameter from reflection
*
* @param \ReflectionParameter $ref
* @return PhpParameter
*/
public static function fromReflection(\ReflectionParameter $ref)
{
$parameter = new static();
$parameter->setName($ref->name)->setPassedByReference($ref->isPassedByReference());
if ($ref->isDefaultValueAvailable()) {
$parameter->setDefaultValue($ref->getDefaultValue());
}
// find type and description in docblock
$docblock = new Docblock($ref->getDeclaringFunction());
$params = $docblock->getTags('param');
$tag = $params->find($ref->name, function (ParamTag $t, $name) {
return $t->getVariable() == '$' . $name;
});
if ($tag !== null) {
$parameter->setType($tag->getType(), $tag->getDescription());
}
// set type if not found in comment
if ($parameter->getType() === null) {
if ($ref->isArray()) {
$parameter->setType('array');
} elseif ($class = $ref->getClass()) {
$parameter->setType($class->getName());
} elseif (method_exists($ref, 'isCallable') && $ref->isCallable()) {
$parameter->setType('callable');
}
}
return $parameter;
}
public static function fromReflection(\ReflectionParameter $ref)
{
$parameter = new static();
$parameter->setName($ref->name)->setPassedByReference($ref->isPassedByReference());
if ($ref->isDefaultValueAvailable()) {
$parameter->setDefaultValue($ref->getDefaultValue());
}
if ($ref->isArray()) {
$parameter->setType('array');
} elseif ($class = $ref->getClass()) {
$parameter->setType($class->getName());
} elseif (method_exists($ref, 'isCallable') && $ref->isCallable()) {
$parameter->setType('callable');
}
return $parameter;
}
/**
* Magic metod for constructor.
*
* @param string $type
* @param string $element
*
* @return self
*/
public static function make($type, $element)
{
$chart = new static();
$chart->setType($type);
$chart->setElement($element);
return $chart;
}
public static function fromString($headerLine)
{
$headerLine = iconv_mime_decode($headerLine, ICONV_MIME_DECODE_CONTINUE_ON_ERROR, 'UTF-8');
list($name, $value) = GenericHeader::splitHeaderLine($headerLine);
// check to ensure proper header type for this factory
if (strtolower($name) !== 'content-type') {
throw new Exception\InvalidArgumentException('Invalid header line for Content-Type string');
}
$value = str_replace(Headers::FOLDING, " ", $value);
$values = preg_split('#\\s*;\\s*#', $value);
$type = array_shift($values);
//Remove empty values
$values = array_filter($values);
$header = new static();
$header->setType($type);
$values = array_filter($values);
if (count($values)) {
foreach ($values as $keyValuePair) {
list($key, $value) = explode('=', $keyValuePair, 2);
$value = trim($value, "'\" \t\n\r\v");
$header->addParameter($key, $value);
}
}
return $header;
}
/**
* Factory: create Content-Type header object from string
*
* @param string $headerLine
* @throws Exception\InvalidArgumentException
* @return ContentType
*/
public static function fromString($headerLine)
{
$headerLine = iconv_mime_decode($headerLine, ICONV_MIME_DECODE_CONTINUE_ON_ERROR);
list($name, $value) = explode(': ', $headerLine, 2);
// check to ensure proper header type for this factory
if (strtolower($name) !== 'content-type') {
throw new Exception\InvalidArgumentException('Invalid header line for Content-Type string');
}
$value = str_replace("\r\n ", " ", $value);
$values = preg_split('#\s*;\s*#', $value);
$type = array_shift($values);
$header = new static();
$header->setType($type);
if (count($values)) {
foreach ($values as $keyValuePair) {
list($key, $value) = explode('=', $keyValuePair);
$value = trim($value, "\"\' \t\n\r\0\x0B");
$header->addParameter($key, $value);
}
}
return $header;
}
public static function fromArray(string $name, array $data = [])
{
$instance = new static($name);
if (isset($data['Type'])) {
$instance->setType($data['Type']);
}
if (isset($data['type'])) {
$instance->setType($data['type']);
}
if (isset($data['Comment'])) {
$instance->setComment($data['Comment']);
}
if (isset($data['comment'])) {
$instance->setComment($data['comment']);
}
if (isset($data['Null']) && $data['Null'] === 'YES') {
$instance->setNullable(true);
}
if (isset($data['nullable']) && is_bool($data['nullable'])) {
$instance->setNullable($data['nullable']);
}
if (isset($data['Default'])) {
$instance->setDefault($data['Default']);
}
if (isset($data['default'])) {
$instance->setDefault($data['default']);
}
if ($instance->getBasicType() === 'enum' && strpos($instance->getType(), 'enum(') === 0) {
$temp = array_map(function ($v) {
return str_replace("''", "'", $v);
}, explode("','", substr($instance->getType(), 6, -2)));
$instance->setValues($temp);
}
if (isset($data['values']) && is_array($data['values'])) {
$instance->setValues($data['values']);
}
if (isset($data['DATA_TYPE'])) {
$instance->setType($data['DATA_TYPE']);
}
if (isset($data['NULLABLE']) && $data['NULLABLE'] !== 'N') {
$instance->setNullable(true);
}
if (isset($data['DATA_DEFAULT'])) {
$instance->setDefault($data['DATA_DEFAULT']);
}
return $instance;
}
public static function createFromConfig($number, array $config)
{
$step = new static();
$step->setNumber($number);
$step->setLabel(array_key_exists('label', $config) ? $config['label'] : null);
$step->setType(array_key_exists('type', $config) ? $config['type'] : null);
$step->setSkip(array_key_exists('skip', $config) ? $config['skip'] : false);
return $step;
}
/**
* @param string $text
* @param string $type
*
* @return static
*/
public static function make($text, $type = null)
{
$tag = new static();
$tag->setContents($text);
if ($type) {
$tag->setType($type);
}
return $tag;
}
/**
* Construct the suggestion based on the given result xml.
* @param SimpleXMLElement $xmlElement
* @return \CultuurNet\Search\SuggestionItem
*/
public static function fromXml(SimpleXMLElement $xmlElement)
{
$suggestionItem = new static();
$attributes = $xmlElement->attributes();
$suggestionItem->setCdbid((string) $attributes['cdbid']);
$suggestionItem->setType((string) $attributes['type']);
if (!empty($attributes['location'])) {
$suggestionItem->setLocation((string) $attributes['location']);
$suggestionItem->setZipcode((string) $attributes['zipcode']);
}
$suggestionItem->setTitle((string) $xmlElement);
return $suggestionItem;
}
/**
*
*
*
*
*/
public static function where($criteria, array $projection)
{
$relationship = new static();
if (!empty($relationship->getType())) {
$criteria['$type'] = $relationship->getType();
}
$query = new RelQuery($criteria);
$document = $query->execute($projection)->current();
$relationship->setType($criteria['$type']);
$data = $document->getProperty(Relationship::REL_PREFIX . $criteria['$type']);
$relationship->parseData($data[0], $document);
return $relationship;
}
/**
* @override - uses `static` to instantiate the parameter
*
* {@inheritDoc}
*/
public static function fromReflection(ParameterReflection $reflectionParameter)
{
/* @var $param self */
$param = new static();
$param->setName($reflectionParameter->getName());
$param->setPosition($reflectionParameter->getPosition());
$type = self::extractParameterType($reflectionParameter);
if (null !== $type) {
$param->setType($type);
}
self::setOptionalParameter($param, $reflectionParameter);
$param->setPassedByReference($reflectionParameter->isPassedByReference());
return $param;
}
public static function make($source = null, $type = null, $media = null)
{
$tag = new static();
if ($source) {
$tag->setSource($source);
}
if ($type) {
$tag->setType($type);
}
if ($media) {
$tag->setMedia($source);
}
return $tag;
}
/**
* Creates object instance.
*
* @param int|null $type
* @param string|null $text
* @param int|null $length
* @param string|null $value
* @return static
*/
public static function factory($type = null, $text = null, $length = null, $value = null)
{
$token = new static();
if (null !== $type) {
$token->setType($type);
}
if (null !== $text) {
$token->setText($text);
}
if (null !== $length) {
$token->setLength($length);
}
if (null !== $value) {
$token->setValue($value);
}
return $token;
}
public static function create($type, $scope, $message, $scopeId = null, $link = null)
{
$rtn = new static();
$rtn->setType($type);
$rtn->setScope($scope);
if (!empty($scopeId)) {
$rtn->setScopeId($scopeId);
}
$rtn->setMessage($message);
if (!empty($link)) {
$rtn->setLink($link);
}
$rtn->setLogDate(new \DateTime());
$rtn->setUser($_SESSION['user']);
$rtn = Store::get('Log')->save($rtn);
return $rtn;
}
/**
* Create a security scheme from an array
*
* @param string $key
* @param array $data
* [
* description: ?string
* type: ?string
* describedBy: ?string[]
* settings: ?object[]
* ]
* @param ApiDefinition $apiDefinition
*
* @return SecurityScheme
*/
public static function createFromArray($key, array $data = [], ApiDefinition $apiDefinition = null)
{
$securityScheme = new static($key);
if (isset($data['description'])) {
$securityScheme->setDescription($data['description']);
}
if (isset($data['type'])) {
$securityScheme->setType($data['type']);
}
if (isset($data['describedBy'])) {
$securityScheme->setDescribedBy(SecuritySchemeDescribedBy::createFromArray('describedBy', $data['describedBy']));
}
if (isset($data['settings'])) {
$securityScheme->setSettings($data['settings']);
}
return $securityScheme;
}
/**
* Creates a new PHP property from reflection
*
* @param \ReflectionProperty $ref
* @return static
*/
public static function fromReflection(\ReflectionProperty $ref)
{
$property = new static($ref->name);
$property->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE));
$docblock = new Docblock($ref);
$property->setDocblock($docblock);
$property->setDescription($docblock->getShortDescription());
$property->setLongDescription($docblock->getLongDescription());
$vars = $docblock->getTags('var');
if ($vars->size() > 0) {
$var = $vars->get(0);
$property->setType($var->getType(), $var->getDescription());
}
$defaultProperties = $ref->getDeclaringClass()->getDefaultProperties();
if (isset($defaultProperties[$ref->name])) {
$property->setDefaultValue($defaultProperties[$ref->name]);
}
return $property;
}
/**
* Creates a PHP method from reflection
*
* @param \ReflectionMethod $ref
* @return PhpMethod
*/
public static function fromReflection(\ReflectionMethod $ref)
{
$method = new static($ref->name);
$method->setFinal($ref->isFinal())->setAbstract($ref->isAbstract())->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE))->setReferenceReturned($ref->returnsReference())->setBody(ReflectionUtils::getFunctionBody($ref));
$docblock = new Docblock($ref);
$method->setDocblock($docblock);
$method->setDescription($docblock->getShortDescription());
$method->setLongDescription($docblock->getLongDescription());
// return type and description
$returns = $method->getDocblock()->getTags('return');
if ($returns->size() > 0) {
$return = $returns->get(0);
$method->setType($return->getType(), $return->getDescription());
}
// params
foreach ($ref->getParameters() as $param) {
$method->addParameter(static::createParameter($param));
}
return $method;
}
public static function fromString($headerLine)
{
list($name, $value) = GenericHeader::splitHeaderLine($headerLine);
$value = HeaderWrap::mimeDecodeValue($value);
// check to ensure proper header type for this factory
if (strtolower($name) !== 'content-type') {
throw new Exception\InvalidArgumentException('Invalid header line for Content-Type string');
}
$value = str_replace(Headers::FOLDING, ' ', $value);
$values = preg_split('#\\s*;\\s*#', $value);
$type = array_shift($values);
$header = new static();
$header->setType($type);
// Remove empty values
$values = array_filter($values);
foreach ($values as $keyValuePair) {
$parts = explode('=', $keyValuePair, 2);
$key = $parts[0];
$value = count($parts) > 1 ? $parts[1] : "";
$value = trim($value, "'\" \t\n\r\v");
$header->addParameter($key, $value);
}
return $header;
}
/**
* Return new instance with needed OtpAlgorithm type
*
* @param string $type Type of OtpAlgorithm (see getAvailableTypes).
* @throws \Bitrix\Main\ArgumentOutOfRangeException
* @return static New instance
*/
public static function getByType($type)
{
if (!in_array($type, static::$availableTypes)) {
throw new ArgumentOutOfRangeException('type', static::$availableTypes);
}
$algo = static::$typeMap[$type];
$instance = new static($algo);
$instance->setType($type);
return $instance;
}
/**
* Generate from array
*
* @configkey name string [required] Class Name
* @configkey type string
* @configkey defaultvalue null|bool|string|int|float|array|ValueGenerator
* @configkey passedbyreference bool
* @configkey position int
* @configkey sourcedirty bool
* @configkey indentation string
* @configkey sourcecontent string
*
* @throws Exception\InvalidArgumentException
* @param array $array
* @return ParameterGenerator
*/
public static function fromArray(array $array)
{
if (!isset($array['name'])) {
throw new Exception\InvalidArgumentException('Paramerer generator requires that a name is provided for this object');
}
$param = new static($array['name']);
foreach ($array as $name => $value) {
// normalize key
switch (strtolower(str_replace(['.', '-', '_'], '', $name))) {
case 'type':
$param->setType($value);
break;
case 'defaultvalue':
$param->setDefaultValue($value);
break;
case 'passedbyreference':
$param->setPassedByReference($value);
break;
case 'position':
$param->setPosition($value);
break;
case 'sourcedirty':
$param->setSourceDirty($value);
break;
case 'indentation':
$param->setIndentation($value);
break;
case 'sourcecontent':
$param->setSourceContent($value);
break;
}
}
return $param;
}
public static function createNew($params)
{
$star = new static($params);
$star->setType();
if ($star->isValid()) {
DB::transaction(function () use($star) {
// So the strings can be used with interpolation
// instead of concatenation or sprintf.
$cost = (string) static::COST;
$increment = (string) $star->voteIncrement();
return $star->user->update(['osu_featurevotes' => DB::raw("osu_featurevotes - ({$cost})")]) && $star->topic->update(['osu_starpriority' => DB::raw("osu_starpriority + ({$increment})")]) && $star->saveOrFail();
});
}
return $star;
}
/**
* Decompiles an array into an ApiProblem object.
*
* @param array $parsed
* An array parsed from JSON or XML to turn into an ApiProblem object.
* @return \Crell\ApiProblem\ApiProblem
* A new ApiProblem object.
*/
protected static function decompile(array $parsed)
{
$problem = new static();
if (!empty($parsed['title'])) {
$problem->setTitle($parsed['title']);
}
if (!empty($parsed['type'])) {
$problem->setType($parsed['type']);
}
if (!empty($parsed['status'])) {
$problem->setStatus($parsed['status']);
}
if (!empty($parsed['detail'])) {
$problem->setDetail($parsed['detail']);
}
if (!empty($parsed['instance'])) {
$problem->setInstance($parsed['instance']);
}
// Remove the defined keys. That means whatever is left must be a custom
// extension property.
unset($parsed['title'], $parsed['type'], $parsed['status'], $parsed['detail'], $parsed['instance']);
foreach ($parsed as $key => $value) {
$problem[$key] = $value;
}
return $problem;
}
/**
* Creates decorator
*
* @param object $oComponent
* @param bool $bHookEnable
*
* @return Decorator
*/
static function Create($oComponent, $bHookEnable = true)
{
$sClassName = get_class($oComponent);
if (!$bHookEnable || $sClassName == 'ModulePlugin' || $sClassName == 'ModuleHook') {
return $oComponent;
}
if (DEBUG) {
$sDecoratorClassName = 'Decorator' . $sClassName;
$sDecoratorClassCode = 'class ' . $sDecoratorClassName . ' extends Decorator { }';
eval($sDecoratorClassCode);
$oComponentDecorator = new $sDecoratorClassName($oComponent);
} else {
$oComponentDecorator = new static($oComponent);
}
$aClassInfo = E::GetClassInfo($oComponent, Engine::CI_ACTION | Engine::CI_MODULE);
if ($aClassInfo[Engine::CI_ACTION]) {
$oComponentDecorator->setType('action');
$oComponentDecorator->setName($aClassInfo[Engine::CI_ACTION]);
$oComponentDecorator->setHookEnable(true);
} elseif ($aClassInfo[Engine::CI_MODULE]) {
$oComponentDecorator->setType('module');
$oComponentDecorator->setName($aClassInfo[Engine::CI_MODULE]);
$oComponentDecorator->setHookEnable(true);
}
return $oComponentDecorator;
}
/**
* @param string $type
*
* @return static
*/
public static function make($type = self::TYPE_TEXT)
{
$tag = new static();
$tag->setType($type);
return $tag;
}
/**
* Rule factory
*
* @param int $type Type
* @param mixed $value Value
* @return RuleInterface A new rule
*/
public function make($type, $value = null)
{
$product = new static();
$product->setType($type)->setValue($value);
return $product;
}
/**
* @param Event $event
* @param User $speaker
* @param TalkType $type
* @param string $title
* @param string $shortDescription
* @param string $longDescription
* @param string $complexity
* @param array $tags
* @param float $cost
* @return Talk
*/
public static function create(Event $event, User $speaker, TalkType $type, $title, $shortDescription, $longDescription, $complexity, array $tags, $cost = null)
{
$talk = new static();
$talk->setEvent($event);
$talk->setType($type);
$talk->setTitle($title);
$talk->setComplexity($complexity);
$talk->setCost($cost);
$talk->setTags($tags);
$talk->setShortDescription($shortDescription);
$talk->setLongDescription($longDescription);
$talk->setCreationTime(new DateTime());
$talk->getSpeakers()->add($speaker);
return $talk;
}
public static function create($locale, $type = 'page-content', $revision = 'default', $slug = NULL)
{
$cs = new static($locale, $slug, $revision);
$cs->setType($type ?: 'page-content');
return $cs;
}
/**
* Inline tag constructor
*
* @param string $name
* @return static
*/
public static function inline($name)
{
$tag = new static($name);
$tag->setType(static::TYPE_INLINE);
return $tag;
}
/**
* Creates decorator
*
* @param object $oComponent
* @param bool $bHookEnable
*
* @return object
*/
static function Create($oComponent, $bHookEnable = true)
{
$sClassName = get_class($oComponent);
if (!$bHookEnable || $sClassName == 'ModulePlugin' || $sClassName == 'ModuleHook') {
return $oComponent;
}
$oComponentDecorator = new static($oComponent);
$aClassInfo = E::GetClassInfo($oComponent, Engine::CI_ACTION | Engine::CI_MODULE);
if ($aClassInfo[Engine::CI_ACTION]) {
$oComponentDecorator->setType('action');
$oComponentDecorator->setName($aClassInfo[Engine::CI_ACTION]);
$oComponentDecorator->setHookEnable(true);
} elseif ($aClassInfo[Engine::CI_MODULE]) {
$oComponentDecorator->setType('module');
$oComponentDecorator->setName($aClassInfo[Engine::CI_MODULE]);
$oComponentDecorator->setHookEnable(true);
}
return $oComponentDecorator;
}
/**
* Create a Query Parameter from an Array
*
* @param $key
* @param $data
* [
* displayName: ?string
* description: ?string
* type: ?["string","number","integer","date","boolean","file"]
* enum: ?array
* pattern: ?string
* validationPattern: ?string
* minLength: ?integer
* maxLength: ?integer
* minimum: ?integer
* maximum: ?integer
* example: ?string
* examples: ?array
* repeat: ?boolean
* required: ?boolean
* default: ?string
* ]
*
* @throws \Exception
*
* @return NamedParameter
*/
public static function createFromArray($key, array $data = [])
{
$namedParameter = new static($key);
if (isset($data['displayName'])) {
$namedParameter->setDisplayName($data['displayName']);
}
if (isset($data['description'])) {
$namedParameter->setDescription($data['description']);
}
if (isset($data['type'])) {
$namedParameter->setType($data['type']);
}
if (isset($data['enum'])) {
$namedParameter->setEnum($data['enum']);
}
if (isset($data['pattern'])) {
$namedParameter->setValidationPattern($data['pattern']);
}
// RAML 1.0
if (isset($data['validationPattern'])) {
$namedParameter->setValidationPattern($data['validationPattern']);
}
if (isset($data['minLength'])) {
$namedParameter->setMinLength($data['minLength']);
}
if (isset($data['maxLength'])) {
$namedParameter->setMaxLength($data['maxLength']);
}
if (isset($data['minimum'])) {
$namedParameter->setMinimum($data['minimum']);
}
if (isset($data['maximum'])) {
$namedParameter->setMaximum($data['maximum']);
}
if (isset($data['example'])) {
$namedParameter->addExample($data['example']);
}
if (isset($data['examples'])) {
foreach ($data['examples'] as $example) {
$namedParameter->addExample($example);
}
}
if (isset($data['repeat'])) {
$namedParameter->setRepeat($data['repeat']);
}
if (isset($data['required'])) {
$namedParameter->setRequired($data['required']);
}
if (isset($data['default'])) {
if ($namedParameter->getType() === self::TYPE_DATE) {
$namedParameter->setDefault(\DateTime::createFromFormat('D, d M Y H:i:s T', $data['default']));
} else {
$namedParameter->setDefault($data['default']);
}
}
return $namedParameter;
}
