Esempio n. 1
0
 /**
  * {@inheritdoc}
  */
 public function getErrorMessage() : string
 {
     $opts = \sndsgd\Arr::implode(", ", $this->getWrappedOptions(), _("or") . " ");
     if ($this->errorMessage) {
         return sprintf($this->errorMessage, $opts);
     }
     return sprintf(_("must be %s"), $opts);
 }
Esempio n. 2
0
 /**
  * Add multiple headers
  *
  * @param array<string,string> $headers
  */
 public function addMultiple(array $headers) : HeaderCollection
 {
     foreach ($headers as $key => $value) {
         $key = $this->getKey($key, true);
         \sndsgd\Arr::addValue($this->headers, $key, $value);
     }
     return $this;
 }
Esempio n. 3
0
 /**
  * {@inheritdoc}
  */
 public function getErrorMessage() : string
 {
     $template = _("value must be a child of %s");
     if (count($this->parentPaths) === 1) {
         return sprintf($template, $this->parentPaths[0]);
     }
     $parents = \sndsgd\Arr::implode(", ", $this->parentPaths, _("or") . " ");
     return sprintf($template, $parents);
 }
Esempio n. 4
0
 /**
  * {@inheritdoc}
  */
 public function getErrorMessage() : string
 {
     if (count($this->extensions) === 1) {
         $template = _("must be a file with a %s extension");
         $value = $this->extensions[0];
     } else {
         $template = _("must be a file with one of the following extensions: %s");
         $value = \sndsgd\Arr::implode(", ", $this->extensions, _("or") . " ");
     }
     return sprintf($template, $value);
 }
Esempio n. 5
0
 /**
  * Parse a string
  *
  * @param string $header
  */
 public function parseString($header)
 {
     $parts = explode("\r\n", $header, 2);
     if (count($parts) !== 2) {
         throw new InvalidArgumentException("invalid value provided for 'header'; expecting a string that " . "utilizes \\r\\n line breaks");
     }
     list($info, $fields) = $parts;
     list($protocol, $code, $message) = preg_split("/\\s+/", $info, 3);
     $this->protocol = $protocol;
     $this->statusCode = intval($code);
     $lines = explode("\r\n", trim($fields));
     foreach ($lines as $line) {
         list($key, $value) = explode(":", $line, 2);
         $key = strtolower($key);
         $value = trim($value);
         Arr::addvalue($this->fields, $key, $value);
     }
 }
Esempio n. 6
0
 /**
  * Process the $_POST superglobal to spoof the results of a decoder
  *
  * @return array
  */
 protected function parsePost()
 {
     $ret = $_POST ?: [];
     if (isset($_FILES)) {
         foreach ($_FILES as $name => $info) {
             if (is_array($info["name"])) {
                 $len = count($info["name"]);
                 for ($i = 0; $i < $len; $i++) {
                     $file = $this->createUploadedFile(["name" => $info["name"][$i] ?? "", "type" => $info["type"][$i] ?? "", "tmp_name" => $info["tmp_name"][$i] ?? "", "error" => $info["error"][$i] ?? 0, "size" => $info["size"][$i] ?? 0]);
                     \sndsgd\Arr::addValue($ret, $name, $file);
                 }
             } else {
                 $file = $this->createUploadedFile($info);
                 \sndsgd\Arr::addValue($ret, $name, $file);
             }
         }
     }
     return $ret;
 }
Esempio n. 7
0
 /**
  * {@inheritdoc}
  */
 public function getErrorMessage() : string
 {
     if ($this->errorMessage) {
         return $this->errorMessage;
     }
     $testTypes = array_values($this->getTestTypes());
     switch (count($testTypes)) {
         case 0:
             return _("must be a file");
         case 1:
             $desc = $testTypes[0];
             break;
         case 2:
             $desc = $testTypes[0] . " " . _("and") . " " . $testTypes[1];
             break;
         default:
             $desc = \sndsgd\Arr::implode(", ", $testTypes, _("and") . " ");
     }
     return sprintf(_("must be a %s file"), $desc);
 }
Esempio n. 8
0
 /**
  * Export the current value(s)
  *
  * note: when exporting from a collection (collection->getValues()), this
  * method is not called if `$this->exportHandler === Field::EXPORT_SKIP`
  * @param ?integer $exportHandler A handler to override the 
  * @return array<number|string>|number|string
  */
 public function exportValue($exportHandler = null)
 {
     if ($exportHandler === null) {
         $exportHandler = $this->exportHandler;
     }
     if ($exportHandler === self::EXPORT_NORMAL || $exportHandler === self::EXPORT_SKIP) {
         $values = $this->getValuesAsArray();
         return count($values) === 1 ? $values[0] : $values;
     } else {
         if ($exportHandler === self::EXPORT_ARRAY) {
             if ($this->value === null) {
                 return $this->defaultValue === null ? [] : $this->defaultValue;
             }
             return Arr::cast($this->value);
         } else {
             return call_user_func($exportHandler, $this->getValuesAsArray());
         }
     }
 }
Esempio n. 9
0
 /**
  * Add more data to the query
  * 
  * @param string|array $data
  * @return \sndsgd\Url
  */
 public function addQueryData($data)
 {
     if (is_string($data)) {
         $data = self::decodeQueryString($data);
     } else {
         if (is_object($data)) {
             $data = (array) $data;
         } else {
             if (!is_array($data)) {
                 throw new InvalidArgumentException("invalid value provided for 'query'; " . "expecting a string, array, or object");
             }
         }
     }
     foreach ($data as $k => $v) {
         Arr::addValue($this->query, $k, $v);
     }
     return $this;
 }
Esempio n. 10
0
 /**
  * Add a value that has a nested key
  *
  * @param string $key
  * @param mixed $value
  * @param integer $pos The position of the first open bracket
  */
 protected function addNestedValue(string $key, $value, int $pos)
 {
     # convert the levels into an array of strings
     $levels = strpos($key, "][") !== false ? explode("][", substr($key, $pos + 1, -1)) : [substr($key, $pos + 1, -1)];
     array_unshift($levels, substr($key, 0, $pos));
     # ensure the nesting doesn't exceed `max_nesting_levels`
     $levelLen = count($levels);
     if ($levelLen > $this->maxNestingLevels) {
         throw new DecodeException("max_input_nesting_level exceeded");
     }
     $lastKey = array_pop($levels);
     $values =& $this->values;
     foreach ($levels as $level) {
         if ($level === "") {
             $level = count($values);
         }
         if (!array_key_exists($level, $values)) {
             $values[$level] = [];
         }
         $values =& $values[$level];
     }
     if ($lastKey === "") {
         $lastKey = count($values);
     }
     \sndsgd\Arr::addValue($values, $lastKey, $value);
 }
Esempio n. 11
0
 /**
  * Add values to the fields in the collection
  *
  * @param array.<string,mixed> $fieldValues
  */
 public function addValues(array $fieldValues)
 {
     foreach ($fieldValues as $fieldName => $values) {
         $values = Arr::cast($values);
         if (null === ($field = $this->getField($fieldName))) {
             $message = "unknown field";
             $len = count($values);
             if ($len !== 1) {
                 $message .= " (encountered {$len} values)";
             }
             $error = new Error($message);
             $error->setName($fieldName);
             $this->addError($error);
         } else {
             foreach ($values as $index => $value) {
                 $field->addValue($value, $index);
             }
         }
     }
 }
Esempio n. 12
0
 /**
  * Verify a node type is valid
  *
  * @param string $nodeType The value to verify
  * @return string The verified node type
  * @throws \InvalidArgumentException If the node type is not valid
  */
 protected function validateNodeType(string $nodeType) : string
 {
     if (!in_array($nodeType, static::$validNodeTypes)) {
         throw new \InvalidArgumentException("invalid value node type '{$nodeType}'; expecting " . \sndsgd\Arr::implode(", ", static::$validNodeTypes, "or "));
     }
     return $nodeType;
 }