opdavies/drupalcampbristol
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update core 8.3.0

Browse source
This commit is contained in:
Rob Davies 2017-04-13 15:53:35 +01:00
parent da7a7918f8
commit cd7a898e66
6144 changed files with 132297 additions and 87747 deletions
Download patch file Download diff file Expand all files Collapse all files

1
web/vendor/zendframework/zend-diactoros/.coveralls.yml vendored
View file

@ -1,3 +1,2 @@
coverage_clover: clover.xml
json_path: coveralls-upload.json
src_dir: src

457
web/vendor/zendframework/zend-diactoros/CHANGELOG.md vendored
View file

@ -2,11 +2,464 @@
All notable changes to this project will be documented in this file, in reverse chronological order by release.
## 1.4.0 - 2017-04-06
### Added
- [#219](https://github.com/zendframework/zend-diactoros/pull/219) adds two new
classes, `Zend\Diactoros\Request\ArraySerializer` and
`Zend\Diactoros\Response\ArraySerializer`. Each exposes the static methods
`toArray()` and `fromArray()`, allowing de/serialization of messages from and
to arrays.
- [#236](https://github.com/zendframework/zend-diactoros/pull/236) adds two new
constants to the `Response` class: `MIN_STATUS_CODE_VALUE` and
`MAX_STATUS_CODE_VALUE`.
### Changes
- [#240](https://github.com/zendframework/zend-diactoros/pull/240) changes the
behavior of `ServerRequestFactory::fromGlobals()` when no `$cookies` argument
is present. Previously, it would use `$_COOKIES`; now, if a `Cookie` header is
present, it will parse and use that to populate the instance instead.
This change allows utilizing cookies that contain period characters (`.`) in
their names (PHP's built-in cookie handling renames these to replace `.` with
`_`, which can lead to synchronization issues with clients).
- [#235](https://github.com/zendframework/zend-diactoros/pull/235) changes the
behavior of `Uri::__toString()` to better follow proscribed behavior in PSR-7.
In particular, prior to this release, if a scheme was missing but an authority
was present, the class was incorrectly returning a value that did not include
a `//` prefix. As of this release, it now does this correctly.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- Nothing.
## 1.3.11 - 2017-04-06
### Added
- Nothing.
### Changes
- [#241](https://github.com/zendframework/zend-diactoros/pull/241) changes the
constraint by which the package provides `psr/http-message-implementation` to
simply `1.0` instead of `~1.0.0`, to follow how other implementations provide
PSR-7.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#161](https://github.com/zendframework/zend-diactoros/pull/161) adds
additional validations to header names and values to ensure no malformed values
are provided.
- [#234](https://github.com/zendframework/zend-diactoros/pull/234) fixes a
number of reason phrases in the `Response` instance, and adds automation from
the canonical IANA sources to ensure any new phrases added are correct.
## 1.3.10 - 2017-01-23
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#226](https://github.com/zendframework/zend-diactoros/pull/226) fixed an
issue with the `SapiStreamEmitter` causing the response body to be cast
to `(string)` and also be read as a readable stream, potentially producing
double output.
## 1.3.9 - 2017-01-17
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#223](https://github.com/zendframework/zend-diactoros/issues/223)
[#224](https://github.com/zendframework/zend-diactoros/pull/224) fixed an issue
with the `SapiStreamEmitter` consuming too much memory when producing output
for readable bodies.
## 1.3.8 - 2017-01-05
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#222](https://github.com/zendframework/zend-diactoros/pull/222) fixes the
`SapiStreamEmitter`'s handling of the `Content-Range` header to properly only
emit a range of bytes if the header value is in the form `bytes {first-last}/length`.
This allows using other range units, such as `items`, without incorrectly
emitting truncated content.
## 1.3.7 - 2016-10-11
### Added
- [#208](https://github.com/zendframework/zend-diactoros/pull/208) adds several
missing response codes to `Zend\Diactoros\Response`, including:
- 226 ('IM used')
- 308 ('Permanent Redirect')
- 444 ('Connection Closed Without Response')
- 499 ('Client Closed Request')
- 510 ('Not Extended')
- 599 ('Network Connect Timeout Error')
- [#211](https://github.com/zendframework/zend-diactoros/pull/211) adds support
for UTF-8 characters in query strings handled by `Zend\Diactoros\Uri`.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- Nothing.
## 1.3.6 - 2016-09-07
### Added
- [#170](https://github.com/zendframework/zend-diactoros/pull/170) prepared
documentation for publication at https://zendframework.github.io/zend-diactoros/
- [#165](https://github.com/zendframework/zend-diactoros/pull/165) adds support
for Apache `REDIRECT_HTTP_*` header detection in the `ServerRequestFactory`.
- [#166](https://github.com/zendframework/zend-diactoros/pull/166) adds support
for UTF-8 characters in URI paths.
- [#204](https://github.com/zendframework/zend-diactoros/pull/204) adds testing
against PHP 7.1 release-candidate builds.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#186](https://github.com/zendframework/zend-diactoros/pull/186) fixes a typo
in a variable name within the `SapiStreamEmitter`.
- [#200](https://github.com/zendframework/zend-diactoros/pull/200) updates the
`SapiStreamEmitter` to implement a check for `isSeekable()` prior to attempts
to rewind; this allows it to work with non-seekable streams such as the
`CallbackStream`.
- [#169](https://github.com/zendframework/zend-diactoros/pull/169) ensures that
response serialization always provides a `\r\n\r\n` sequence following the
headers, even when no message body is present, to ensure it conforms with RFC
7230.
- [#175](https://github.com/zendframework/zend-diactoros/pull/175) updates the
`Request` class to set the `Host` header from the URI host if no header is
already present. (Ensures conformity with PSR-7 specification.)
- [#197](https://github.com/zendframework/zend-diactoros/pull/197) updates the
`Uri` class to ensure that string serialization does not include a colon after
the host name if no port is present in the instance.
## 1.3.5 - 2016-03-17
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#160](https://github.com/zendframework/zend-diactoros/pull/160) fixes HTTP
protocol detection in the `ServerRequestFactory` to work correctly with HTTP/2.
## 1.3.4 - 2016-03-17
### Added
- [#119](https://github.com/zendframework/zend-diactoros/pull/119) adds the 451
(Unavailable for Legal Reasons) status code to the `Response` class.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#117](https://github.com/zendframework/zend-diactoros/pull/117) provides
validation of the HTTP protocol version.
- [#127](https://github.com/zendframework/zend-diactoros/pull/127) now properly
removes attributes with `null` values when calling `withoutAttribute()`.
- [#132](https://github.com/zendframework/zend-diactoros/pull/132) updates the
`ServerRequestFactory` to marshal the request path fragment, if present.
- [#142](https://github.com/zendframework/zend-diactoros/pull/142) updates the
exceptions thrown by `HeaderSecurity` to include the header name and/or
value.
- [#148](https://github.com/zendframework/zend-diactoros/pull/148) fixes several
stream operations to ensure they raise exceptions when the internal pointer
is at an invalid position.
- [#151](https://github.com/zendframework/zend-diactoros/pull/151) ensures
URI fragments are properly encoded.
## 1.3.3 - 2016-01-04
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#135](https://github.com/zendframework/zend-diactoros/pull/135) fixes the
behavior of `ServerRequestFactory::marshalHeaders()` to no longer omit
`Cookie` headers from the aggregated headers. While the values are parsed and
injected into the cookie params, it's useful to have access to the raw headers
as well.
## 1.3.2 - 2015-12-22
### Added
- [#124](https://github.com/zendframework/zend-diactoros/pull/124) adds four
more optional arguments to the `ServerRequest` constructor:
- `array $cookies`
- `array $queryParams`
- `null|array|object $parsedBody`
- `string $protocolVersion`
`ServerRequestFactory` was updated to pass values for each of these parameters
when creating an instance, instead of using the related `with*()` methods on
an instance.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#122](https://github.com/zendframework/zend-diactoros/pull/122) updates the
`ServerRequestFactory` to retrieve the HTTP protocol version and inject it in
the generated `ServerRequest`, which previously was not performed.
## 1.3.1 - 2015-12-16
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#113](https://github.com/zendframework/zend-diactoros/pull/113) fixes an
issue in the response serializer, ensuring that the status code in the
deserialized response is an integer.
- [#115](https://github.com/zendframework/zend-diactoros/pull/115) fixes an
issue in the various text-basd response types (`TextResponse`, `HtmlResponse`,
and `JsonResponse`); due to the fact that the constructor was not
rewinding the message body stream, `getContents()` was thus returning `null`,
as the pointer was at the end of the stream. The constructor now rewinds the
stream after populating it in the constructor.
## 1.3.0 - 2015-12-15
### Added
- [#110](https://github.com/zendframework/zend-diactoros/pull/110) adds
`Zend\Diactoros\Response\SapiEmitterTrait`, which provides the following
private method definitions:
- `injectContentLength()`
- `emitStatusLine()`
- `emitHeaders()`
- `flush()`
- `filterHeader()`
The `SapiEmitter` implementation has been updated to remove those methods and
instead compose the trait.
- [#111](https://github.com/zendframework/zend-diactoros/pull/111) adds
a new emitter implementation, `SapiStreamEmitter`; this emitter type will
loop through the stream instead of emitting it in one go, and supports content
ranges.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- Nothing.
## 1.2.1 - 2015-12-15
### Added
- Nothing.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#101](https://github.com/zendframework/zend-diactoros/pull/101) fixes the
`withHeader()` implementation to ensure that if the header existed previously
but using a different casing strategy, the previous version will be removed
in the cloned instance.
- [#103](https://github.com/zendframework/zend-diactoros/pull/103) fixes the
constructor of `Response` to ensure that null status codes are not possible.
- [#99](https://github.com/zendframework/zend-diactoros/pull/99) fixes
validation of header values submitted via request and response constructors as
follows:
- numeric (integer and float) values are now properly allowed (this solves
some reported issues with setting Content-Length headers)
- invalid header names (non-string values or empty strings) now raise an
exception.
- invalid individual header values (non-string, non-numeric) now raise an
exception.
## 1.2.0 - 2015-11-24
### Added
- [#88](https://github.com/zendframework/zend-diactoros/pull/88) updates the
`SapiEmitter` to emit a `Content-Length` header with the content length as
reported by the response body stream, assuming that
`StreamInterface::getSize()` returns an integer.
- [#77](https://github.com/zendframework/zend-diactoros/pull/77) adds a new
response type, `Zend\Diactoros\Response\TextResponse`, for returning plain
text responses. By default, it sets the content type to `text/plain;
charset=utf-8`; per the other response types, the signature is `new
TextResponse($text, $status = 200, array $headers = [])`.
- [#90](https://github.com/zendframework/zend-diactoros/pull/90) adds a new
`Zend\Diactoros\CallbackStream`, allowing you to back a stream with a PHP
callable (such as a generator) to generate the message content. Its
constructor accepts the callable: `$stream = new CallbackStream($callable);`
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#77](https://github.com/zendframework/zend-diactoros/pull/77) updates the
`HtmlResponse` to set the charset to utf-8 by default (if no content type
header is provided at instantiation).
## 1.1.4 - 2015-10-16
### Added
- [#98](https://github.com/zendframework/zend-diactoros/pull/98) adds
`JSON_UNESCAPED_SLASHES` to the default `json_encode` flags used by
`Zend\Diactoros\Response\JsonResponse`.
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#96](https://github.com/zendframework/zend-diactoros/pull/96) updates
`withPort()` to allow `null` port values (indicating usage of default for
the given scheme).
- [#91](https://github.com/zendframework/zend-diactoros/pull/91) fixes the
logic of `withUri()` to do a case-insensitive check for an existing `Host`
header, replacing it with the new one.
## 1.1.3 - 2015-08-10
### Added
- Nothing.
- [#73](https://github.com/zendframework/zend-diactoros/pull/73) adds caching of
the vendor directory to the Travis-CI configuration, to speed up builds.
### Deprecated
@ -181,7 +634,7 @@ immediately.
- [#57](https://github.com/zendframework/zend-diactoros/pull/57) fixes the
behavior of how the `ServerRequestFactory` marshals upload files when they are
represented as a nested associative array.
- [#49](https://github.com/zendframework/zend-diactoros/pull/49) provides several
- [#49](https://github.com/zendframework/zend-diactoros/pull/49) provides several
fixes that ensure that Diactoros complies with the PSR-7 specification:
- `MessageInterface::getHeaderLine()` MUST return a string (that string CAN be
empty). Previously, Diactoros would return `null`.

43
web/vendor/zendframework/zend-diactoros/CONDUCT.md vendored Normal file
View file

@ -0,0 +1,43 @@
# Contributor Code of Conduct
The Zend Framework project adheres to [The Code Manifesto](http://codemanifesto.com)
as its guidelines for contributor interactions.
## The Code Manifesto
We want to work in an ecosystem that empowers developers to reach their
potential — one that encourages growth and effective collaboration. A space that
is safe for all.
A space such as this benefits everyone that participates in it. It encourages
new developers to enter our field. It is through discussion and collaboration
that we grow, and through growth that we improve.
In the effort to create such a place, we hold to these values:
1. **Discrimination limits us.** This includes discrimination on the basis of
race, gender, sexual orientation, gender identity, age, nationality, technology
and any other arbitrary exclusion of a group of people.
2. **Boundaries honor us.** Your comfort levels are not everyone’s comfort
levels. Remember that, and if brought to your attention, heed it.
3. **We are our biggest assets.** None of us were born masters of our trade.
Each of us has been helped along the way. Return that favor, when and where
you can.
4. **We are resources for the future.** As an extension of #3, share what you
know. Make yourself a resource to help those that come after you.
5. **Respect defines us.** Treat others as you wish to be treated. Make your
discussions, criticisms and debates from a position of respectfulness. Ask
yourself, is it true? Is it necessary? Is it constructive? Anything less is
unacceptable.
6. **Reactions require grace.** Angry responses are valid, but abusive language
and vindictive actions are toxic. When something happens that offends you,
handle it assertively, but be respectful. Escalate reasonably, and try to
allow the offender an opportunity to explain themselves, and possibly correct
the issue.
7. **Opinions are just that: opinions.** Each and every one of us, due to our
background and upbringing, have varying opinions. The fact of the matter, is
that is perfectly acceptable. Remember this: if you respect your own
opinions, you should respect the opinions of others.
8. **To err is human.** You might not intend it, but mistakes do happen and
contribute to build experience. Tolerate honest mistakes, and don't hesitate
to apologize if you make one yourself.

11
web/vendor/zendframework/zend-diactoros/CONTRIBUTING.md vendored
View file

@ -78,14 +78,14 @@ standards checks, and provides configuration for our selected checks.
To run checks only:
```console
$ ./vendor/bin/phpcs --standard=PSR2 src test
$ composer cs-check
```
`phpcs` also installs a tool named `phpcbf` which can attempt to fix problems
for you:
```console
$ ./vendor/bin/phpcbf --standard=PSR2 src test
$ composer cs-fix
```
If you allow phpcbf to fix CS issues, please re-run the tests to ensure
@ -102,7 +102,7 @@ pull your work into the master repository. We recommend using
3. Clone the canonical repository locally and enter it.
```console
$ git clone git://github.com:zendframework/zend-diactoros.git
$ git clone git://github.com/zendframework/zend-diactoros.git
$ cd zend-diactoros
```
@ -221,3 +221,8 @@ repository, we suggest doing some cleanup of these branches.
```console
$ git push {username} :<branchname>
```
## Conduct
Please see our [CONDUCT.md](CONDUCT.md) to understand expected behavior when interacting with others in the project.

2
web/vendor/zendframework/zend-diactoros/LICENSE.md vendored
View file

@ -1,4 +1,4 @@
Copyright (c) 2015, Zend Technologies USA, Inc.
Copyright (c) 2015-2016, Zend Technologies USA, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

12
web/vendor/zendframework/zend-diactoros/README.md vendored
View file

@ -18,17 +18,11 @@ This package supercedes and replaces [phly/http](https://github.com/phly/http).
## Documentation
Documentation is [in the doc tree](doc/), and can be compiled using [bookdown](http://bookdown.io):
Documentation is available at:
```console
$ bookdown doc/bookdown.json
$ php -S 0.0.0.0:8080 -t doc/html/ # then browse to http://localhost:8080/
```
- https://zendframework.github.io/zend-diactoros/
> ### Bookdown
>
> You can install bookdown globally using `composer global require bookdown/bookdown`. If you do
> this, make sure that `$HOME/.composer/vendor/bin` is on your `$PATH`.
Source files for documentation are [in the doc/ tree](doc/).
[Master]: https://travis-ci.org/zendframework/zend-diactoros
[Master image]: https://secure.travis-ci.org/zendframework/zend-diactoros.svg?branch=master

25
web/vendor/zendframework/zend-diactoros/composer.json vendored
View file

@ -15,20 +15,22 @@
},
"extra": {
"branch-alias": {
"dev-master": "1.0-dev",
"dev-develop": "1.1-dev"
"dev-master": "1.4-dev",
"dev-develop": "1.5-dev"
}
},
"require": {
"php": ">=5.4",
"php": "^5.4 || ^7.0",
"psr/http-message": "~1.0"
},
"require-dev": {
"phpunit/PHPUnit": "~4.6",
"squizlabs/php_codesniffer": "^2.3.1"
"phpunit/phpunit": "^4.6 || ^5.5",
"zendframework/zend-coding-standard": "~1.0.0",
"ext-dom": "*",
"ext-libxml": "*"
},
"provide": {
"psr/http-message-implementation": "~1.0.0"
"psr/http-message-implementation": "1.0"
},
"autoload": {
"psr-4": {
@ -43,5 +45,16 @@
"test/TestAsset/Functions.php",
"test/TestAsset/SapiResponse.php"
]
},
"scripts": {
"check": [
"@cs-check",
"@test"
],
"upload-coverage": "coveralls -v",
"cs-check": "phpcs",
"cs-fix": "phpcbf",
"test": "phpunit --colors=always",
"test-coverage": "phpunit --colors=always --coverage-clover clover.xml"
}
}

1494
web/vendor/zendframework/zend-diactoros/composer.lock generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

16
web/vendor/zendframework/zend-diactoros/mkdocs.yml vendored Normal file
View file

@ -0,0 +1,16 @@
docs_dir: doc/book
site_dir: doc/html
pages:
- index.md
- Overview: overview.md
- Installation: install.md
- Usage: usage.md
- Reference:
- "Custom Responses": custom-responses.md
- "Emitting Responses": emitting-responses.md
- Serialization: serialization.md
- API: api.md
site_name: zend-diactoros
site_description: 'zend-diactoros: PSR-7 HTTP message implementation'
repo_url: 'https://github.com/zendframework/zend-diactoros'
copyright: 'Copyright (c) 2016 <a href="http://www.zend.com/">Zend Technologies USA Inc.</a>'

2
web/vendor/zendframework/zend-diactoros/src/AbstractSerializer.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

181
web/vendor/zendframework/zend-diactoros/src/CallbackStream.php vendored Normal file
View file

@ -0,0 +1,181 @@
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros;
use InvalidArgumentException;
use RuntimeException;
use Psr\Http\Message\StreamInterface;
/**
* Implementation of PSR HTTP streams
*/
class CallbackStream implements StreamInterface
{
/**
* @var callable|null
*/
protected $callback;
/**
* @param callable $callback
* @throws InvalidArgumentException
*/
public function __construct(callable $callback)
{
$this->attach($callback);
}
/**
* {@inheritdoc}
*/
public function __toString()
{
return $this->getContents();
}
/**
* {@inheritdoc}
*/
public function close()
{
$this->callback = null;
}
/**
* {@inheritdoc}
*/
public function detach()
{
$callback = $this->callback;
$this->callback = null;
return $callback;
}
/**
* Attach a new callback to the instance.
*
* @param callable $callback
* @throws InvalidArgumentException for callable callback
*/
public function attach(callable $callback)
{
$this->callback = $callback;
}
/**
* {@inheritdoc}
*/
public function getSize()
{
}
/**
* {@inheritdoc}
*/
public function tell()
{
throw new RuntimeException('Callback streams cannot tell position');
}
/**
* {@inheritdoc}
*/
public function eof()
{
return empty($this->callback);
}
/**
* {@inheritdoc}
*/
public function isSeekable()
{
return false;
}
/**
* {@inheritdoc}
*/
public function seek($offset, $whence = SEEK_SET)
{
throw new RuntimeException('Callback streams cannot seek position');
}
/**
* {@inheritdoc}
*/
public function rewind()
{
throw new RuntimeException('Callback streams cannot rewind position');
}
/**
* {@inheritdoc}
*/
public function isWritable()
{
return false;
}
/**
* {@inheritdoc}
*/
public function write($string)
{
throw new RuntimeException('Callback streams cannot write');
}
/**
* {@inheritdoc}
*/
public function isReadable()
{
return false;
}
/**
* {@inheritdoc}
*/
public function read($length)
{
throw new RuntimeException('Callback streams cannot read');
}
/**
* {@inheritdoc}
*/
public function getContents()
{
$callback = $this->detach();
return $callback ? $callback() : '';
}
/**
* {@inheritdoc}
*/
public function getMetadata($key = null)
{
$metadata = [
'eof' => $this->eof(),
'stream_type' => 'callback',
'seekable' => false
];
if (null === $key) {
return $metadata;
}
if (! array_key_exists($key, $metadata)) {
return null;
}
return $metadata[$key];
}
}

2
web/vendor/zendframework/zend-diactoros/src/Exception/DeprecatedMethodException.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

2
web/vendor/zendframework/zend-diactoros/src/Exception/ExceptionInterface.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

25
web/vendor/zendframework/zend-diactoros/src/HeaderSecurity.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -24,6 +24,7 @@ final class HeaderSecurity
{
/**
* Private constructor; non-instantiable.
* @codeCoverageIgnore
*/
private function __construct()
{
@ -128,8 +129,17 @@ final class HeaderSecurity
*/
public static function assertValid($value)
{
if (! is_string($value) && ! is_numeric($value)) {
throw new InvalidArgumentException(sprintf(
'Invalid header value type; must be a string or numeric; received %s',
(is_object($value) ? get_class($value) : gettype($value))
));
}
if (! self::isValid($value)) {
throw new InvalidArgumentException('Invalid header value');
throw new InvalidArgumentException(sprintf(
'"%s" is not valid header value',
$value
));
}
}
@ -142,8 +152,17 @@ final class HeaderSecurity
*/
public static function assertValidName($name)
{
if (! is_string($name)) {
throw new InvalidArgumentException(sprintf(
'Invalid header name type; expected string; received %s',
(is_object($name) ? get_class($name) : gettype($name))
));
}
if (! preg_match('/^[a-zA-Z0-9\'`#$%&*+.^_|~!-]+$/', $name)) {
throw new InvalidArgumentException('Invalid header name');
throw new InvalidArgumentException(sprintf(
'"%s" is not valid header name',
$name
));
}
}
}

146
web/vendor/zendframework/zend-diactoros/src/MessageTrait.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -70,6 +70,7 @@ trait MessageTrait
*/
public function withProtocolVersion($version)
{
$this->validateProtocolVersion($version);
$new = clone $this;
$new->protocol = $version;
return $new;
@ -111,7 +112,7 @@ trait MessageTrait
*/
public function hasHeader($header)
{
return array_key_exists(strtolower($header), $this->headerNames);
return isset($this->headerNames[strtolower($header)]);
}
/**
@ -135,10 +136,8 @@ trait MessageTrait
}
$header = $this->headerNames[strtolower($header)];
$value = $this->headers[$header];
$value = is_array($value) ? $value : [$value];
return $value;
return $this->headers[$header];
}
/**
@ -188,22 +187,17 @@ trait MessageTrait
*/
public function withHeader($header, $value)
{
if (is_string($value)) {
$value = [$value];
}
if (! is_array($value) || ! $this->arrayContainsOnlyStrings($value)) {
throw new InvalidArgumentException(
'Invalid header value; must be a string or array of strings'
);
}
HeaderSecurity::assertValidName($header);
self::assertValidHeaderValue($value);
$this->assertHeader($header);
$normalized = strtolower($header);
$new = clone $this;
if ($new->hasHeader($header)) {
unset($new->headers[$new->headerNames[$normalized]]);
}
$value = $this->filterHeaderValue($value);
$new->headerNames[$normalized] = $header;
$new->headers[$header] = $value;
@ -229,27 +223,16 @@ trait MessageTrait
*/
public function withAddedHeader($header, $value)
{
if (is_string($value)) {
$value = [ $value ];
}
if (! is_array($value) || ! $this->arrayContainsOnlyStrings($value)) {
throw new InvalidArgumentException(
'Invalid header value; must be a string or array of strings'
);
}
HeaderSecurity::assertValidName($header);
self::assertValidHeaderValue($value);
$this->assertHeader($header);
if (! $this->hasHeader($header)) {
return $this->withHeader($header, $value);
}
$normalized = strtolower($header);
$header = $this->headerNames[$normalized];
$header = $this->headerNames[strtolower($header)];
$new = clone $this;
$value = $this->filterHeaderValue($value);
$new->headers[$header] = array_merge($this->headers[$header], $value);
return $new;
}
@ -310,15 +293,21 @@ trait MessageTrait
return $new;
}
/**
* Test that an array contains only strings
*
* @param array $array
* @return bool
*/
private function arrayContainsOnlyStrings(array $array)
private function getStream($stream, $modeIfNotInstance)
{
return array_reduce($array, [__CLASS__, 'filterStringValue'], true);
if ($stream instanceof StreamInterface) {
return $stream;
}
if (! is_string($stream) && ! is_resource($stream)) {
throw new InvalidArgumentException(
'Stream must be a string stream resource identifier, '
. 'an actual stream resource, '
. 'or a Psr\Http\Message\StreamInterface implementation'
);
}
return new Stream($stream, $modeIfNotInstance);
}
/**
@ -327,57 +316,80 @@ trait MessageTrait
* Used by message constructors to allow setting all initial headers at once.
*
* @param array $originalHeaders Headers to filter.
* @return array Filtered headers and names.
*/
private function filterHeaders(array $originalHeaders)
private function setHeaders(array $originalHeaders)
{
$headerNames = $headers = [];
foreach ($originalHeaders as $header => $value) {
if (! is_string($header)) {
continue;
}
$value = $this->filterHeaderValue($value);
if (! is_array($value) && ! is_string($value)) {
continue;
}
if (! is_array($value)) {
$value = [ $value ];
}
$this->assertHeader($header);
$headerNames[strtolower($header)] = $header;
$headers[$header] = $value;
}
return [$headerNames, $headers];
$this->headerNames = $headerNames;
$this->headers = $headers;
}
/**
* Test if a value is a string
* Validate the HTTP protocol version
*
* Used with array_reduce.
*
* @param bool $carry
* @param mixed $item
* @return bool
* @param string $version
* @throws InvalidArgumentException on invalid HTTP protocol version
*/
private static function filterStringValue($carry, $item)
private function validateProtocolVersion($version)
{
if (! is_string($item)) {
return false;
if (empty($version)) {
throw new InvalidArgumentException(sprintf(
'HTTP protocol version can not be empty'
));
}
if (! is_string($version)) {
throw new InvalidArgumentException(sprintf(
'Unsupported HTTP protocol version; must be a string, received %s',
(is_object($version) ? get_class($version) : gettype($version))
));
}
// HTTP/1 uses a "<major>.<minor>" numbering scheme to indicate
// versions of the protocol, while HTTP/2 does not.
if (! preg_match('#^(1\.[01]|2)$#', $version)) {
throw new InvalidArgumentException(sprintf(
'Unsupported HTTP protocol version "%s" provided',
$version
));
}
return $carry;
}
/**
* Assert that the provided header values are valid.
* @param mixed $values
* @return string[]
*/
private function filterHeaderValue($values)
{
if (! is_array($values)) {
$values = [$values];
}
return array_map(function ($value) {
HeaderSecurity::assertValid($value);
return (string) $value;
}, $values);
}
/**
* Ensure header name and values are valid.
*
* @param string $name
*
* @see http://tools.ietf.org/html/rfc7230#section-3.2
* @param string[] $values
* @throws InvalidArgumentException
*/
private static function assertValidHeaderValue(array $values)
private function assertHeader($name)
{
array_walk($values, __NAMESPACE__ . '\HeaderSecurity::assertValid');
HeaderSecurity::assertValidName($name);
}
}

8
web/vendor/zendframework/zend-diactoros/src/PhpInputStream.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -26,12 +26,10 @@ class PhpInputStream extends Stream
/**
* @param string|resource $stream
* @param string $mode
*/
public function __construct($stream = 'php://input', $mode = 'r')
public function __construct($stream = 'php://input')
{
$mode = 'r';
parent::__construct($stream, $mode);
parent::__construct($stream, 'r');
}
/**

12
web/vendor/zendframework/zend-diactoros/src/RelativeStream.php vendored
View file

@ -3,13 +3,14 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros;
use Psr\Http\Message\StreamInterface;
use RuntimeException;
/**
* Class RelativeStream
@ -131,6 +132,9 @@ final class RelativeStream implements StreamInterface
*/
public function write($string)
{
if ($this->tell() < 0) {
throw new RuntimeException('Invalid pointer position');
}
return $this->decoratedStream->write($string);
}
@ -147,6 +151,9 @@ final class RelativeStream implements StreamInterface
*/
public function read($length)
{
if ($this->tell() < 0) {
throw new RuntimeException('Invalid pointer position');
}
return $this->decoratedStream->read($length);
}
@ -155,6 +162,9 @@ final class RelativeStream implements StreamInterface
*/
public function getContents()
{
if ($this->tell() < 0) {
throw new RuntimeException('Invalid pointer position');
}
return $this->decoratedStream->getContents();
}

15
web/vendor/zendframework/zend-diactoros/src/Request.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -11,6 +11,7 @@ namespace Zend\Diactoros;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;
/**
* HTTP Request encapsulation
@ -21,10 +22,10 @@ use Psr\Http\Message\StreamInterface;
*/
class Request implements RequestInterface
{
use MessageTrait, RequestTrait;
use RequestTrait;
/**
* @param null|string $uri URI for the request, if any.
* @param null|string|UriInterface $uri URI for the request, if any.
* @param null|string $method HTTP method for the request, if any.
* @param string|resource|StreamInterface $body Message body, if any.
* @param array $headers Headers for the message, if any.
@ -42,7 +43,7 @@ class Request implements RequestInterface
{
$headers = $this->headers;
if (! $this->hasHeader('host')
&& ($this->uri && $this->uri->getHost())
&& $this->uri->getHost()
) {
$headers['Host'] = [$this->getHostFromUri()];
}
@ -57,7 +58,7 @@ class Request implements RequestInterface
{
if (! $this->hasHeader($header)) {
if (strtolower($header) === 'host'
&& ($this->uri && $this->uri->getHost())
&& $this->uri->getHost()
) {
return [$this->getHostFromUri()];
}
@ -66,9 +67,7 @@ class Request implements RequestInterface
}
$header = $this->headerNames[strtolower($header)];
$value = $this->headers[$header];
$value = is_array($value) ? $value : [$value];
return $value;
return $this->headers[$header];
}
}

85
web/vendor/zendframework/zend-diactoros/src/Request/ArraySerializer.php vendored Normal file
View file

@ -0,0 +1,85 @@
<?php
/**
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2017 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros\Request;
use Psr\Http\Message\RequestInterface;
use UnexpectedValueException;
use Zend\Diactoros\Request;
use Zend\Diactoros\Stream;
/**
* Serialize or deserialize request messages to/from arrays.
*
* This class provides functionality for serializing a RequestInterface instance
* to an array, as well as the reverse operation of creating a Request instance
* from an array representing a message.
*/
final class ArraySerializer
{
/**
* Serialize a request message to an array.
*
* @param RequestInterface $request
* @return array
*/
public static function toArray(RequestInterface $request)
{
return [
'method' => $request->getMethod(),
'request_target' => $request->getRequestTarget(),
'uri' => (string) $request->getUri(),
'protocol_version' => $request->getProtocolVersion(),
'headers' => $request->getHeaders(),
'body' => (string) $request->getBody(),
];
}
/**
* Deserialize a request array to a request instance.
*
* @param array $serializedRequest
* @return Request
* @throws UnexpectedValueException when cannot deserialize response
*/
public static function fromArray(array $serializedRequest)
{
try {
$uri = self::getValueFromKey($serializedRequest, 'uri');
$method = self::getValueFromKey($serializedRequest, 'method');
$body = new Stream('php://memory', 'wb+');
$body->write(self::getValueFromKey($serializedRequest, 'body'));
$headers = self::getValueFromKey($serializedRequest, 'headers');
$requestTarget = self::getValueFromKey($serializedRequest, 'request_target');
$protocolVersion = self::getValueFromKey($serializedRequest, 'protocol_version');
return (new Request($uri, $method, $body, $headers))
->withRequestTarget($requestTarget)
->withProtocolVersion($protocolVersion);
} catch (\Exception $exception) {
throw new UnexpectedValueException('Cannot deserialize request', null, $exception);
}
}
/**
* @param array $data
* @param string $key
* @param string $message
* @return mixed
* @throws UnexpectedValueException
*/
private static function getValueFromKey(array $data, $key, $message = null)
{
if (isset($data[$key])) {
return $data[$key];
}
if ($message === null) {
$message = sprintf('Missing "%s" key in serialized request', $key);
}
throw new UnexpectedValueException($message);
}
}

8
web/vendor/zendframework/zend-diactoros/src/Request/Serializer.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -76,6 +76,10 @@ final class Serializer extends AbstractSerializer
*/
public static function toString(RequestInterface $request)
{
$httpMethod = $request->getMethod();
if (empty($httpMethod)) {
throw new UnexpectedValueException('Object can not be serialized because HTTP method is empty');
}
$headers = self::serializeHeaders($request->getHeaders());
$body = (string) $request->getBody();
$format = '%s %s HTTP/%s%s%s';
@ -89,7 +93,7 @@ final class Serializer extends AbstractSerializer
return sprintf(
$format,
$request->getMethod(),
$httpMethod,
$request->getRequestTarget(),
$request->getProtocolVersion(),
$headers,

106
web/vendor/zendframework/zend-diactoros/src/RequestTrait.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -22,14 +22,11 @@ use Psr\Http\Message\UriInterface;
* the environment. As such, this trait exists to provide the common code
* between both client-side and server-side requests, and each can then
* use the headers functionality required by their implementations.
*
* @property array $headers
* @property array $headerNames
* @property StreamInterface $stream
* @method bool hasHeader(string $header)
*/
trait RequestTrait
{
use MessageTrait;
/**
* @var string
*/
@ -43,7 +40,7 @@ trait RequestTrait
private $requestTarget;
/**
* @var null|UriInterface
* @var UriInterface
*/
private $uri;
@ -52,7 +49,7 @@ trait RequestTrait
*
* Used by constructors.
*
* @param null|string $uri URI for the request, if any.
* @param null|string|UriInterface $uri URI for the request, if any.
* @param null|string $method HTTP method for the request, if any.
* @param string|resource|StreamInterface $body Message body, if any.
* @param array $headers Headers for the message, if any.
@ -60,33 +57,52 @@ trait RequestTrait
*/
private function initialize($uri = null, $method = null, $body = 'php://memory', array $headers = [])
{
if (! $uri instanceof UriInterface && ! is_string($uri) && null !== $uri) {
throw new InvalidArgumentException(
'Invalid URI provided; must be null, a string, or a Psr\Http\Message\UriInterface instance'
);
}
$this->validateMethod($method);
if (! is_string($body) && ! is_resource($body) && ! $body instanceof StreamInterface) {
throw new InvalidArgumentException(
'Body must be a string stream resource identifier, '
. 'an actual stream resource, '
. 'or a Psr\Http\Message\StreamInterface implementation'
);
}
if (is_string($uri)) {
$uri = new Uri($uri);
}
$this->method = $method ?: '';
$this->uri = $uri ?: new Uri();
$this->stream = ($body instanceof StreamInterface) ? $body : new Stream($body, 'wb+');
$this->uri = $this->createUri($uri);
$this->stream = $this->getStream($body, 'wb+');
list($this->headerNames, $headers) = $this->filterHeaders($headers);
$this->assertHeaders($headers);
$this->headers = $headers;
$this->setHeaders($headers);
// per PSR-7: attempt to set the Host header from a provided URI if no
// Host header is provided
if (! $this->hasHeader('Host') && $this->uri->getHost()) {
$this->headerNames['host'] = 'Host';
$this->headers['Host'] = [$this->getHostFromUri()];
}
}
/**
* Create and return a URI instance.
*
* If `$uri` is a already a `UriInterface` instance, returns it.
*
* If `$uri` is a string, passes it to the `Uri` constructor to return an
* instance.
*
* If `$uri is null, creates and returns an empty `Uri` instance.
*
* Otherwise, it raises an exception.
*
* @param null|string|UriInterface $uri
* @return UriInterface
* @throws InvalidArgumentException
*/
private function createUri($uri)
{
if ($uri instanceof UriInterface) {
return $uri;
}
if (is_string($uri)) {
return new Uri($uri);
}
if ($uri === null) {
return new Uri();
}
throw new InvalidArgumentException(
'Invalid URI provided; must be null, a string, or a Psr\Http\Message\UriInterface instance'
);
}
/**
@ -111,10 +127,6 @@ trait RequestTrait
return $this->requestTarget;
}
if (! $this->uri) {
return '/';
}
$target = $this->uri->getPath();
if ($this->uri->getQuery()) {
$target .= '?' . $this->uri->getQuery();
@ -249,6 +261,16 @@ trait RequestTrait
}
$new->headerNames['host'] = 'Host';
// Remove an existing host header if present, regardless of current
// de-normalization of the header name.
// @see https://github.com/zendframework/zend-diactoros/issues/91
foreach (array_keys($new->headers) as $header) {
if (strtolower($header) === 'host') {
unset($new->headers[$header]);
}
}
$new->headers['Host'] = [$host];
return $new;
@ -292,18 +314,4 @@ trait RequestTrait
$host .= $this->uri->getPort() ? ':' . $this->uri->getPort() : '';
return $host;
}
/**
* Ensure header names and values are valid.
*
* @param array $headers
* @throws InvalidArgumentException
*/
private function assertHeaders(array $headers)
{
foreach ($headers as $name => $headerValues) {
HeaderSecurity::assertValidName($name);
array_walk($headerValues, __NAMESPACE__ . '\HeaderSecurity::assertValid');
}
}
}

88
web/vendor/zendframework/zend-diactoros/src/Response.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -24,6 +24,9 @@ class Response implements ResponseInterface
{
use MessageTrait;
const MIN_STATUS_CODE_VALUE = 100;
const MAX_STATUS_CODE_VALUE = 599;
/**
* Map of standard HTTP status code/reason phrases
*
@ -42,8 +45,9 @@ class Response implements ResponseInterface
204 => 'No Content',
205 => 'Reset Content',
206 => 'Partial Content',
207 => 'Multi-status',
207 => 'Multi-Status',
208 => 'Already Reported',
226 => 'IM Used',
// REDIRECTION CODES
300 => 'Multiple Choices',
301 => 'Moved Permanently',
@ -51,8 +55,9 @@ class Response implements ResponseInterface
303 => 'See Other',
304 => 'Not Modified',
305 => 'Use Proxy',
306 => 'Switch Proxy', // Deprecated
306 => 'Switch Proxy', // Deprecated to 306 => '(Unused)'
307 => 'Temporary Redirect',
308 => 'Permanent Redirect',
// CLIENT ERROR
400 => 'Bad Request',
401 => 'Unauthorized',
@ -62,17 +67,18 @@ class Response implements ResponseInterface
405 => 'Method Not Allowed',
406 => 'Not Acceptable',
407 => 'Proxy Authentication Required',
408 => 'Request Time-out',
408 => 'Request Timeout',
409 => 'Conflict',
410 => 'Gone',
411 => 'Length Required',
412 => 'Precondition Failed',
413 => 'Request Entity Too Large',
414 => 'Request-URI Too Large',
413 => 'Payload Too Large',
414 => 'URI Too Long',
415 => 'Unsupported Media Type',
416 => 'Requested range not satisfiable',
416 => 'Range Not Satisfiable',
417 => 'Expectation Failed',
418 => 'I\'m a teapot',
421 => 'Misdirected Request',
422 => 'Unprocessable Entity',
423 => 'Locked',
424 => 'Failed Dependency',
@ -81,17 +87,22 @@ class Response implements ResponseInterface
428 => 'Precondition Required',
429 => 'Too Many Requests',
431 => 'Request Header Fields Too Large',
444 => 'Connection Closed Without Response',
451 => 'Unavailable For Legal Reasons',
// SERVER ERROR
499 => 'Client Closed Request',
500 => 'Internal Server Error',
501 => 'Not Implemented',
502 => 'Bad Gateway',
503 => 'Service Unavailable',
504 => 'Gateway Time-out',
505 => 'HTTP Version not supported',
504 => 'Gateway Timeout',
505 => 'HTTP Version Not Supported',
506 => 'Variant Also Negotiates',
507 => 'Insufficient Storage',
508 => 'Loop Detected',
510 => 'Not Extended',
511 => 'Network Authentication Required',
599 => 'Network Connect Timeout Error',
];
/**
@ -102,34 +113,19 @@ class Response implements ResponseInterface
/**
* @var int
*/
private $statusCode = 200;
private $statusCode;
/**
* @param string|resource|StreamInterface $stream Stream identifier and/or actual stream resource
* @param string|resource|StreamInterface $body Stream identifier and/or actual stream resource
* @param int $status Status code for the response, if any.
* @param array $headers Headers for the response, if any.
* @throws InvalidArgumentException on any invalid element.
*/
public function __construct($body = 'php://memory', $status = 200, array $headers = [])
{
if (! is_string($body) && ! is_resource($body) && ! $body instanceof StreamInterface) {
throw new InvalidArgumentException(
'Stream must be a string stream resource identifier, '
. 'an actual stream resource, '
. 'or a Psr\Http\Message\StreamInterface implementation'
);
}
if (null !== $status) {
$this->validateStatus($status);
}
$this->stream = ($body instanceof StreamInterface) ? $body : new Stream($body, 'wb+');
$this->statusCode = $status ? (int) $status : 200;
list($this->headerNames, $headers) = $this->filterHeaders($headers);
$this->assertHeaders($headers);
$this->headers = $headers;
$this->setStatusCode($status);
$this->stream = $this->getStream($body, 'wb+');
$this->setHeaders($headers);
}
/**
@ -159,44 +155,32 @@ class Response implements ResponseInterface
*/
public function withStatus($code, $reasonPhrase = '')
{
$this->validateStatus($code);
$new = clone $this;
$new->statusCode = (int) $code;
$new->setStatusCode($code);
$new->reasonPhrase = $reasonPhrase;
return $new;
}
/**
* Validate a status code.
* Set a valid status code.
*
* @param int|string $code
* @param int $code
* @throws InvalidArgumentException on an invalid status code.
*/
private function validateStatus($code)
private function setStatusCode($code)
{
if (! is_numeric($code)
|| is_float($code)
|| $code < 100
|| $code >= 600
|| $code < static::MIN_STATUS_CODE_VALUE
|| $code > static::MAX_STATUS_CODE_VALUE
) {
throw new InvalidArgumentException(sprintf(
'Invalid status code "%s"; must be an integer between 100 and 599, inclusive',
(is_scalar($code) ? $code : gettype($code))
'Invalid status code "%s"; must be an integer between %d and %d, inclusive',
(is_scalar($code) ? $code : gettype($code)),
static::MIN_STATUS_CODE_VALUE,
static::MAX_STATUS_CODE_VALUE
));
}
}
/**
* Ensure header names and values are valid.
*
* @param array $headers
* @throws InvalidArgumentException
*/
private function assertHeaders(array $headers)
{
foreach ($headers as $name => $headerValues) {
HeaderSecurity::assertValidName($name);
array_walk($headerValues, __NAMESPACE__ . '\HeaderSecurity::assertValid');
}
$this->statusCode = $code;
}
}

84
web/vendor/zendframework/zend-diactoros/src/Response/ArraySerializer.php vendored Normal file
View file

@ -0,0 +1,84 @@
<?php
/**
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2017 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros\Response;
use Psr\Http\Message\ResponseInterface;
use UnexpectedValueException;
use Zend\Diactoros\Response;
use Zend\Diactoros\Stream;
/**
* Serialize or deserialize response messages to/from arrays.
*
* This class provides functionality for serializing a ResponseInterface instance
* to an array, as well as the reverse operation of creating a Response instance
* from an array representing a message.
*/
final class ArraySerializer
{
/**
* Serialize a response message to an array.
*
* @param ResponseInterface $response
* @return array
*/
public static function toArray(ResponseInterface $response)
{
return [
'status_code' => $response->getStatusCode(),
'reason_phrase' => $response->getReasonPhrase(),
'protocol_version' => $response->getProtocolVersion(),
'headers' => $response->getHeaders(),
'body' => (string) $response->getBody(),
];
}
/**
* Deserialize a response array to a response instance.
*
* @param array $serializedResponse
* @return Response
* @throws UnexpectedValueException when cannot deserialize response
*/
public static function fromArray(array $serializedResponse)
{
try {
$body = new Stream('php://memory', 'wb+');
$body->write(self::getValueFromKey($serializedResponse, 'body'));
$statusCode = self::getValueFromKey($serializedResponse, 'status_code');
$headers = self::getValueFromKey($serializedResponse, 'headers');
$protocolVersion = self::getValueFromKey($serializedResponse, 'protocol_version');
$reasonPhrase = self::getValueFromKey($serializedResponse, 'reason_phrase');
return (new Response($body, $statusCode, $headers))
->withProtocolVersion($protocolVersion)
->withStatus($statusCode, $reasonPhrase);
} catch (\Exception $exception) {
throw new UnexpectedValueException('Cannot deserialize response', null, $exception);
}
}
/**
* @param array $data
* @param string $key
* @param string $message
* @return mixed
* @throws UnexpectedValueException
*/
private static function getValueFromKey(array $data, $key, $message = null)
{
if (isset($data[$key])) {
return $data[$key];
}
if ($message === null) {
$message = sprintf('Missing "%s" key in serialized request', $key);
}
throw new UnexpectedValueException($message);
}
}

2
web/vendor/zendframework/zend-diactoros/src/Response/EmitterInterface.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

2
web/vendor/zendframework/zend-diactoros/src/Response/EmptyResponse.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

5
web/vendor/zendframework/zend-diactoros/src/Response/HtmlResponse.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -41,7 +41,7 @@ class HtmlResponse extends Response
parent::__construct(
$this->createBody($html),
$status,
$this->injectContentType('text/html', $headers)
$this->injectContentType('text/html; charset=utf-8', $headers)
);
}
@ -68,6 +68,7 @@ class HtmlResponse extends Response
$body = new Stream('php://temp', 'wb+');
$body->write($html);
$body->rewind();
return $body;
}
}

2
web/vendor/zendframework/zend-diactoros/src/Response/InjectContentTypeTrait.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

23
web/vendor/zendframework/zend-diactoros/src/Response/JsonResponse.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -24,6 +24,17 @@ class JsonResponse extends Response
{
use InjectContentTypeTrait;
/**
* Default flags for json_encode; value of:
*
* <code>
* JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT | JSON_UNESCAPED_SLASHES
* </code>
*
* @const int
*/
const DEFAULT_JSON_FLAGS = 79;
/**
* Create a JSON response with the given data.
*
@ -34,6 +45,7 @@ class JsonResponse extends Response
* - JSON_HEX_APOS
* - JSON_HEX_AMP
* - JSON_HEX_QUOT
* - JSON_UNESCAPED_SLASHES
*
* @param mixed $data Data to convert to JSON.
* @param int $status Integer status code for the response; 200 by default.
@ -41,10 +53,15 @@ class JsonResponse extends Response
* @param int $encodingOptions JSON encoding options to use.
* @throws InvalidArgumentException if unable to encode the $data to JSON.
*/
public function __construct($data, $status = 200, array $headers = [], $encodingOptions = 15)
{
public function __construct(
$data,
$status = 200,
array $headers = [],
$encodingOptions = self::DEFAULT_JSON_FLAGS
) {
$body = new Stream('php://temp', 'wb+');
$body->write($this->jsonEncode($data, $encodingOptions));
$body->rewind();
$headers = $this->injectContentType('application/json', $headers);

3
web/vendor/zendframework/zend-diactoros/src/Response/RedirectResponse.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -12,7 +12,6 @@ namespace Zend\Diactoros\Response;
use InvalidArgumentException;
use Psr\Http\Message\UriInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\Stream;
/**
* Produce a redirect response.

81
web/vendor/zendframework/zend-diactoros/src/Response/SapiEmitter.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -14,6 +14,8 @@ use RuntimeException;
class SapiEmitter implements EmitterInterface
{
use SapiEmitterTrait;
/**
* Emits a response for a PHP SAPI environment.
*
@ -29,88 +31,21 @@ class SapiEmitter implements EmitterInterface
throw new RuntimeException('Unable to emit response; headers already sent');
}
$response = $this->injectContentLength($response);
$this->emitStatusLine($response);
$this->emitHeaders($response);
$this->emitBody($response, $maxBufferLevel);
}
/**
* Emit the status line.
*
* Emits the status line using the protocol version and status code from
* the response; if a reason phrase is availble, it, too, is emitted.
*
* @param ResponseInterface $response
*/
private function emitStatusLine(ResponseInterface $response)
{
$reasonPhrase = $response->getReasonPhrase();
header(sprintf(
'HTTP/%s %d%s',
$response->getProtocolVersion(),
$response->getStatusCode(),
($reasonPhrase ? ' ' . $reasonPhrase : '')
));
}
/**
* Emit response headers.
*
* Loops through each header, emitting each; if the header value
* is an array with multiple values, ensures that each is sent
* in such a way as to create aggregate headers (instead of replace
* the previous).
*
* @param ResponseInterface $response
*/
private function emitHeaders(ResponseInterface $response)
{
foreach ($response->getHeaders() as $header => $values) {
$name = $this->filterHeader($header);
$first = true;
foreach ($values as $value) {
header(sprintf(
'%s: %s',
$name,
$value
), $first);
$first = false;
}
}
$this->flush($maxBufferLevel);
$this->emitBody($response);
}
/**
* Emit the message body.
*
* Loops through the output buffer, flushing each, before emitting
* the response body using `echo()`.
*
* @param ResponseInterface $response
* @param int $maxBufferLevel Flush up to this buffer level.
*/
private function emitBody(ResponseInterface $response, $maxBufferLevel)
private function emitBody(ResponseInterface $response)
{
if (null === $maxBufferLevel) {
$maxBufferLevel = ob_get_level();
}
while (ob_get_level() > $maxBufferLevel) {
ob_end_flush();
}
echo $response->getBody();
}
/**
* Filter a header name to wordcase
*
* @param string $header
* @return string
*/
private function filterHeader($header)
{
$filtered = str_replace('-', ' ', $header);
$filtered = ucwords($filtered);
return str_replace(' ', '-', $filtered);
}
}

109
web/vendor/zendframework/zend-diactoros/src/Response/SapiEmitterTrait.php vendored Normal file
View file

@ -0,0 +1,109 @@
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros\Response;
use Psr\Http\Message\ResponseInterface;
trait SapiEmitterTrait
{
/**
* Inject the Content-Length header if is not already present.
*
* @param ResponseInterface $response
* @return ResponseInterface
*/
private function injectContentLength(ResponseInterface $response)
{
if (! $response->hasHeader('Content-Length')) {
// PSR-7 indicates int OR null for the stream size; for null values,
// we will not auto-inject the Content-Length.
if (null !== $response->getBody()->getSize()) {
return $response->withHeader('Content-Length', (string) $response->getBody()->getSize());
}
}
return $response;
}
/**
* Emit the status line.
*
* Emits the status line using the protocol version and status code from
* the response; if a reason phrase is available, it, too, is emitted.
*
* @param ResponseInterface $response
*/
private function emitStatusLine(ResponseInterface $response)
{
$reasonPhrase = $response->getReasonPhrase();
header(sprintf(
'HTTP/%s %d%s',
$response->getProtocolVersion(),
$response->getStatusCode(),
($reasonPhrase ? ' ' . $reasonPhrase : '')
));
}
/**
* Emit response headers.
*
* Loops through each header, emitting each; if the header value
* is an array with multiple values, ensures that each is sent
* in such a way as to create aggregate headers (instead of replace
* the previous).
*
* @param ResponseInterface $response
*/
private function emitHeaders(ResponseInterface $response)
{
foreach ($response->getHeaders() as $header => $values) {
$name = $this->filterHeader($header);
$first = true;
foreach ($values as $value) {
header(sprintf(
'%s: %s',
$name,
$value
), $first);
$first = false;
}
}
}
/**
* Loops through the output buffer, flushing each, before emitting
* the response.
*
* @param int|null $maxBufferLevel Flush up to this buffer level.
*/
private function flush($maxBufferLevel = null)
{
if (null === $maxBufferLevel) {
$maxBufferLevel = ob_get_level();
}
while (ob_get_level() > $maxBufferLevel) {
ob_end_flush();
}
}
/**
* Filter a header name to wordcase
*
* @param string $header
* @return string
*/
private function filterHeader($header)
{
$filtered = str_replace('-', ' ', $header);
$filtered = ucwords($filtered);
return str_replace(' ', '-', $filtered);
}
}

135
web/vendor/zendframework/zend-diactoros/src/Response/SapiStreamEmitter.php vendored Normal file
View file

@ -0,0 +1,135 @@
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros\Response;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
use Zend\Diactoros\RelativeStream;
class SapiStreamEmitter implements EmitterInterface
{
use SapiEmitterTrait;
/**
* Emits a response for a PHP SAPI environment.
*
* Emits the status line and headers via the header() function, and the
* body content via the output buffer.
*
* @param ResponseInterface $response
* @param int $maxBufferLength Maximum output buffering size for each iteration
*/
public function emit(ResponseInterface $response, $maxBufferLength = 8192)
{
if (headers_sent()) {
throw new RuntimeException('Unable to emit response; headers already sent');
}
$response = $this->injectContentLength($response);
$this->emitStatusLine($response);
$this->emitHeaders($response);
$this->flush();
$range = $this->parseContentRange($response->getHeaderLine('Content-Range'));
if (is_array($range) && $range[0] === 'bytes') {
$this->emitBodyRange($range, $response, $maxBufferLength);
return;
}
$this->emitBody($response, $maxBufferLength);
}
/**
* Emit the message body.
*
* @param ResponseInterface $response
* @param int $maxBufferLength
*/
private function emitBody(ResponseInterface $response, $maxBufferLength)
{
$body = $response->getBody();
if ($body->isSeekable()) {
$body->rewind();
}
if (! $body->isReadable()) {
echo $body;
return;
}
while (! $body->eof()) {
echo $body->read($maxBufferLength);
}
}
/**
* Emit a range of the message body.
*
* @param array $range
* @param ResponseInterface $response
* @param int $maxBufferLength
*/
private function emitBodyRange(array $range, ResponseInterface $response, $maxBufferLength)
{
list($unit, $first, $last, $length) = $range;
$body = $response->getBody();
$length = $last - $first + 1;
if ($body->isSeekable()) {
$body->seek($first);
$first = 0;
}
if (! $body->isReadable()) {
echo substr($body->getContents(), $first, $length);
return;
}
$remaining = $length;
while ($remaining >= $maxBufferLength && ! $body->eof()) {
$contents = $body->read($maxBufferLength);
$remaining -= strlen($contents);
echo $contents;
}
if ($remaining > 0 && ! $body->eof()) {
echo $body->read($remaining);
}
}
/**
* Parse content-range header
* http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.16
*
* @param string $header
* @return false|array [unit, first, last, length]; returns false if no
* content range or an invalid content range is provided
*/
private function parseContentRange($header)
{
if (preg_match('/(?P<unit>[\w]+)\s+(?P<first>\d+)-(?P<last>\d+)\/(?P<length>\d+|\*)/', $header, $matches)) {
return [
$matches['unit'],
(int) $matches['first'],
(int) $matches['last'],
$matches['length'] === '*' ? '*' : (int) $matches['length'],
];
}
return false;
}
}

11
web/vendor/zendframework/zend-diactoros/src/Response/Serializer.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -37,7 +37,7 @@ final class Serializer extends AbstractSerializer
* Parse a response from a stream.
*
* @param StreamInterface $stream
* @return ResponseInterface
* @return Response
* @throws InvalidArgumentException when the stream is not readable.
* @throws UnexpectedValueException when errors occur parsing the message.
*/
@ -54,7 +54,7 @@ final class Serializer extends AbstractSerializer
return (new Response($body, $status, $headers))
->withProtocolVersion($version)
->withStatus($status, $reasonPhrase);
->withStatus((int) $status, $reasonPhrase);
}
/**
@ -73,9 +73,8 @@ final class Serializer extends AbstractSerializer
if (! empty($headers)) {
$headers = "\r\n" . $headers;
}
if (! empty($body)) {
$headers .= "\r\n\r\n";
}
$headers .= "\r\n\r\n";
return sprintf(
$format,

74
web/vendor/zendframework/zend-diactoros/src/Response/TextResponse.php vendored Normal file
View file

@ -0,0 +1,74 @@
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros\Response;
use InvalidArgumentException;
use Psr\Http\Message\StreamInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\Stream;
/**
* Plain text response.
*
* Allows creating a response by passing a string to the constructor;
* by default, sets a status code of 200 and sets the Content-Type header to
* text/plain.
*/
class TextResponse extends Response
{
use InjectContentTypeTrait;
/**
* Create a plain text response.
*
* Produces a text response with a Content-Type of text/plain and a default
* status of 200.
*
* @param string|StreamInterface $text String or stream for the message body.
* @param int $status Integer status code for the response; 200 by default.
* @param array $headers Array of headers to use at initialization.
* @throws InvalidArgumentException if $text is neither a string or stream.
*/
public function __construct($text, $status = 200, array $headers = [])
{
parent::__construct(
$this->createBody($text),
$status,
$this->injectContentType('text/plain; charset=utf-8', $headers)
);
}
/**
* Create the message body.
*
* @param string|StreamInterface $text
* @return StreamInterface
* @throws InvalidArgumentException if $html is neither a string or stream.
*/
private function createBody($text)
{
if ($text instanceof StreamInterface) {
return $text;
}
if (! is_string($text)) {
throw new InvalidArgumentException(sprintf(
'Invalid content (%s) provided to %s',
(is_object($text) ? get_class($text) : gettype($text)),
__CLASS__
));
}
$body = new Stream('php://temp', 'wb+');
$body->write($text);
$body->rewind();
return $body;
}
}

2
web/vendor/zendframework/zend-diactoros/src/Server.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/

57
web/vendor/zendframework/zend-diactoros/src/ServerRequest.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -13,6 +13,7 @@ use InvalidArgumentException;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UploadedFileInterface;
use Psr\Http\Message\UriInterface;
/**
* Server-side HTTP request
@ -30,7 +31,7 @@ use Psr\Http\Message\UploadedFileInterface;
*/
class ServerRequest implements ServerRequestInterface
{
use MessageTrait, RequestTrait;
use RequestTrait;
/**
* @var array
@ -65,10 +66,14 @@ class ServerRequest implements ServerRequestInterface
/**
* @param array $serverParams Server parameters, typically from $_SERVER
* @param array $uploadedFiles Upload file information, a tree of UploadedFiles
* @param null|string $uri URI for the request, if any.
* @param null|string|UriInterface $uri URI for the request, if any.
* @param null|string $method HTTP method for the request, if any.
* @param string|resource|StreamInterface $body Message body, if any.
* @param array $headers Headers for the message, if any.
* @param array $cookies Cookies for the message, if any.
* @param array $queryParams Query params for the message, if any.
* @param null|array|object $parsedBody The deserialized body parameters, if any.
* @param string $protocol HTTP protocol version.
* @throws InvalidArgumentException for any invalid value.
*/
public function __construct(
@ -77,14 +82,25 @@ class ServerRequest implements ServerRequestInterface
$uri = null,
$method = null,
$body = 'php://input',
array $headers = []
array $headers = [],
array $cookies = [],
array $queryParams = [],
$parsedBody = null,
$protocol = '1.1'
) {
$this->validateUploadedFiles($uploadedFiles);
$body = $this->getStream($body);
if ($body === 'php://input') {
$body = new PhpInputStream();
}
$this->initialize($uri, $method, $body, $headers);
$this->serverParams = $serverParams;
$this->uploadedFiles = $uploadedFiles;
$this->cookieParams = $cookies;
$this->queryParams = $queryParams;
$this->parsedBody = $parsedBody;
$this->protocol = $protocol;
}
/**
@ -203,10 +219,6 @@ class ServerRequest implements ServerRequestInterface
*/
public function withoutAttribute($attribute)
{
if (! isset($this->attributes[$attribute])) {
return clone $this;
}
$new = clone $this;
unset($new->attributes[$attribute]);
return $new;
@ -248,33 +260,6 @@ class ServerRequest implements ServerRequestInterface
return $new;
}
/**
* Set the body stream
*
* @param string|resource|StreamInterface $stream
* @return StreamInterface
*/
private function getStream($stream)
{
if ($stream === 'php://input') {
return new PhpInputStream();
}
if (! is_string($stream) && ! is_resource($stream) && ! $stream instanceof StreamInterface) {
throw new InvalidArgumentException(
'Stream must be a string stream resource identifier, '
. 'an actual stream resource, '
. 'or a Psr\Http\Message\StreamInterface implementation'
);
}
if (! $stream instanceof StreamInterface) {
return new Stream($stream, 'r');
}
return $stream;
}
/**
* Recursively validate the structure in an uploaded files array.
*

104
web/vendor/zendframework/zend-diactoros/src/ServerRequestFactory.php vendored
View file

@ -3,17 +3,16 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
namespace Zend\Diactoros;
use InvalidArgumentException;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\MessageInterface;
use Psr\Http\Message\UploadedFileInterface;
use stdClass;
use UnexpectedValueException;
/**
* Class for marshaling a request object from the current PHP environment.
@ -60,19 +59,23 @@ abstract class ServerRequestFactory
$server = static::normalizeServer($server ?: $_SERVER);
$files = static::normalizeFiles($files ?: $_FILES);
$headers = static::marshalHeaders($server);
$request = new ServerRequest(
if (null === $cookies && array_key_exists('cookie', $headers)) {
$cookies = self::parseCookieHeader($headers['cookie']);
}
return new ServerRequest(
$server,
$files,
static::marshalUriFromServer($server, $headers),
static::get('REQUEST_METHOD', $server, 'GET'),
'php://input',
$headers
$headers,
$cookies ?: $_COOKIE,
$query ?: $_GET,
$body ?: $_POST,
static::marshalProtocolVersion($server)
);
return $request
->withCookieParams($cookies ?: $_COOKIE)
->withQueryParams($query ?: $_GET)
->withParsedBody($body ?: $_POST);
}
/**
@ -196,24 +199,26 @@ abstract class ServerRequestFactory
{
$headers = [];
foreach ($server as $key => $value) {
if (strpos($key, 'HTTP_COOKIE') === 0) {
// Cookies are handled using the $_COOKIE superglobal
continue;
// Apache prefixes environment variables with REDIRECT_
// if they are added by rewrite rules
if (strpos($key, 'REDIRECT_') === 0) {
$key = substr($key, 9);
// We will not overwrite existing variables with the
// prefixed versions, though
if (array_key_exists($key, $server)) {
continue;
}
}
if ($value && strpos($key, 'HTTP_') === 0) {
$name = strtr(substr($key, 5), '_', ' ');
$name = strtr(ucwords(strtolower($name)), ' ', '-');
$name = strtolower($name);
$name = strtr(strtolower(substr($key, 5)), '_', '-');
$headers[$name] = $value;
continue;
}
if ($value && strpos($key, 'CONTENT_') === 0) {
$name = substr($key, 8); // Content-
$name = 'Content-' . (($name == 'MD5') ? $name : ucfirst(strtolower($name)));
$name = strtolower($name);
$name = 'content-' . strtolower(substr($key, 8));
$headers[$name] = $value;
continue;
}
@ -267,8 +272,15 @@ abstract class ServerRequestFactory
$query = ltrim($server['QUERY_STRING'], '?');
}
// URI fragment
$fragment = '';
if (strpos($path, '#') !== false) {
list($path, $fragment) = explode('#', $path, 2);
}
return $uri
->withPath($path)
->withFragment($fragment)
->withQuery($query);
}
@ -455,4 +467,56 @@ abstract class ServerRequestFactory
}
return $normalizedFiles;
}
/**
* Return HTTP protocol version (X.Y)
*
* @param array $server
* @return string
*/
private static function marshalProtocolVersion(array $server)
{
if (! isset($server['SERVER_PROTOCOL'])) {
return '1.1';
}
if (! preg_match('#^(HTTP/)?(?P<version>[1-9]\d*(?:\.\d)?)$#', $server['SERVER_PROTOCOL'], $matches)) {
throw new UnexpectedValueException(sprintf(
'Unrecognized protocol version (%s)',
$server['SERVER_PROTOCOL']
));
}
return $matches['version'];
}
/**
* Parse a cookie header according to RFC 6265.
*
* PHP will replace special characters in cookie names, which results in other cookies not being available due to
* overwriting. Thus, the server request should take the cookies from the request header instead.
*
* @param $cookieHeader
* @return array
*/
private static function parseCookieHeader($cookieHeader)
{
preg_match_all('(
(?:^\\n?[ \t]*|;[ ])
(?P<name>[!#$%&\'*+-.0-9A-Z^_`a-z|~]+)
=
(?P<DQUOTE>"?)
(?P<value>[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*)
(?P=DQUOTE)
(?=\\n?[ \t]*$|;[ ])
)x', $cookieHeader, $matches, PREG_SET_ORDER);
$cookies = [];
foreach ($matches as $match) {
$cookies[$match['name']] = urldecode($match['value']);
}
return $cookies;
}
}

4
web/vendor/zendframework/zend-diactoros/src/Stream.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -19,7 +19,7 @@ use Psr\Http\Message\StreamInterface;
class Stream implements StreamInterface
{
/**
* @var resource
* @var resource|null
*/
protected $resource;

30
web/vendor/zendframework/zend-diactoros/src/UploadedFile.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -51,6 +51,14 @@ class UploadedFile implements UploadedFileInterface
*/
private $stream;
/**
* @param string|resource $streamOrFile
* @param int $size
* @param int $errorStatus
* @param string|null $clientFilename
* @param string|null $clientMediaType
* @throws InvalidArgumentException
*/
public function __construct($streamOrFile, $size, $errorStatus, $clientFilename = null, $clientMediaType = null)
{
if ($errorStatus === UPLOAD_ERR_OK) {
@ -134,24 +142,26 @@ class UploadedFile implements UploadedFileInterface
*/
public function moveTo($targetPath)
{
if ($this->moved) {
throw new RuntimeException('Cannot move file; already moved!');
}
if ($this->error !== UPLOAD_ERR_OK) {
throw new RuntimeException('Cannot retrieve stream due to upload error');
}
if (! is_string($targetPath)) {
throw new InvalidArgumentException(
'Invalid path provided for move operation; must be a string'
);
}
if (empty($targetPath)) {
if (! is_string($targetPath) || empty($targetPath)) {
throw new InvalidArgumentException(
'Invalid path provided for move operation; must be a non-empty string'
);
}
if ($this->moved) {
throw new RuntimeException('Cannot move file; already moved!');
$targetDirectory = dirname($targetPath);
if (! is_dir($targetDirectory) || ! is_writable($targetDirectory)) {
throw new RuntimeException(sprintf(
'The target directory `%s` does not exists or is not writable',
$targetDirectory
));
}
$sapi = PHP_SAPI;

39
web/vendor/zendframework/zend-diactoros/src/Uri.php vendored
View file

@ -3,7 +3,7 @@
* Zend Framework (http://framework.zend.com/)
*
* @see http://github.com/zendframework/zend-diactoros for the canonical source repository
* @copyright Copyright (c) 2015 Zend Technologies USA Inc. (http://www.zend.com)
* @copyright Copyright (c) 2015-2016 Zend Technologies USA Inc. (http://www.zend.com)
* @license https://github.com/zendframework/zend-diactoros/blob/master/LICENSE.md New BSD License
*/
@ -36,7 +36,7 @@ class Uri implements UriInterface
*
* @const string
*/
const CHAR_UNRESERVED = 'a-zA-Z0-9_\-\.~';
const CHAR_UNRESERVED = 'a-zA-Z0-9_\-\.~\pL';
/**
* @var int[] Array indexed by valid scheme names to their corresponding ports.
@ -306,21 +306,23 @@ class Uri implements UriInterface
*/
public function withPort($port)
{
if (! is_numeric($port)) {
if (! is_numeric($port) && $port !== null) {
throw new InvalidArgumentException(sprintf(
'Invalid port "%s" specified; must be an integer or integer string',
'Invalid port "%s" specified; must be an integer, an integer string, or null',
(is_object($port) ? get_class($port) : gettype($port))
));
}
$port = (int) $port;
if ($port !== null) {
$port = (int) $port;
}
if ($port === $this->port) {
// Do nothing if no change was made.
return clone $this;
}
if ($port < 1 || $port > 65535) {
if ($port !== null && $port < 1 || $port > 65535) {
throw new InvalidArgumentException(sprintf(
'Invalid port "%d" specified; must be a valid TCP/UDP port',
$port
@ -440,12 +442,12 @@ class Uri implements UriInterface
);
}
$this->scheme = isset($parts['scheme']) ? $this->filterScheme($parts['scheme']) : '';
$this->userInfo = isset($parts['user']) ? $parts['user'] : '';
$this->host = isset($parts['host']) ? $parts['host'] : '';
$this->port = isset($parts['port']) ? $parts['port'] : null;
$this->path = isset($parts['path']) ? $this->filterPath($parts['path']) : '';
$this->query = isset($parts['query']) ? $this->filterQuery($parts['query']) : '';
$this->scheme = isset($parts['scheme']) ? $this->filterScheme($parts['scheme']) : '';
$this->userInfo = isset($parts['user']) ? $parts['user'] : '';
$this->host = isset($parts['host']) ? $parts['host'] : '';
$this->port = isset($parts['port']) ? $parts['port'] : null;
$this->path = isset($parts['path']) ? $this->filterPath($parts['path']) : '';
$this->query = isset($parts['query']) ? $this->filterQuery($parts['query']) : '';
$this->fragment = isset($parts['fragment']) ? $this->filterFragment($parts['fragment']) : '';
if (isset($parts['pass'])) {
@ -468,11 +470,11 @@ class Uri implements UriInterface
$uri = '';
if (! empty($scheme)) {
$uri .= sprintf('%s://', $scheme);
$uri .= sprintf('%s:', $scheme);
}
if (! empty($authority)) {
$uri .= $authority;
$uri .= '//' . $authority;
}
if ($path) {
@ -505,6 +507,9 @@ class Uri implements UriInterface
private function isNonStandardPort($scheme, $host, $port)
{
if (! $scheme) {
if ($host && ! $port) {
return false;
}
return true;
}
@ -551,7 +556,7 @@ class Uri implements UriInterface
private function filterPath($path)
{
$path = preg_replace_callback(
'/(?:[^' . self::CHAR_UNRESERVED . ':@&=\+\$,\/;%]+|%(?![A-Fa-f0-9]{2}))/',
'/(?:[^' . self::CHAR_UNRESERVED . ':@&=\+\$,\/;%]+|%(?![A-Fa-f0-9]{2}))/u',
[$this, 'urlEncodeChar'],
$path
);
@ -625,7 +630,7 @@ class Uri implements UriInterface
private function filterFragment($fragment)
{
if (! empty($fragment) && strpos($fragment, '#') === 0) {
$fragment = substr($fragment, 1);
$fragment = '%23' . substr($fragment, 1);
}
return $this->filterQueryOrFragment($fragment);
@ -640,7 +645,7 @@ class Uri implements UriInterface
private function filterQueryOrFragment($value)
{
return preg_replace_callback(
'/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/\?]+|%(?![A-Fa-f0-9]{2}))/',
'/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/\?]+|%(?![A-Fa-f0-9]{2}))/u',
[$this, 'urlEncodeChar'],
$value
);

26
web/vendor/zendframework/zend-escaper/CHANGELOG.md vendored Normal file
View file

@ -0,0 +1,26 @@
# Changelog
All notable changes to this project will be documented in this file, in reverse chronological order by release.
## 2.5.2 - 2016-06-30
### Added
- [#11](https://github.com/zendframework/zend-escaper/pull/11),
[#12](https://github.com/zendframework/zend-escaper/pull/12), and
[#13](https://github.com/zendframework/zend-escaper/pull/13) prepare and
publish documentation to https://zendframework.github.io/zend-escaper/
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#3](https://github.com/zendframework/zend-escaper/pull/3) updates the
the escaping mechanism to add support for escaping characters outside the Basic
Multilingual Plane when escaping for JS, CSS, or HTML attributes.

43
web/vendor/zendframework/zend-escaper/CONDUCT.md vendored Normal file
View file

@ -0,0 +1,43 @@
# Contributor Code of Conduct
The Zend Framework project adheres to [The Code Manifesto](http://codemanifesto.com)
as its guidelines for contributor interactions.
## The Code Manifesto
We want to work in an ecosystem that empowers developers to reach their
potential — one that encourages growth and effective collaboration. A space that
is safe for all.
A space such as this benefits everyone that participates in it. It encourages
new developers to enter our field. It is through discussion and collaboration
that we grow, and through growth that we improve.
In the effort to create such a place, we hold to these values:
1. **Discrimination limits us.** This includes discrimination on the basis of
race, gender, sexual orientation, gender identity, age, nationality, technology
and any other arbitrary exclusion of a group of people.
2. **Boundaries honor us.** Your comfort levels are not everyone’s comfort
levels. Remember that, and if brought to your attention, heed it.
3. **We are our biggest assets.** None of us were born masters of our trade.
Each of us has been helped along the way. Return that favor, when and where
you can.
4. **We are resources for the future.** As an extension of #3, share what you
know. Make yourself a resource to help those that come after you.
5. **Respect defines us.** Treat others as you wish to be treated. Make your
discussions, criticisms and debates from a position of respectfulness. Ask
yourself, is it true? Is it necessary? Is it constructive? Anything less is
unacceptable.
6. **Reactions require grace.** Angry responses are valid, but abusive language
and vindictive actions are toxic. When something happens that offends you,
handle it assertively, but be respectful. Escalate reasonably, and try to
allow the offender an opportunity to explain themselves, and possibly correct
the issue.
7. **Opinions are just that: opinions.** Each and every one of us, due to our
background and upbringing, have varying opinions. The fact of the matter, is
that is perfectly acceptable. Remember this: if you respect your own
opinions, you should respect the opinions of others.
8. **To err is human.** You might not intend it, but mistakes do happen and
contribute to build experience. Tolerate honest mistakes, and don't hesitate
to apologize if you make one yourself.

5
web/vendor/zendframework/zend-escaper/CONTRIBUTING.md vendored
View file

@ -227,3 +227,8 @@ repository, we suggest doing some cleanup of these branches.
```console
$ git push {username} :<branchname>
```
## Conduct
Please see our [CONDUCT.md](CONDUCT.md) to understand expected behavior when interacting with others in the project.

5
web/vendor/zendframework/zend-escaper/README.md vendored
View file

@ -5,10 +5,9 @@
The OWASP Top 10 web security risks study lists Cross-Site Scripting (XSS) in
second place. PHP’s sole functionality against XSS is limited to two functions
of which one is commonly misapplied. Thus, the `Zend\Escaper` component was written.
of which one is commonly misapplied. Thus, the zend-escaper component was written.
It offers developers a way to escape output and defend from XSS and related
vulnerabilities by introducing contextual escaping based on peer-reviewed rules.
- File issues at https://github.com/zendframework/zend-escaper/issues
- Documentation is at http://framework.zend.com/manual/current/en/index.html#zend-escaper
- Documentation is at https://zendframework.github.io/zend-escaper/

4
web/vendor/zendframework/zend-escaper/composer.json vendored
View file

@ -13,7 +13,7 @@
}
},
"require": {
"php": ">=5.3.23"
"php": ">=5.5"
},
"minimum-stability": "dev",
"prefer-stable": true,
@ -32,4 +32,4 @@
"fabpot/php-cs-fixer": "1.7.*",
"phpunit/PHPUnit": "~4.0"
}
}
}

21
web/vendor/zendframework/zend-escaper/doc/book/configuration.md vendored Normal file
View file

@ -0,0 +1,21 @@
# Configuration
`Zend\Escaper\Escaper` has only one configuration option available, and that is
the encoding to be used by the `Escaper` instance.
The default encoding is **utf-8**. Other supported encodings are:
- iso-8859-1
- iso-8859-5
- iso-8859-15
- cp866, ibm866, 866
- cp1251, windows-1251
- cp1252, windows-1252
- koi8-r, koi8-ru
- big5, big5-hkscs, 950, gb2312, 936
- shift\_jis, sjis, sjis-win, cp932
- eucjp, eucjp-win
- macroman
If an unsupported encoding is passed to `Zend\Escaper\Escaper`, a
`Zend\Escaper\Exception\InvalidArgumentException` will be thrown.

74
web/vendor/zendframework/zend-escaper/doc/book/escaping-css.md vendored Normal file
View file

@ -0,0 +1,74 @@
# Escaping Cascading Style Sheets
CSS is similar to [escaping Javascript](escaping-javascript.md). CSS escaping
excludes only basic alphanumeric characters and escapes all other characters
into valid CSS hexadecimal escapes.
## Example of Bad CSS Escaping
In most cases developers forget to escape CSS completely:
```php
<?php header('Content-Type: application/xhtml+xml; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
body {
background-image: url('http://example.com/foo.jpg?</style><script>alert(1)</script>');
}
INPUT;
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Unescaped CSS</title>
<meta charset="UTF-8"/>
<style>
<?= $input ?>
</style>
</head>
<body>
<p>User controlled CSS needs to be properly escaped!</p>
</body>
</html>
```
In the above example, by failing to escape the user provided CSS, an attacker
can execute an XSS attack fairly easily.
## Example of Good CSS Escaping
By using `escapeCss()` method in the CSS context, such attacks can be prevented:
```php
<?php header('Content-Type: application/xhtml+xml; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
body {
background-image: url('http://example.com/foo.jpg?</style><script>alert(1)</script>');
}
INPUT;
$escaper = new Zend\Escaper\Escaper('utf-8');
$output = $escaper->escapeCss($input);
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Escaped CSS</title>
<meta charset="UTF-8"/>
<style>
<?php
// output will look something like
// body\20 \7B \A \20 \20 \20 \20 background\2D image\3A \20 url\28 ...
echo $output;
?>
</style>
</head>
<body>
<p>User controlled CSS needs to be properly escaped!</p>
</body>
</html>
```
By properly escaping user controlled CSS, we can prevent XSS attacks in our web
applications.

128
web/vendor/zendframework/zend-escaper/doc/book/escaping-html-attributes.md vendored Normal file
View file

@ -0,0 +1,128 @@
# Escaping HTML Attributes
Escaping data in **HTML Attribute** contexts is most often done incorrectly, if
not overlooked completely by developers. Regular [HTML
escaping](escaping-html.md) can be used for escaping HTML attributes *only* if
the attribute value can be **guaranteed as being properly quoted**! To avoid
confusion, we recommend always using the HTML Attribute escaper method when
dealing with HTTP attributes specifically.
To escape data for an HTML Attribute, use `Zend\Escaper\Escaper`'s
`escapeHtmlAttr()` method. Internally it will convert the data to UTF-8, check
for its validity, and use an extended set of characters to escape that are not
covered by `htmlspecialchars()` to cover the cases where an attribute might be
unquoted or quoted illegally.
## Examples of Bad HTML Attribute Escaping
An example of incorrect HTML attribute escaping:
```php
<?php header('Content-Type: text/html; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
' onmouseover='alert(/ZF2!/);
INPUT;
/**
* NOTE: This is equivalent to using htmlspecialchars($input, ENT_COMPAT)
*/
$output = htmlspecialchars($input);
?>
<html>
<head>
<title>Single Quoted Attribute</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<div>
<?php
// the span tag will look like:
// <span title='' onmouseover='alert(/ZF2!/);'>
?>
<span title='<?= $output ?>'>
What framework are you using?
</span>
</div>
</body>
</html>
```
In the above example, the default `ENT_COMPAT` flag is being used, which does
not escape single quotes, thus resulting in an alert box popping up when the
`onmouseover` event happens on the `span` element.
Another example of incorrect HTML attribute escaping can happen when unquoted
attributes are used (which is, by the way, perfectly valid HTML5):
```php
<?php header('Content-Type: text/html; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
faketitle onmouseover=alert(/ZF2!/);
INPUT;
// Tough luck using proper flags when the title attribute is unquoted!
$output = htmlspecialchars($input, ENT_QUOTES);
?>
<html>
<head>
<title>Quoteless Attribute</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<div>
<?php
// the span tag will look like:
// <span title=faketitle onmouseover=alert(/ZF2!/);>
?>
<span title=<?= $output ?>>
What framework are you using?
</span>
</div>
</body>
</html>
```
The above example shows how it is easy to break out from unquoted attributes in
HTML5.
## Example of Good HTML Attribute Escaping
Both of the previous examples can be avoided by simply using the
`escapeHtmlAttr()` method:
```php
<?php header('Content-Type: text/html; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
faketitle onmouseover=alert(/ZF2!/);
INPUT;
$escaper = new Zend\Escaper\Escaper('utf-8');
$output = $escaper->escapeHtmlAttr($input);
?>
<html>
<head>
<title>Quoteless Attribute</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<div>
<?php
// the span tag will look like:
// <span title=faketitle&#x20;onmouseover&#x3D;alert&#x28;&#x2F;ZF2&#x21;&#x2F;&#x29;&#x3B;>
?>
<span title=<?= $output ?>>
What framework are you using?
</span>
</div>
</body>
</html>
```
In the above example, the malicious input from the attacker becomes completely
harmless as we used proper HTML attribute escaping!

74
web/vendor/zendframework/zend-escaper/doc/book/escaping-html.md vendored Normal file
View file

@ -0,0 +1,74 @@
# Escaping HTML
Probably the most common escaping happens for **HTML body** contexts. There are
very few characters with special meaning in this context, yet it is quite common
to escape data incorrectly, namely by setting the wrong flags and character
encoding.
For escaping data to use within an HTML body context, use
`Zend\Escaper\Escaper`'s `escapeHtml()` method. Internally it uses PHP's
`htmlspecialchars()`, correctly setting the flags and encoding for you.
```php
// Outputting this without escaping would be a bad idea!
$input = '<script>alert("zf2")</script>';
$escaper = new Zend\Escaper\Escaper('utf-8');
// somewhere in an HTML template
<div class="user-provided-input">
<?= $escaper->escapeHtml($input) // all safe! ?>
</div>
```
One thing a developer needs to pay special attention to is the encoding in which
the document is served to the client, as it **must be the same** as the encoding
used for escaping!
## Example of Bad HTML Escaping
An example of incorrect usage:
```php
<?php
$input = '<script>alert("zf2")</script>';
$escaper = new Zend\Escaper\Escaper('utf-8');
?>
<?php header('Content-Type: text/html; charset=ISO-8859-1'); ?>
<!DOCTYPE html>
<html>
<head>
<title>Encodings set incorrectly!</title>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
</head>
<body>
<?php
// Bad! The escaper's and the document's encodings are different!
echo $escaper->escapeHtml($input);
?>
</body>
```
## Example of Good HTML Escaping
An example of correct usage:
```php
<?php
$input = '<script>alert("zf2")</script>';
$escaper = new Zend\Escaper\Escaper('utf-8');
?>
<?php header('Content-Type: text/html; charset=UTF-8'); ?>
<!DOCTYPE html>
<html>
<head>
<title>Encodings set correctly!</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<?php
// Good! The escaper's and the document's encodings are same!
echo $escaper->escapeHtml($input);
?>
</body>
```

93
web/vendor/zendframework/zend-escaper/doc/book/escaping-javascript.md vendored Normal file
View file

@ -0,0 +1,93 @@
# Escaping Javascript
Javascript string literals in HTML are subject to significant restrictions due
to the potential for unquoted attributes and uncertainty as to whether
Javascript will be viewed as being `CDATA` or `PCDATA` by the browser. To
eliminate any possible XSS vulnerabilities, Javascript escaping for HTML extends
the escaping rules of both ECMAScript and JSON to include any potentially
dangerous character. Very similar to HTML attribute value escaping, this means
escaping everything except basic alphanumeric characters and the comma, period,
and underscore characters as hexadecimal or unicode escapes.
Javascript escaping applies to all literal strings and digits. It is not
possible to safely escape other Javascript markup.
To escape data in the **Javascript context**, use `Zend\Escaper\Escaper`'s
`escapeJs()` method. An extended set of characters are escaped beyond
ECMAScript's rules for Javascript literal string escaping in order to prevent
misinterpretation of Javascript as HTML leading to the injection of special
characters and entities.
## Example of Bad Javascript Escaping
An example of incorrect Javascript escaping:
```php
<?php header('Content-Type: application/xhtml+xml; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
bar&quot;; alert(&quot;Meow!&quot;); var xss=&quot;true
INPUT;
$output = json_encode($input);
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Unescaped Entities</title>
<meta charset="UTF-8"/>
<script type="text/javascript">
<?php
// this will result in
// var foo = "bar&quot;; alert(&quot;Meow!&quot;); var xss=&quot;true";
?>
var foo = <?= $output ?>;
</script>
</head>
<body>
<p>json_encode() is not good for escaping javascript!</p>
</body>
</html>
```
The above example will show an alert popup box as soon as the page is loaded,
because the data is not properly escaped for the Javascript context.
## Example of Good Javascript Escaping
By using the `escapeJs()` method in the Javascript context, such attacks can be
prevented:
```php
<?php header('Content-Type: text/html; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
bar&quot;; alert(&quot;Meow!&quot;); var xss=&quot;true
INPUT;
$escaper = new Zend\Escaper\Escaper('utf-8');
$output = $escaper->escapeJs($input);
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Escaped Entities</title>
<meta charset="UTF-8"/>
<script type="text/javascript">
<?php
// this will look like
// var foo =
bar\x26quot\x3B\x3B\x20alert\x28\x26quot\x3BMeow\x21\x26quot\x3B\x29\x3B\x20var\x20xss\x3D\x26quot\x3Btrue;
?>
var foo = <?= $output ?>;
</script>
</head>
<body>
<p>Zend\Escaper\Escaper::escapeJs() is good for escaping javascript!</p>
</body>
</html>
```
In the above example, the Javascript parser will most likely report a
`SyntaxError`, but at least the targeted application remains safe from such
attacks.

57
web/vendor/zendframework/zend-escaper/doc/book/escaping-url.md vendored Normal file
View file

@ -0,0 +1,57 @@
# Escaping URLs
This method is basically an alias for PHP's `rawurlencode()` which has applied
RFC 3986 since PHP 5.3. It is included primarily for consistency.
URL escaping applies to data being inserted into a URL and not to the whole URL
itself.
## Example of Bad URL Escaping
XSS attacks are easy if data inserted into URLs is not escaped properly:
```php
<?php header('Content-Type: application/xhtml+xml; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
" onmouseover="alert('zf2')
INPUT;
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Unescaped URL data</title>
<meta charset="UTF-8"/>
</head>
<body>
<a href="http://example.com/?name=<?= $input ?>">Click here!</a>
</body>
</html>
```
## Example of Good URL Escaping
By properly escaping data in URLs by using `escapeUrl()`, we can prevent XSS
attacks:
```php
<?php header('Content-Type: application/xhtml+xml; charset=UTF-8'); ?>
<!DOCTYPE html>
<?php
$input = <<<INPUT
" onmouseover="alert('zf2')
INPUT;
$escaper = new Zend\Escaper\Escaper('utf-8');
$output = $escaper->escapeUrl($input);
?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Unescaped URL data</title>
<meta charset="UTF-8"/>
</head>
<body>
<a href="http://example.com/?name=<?= $output ?>">Click here!</a>
</body>
</html>
```

10
web/vendor/zendframework/zend-escaper/doc/book/index.html vendored Normal file
View file

@ -0,0 +1,10 @@
<div class="container">
<div class="jumbotron">
<h1>zend-escaper</h1>
<p>Securely and safely escape HTML, HTML attributes, JavaScript, CSS, and URLs.</p>
<pre><code class="language-bash">$ composer require zendframework/zend-escaper</code></pre>
</div>
</div>

1
web/vendor/zendframework/zend-escaper/doc/book/index.md vendored Symbolic link
View file

@ -0,0 +1 @@
../../README.md

51
web/vendor/zendframework/zend-escaper/doc/book/intro.md vendored Normal file
View file

@ -0,0 +1,51 @@
# Introduction
The [OWASP Top 10 web security risks](https://www.owasp.org/index.php/Top_10_2010-Main)
study lists Cross-Site Scripting (XSS) in second place. PHP's sole functionality
against XSS is limited to two functions of which one is commonly misapplied.
Thus, the zend-escaper component was written. It offers developers a way to
escape output and defend from XSS and related vulnerabilities by introducing
**contextual escaping based on peer-reviewed rules**.
zend-escaper was written with ease of use in mind, so it can be used completely stand-alone from
the rest of the framework, and as such can be installed with Composer:
```bash
$ composer install zendframework/zend-escaper
```
Several Zend Framework components provide integrations for consuming
zend-escaper, including [zend-view](https://github.com/zendframework/zend-view),
which provides a set of helpers that consume it.
> ### Security
>
> zend-escaper is a security related component. As such, if you believe you have
> found an issue, we ask that you follow our [Security Policy](http://framework.zend.com/security/)
> and report security issues accordingly. The Zend Framework team and the
> contributors thank you in advance.
## Overview
zend-escaper provides one class, `Zend\Escaper\Escaper`, which in turn provides
five methods for escaping output. Which method to use depends on the context in
which the output is used. It is up to the developer to use the right methods in
the right context.
`Zend\Escaper\Escaper` has the following escaping methods available for each context:
- `escapeHtml`: escape a string for an HTML body context.
- `escapeHtmlAttr`: escape a string for an HTML attribute context.
- `escapeJs`: escape a string for a Javascript context.
- `escapeCss`: escape a string for a CSS context.
- `escapeUrl`: escape a string for a URI or URI parameter context.
Usage of each method will be discussed in detail in later chapters.
## What zend-Escaper is not
zend-escaper is meant to be used only for *escaping data for output*, and as
such should not be misused for *filtering input data*. For such tasks, use
[zend-filter](https://zendframework.github.io/zend-filter/),
[HTMLPurifier](http://htmlpurifier.org/) or PHP's
[Filter](http://php.net/filter) functionality should be used.

147
web/vendor/zendframework/zend-escaper/doc/book/theory-of-operation.md vendored Normal file
View file

@ -0,0 +1,147 @@
# Theory of Operation
zend-escaper provides methods for escaping output data, dependent on the context
in which the data will be used. Each method is based on peer-reviewed rules and
is in compliance with the current OWASP recommendations.
The escaping follows a well-known and fixed set of encoding rules defined by
OWASP for each key HTML context. These rules cannot be impacted or negated by
browser quirks or edge-case HTML parsing unless the browser suffers a
catastrophic bug in its HTML parser or Javascript interpreter &mdash; both of
these are unlikely.
The contexts in which zend-escaper should be used are **HTML Body**, **HTML
Attribute**, **Javascript**, **CSS**, and **URL/URI** contexts.
Every escaper method will take the data to be escaped, make sure it is utf-8
encoded data (or try to convert it to utf-8), perform context-based escaping,
encode the escaped data back to its original encoding, and return the data to
the caller.
The actual escaping of the data differs between each method; they all have their
own set of rules according to which escaping is performed. An example will allow
us to clearly demonstrate the difference, and how the same characters are being
escaped differently between contexts:
```php
$escaper = new Zend\Escaper\Escaper('utf-8');
// &lt;script&gt;alert(&quot;zf2&quot;)&lt;/script&gt;
echo $escaper->escapeHtml('<script>alert("zf2")</script>');
// &lt;script&gt;alert&#x28;&quot;zf2&quot;&#x29;&lt;&#x2F;script&gt;
echo $escaper->escapeHtmlAttr('<script>alert("zf2")</script>');
// \x3Cscript\x3Ealert\x28\x22zf2\x22\x29\x3C\x2Fscript\x3E
echo $escaper->escapeJs('<script>alert("zf2")</script>');
// \3C script\3E alert\28 \22 zf2\22 \29 \3C \2F script\3E
echo $escaper->escapeCss('<script>alert("zf2")</script>');
// %3Cscript%3Ealert%28%22zf2%22%29%3C%2Fscript%3E
echo $escaper->escapeUrl('<script>alert("zf2")</script>');
```
More detailed examples will be given in later chapters.
## The Problem with Inconsistent Functionality
At present, programmers orient towards the following PHP functions for each
common HTML context:
- **HTML Body**: `htmlspecialchars()` or `htmlentities()`
- **HTML Attribute**: `htmlspecialchars()` or `htmlentities()`
- **Javascript**: `addslashes()` or `json_encode()`
- **CSS**: n/a
- **URL/URI**: `rawurlencode()` or `urlencode()`
In practice, these decisions appear to depend more on what PHP offers, and if it
can be interpreted as offering sufficient escaping safety, than it does on what
is recommended in reality to defend against XSS. While these functions can
prevent some forms of XSS, they do not cover all use cases or risks and are
therefore insufficient defenses.
Using `htmlspecialchars()` in a perfectly valid HTML5 unquoted attribute value,
for example, is completely useless since the value can be terminated by a space
(among other things), which is never escaped. Thus, in this instance, we have a
conflict between a widely used HTML escaper and a modern HTML specification,
with no specific function available to cover this use case. While it's tempting
to blame users, or the HTML specification authors, escaping just needs to deal
with whatever HTML and browsers allow.
Using `addslashes()`, custom backslash escaping, or `json_encode()` will
typically ignore HTML special characters such as ampersands, which may be used
to inject entities into Javascript. Under the right circumstances, the browser
will convert these entities into their literal equivalents before interpreting
Javascript, thus allowing attackers to inject arbitrary code.
Inconsistencies with valid HTML, insecure default parameters, lack of character
encoding awareness, and misrepresentations of what functions are capable of by
some programmers &mdash; these all make escaping in PHP an unnecessarily
convoluted quest.
To circumvent the lack of escaping methods in PHP, zend-escaper addresses the
need to apply context-specific escaping in web applications. It implements
methods that specifically target XSS and offers programmers a tool to secure
their applications without misusing other inadequate methods, or using, most
likely incomplete, home-grown solutions.
## Why Contextual Escaping?
To understand why multiple standardised escaping methods are needed, what
follows are several quick points; they are by no means a complete set of
reasons, however!
### HTML escaping of unquoted HTML attribute values still allows XSS
This is probably the best known way to defeat `htmlspecialchars()` when used on
attribute values, since any space (or character interpreted as a space &mdash;
there are a lot) lets you inject new attributes whose content can't be
neutralised by HTML escaping. The solution (where this is possible) is
additional escaping as defined by the OWASP ESAPI codecs. The point here can be
extended further &mdash; escaping only works if a programmer or designer knows
what they're doing. In many contexts, there are additional practices and gotchas
that need to be carefully monitored since escaping sometimes needs a little
extra help to protect against XSS &mdash; even if that means ensuring all
attribute values are properly double quoted despite this not being required for
valid HTML.
### HTML escaping of CSS, Javascript or URIs is often reversed when passed to non-HTML interpreters by the browser
HTML escaping is just that &mdsash; it's designed to escape a string for HTML
(i.e. prevent tag or attribute insertion), but not alter the underlying meaning
of the content, whether it be text, Javascript, CSS, or URIs. For that purpose,
a fully HTML-escaped version of any other context may still have its unescaped
form extracted before it's interpreted or executed. For this reason we need
separate escapers for Javascript, CSS, and URIs, and developers or designers
writing templates **must** know which escaper to apply to which context. Of
course, this means you need to be able to identify the correct context before
selecting the right escaper!
### DOM-based XSS requires a defence using at least two levels of different escaping in many cases
DOM-based XSS has become increasingly common as Javascript has taken off in
popularity for large scale client-side coding. A simple example is Javascript
defined in a template which inserts a new piece of HTML text into the DOM. If
the string is only HTML escaped, it may still contain Javascript that will
execute in that context. If the string is only Javascript-escaped, it may
contain HTML markup (new tags and attributes) which will be injected into the
DOM and parsed once the inserting Javascript executes. Damned either way? The
solution is to escape twice &mdash; first escape the string for HTML (make it
safe for DOM insertion), and then for Javascript (make it safe for the current
Javascript context). Nested contexts are a common means of bypassing naive
escaping habits (e.g. you can inject Javascript into a CSS expression within an
HTML attribute).
### PHP has no known anti-XSS escape functions (only those kidnapped from their original purposes)
A simple example, widely used, is when you see `json_encode()` used to escape
Javascript, or worse, some kind of mutant `addslashes()` implementation. These
were never designed to eliminate XSS, yet PHP programmers use them as such. For
example, `json_encode()` does not escape the ampersand or semi-colon characters
by default. That means you can easily inject HTML entities which could then be
decoded before the Javascript is evaluated in a HTML document. This lets you
break out of strings, add new JS statements, close tags, etc. In other words,
using `json_encode()` is insufficient and naive. The same, arguably, could be
said for `htmlspecialchars()` which has its own well known limitations that make
a singular reliance on it a questionable practice.

17
web/vendor/zendframework/zend-escaper/mkdocs.yml vendored Normal file
View file

@ -0,0 +1,17 @@
docs_dir: doc/book
site_dir: doc/html
pages:
- index.md
- Intro: intro.md
- Reference:
- "Theory of Operation": theory-of-operation.md
- Configuration: configuration.md
- "Escaping HTML": escaping-html.md
- "Escaping HTML Attributes": escaping-html-attributes.md
- "Escaping Javascript": escaping-javascript.md
- "Escaping CSS": escaping-css.md
- "Escaping URLs": escaping-url.md
site_name: zend-escaper
site_description: zend-escaper
repo_url: 'https://github.com/zendframework/zend-escaper'
copyright: 'Copyright (c) 2016 <a href="http://www.zend.com/">Zend Technologies USA Inc.</a>'

42
web/vendor/zendframework/zend-escaper/src/Escaper.php vendored
View file

@ -24,12 +24,12 @@ class Escaper
*
* @var array
*/
protected static $htmlNamedEntityMap = array(
protected static $htmlNamedEntityMap = [
34 => 'quot', // quotation mark
38 => 'amp', // ampersand
60 => 'lt', // less-than sign
62 => 'gt', // greater-than sign
);
];
/**
* Current encoding for escaping. If not UTF-8, we convert strings from this encoding
@ -41,13 +41,11 @@ class Escaper
/**
* Holds the value of the special flags passed as second parameter to
* htmlspecialchars(). We modify these for PHP 5.4 to take advantage
* of the new ENT_SUBSTITUTE flag for correctly dealing with invalid
* UTF-8 sequences.
* htmlspecialchars().
*
* @var string
* @var int
*/
protected $htmlSpecialCharsFlags = ENT_QUOTES;
protected $htmlSpecialCharsFlags;
/**
* Static Matcher which escapes characters for HTML Attribute contexts
@ -75,7 +73,7 @@ class Escaper
*
* @var array
*/
protected $supportedEncodings = array(
protected $supportedEncodings = [
'iso-8859-1', 'iso8859-1', 'iso-8859-5', 'iso8859-5',
'iso-8859-15', 'iso8859-15', 'utf-8', 'cp866',
'ibm866', '866', 'cp1251', 'windows-1251',
@ -85,12 +83,11 @@ class Escaper
'big5-hkscs', 'shift_jis', 'sjis', 'sjis-win',
'cp932', '932', 'euc-jp', 'eucjp',
'eucjp-win', 'macroman'
);
];
/**
* Constructor: Single parameter allows setting of global encoding for use by
* the current object. If PHP 5.4 is detected, additional ENT_SUBSTITUTE flag
* is set for htmlspecialchars() calls.
* the current object.
*
* @param string $encoding
* @throws Exception\InvalidArgumentException
@ -116,14 +113,13 @@ class Escaper
$this->encoding = $encoding;
}
if (defined('ENT_SUBSTITUTE')) {
$this->htmlSpecialCharsFlags|= ENT_SUBSTITUTE;
}
// We take advantage of ENT_SUBSTITUTE flag to correctly deal with invalid UTF-8 sequences.
$this->htmlSpecialCharsFlags = ENT_QUOTES | ENT_SUBSTITUTE;
// set matcher callbacks
$this->htmlAttrMatcher = array($this, 'htmlAttrMatcher');
$this->jsMatcher = array($this, 'jsMatcher');
$this->cssMatcher = array($this, 'cssMatcher');
$this->htmlAttrMatcher = [$this, 'htmlAttrMatcher'];
$this->jsMatcher = [$this, 'jsMatcher'];
$this->cssMatcher = [$this, 'cssMatcher'];
}
/**
@ -248,7 +244,7 @@ class Escaper
* replace it with while grabbing the integer value of the character.
*/
if (strlen($chr) > 1) {
$chr = $this->convertEncoding($chr, 'UTF-16BE', 'UTF-8');
$chr = $this->convertEncoding($chr, 'UTF-32BE', 'UTF-8');
}
$hex = bin2hex($chr);
@ -281,7 +277,13 @@ class Escaper
return sprintf('\\x%02X', ord($chr));
}
$chr = $this->convertEncoding($chr, 'UTF-16BE', 'UTF-8');
return sprintf('\\u%04s', strtoupper(bin2hex($chr)));
$hex = strtoupper(bin2hex($chr));
if (strlen($hex) <= 4) {
return sprintf('\\u%04s', $hex);
}
$highSurrogate = substr($hex, 0, 4);
$lowSurrogate = substr($hex, 4, 4);
return sprintf('\\u%04s\\u%04s', $highSurrogate, $lowSurrogate);
}
/**
@ -297,7 +299,7 @@ class Escaper
if (strlen($chr) == 1) {
$ord = ord($chr);
} else {
$chr = $this->convertEncoding($chr, 'UTF-16BE', 'UTF-8');
$chr = $this->convertEncoding($chr, 'UTF-32BE', 'UTF-8');
$ord = hexdec(bin2hex($chr));
}
return sprintf('\\%X ', $ord);

100
web/vendor/zendframework/zend-feed/CHANGELOG.md vendored
View file

@ -2,12 +2,94 @@
All notable changes to this project will be documented in this file, in reverse chronological order by release.
## 2.5.2 - TBD
## 2.8.0 - 2017-04-02
### Added
- [#27](https://github.com/zendframework/zend-feed/pull/27) adds a documentation
chapter demonstrating wrapping a PSR-7 client to use with `Zend\Feed\Reader`.
- [#22](https://github.com/zendframework/zend-feed/pull/22) adds missing
ExtensionManagerInterface on Writer\ExtensionPluginManager.
- [#32](https://github.com/zendframework/zend-feed/pull/32) adds missing
ExtensionManagerInterface on Reader\ExtensionPluginManager.
### Deprecated
- Nothing.
### Removed
- [#38](https://github.com/zendframework/zend-feed/pull/38) dropped php 5.5
support
### Fixed
- [#35](https://github.com/zendframework/zend-feed/pull/35) fixed
"A non-numeric value encountered" in php 7.1
- [#39](https://github.com/zendframework/zend-feed/pull/39) fixed protocol
relative link absolutisation
- [#40](https://github.com/zendframework/zend-feed/pull/40) fixed service
manager v3 compatibility aliases in extension plugin managers
## 2.7.0 - 2016-02-11
### Added
- [#21](https://github.com/zendframework/zend-feed/pull/21) edits, revises, and
prepares the documentation for publication at https://zendframework.github.io/zend-feed/
### Deprecated
- Nothing.
### Removed
- Nothing.
### Fixed
- [#20](https://github.com/zendframework/zend-feed/pull/20) makes the two
zend-servicemanager extension manager implementations forwards compatible
with version 3, and the overall code base forwards compatible with zend-stdlib
v3.
## 2.6.0 - 2015-11-24
### Added
- [#13](https://github.com/zendframework/zend-feed/pull/13) introduces
`Zend\Feed\Writer\StandaloneExtensionManager`, an implementation of
`Zend\Feed\Writer\ExtensionManagerInterface` that has no dependencies.
`Zend\Feed\Writer\ExtensionManager` now composes this by default, instead of
`Zend\Feed\Writer\ExtensionPluginManager`, for managing the various feed and
entry extensions. If you relied on `ExtensionPluginManager` previously, you
will need to create an instance manually and inject it into the `Writer`
instance.
- [#14](https://github.com/zendframework/zend-feed/pull/14) introduces:
- `Zend\Feed\Reader\Http\HeaderAwareClientInterface`, which extends
`ClientInterface` and adds an optional argument to the `get()` method,
`array $headers = []`; this argument allows specifying request headers for
the client to send. `$headers` should have header names for keys, and the
values should be arrays of strings/numbers representing the header values
(if only a single value is necessary, it should be represented as an single
value array).
- `Zend\Feed\Reader\Http\HeaderAwareResponseInterface`, which extends
`ResponseInterface` and adds the method `getHeader($name, $default = null)`.
Clients may return either a `ResponseInterface` or
`HeaderAwareResponseInterface` instance.
- `Zend\Feed\Reader\Http\Response`, which is an implementation of
`HeaderAwareResponseInterface`. Its constructor accepts the status code,
body, and, optionally, headers.
- `Zend\Feed\Reader\Http\Psr7ResponseDecorator`, which is an implementation of
`HeaderAwareResponseInterface`. Its constructor accepts a PSR-7 response
instance, and the various methdos then proxy to those methods. This should
make creating wrappers for PSR-7 HTTP clients trivial.
- `Zend\Feed\Reader\Http\ZendHttpClientDecorator`, which decorates a
`Zend\Http\Client` instance, implements `HeaderAwareClientInterface`, and
returns a `Response` instance seeded from the zend-http response upon
calling `get()`. The class exposes a `getDecoratedClient()` method to allow
retrieval of the decorated zend-http client instance.
### Deprecated
- Nothing.
@ -23,3 +105,19 @@ All notable changes to this project will be documented in this file, in reverse
- [#2](https://github.com/zendframework/zend-feed/pull/2) ensures that the
routine for "absolutising" a link in `Reader\FeedSet` always generates a URI
with a scheme.
- [#14](https://github.com/zendframework/zend-feed/pull/14) makes the following
changes to fix behavior around HTTP clients used within
`Zend\Feed\Reader\Reader`:
- `setHttpClient()` now ensures that the passed client is either a
`Zend\Feed\Reader\Http\ClientInterface` or `Zend\Http\Client`, raising an
`InvalidArgumentException` if neither. If a `Zend\Http\Client` is passed, it
is passed to the constructor of `Zend\Feed\Reader\Http\ZendHttpClientDecorator`,
and the decorator instance is used.
- `getHttpClient()` now *always* returns a `Zend\Feed\Reader\Http\ClientInterface`
instance. If no instance is currently registered, it lazy loads a
`ZendHttpClientDecorator` instance.
- `import()` was updated to consume a `ClientInterface` instance; when caches
are in play, it checks the client against `HeaderAwareClientInterface` to
determine if it can check for HTTP caching headers, and, if so, to retrieve
them.
- `findFeedLinks()` was updated to consume a `ClientInterface`.

43
web/vendor/zendframework/zend-feed/CONDUCT.md vendored Normal file
View file

@ -0,0 +1,43 @@
# Contributor Code of Conduct
The Zend Framework project adheres to [The Code Manifesto](http://codemanifesto.com)
as its guidelines for contributor interactions.
## The Code Manifesto
We want to work in an ecosystem that empowers developers to reach their
potential — one that encourages growth and effective collaboration. A space that
is safe for all.
A space such as this benefits everyone that participates in it. It encourages
new developers to enter our field. It is through discussion and collaboration
that we grow, and through growth that we improve.
In the effort to create such a place, we hold to these values:
1. **Discrimination limits us.** This includes discrimination on the basis of
race, gender, sexual orientation, gender identity, age, nationality, technology
and any other arbitrary exclusion of a group of people.
2. **Boundaries honor us.** Your comfort levels are not everyone’s comfort
levels. Remember that, and if brought to your attention, heed it.
3. **We are our biggest assets.** None of us were born masters of our trade.
Each of us has been helped along the way. Return that favor, when and where
you can.
4. **We are resources for the future.** As an extension of #3, share what you
know. Make yourself a resource to help those that come after you.
5. **Respect defines us.** Treat others as you wish to be treated. Make your
discussions, criticisms and debates from a position of respectfulness. Ask
yourself, is it true? Is it necessary? Is it constructive? Anything less is
unacceptable.
6. **Reactions require grace.** Angry responses are valid, but abusive language
and vindictive actions are toxic. When something happens that offends you,
handle it assertively, but be respectful. Escalate reasonably, and try to
allow the offender an opportunity to explain themselves, and possibly correct
the issue.
7. **Opinions are just that: opinions.** Each and every one of us, due to our
background and upbringing, have varying opinions. The fact of the matter, is
that is perfectly acceptable. Remember this: if you respect your own
opinions, you should respect the opinions of others.
8. **To err is human.** You might not intend it, but mistakes do happen and
contribute to build experience. Tolerate honest mistakes, and don't hesitate
to apologize if you make one yourself.

19
web/vendor/zendframework/zend-feed/CONTRIBUTING.md vendored
View file

@ -77,24 +77,24 @@ To do so:
## Running Coding Standards Checks
This component uses [php-cs-fixer](http://cs.sensiolabs.org/) for coding
This component uses [phpcs](https://github.com/squizlabs/PHP_CodeSniffer) for coding
standards checks, and provides configuration for our selected checks.
`php-cs-fixer` is installed by default via Composer.
`phpcs` is installed by default via Composer.
To run checks only:
```console
$ ./vendor/bin/php-cs-fixer fix . -v --diff --dry-run --config-file=.php_cs
$ composer cs-check
```
To have `php-cs-fixer` attempt to fix problems for you, omit the `--dry-run`
flag:
`phpcs` also includes a tool for fixing most CS violations, `phpcbf`:
```console
$ ./vendor/bin/php-cs-fixer fix . -v --diff --config-file=.php_cs
$ composer cs-fix
```
If you allow php-cs-fixer to fix CS issues, please re-run the tests to ensure
If you allow `phpcbf` to fix CS issues, please re-run the tests to ensure
they pass, and make sure you add and commit the changes after verification.
## Recommended Workflow for Contributions
@ -227,3 +227,8 @@ repository, we suggest doing some cleanup of these branches.
```console
$ git push {username} :<branchname>
```
## Conduct
Please see our [CONDUCT.md](CONDUCT.md) to understand expected behavior when interacting with others in the project.

2
web/vendor/zendframework/zend-feed/README.md vendored
View file

@ -10,4 +10,4 @@ structure with the same natural syntax, and turning the result back into XML.
- File issues at https://github.com/zendframework/zend-feed/issues
- Documentation is at http://framework.zend.com/manual/current/en/index.html#zend-feed
- Documentation is at https://zendframework.github.io/zend-feed/

49
web/vendor/zendframework/zend-feed/composer.json vendored
View file

@ -13,37 +13,48 @@
}
},
"require": {
"php": ">=5.5",
"zendframework/zend-escaper": "~2.5",
"zendframework/zend-stdlib": "~2.5"
"php": "^5.6 || ^7.0",
"zendframework/zend-escaper": "^2.5",
"zendframework/zend-stdlib": "^2.7 || ^3.1"
},
"require-dev": {
"zendframework/zend-db": "~2.5",
"zendframework/zend-cache": "~2.5",
"zendframework/zend-http": "~2.5",
"zendframework/zend-servicemanager": "~2.5",
"zendframework/zend-validator": "~2.5",
"fabpot/php-cs-fixer": "1.7.*",
"phpunit/PHPUnit": "~4.0"
"zendframework/zend-db": "^2.7",
"zendframework/zend-cache": "^2.6",
"zendframework/zend-http": "^2.5.4",
"zendframework/zend-servicemanager": "^2.7.5 || ^3.0.3",
"zendframework/zend-validator": "^2.6",
"phpunit/PHPUnit": "^6.0.8 || ^5.7.15",
"psr/http-message": "^1.0",
"zendframework/zend-coding-standard": "~1.0.0"
},
"suggest": {
"zendframework/zend-cache": "Zend\\Cache component",
"zendframework/zend-db": "Zend\\Db component",
"psr/http-message": "PSR-7 ^1.0, if you wish to use Zend\\Feed\\Reader\\Http\\Psr7ResponseDecorator",
"zendframework/zend-cache": "Zend\\Cache component, for optionally caching feeds between requests",
"zendframework/zend-db": "Zend\\Db component, for use with PubSubHubbub",
"zendframework/zend-http": "Zend\\Http for PubSubHubbub, and optionally for use with Zend\\Feed\\Reader",
"zendframework/zend-servicemanager": "Zend\\ServiceManager component, for default/recommended ExtensionManager implementations",
"zendframework/zend-validator": "Zend\\Validator component"
"zendframework/zend-servicemanager": "Zend\\ServiceManager component, for easily extending ExtensionManager implementations",
"zendframework/zend-validator": "Zend\\Validator component, for validating email addresses used in Atom feeds and entries ehen using the Writer subcomponent"
},
"minimum-stability": "dev",
"prefer-stable": true,
"extra": {
"branch-alias": {
"dev-master": "2.5-dev",
"dev-develop": "2.6-dev"
"dev-master": "2.8-dev",
"dev-develop": "2.9-dev"
}
},
"autoload-dev": {
"psr-4": {
"ZendTest\\Feed\\": "test/"
}
},
"scripts": {
"check": [
"@cs-check",
"@test"
],
"cs-check": "phpcs",
"cs-fix": "phpcbf",
"test": "phpunit --colors=always",
"test-coverage": "phpunit --colors=always --coverage-clover clover.xml",
"upload-coverage": "coveralls -v"
}
}
}

2115
web/vendor/zendframework/zend-feed/composer.lock generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

23
web/vendor/zendframework/zend-feed/doc/book/consuming-atom-entry.md vendored Normal file
View file

@ -0,0 +1,23 @@
# Consuming a Single Atom Entry
Single Atom `<entry>` elements are also valid by themselves. Usually the URL for
an entry is the feed's URL followed by `/<entryId>`, such as
`http://atom.example.com/feed/1`, using the example URL we used above. This
pattern may exist for some web services which use Atom as a container syntax.
If you read a single entry, you will have a `Zend\Feed\Reader\Entry\Atom` object.
## Reading a Single-Entry Atom Feed
```php
$entry = Zend\Feed\Reader\Reader::import('http://atom.example.com/feed/1');
echo 'Entry title: ' . $entry->getTitle();
```
> ## Importing requires an HTTP client
>
> To import a feed, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).

62
web/vendor/zendframework/zend-feed/doc/book/consuming-atom.md vendored Normal file
View file

@ -0,0 +1,62 @@
# Consuming Atom Feeds
`Zend\Feed\Reader\Feed\Atom` is used in much the same way as
`Zend\Feed\Reader\Feed\Rss`. It provides the same access to feed-level
properties and iteration over entries in the feed. The main difference is in the
structure of the Atom protocol itself. Atom is a successor to RSS; it is a
more generalized protocol and it is designed to deal more easily with feeds that
provide their full content inside the feed, splitting RSS' `description` tag
into two elements, `summary` and `content`, for that purpose.
## Basic Use of an Atom Feed
Read an Atom feed and print the `title` and `summary` of each entry:
```php
$feed = Zend\Feed\Reader\Reader::import('http://atom.example.com/feed/');
echo 'The feed contains ' . $feed->count() . ' entries.' . "\n\n";
foreach ($feed as $entry) {
echo 'Title: ' . $entry->getTitle() . "\n";
echo 'Description: ' . $entry->getDescription() . "\n";
echo 'URL: ' . $entry->getLink() . "\n\n";
}
```
> ## Importing requires an HTTP client
>
> To import a feed, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
In an Atom feed, you can expect to find the following feed properties:
- `title`: The feed's title, same as RSS' channel title.
- `id`: Every feed and entry in Atom has a unique identifier.
- `link`: Feeds can have multiple links, which are distinguished by a `type`
attribute. The equivalent to RSS's channel link would be `type="text/html"`.
If the link is to an alternate version of the same content that's in the feed,
it would have a `rel="alternate"` attribute.
- `subtitle`: The feed's description, equivalent to RSS' channel description.
- `author`: The feed's author, with `name` and `email` sub-tags.
Atom entries commonly have the following properties:
- `id`: The entry's unique identifier.
- `title`: The entry's title, same as RSS item titles.
- `link`: A link to another format or an alternate view of this entry.
The link property of an atom entry typically has an `href` attribute.
- `summary`: A summary of this entry's content.
- `content`: The full content of the entry; can be skipped if the feed just
contains summaries.
- `author`: with `name` and `email` sub-tags like feeds have.
- `published`: the date the entry was published, in RFC 3339 format.
- `updated`: the date the entry was last updated, in RFC 3339 format.
Where relevant, `Zend\Feed` supports a number of common RSS extensions including
Dublin Core; Content, Slash, Syndication, and Syndication/Thread; and several
others in common use on blogs.
For more information on Atom and plenty of resources, see
[http://www.atomenabled.org/](http://www.atomenabled.org/).

99
web/vendor/zendframework/zend-feed/doc/book/consuming-rss.md vendored Normal file
View file

@ -0,0 +1,99 @@
# Consuming RSS Feeds
## Reading a feed
To read an RSS feed, pass its URL to `Zend\Feed\Reader\Reader::import()`:
```php
$channel = Zend\Feed\Reader\Reader::import('http://rss.example.com/channelName');
```
> ## Importing requires an HTTP client
>
> To import a feed, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
If any errors occur fetching the feed, a
`Zend\Feed\Reader\Exception\RuntimeException` will be thrown.
## Get properties
Once you have a feed object, you can access any of the standard RSS channel
properties via the various instance getter methods:
```php
echo $channel->getTitle();
echo $channel->getAuthor();
// etc.
```
If channel properties have attributes, the getter method will return a key/value
pair, where the key is the attribute name, and the value is the attribute value.
```php
$author = $channel->getAuthor();
echo $author['name'];
```
Most commonly, you'll want to loop through the feed and do something with its
entries. `Zend\Feed\Reader\Feed\Rss` internally converts all entries to a
`Zend\Feed\Reader\Entry\Rss` instance. Entry properties, similarly to channel
properties, can be accessed via getter methods, such as `getTitle`,
`getDescription`, etc.
An example of printing all titles of articles in a channel is:
```php
foreach ($channel as $item) {
echo $item->getTitle() . "\n";
}
```
If you are not familiar with RSS, here are the standard elements you can expect
to be available in an RSS channel and in individual RSS items (entries).
Required channel elements:
- `title`: The name of the channel.
- `link`: The URL of the web site corresponding to the channel.
- `description`: A sentence (or more) describing the channel.
Common optional channel elements:
- `pubDate`: The publication date of this set of content, in RFC 822 date
format.
- `language`: The language the channel is written in.
- `category`: One or more (specified by multiple tags) categories the channel
belongs to.
RSS `<item>` elements do not have any strictly required elements. However,
either `title` or `description` must be present.
Common item elements:
- `title`: The title of the item.
- `link`: The URL of the item.
- `description`: A synopsis of the item.
- `author`: The author's email address.
- `category`: One more categories that the item belongs to.
- `comments`: URL of comments relating to this item.
- `pubDate`: The date the item was published, in RFC 822 date format.
In your code you can always test to see if an element is non-empty by calling
the getter:
```php
if ($item->getPropname()) {
// ... proceed.
}
```
Where relevant, `Zend\Feed` supports a number of common RSS extensions including
Dublin Core, Atom (inside RSS); the Content, Slash, Syndication,
Syndication/Thread extensions; as well as several others.
Please see the official [RSS 2.0 specification](http://cyber.law.harvard.edu/rss/rss.html)
for further information.

48
web/vendor/zendframework/zend-feed/doc/book/find-feeds.md vendored Normal file
View file

@ -0,0 +1,48 @@
# Feed Discovery from Web Pages
Web pages often contain `<link>` tags that refer to feeds with content relevant
to the particular page. `Zend\Feed\Reader\Reader` enables you to retrieve all
feeds referenced by a web page with one method call:
```php
$feedLinks = Zend\Feed\Reader\Reader::findFeedLinks('http://www.example.com/news.html');
```
> ## Finding feed links requires an HTTP client
>
> To find feed links, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
Here the `findFeedLinks()` method returns a `Zend\Feed\Reader\FeedSet` object,
which is in turn a collection of other `Zend\Feed\Reader\FeedSet` objects, each
referenced by `<link>` tags on the `news.html` web page.
`Zend\Feed\Reader\Reader` will throw a
`Zend\Feed\Reader\Exception\RuntimeException` upon failure, such as an HTTP
404 response code or a malformed feed.
You can examine all feed links located by iterating across the collection:
```php
$rssFeed = null;
$feedLinks = Zend\Feed\Reader\Reader::findFeedLinks('http://www.example.com/news.html');
foreach ($feedLinks as $link) {
if (stripos($link['type'], 'application/rss+xml') !== false) {
$rssFeed = $link['href'];
break;
}
```
Each `Zend\Feed\Reader\FeedSet` object will expose the `rel`, `href`, `type`,
and `title` properties of detected links for all RSS, Atom, or RDF feeds. You
can always select the first encountered link of each type by using a shortcut:
the first encountered link of a given type is assigned to a property named after
the feed type.
```php
$rssFeed = null;
$feedLinks = Zend\Feed\Reader\Reader::findFeedLinks('http://www.example.com/news.html');
$firstAtomFeed = $feedLinks->atom;
```

236
web/vendor/zendframework/zend-feed/doc/book/http-clients.md vendored Normal file
View file

@ -0,0 +1,236 @@
# HTTP Clients and zend-feed
Several operations in zend-feed's Reader subcomponent require an HTTP client:
- importing a feed
- finding links in a feed
In order to allow developers a choice in HTTP clients, the subcomponent defines
several interfaces and classes. Elsewhere in the documentation, we reference
where an HTTP client may be used; this document details what constitutes an HTTP
client and its behavior, and some of the concrete classes available within the
component for implementing this behavior.
## ClientInterface and HeaderAwareClientInterface
First, we define two interfaces for clients,
`Zend\Feed\Reader\Http\ClientInterface` and `HeaderAwareClientInterface`:
```php
namespace Zend\Feed\Reader\Http;
interface ClientInterface
{
/**
* Make a GET request to a given URL.
*
* @param string $url
* @return ResponseInterface
*/
public function get($url);
}
interface HeaderAwareClientInterface extends ClientInterface
{
/**
* Make a GET request to a given URL.
*
* @param string $url
* @param array $headers
* @return ResponseInterface
*/
public function get($url, array $headers = []);
}
```
The first is header-agnostic, and assumes that the client will simply perform an
HTTP GET request. The second allows providing headers to the client; typically,
these are used for HTTP caching headers. `$headers` must be in the following
structure:
```php
$headers = [
'X-Header-Name' => [
'header',
'values',
],
];
```
i.e., each key is a header name, and each value is an array of values for that
header. If the header represents only a single value, it should be an array with
that value:
```php
$headers = [
'Accept' => [ 'application/rss+xml' ],
];
```
A call to `get()` should yield a *response*.
## ResponseInterface and HeaderAwareResponseInterface
Responses are modeled using `Zend\Feed\Reader\Http\ResponseInterface` and
`HeaderAwareResponseInterface`:
```php
namespace Zend\Feed\Reader\Http;
class ResponseInterface
{
/**
* Retrieve the status code.
*
* @return int
*/
public function getStatusCode();
/**
* Retrieve the response body contents.
*
* @return string
*/
public function getBody();
}
class HeaderAwareResponseInterface extends ResponseInterface
{
/**
* Retrieve a named header line.
*
* Retrieve a header by name; all values MUST be concatenated to a single
* line. If no matching header is found, return the $default value.
*
* @param string $name
* @param null|string $default
* @return string
public function getHeaderLine($name, $default = null);
}
```
Internally, `Reader` will typehint against `ClientInterface` for the bulk of
operations. In some cases, however, certain capabilities are only possible if
the response can provide headers (e.g., for caching); in such cases, it will
check the instance against `HeaderAwareResponseInterface`, and only call
`getHeaderLine()` if it matches.
## Response
zend-feed ships with a generic `ResponseInterface` implementation,
`Zend\Feed\Http\Response`. It implements `HeaderAwareResponseInterface`, and
defines the following constructor:
```php
namespace Zend\Feed\Reader\Http;
class Response implements HeaderAwareResponseInterface
{
/**
* Constructor
*
* @param int $statusCode Response status code
* @param string $body Response body
* @param array $headers Response headers, if available
*/
public function __construct($statusCode, $body, array $headers = []);
}
```
## PSR-7 Response
[PSR-7](http://www.php-fig.org/psr/psr-7/) defines a set of HTTP message
interfaces, but not a client interface. To facilitate wrapping an HTTP client
that uses PSR-7 messages, we provide `Zend\Feed\Reader\Psr7ResponseDecorator`:
```php
namespace Zend\Feed\Reader\Http;
use Psr\Http\Message\ResponseInterface as PsrResponseInterface;
class Psr7ResponseDecorator implements HeaderAwareResponseInterface
{
/**
* @param PsrResponseInterface $response
*/
public function __construct(PsrResponseInterface $response);
/**
* @return PsrResponseInterface
*/
public function getDecoratedResponse();
}
```
Clients can then take the PSR-7 response they receive, pass it to the decorator,
and return the decorator.
To use the PSR-7 response, you will need to add the PSR-7 interfaces to your
application, if they are not already installed by the client of your choice:
```bash
$ composer require psr/http-message
```
## zend-http
We also provide a zend-http client decorator,
`Zend\Feed\Reader\Http\ZendHttpClientDecorator`:
```php
namespace Zend\Feed\Reader\Http;
use Zend\Http\Client as HttpClient;
class ZendHttpClientDecorator implements HeaderAwareClientInterface
{
/**
* @param HttpClient $client
*/
public function __construct(HttpClient $client);
/**
* @return HttpClient
*/
public function getDecoratedClient();
}
```
Its `get()` implementation returns a `Response` instance seeded from the
zend-http response returned, including status, body, and headers.
zend-http is the default implementation assumed by `Zend\Feed\Reader\Reader`,
but *is not installed by default*. You may install it using composer:
```bash
$ composer require zendframework/zend-http
```
## Providing a client to Reader
By default, `Zend\Feed\Reader\Reader` will lazy load a zend-http client. If you
have not installed zend-http, however, PHP will raise an error indicating the
class is not found!
As such, you have two options:
1. Install zend-http: `composer require zendframework/zend-http`.
2. Inject the `Reader` with your own HTTP client.
To accomplish the second, you will need an implementation of
`Zend\Feed\Reader\Http\ClientInterface` or `HeaderAwareClientInterface`, and an
instance of that implementation. Once you do, you can use the static method
`setHttpClient()` to inject it.
As an example, let's say you've created a PSR-7-based implementation named
`My\Http\Psr7FeedClient`. You could then do the following:
```php
use My\Http\Psr7FeedClient;
use Zend\Feed\Reader\Reader;
Reader::setHttpClient(new Psr7FeedClient());
```
Your client will then be used for all `import()` and `findFeedLinks()`
operations.

49
web/vendor/zendframework/zend-feed/doc/book/importing.md vendored Normal file
View file

@ -0,0 +1,49 @@
# Importing Feeds
`Zend\Feed` enables developers to retrieve feeds via `Zend\Feader\Reader`. If
you know the URI of a feed, use the `Zend\Feed\Reader\Reader::import()` method
to consume it:
```php
$feed = Zend\Feed\Reader\Reader::import('http://feeds.example.com/feedName');
```
> ## Importing requires an HTTP client
>
> To import a feed, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
You can also use `Zend\Feed\Reader\Reader` to fetch the contents of a feed from
a file or the contents of a PHP string variable:
```php
// importing a feed from a text file
$feedFromFile = Zend\Feed\Reader\Reader::importFile('feed.xml');
// importing a feed from a PHP string variable
$feedFromPHP = Zend\Feed\Reader\Reader::importString($feedString);
```
In each of the examples above, an object of a class that extends
`Zend\Feed\Reader\Feed\AbstractFeed` is returned upon success, depending on the
type of the feed. If an RSS feed were retrieved via one of the import methods
above, then a `Zend\Feed\Reader\Feed\Rss` object would be returned. On the other
hand, if an Atom feed were imported, then a `Zend\Feed\Reader\Feed\Atom` object
is returned. The import methods will also throw a
`Zend\Feed\Exception\Reader\RuntimeException` object upon failure, such as an
unreadable or malformed feed.
## Dumping the contents of a feed
To dump the contents of a `Zend\Feed\Reader\Feed\AbstractFeed` instance, you may
use the `saveXml()` method.
```php
assert($feed instanceof Zend\Feed\Reader\Feed\AbstractFeed);
// dump the feed to standard output
print $feed->saveXml();
```

10
web/vendor/zendframework/zend-feed/doc/book/index.html vendored Normal file
View file

@ -0,0 +1,10 @@
<div class="container">
<div class="jumbotron">
<h1>zend-feed</h1>
<p>Consume and generate Atom and RSS feeds, and interact with Pubsubhubbub.</p>
<pre><code class="language-bash">$ composer require zendframework/zend-feed</code></pre>
</div>
</div>

1
web/vendor/zendframework/zend-feed/doc/book/index.md vendored Symbolic link
View file

@ -0,0 +1 @@
../../README.md

62
web/vendor/zendframework/zend-feed/doc/book/intro.md vendored Normal file
View file

@ -0,0 +1,62 @@
# Introduction
`Zend\Feed` provides functionality for consuming RSS and Atom feeds. It provides
a natural syntax for accessing elements of feeds, feed attributes, and entry
attributes. `Zend\Feed` also has extensive support for modifying feed and entry
structure with the same natural syntax, and turning the result back into XML.
In the future, this modification support could provide support for the Atom
Publishing Protocol.
`Zend\Feed` consists of `Zend\Feed\Reader` for reading RSS and Atom feeds,
`Zend\Feed\Writer` for writing RSS and Atom feeds, and `Zend\Feed\PubSubHubbub`
for working with Hub servers. Furthermore, both `Zend\Feed\Reader` and
`Zend\Feed\Writer` support extensions which allows for working with additional
data in feeds, not covered in the core API but used in conjunction with RSS and
Atom feeds.
In the example below, we demonstrate a simple use case of retrieving an RSS feed
and saving relevant portions of the feed data to a simple PHP array, which could
then be used for printing the data, storing to a database, etc.
> ## RSS optional properties
>
> Many *RSS* feeds have different channel and item properties available. The
> *RSS* specification provides for many optional properties, so be aware of this
> when writing code to work with *RSS* data. `Zend\Feed` supports all optional
> properties of the core *RSS* and *Atom* specifications.
## Reading RSS Feed Data
```php
// Fetch the latest Slashdot headlines
try {
$slashdotRss =
Zend\Feed\Reader\Reader::import('http://rss.slashdot.org/Slashdot/slashdot');
} catch (Zend\Feed\Reader\Exception\RuntimeException $e) {
// feed import failed
echo "Exception caught importing feed: {$e->getMessage()}\n";
exit;
}
// Initialize the channel/feed data array
$channel = [
'title' => $slashdotRss->getTitle(),
'link' => $slashdotRss->getLink(),
'description' => $slashdotRss->getDescription(),
'items' => [],
];
// Loop over each channel item/entry and store relevant data for each
foreach ($slashdotRss as $item) {
$channel['items'][] = [
'title' => $item->getTitle(),
'link' => $item->getLink(),
'description' => $item->getDescription(),
];
}
```
Your `$channel` array now contains the basic meta-information for the RSS
channel and all items that it contained. The process is identical for Atom
feeds since `Zend\Feed` provides a common feed API; i.e. all getters and
setters are the same regardless of feed format.

90
web/vendor/zendframework/zend-feed/doc/book/psr7-clients.md vendored Normal file
View file

@ -0,0 +1,90 @@
# Using PSR-7 Clients
As noted in the previous section, you can [substitute your own HTTP client by implementing the ClientInterface](http-clients.md#clientinterface-and-headerawareclientinterface).
In this section, we'll demonstrate doing so in order to use a client that is
[PSR-7](http://www.php-fig.org/psr/psr-7/)-capable.
## Responses
zend-feed provides a facility to assist with generating a
`Zend\Feed\Reader\Response` from a PSR-7 `ResponseInterface` via
`Zend\Feed\Reader\Http\Psr7ResponseDecorator`. As such, if you have a
PSR-7-capable client, you can pass the response to this decorator, and
immediately return it from your custom client:
```php
return new Psr7ResponseDecorator($psr7Response);
```
We'll do this with our PSR-7 client.
## Guzzle
[Guzzle](http://docs.guzzlephp.org/en/latest/) is arguably the most popular HTTP
client library for PHP, and fully supports PSR-7 since version 5. Let's install
it:
```bash
$ composer require guzzlehttp/guzzle
```
We'll use the `GuzzleHttp\Client` to make our requests to feeds.
## Creating a client
From here, we'll create our client. To do this, we'll create a class that:
- implements `Zend\Feed\Reader\Http\ClientInterface`
- accepts a `GuzzleHttp\ClientInterface` to its constructor
- uses the Guzzle client to make the request
- returns a zend-feed response decorating the actual PSR-7 response
The code looks like this:
```php
use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface as GuzzleClientInterface;
use Zend\Feed\Reader\Http\ClientInterface as FeedReaderHttpClientInterface;
use Zend\Feed\Reader\Http\Psr7ResponseDecorator;
class GuzzleClient implements FeedReaderHttpClientInterface
{
/**
* @var GuzzleClientInterface
*/
private $client;
/**
* @param GuzzleClientInterface|null $client
*/
public function __construct(GuzzleClientInterface $client = null)
{
$this->client = $client ?: new Client();
}
/**
* {@inheritdoc}
*/
public function get($uri)
{
return new Psr7ResponseDecorator(
$this->client->request('GET', $uri)
);
}
}
```
## Using the client
In order to use our new client, we need to tell `Zend\Feed\Reader\Reader` about
it:
```php
Zend\Feed\Reader\Reader::setHttpClient(new GuzzleClient());
```
From this point forward, this custom client will be used to retrieve feeds.
## References
This chapter is based on [a blog post by Stefan Gehrig](https://www.teqneers.de/2016/05/zendfeedreader-guzzle-and-psr-7/).

452
web/vendor/zendframework/zend-feed/doc/book/pubsubhubbub.md vendored Normal file
View file

@ -0,0 +1,452 @@
# Zend\\Feed\\PubSubHubbub
`Zend\Feed\PubSubHubbub` is an implementation of the [PubSubHubbub Core 0.2/0.3
Specification (Working Draft)](http://pubsubhubbub.googlecode.com/svn/trunk/pubsubhubbub-core-0.3.html).
It offers implementations of a Pubsubhubbub Publisher and Subscriber suited to
PHP applications.
## What is PubSubHubbub?
Pubsubhubbub is an open, simple, web-scale, pubsub protocol. A common use case
to enable blogs (Publishers) to "push" updates from their RSS or Atom feeds
(Topics) to end Subscribers. These Subscribers will have subscribed to the
blog's RSS or Atom feed via a Hub, a central server which is notified of any
updates by the Publisher, and which then distributes these updates to all
Subscribers. Any feed may advertise that it supports one or more Hubs using an
Atom namespaced link element with a rel attribute of "hub" (i.e., `rel="hub"`).
Pubsubhubbub has garnered attention because it is a pubsub protocol which is
easy to implement and which operates over HTTP. Its philosophy is to replace the
traditional model where blog feeds have been polled at regular intervals to
detect and retrieve updates. Depending on the frequency of polling, this can
take a lot of time to propagate updates to interested parties from planet
aggregators to desktop readers. With a pubsub system in place, updates are not
simply polled by Subscribers, they are pushed to Subscribers, eliminating any
delay. For this reason, Pubsubhubbub forms part of what has been dubbed the
real-time web.
The protocol does not exist in isolation. Pubsub systems have been around for a
while, such as the familiar Jabber Publish-Subscribe protocol,
[XEP-0060](http://www.xmpp.org/extensions/xep-0060.html), or the less well-known
[rssCloud](http://www.rssboard.org/rsscloud-interface) (described in 2001).
However, these have not achieved widespread adoption due to either their
complexity, poor timing, or lack of suitability for web applications. rssCloud,
which was recently revived as a response to the appearance of Pubsubhubbub, has
also seen its usage increase significantly, though it lacks a formal
specification and currently does not support Atom 1.0 feeds.
Perhaps surprisingly given its relative early age, Pubsubhubbub is already in
use including in Google Reader and Feedburner, and there are plugins available
for Wordpress blogs.
## Architecture
`Zend\Feed\PubSubHubbub` implements two sides of the Pubsubhubbub 0.2/0.3
Specification: a Publisher and a Subscriber. It does not currently implement a
Hub Server.
A Publisher is responsible for notifying all supported Hubs (many can be
supported to add redundancy to the system) of any updates to its feeds, whether
they be Atom or RSS based. This is achieved by pinging the supported Hub Servers
with the URL of the updated feed. In Pubsubhubbub terminology, any updatable
resource capable of being subscribed to is referred to as a Topic. Once a ping
is received, the Hub will request the updated feed, process it for updated
items, and forward all updates to all Subscribers subscribed to that feed.
A Subscriber is any party or application which subscribes to one or more Hubs to
receive updates from a Topic hosted by a Publisher. The Subscriber never
directly communicates with the Publisher since the Hub acts as an intermediary,
accepting subscriptions and sending updates to Subscribers. The Subscriber
therefore communicates only with the Hub, either to subscribe or unsubscribe to
Topics, or when it receives updates from the Hub. This communication design
("Fat Pings") effectively removes the possibility of a "Thundering Herd" issue.
(Thundering Herds occur in a pubsub system where the Hub merely informs
Subscribers that an update is available, prompting all Subscribers to
immediately retrieve the feed from the Publisher, giving rise to a traffic
spike.) In Pubsubhubbub, the Hub distributes the actual update in a "Fat Ping"
so the Publisher is not subjected to any traffic spike.
`Zend\Feed\PubSubHubbub` implements Pubsubhubbub Publishers and Subscribers with
the classes `Zend\Feed\PubSubHubbub\Publisher` and
`Zend\Feed\PubSubHubbub\Subscriber`. In addition, the Subscriber implementation
may handle any feed updates forwarded from a Hub by using
`Zend\Feed\PubSubHubbub\Subscriber\Callback`. These classes, their use cases,
and etheir APIs are covered in subsequent sections.
## Zend\\Feed\\PubSubHubbub\\Publisher
In Pubsubhubbub, the Publisher is the party publishing a live feed with content
updates. This may be a blog, an aggregator, or even a web service with a public
feed based API. In order for these updates to be pushed to Subscribers, the
Publisher must notify all of its supported Hubs that an update has occurred
using a simple HTTP POST request containing the URI of the updated Topic (i.e.,
the updated RSS or Atom feed). The Hub will confirm receipt of the notification,
fetch the updated feed, and forward any updates to any Subscribers who have
subscribed to that Hub for updates from the relevant feed.
By design, this means the Publisher has very little to do except send these Hub
pings whenever its feeds change. As a result, the Publisher implementation is
extremely simple to use and requires very little work to setup and use when
feeds are updated.
`Zend\Feed\PubSubHubbub\Publisher` implements a full Pubsubhubbub Publisher. Its
setup for use primarily requires that it is configured with the URI endpoint for
all Hubs to be notified of updates, and the URIs of all Topics to be included in
the notifications.
The following example shows a Publisher notifying a collection of Hubs about
updates to a pair of local RSS and Atom feeds. The class retains a collection of
errors which include the Hub URLs, so that notification can be attempted again
later and/or logged if any notifications happen to fail. Each resulting error
array also includes a "response" key containing the related HTTP response
object. In the event of any errors, it is strongly recommended to attempt the
operation for failed Hub Endpoints at least once more at a future time. This may
require the use of either a scheduled task for this purpose or a job queue,
though such extra steps are optional.
```php
use Zend\Feed\PubSubHubbub\Publisher;
$publisher = Publisher;
$publisher->addHubUrls([
'http://pubsubhubbub.appspot.com/',
'http://hubbub.example.com',
]);
$publisher->addUpdatedTopicUrls([
'http://www.example.net/rss',
'http://www.example.net/atom',
]);
$publisher->notifyAll();
if (! $publisher->isSuccess()) {
// check for errors
$errors = $publisher->getErrors();
$failedHubs = [];
foreach ($errors as $error) {
$failedHubs[] = $error['hubUrl'];
}
}
// reschedule notifications for the failed Hubs in $failedHubs
```
If you prefer having more concrete control over the Publisher, the methods
`addHubUrls()` and `addUpdatedTopicUrls()` pass each array value to the singular
`addHubUrl()` and `addUpdatedTopicUrl()` public methods. There are also matching
`removeUpdatedTopicUrl()` and `removeHubUrl()` methods.
You can also skip setting Hub URIs, and notify each in turn using the
`notifyHub()` method which accepts the URI of a Hub endpoint as its only
argument.
There are no other tasks to cover. The Publisher implementation is very simple
since most of the feed processing and distribution is handled by the selected
Hubs. It is, however, important to detect errors and reschedule notifications as
soon as possible (with a reasonable maximum number of retries) to ensure
notifications reach all Subscribers. In many cases, as a final alternative, Hubs
may frequently poll your feeds to offer some additional tolerance for failures
both in terms of their own temporary downtime or Publisher errors or downtime.
## Zend\\Feed\\PubSubHubbub\\Subscriber
In Pubsubhubbub, the Subscriber is the party who wishes to receive updates to
any Topic (RSS or Atom feed). They achieve this by subscribing to one or more of
the Hubs advertised by that Topic, usually as a set of one or more Atom 1.0
links with a rel attribute of "hub" (i.e., `rel="hub"`). The Hub from that point
forward will send an Atom or RSS feed containing all updates to that
Subscriber's callback URL when it receives an update notification from the
Publisher. In this way, the Subscriber need never actually visit the original
feed (though it's still recommended at some level to ensure updates are
retrieved if ever a Hub goes offline). All subscription requests must contain
the URI of the Topic being subscribed and a callback URL which the Hub will use
to confirm the subscription and to forward updates.
The Subscriber therefore has two roles. The first is to *create* and *manage*
subscriptions, including subscribing for new Topics with a Hub, unsubscribing
(if necessary), and periodically renewing subscriptions, since they may have an
expiry set by the Hub. This is handled by `Zend\Feed\PubSubHubbub\Subscriber`.
The second role is to *accept updates* sent by a Hub to the Subscriber's
callback URL, i.e. the URI the Subscriber has assigned to handle updates. The
callback URL also handles events where the Hub contacts the Subscriber to
confirm all subscriptions and unsubscriptions. This is handled by using an
instance of `Zend\Feed\PubSubHubbub\Subscriber\Callback` when the callback URL
is accessed.
> ### Query strings in callback URLs
>
> `Zend\Feed\PubSubHubbub\Subscriber` implements the Pubsubhubbub 0.2/0.3
> specification. As this is a new specification version, not all Hubs currently
> implement it. The new specification allows the callback URL to include a query
> string which is used by this class, but not supported by all Hubs. In the
> interests of maximising compatibility, it is therefore recommended that the
> query string component of the Subscriber callback URI be presented as a path
> element, i.e. recognised as a parameter in the route associated with the
> callback URI and used by the application's router.
### Subscribing and Unsubscribing
`Zend\Feed\PubSubHubbub\Subscriber` implements a full Pubsubhubbub Subscriber
capable of subscribing to, or unsubscribing from, any Topic via any Hub
advertised by that Topic. It operates in conjunction with
`Zend\Feed\PubSubHubbub\Subscriber\Callback`, which accepts requests from a Hub
to confirm all subscription or unsubscription attempts (to prevent third-party
misuse).
Any subscription (or unsubscription) requires the relevant information before
proceeding, i.e. the URI of the Topic (Atom or RSS feed) to be subscribed to for
updates, and the URI of the endpoint for the Hub which will handle the
subscription and forwarding of the updates. The lifetime of a subscription may
be determined by the Hub, but most Hubs should support automatic subscription
refreshes by checking with the Subscriber. This is supported by
`Zend\Feed\PubSubHubbub\Subscriber\Callback` and requires no other work on your
part. It is still strongly recommended that you use the Hub-sourced subscription
time-to.live (ttl) to schedule the creation of new subscriptions (the process is
identical to that for any new subscription) to refresh it with the Hub. While it
should not be necessary per se, it covers cases where a Hub may not support
automatic subscription refreshing, and rules out Hub errors for additional
redundancy.
With the relevant information to hand, a subscription can be attempted as
demonstrated below:
```php
use Zend\Feed\PubSubHubbub\Model\Subscription;
use Zend\Feed\PubSubHubbub\Subscriber;
$storage = new Subscription;
$subscriber = new Subscriber;
$subscriber->setStorage($storage);
$subscriber->addHubUrl('http://hubbub.example.com');
$subscriber->setTopicUrl('http://www.example.net/rss.xml');
$subscriber->setCallbackUrl('http://www.mydomain.com/hubbub/callback');
$subscriber->subscribeAll();
```
In order to store subscriptions and offer access to this data for general use,
the component requires a database (a schema is provided later in this section).
By default, it is assumed the table name is "subscription", and it utilises
`Zend\Db\TableGateway\TableGateway` in the background, meaning it will use the
default adapter you have set for your application. You may also pass a specific
custom `Zend\Db\TableGateway\TableGateway` instance into the associated model
`Zend\Feed\PubSubHubbub\Model\Subscription`. This custom adapter may be as
simple in intent as changing the table name to use or as complex as you deem
necessary.
While this model is offered as a default ready-to-roll solution, you may create
your own model using any other backend or database layer (e.g. Doctrine) so long
as the resulting class implements the interface
`Zend\Feed\PubSubHubbub\Model\SubscriptionInterface`.
An example schema (MySQL) for a subscription table accessible by the provided
model may look similar to:
```sql
CREATE TABLE IF NOT EXISTS `subscription` (
`id` varchar(32) COLLATE utf8_unicode_ci NOT NULL DEFAULT '',
`topic_url` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`hub_url` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`created_time` datetime DEFAULT NULL,
`lease_seconds` bigint(20) DEFAULT NULL,
`verify_token` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`secret` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`expiration_time` datetime DEFAULT NULL,
`subscription_state` varchar(12) COLLATE utf8_unicode_ci DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
```
Behind the scenes, the Subscriber above will send a request to the Hub endpoint
containing the following parameters (based on the previous example):
Parameter | Value | Explanation
--------- | ----- | -----------
`hub.callback` | `http://www.mydomain.com/hubbub/callback?xhub.subscription=5536df06b5dcb966edab3a4c4d56213c16a8184` | The URI used by a Hub to contact the Subscriber and either request confirmation of a (un)subscription request, or send updates from subscribed feeds. The appended query string contains a custom parameter (hence the xhub designation). It is a query string parameter preserved by the Hub and re-sent with all Subscriber requests. Its purpose is to allow the Subscriber to identify and look up the subscription associated with any Hub request in a backend storage medium. This is a non-standard parameter used by this component in preference to encoding a subscription key in the URI path, which is difficult to enforce generically. Nevertheless, since not all Hubs support query string parameters, we still strongly recommend adding the subscription key as a path component in the form `http://www.mydomain.com/hubbub/callback/5536df06b5dcb966edab3a4c4d56213c16a8184`. This requires defining a route capable of parsing out the final value of the key, retrieving the value, and passing it to the Subscriber callback object. The value should be passed into the method `Zend\PubSubHubbub\Subscriber\Callback::setSubscriptionKey()`. A detailed example is offered later.
`hub.lease_seconds` | `2592000` | The number of seconds for which the Subscriber would like a new subscription to remain valid (i.e. a TTL). Hubs may enforce their own maximum subscription period. All subscriptions should be renewed by re-subscribing before the subscription period ends to ensure continuity of updates. Hubs should additionally attempt to automatically refresh subscriptions before they expire by contacting Subscribers (handled automatically by the `Callback` class).
`hub.mode` | `subscribe` | Value indicating this is a subscription request. Unsubscription requests would use the "unsubscribe" value.
`hub.topic` | `http://www.example.net/rss.xml` | The URI of the Topic (i.e. Atom or RSS feed) which the Subscriber wishes to subscribe to for updates.
`hub.verify` | `sync` or `async` | Indicates to the Hub the preferred mode of verifying subscriptions or unsubscriptions. It is repeated twice in order of preference. Technically this component does not distinguish between the two modes and treats both equally.
`hub.verify_token` | `3065919804abcaa7212ae89.879827871253878386` | A verification token returned to the Subscriber by the Hub when it is confirming a subscription or unsubscription. Offers a measure of reliance that the confirmation request originates from the correct Hub to prevent misuse.
You can modify several of these parameters to indicate a different preference.
For example, you can set a different lease seconds value using
`Zend\Feed\PubSubHubbub\Subscriber::setLeaseSeconds(),` or show a preference for
the `async` verify mode by using `setPreferredVerificationMode(Zend\Feed\PubSubHubbub\PubSubHubbub::VERIFICATION_MODE_ASYNC)`.
However, the Hubs retain the capability to enforce their own preferences, and
for this reason the component is deliberately designed to work across almost any
set of options with minimum end-user configuration required. Conventions are
great when they work!
> ### Verification modes
>
> While Hubs may require the use of a specific verification mode (both are
> supported by `Zend\Feed\PubSubHubbub`), you may indicate a specific preference
> using the `setPreferredVerificationMode()` method. In `sync` (synchronous)
> mode, the Hub attempts to confirm a subscription as soon as it is received,
> and before responding to the subscription request. In `async` (asynchronous)
> mode, the Hub will return a response to the subscription request immediately,
> and its verification request may occur at a later time. Since
> `Zend\Feed\PubSubHubbub` implements the Subscriber verification role as a
> separate callback class and requires the use of a backend storage medium, it
> actually supports both transparently. In terms of end-user performance,
> asynchronous verification is very much preferred to eliminate the impact of a
> poorly performing Hub tying up end-user server resources and connections for
> too long.
Unsubscribing from a Topic follows the exact same pattern as the previous
example, with the exception that we should call `unsubscribeAll()` instead. The
parameters included are identical to a subscription request with the exception
that `hub.mode` is set to "unsubscribe".
By default, a new instance of `Zend\PubSubHubbub\Subscriber` will attempt to use
a database backed storage medium which defaults to using the default zend-db
adapter with a table name of "subscription". It is recommended to set a custom
storage solution where these defaults are not apt either by passing in a new
model supporting the required interface or by passing a new instance of
`Zend\Db\TableGateway\TableGateway` to the default model's constructor to change
the used table name.
### Handling Subscriber Callbacks
Whenever a subscription or unsubscription request is made, the Hub must verify
the request by forwarding a new verification request to the callback URL set in
the subscription or unsubscription parameters. To handle these Hub requests,
which will include all future communications containing Topic (feed) updates,
the callback URL should trigger the execution of an instance of
`Zend\Feed\PubSubHubbub\Subscriber\Callback` to handle the request.
The `Callback` class should be configured to use the same storage medium as the
`Subscriber` class. The bulk of the work is handled internal to these classes.
```php
use Zend\Feed\PubSubHubbub\Model\Subscription;
use Zend\Feed\PubSubHubbub\Subscriber\Callback;
$storage = new Subscription();
$callback = new Callback();
$callback->setStorage($storage);
$callback->handle();
$callback->sendResponse();
/*
* Check if the callback resulting in the receipt of a feed update.
* Otherwise it was either a (un)sub verification request or invalid request.
* Typically we need do nothing other than add feed update handling; the rest
* is handled internally by the class.
*/
if ($callback->hasFeedUpdate()) {
$feedString = $callback->getFeedUpdate();
/*
* Process the feed update asynchronously to avoid a Hub timeout.
*/
}
```
> #### Query and body parameters
>
> It should be noted that `Zend\Feed\PubSubHubbub\Subscriber\Callback` may
> independently parse any incoming query string and other parameters. This is
> necessary since PHP alters the structure and keys of a query string when it is
> parsed into the `$_GET` or `$_POST` superglobals; for example, all duplicate
> keys are ignored and periods are converted to underscores. Pubsubhubbub
> features both of these in the query strings it generates.
> #### Always delay feed processing
>
> It is essential that developers recognise that Hubs are only concerned with
> sending requests and receiving a response which verifies its receipt. If a
> feed update is received, it should never be processed on the spot since this
> leaves the Hub waiting for a response. Rather, any processing should be
> offloaded to another process or deferred until after a response has been
> returned to the Hub. One symptom of a failure to promptly complete Hub
> requests is that a Hub may continue to attempt delivery of the update or
> verification request leading to duplicated update attempts being processed by
> the Subscriber. This appears problematic, but in reality a Hub may apply a
> timeout of just a few seconds, and if no response is received within that time
> it may disconnect (assuming a delivery failure) and retry later. Note that
> Hubs are expected to distribute vast volumes of updates so their resources are
> stretched; please process feeds asynchronously (e.g. in a separate process or
> a job queue or even a cronjob) as much as possible.
### Setting Up And Using A Callback URL Route
As noted earlier, the `Zend\Feed\PubSubHubbub\Subscriber\Callback` class
receives the combined key associated with any subscription from the Hub via one
of two methods. The technically preferred method is to add this key to the
callback URL employed by the Hub in all future requests using a query string
parameter with the key `xhub.subscription`. However, for historical reasons
(primarily that this was not supported in Pubsubhubbub 0.1, and a late addition
to 0.2 ), it is strongly recommended to use the most compatible means of adding
this key to the callback URL by appending it to the URL's path.
Thus the URL `http://www.example.com/callback?xhub.subscription=key` would become
`http://www.example.com/callback/key`.
Since the query string method is the default in anticipation of a greater level
of future support for the full 0.2/0.3 specification, this requires some
additional work to implement.
The first step is to make the `Zend\Feed\PubSubHubbub\Subscriber\Callback` class
aware of the path contained subscription key. It's manually injected; therefore
it also requires manually defining a route for this purpose. This is achieved by
called the method `Zend\Feed\PubSubHubbub\Subscriber\Callback::setSubscriptionKey()`
with the parameter being the key value available from the router. The example
below demonstrates this using a zend-mvc controller.
```php
use Zend\Feed\PubSubHubbub\Model\Subscription;
use Zend\Feed\PubSubHubbub\Subscriber\Callback;
use Zend\Mvc\Controller\AbstractActionController;
class CallbackController extends AbstractActionController
{
public function indexAction()
{
$storage = new Subscription();
$callback = new Callback();
$callback->setStorage($storage);
/*
* Inject subscription key parsing from URL path using
* a parameter from the router.
*/
$subscriptionKey = $this->params()->fromRoute('subkey');
$callback->setSubscriptionKey($subscriptionKey);
$callback->handle();
$callback->sendResponse();
/*
* Check if the callback resulting in the receipt of a feed update.
* Otherwise it was either a (un)sub verification request or invalid
* request. Typically we need do nothing other than add feed update
* handling; the rest is handled internally by the class.
*/
if ($callback->hasFeedUpdate()) {
$feedString = $callback->getFeedUpdate();
/*
* Process the feed update asynchronously to avoid a Hub timeout.
*/
}
}
}
```
The example below illustrates adding a route mapping the path segment to a route
parameter, using zend-mvc:
```php
use Zend\Mvc\Router\Http\Segment as SegmentRoute;;
// Route defininition for enabling appending of a PuSH Subscription's lookup key
$route = SegmentRoute::factory([
'route' => '/callback/:subkey',
'constraints' => [
'subkey' => '[a-z0-9]+',
],
'defaults' => [
'controller' => 'application-index',
'action' => 'index',
]
]);
```

825
web/vendor/zendframework/zend-feed/doc/book/reader.md vendored Normal file
View file

@ -0,0 +1,825 @@
# Zend\\Feed\\Reader
`Zend\Feed\Reader` is a component used to consume RSS and Atom feeds of
any version, including RDF/RSS 1.0, RSS 2.0, Atom 0.3, and Atom 1.0. The API for
retrieving feed data is deliberately simple since `Zend\Feed\Reader` is capable
of searching any feed of any type for the information requested through the API.
If the typical elements containing this information are not present, it will
adapt and fall back on a variety of alternative elements instead. This ability
to choose from alternatives removes the need for users to create their own
abstraction layer on top of the component to make it useful or have any in-depth
knowledge of the underlying standards, current alternatives, and namespaced
extensions.
Internally, the `Zend\Feed\Reader\Reader` class works almost entirely on the
basis of making XPath queries against the feed XML's Document Object Model. This
singular approach to parsing is consistent, and the component offers a plugin
system to add to the Feed and Entry APIs by writing extensions on a similar
basis.
Performance is assisted in three ways. First of all, `Zend\Feed\Reader\Reader`
supports caching using [zend-cache](https://github.com/zendframework/zend-cache)
to maintain a copy of the original feed XML. This allows you to skip network
requests for a feed URI if the cache is valid. Second, the Feed and Entry APIs
are backed by an internal cache (non-persistent) so repeat API calls for the
same feed will avoid additional DOM or XPath use. Thirdly, importing feeds from
a URI can take advantage of HTTP Conditional `GET` requests which allow servers
to issue an empty 304 response when the requested feed has not changed since the
last time you requested it. In the final case, an zend-cache storage instance
will hold the last received feed along with the ETag and Last-Modified header
values sent in the HTTP response.
`Zend\Feed\Reader\Reader` is not capable of constructing feeds, and delegates
this responsibility to `Zend\Feed\Writer\Writer`.
## Importing Feeds
Feeds can be imported from a string, file or a URI. Importing from a URI can
additionally utilise an HTTP Conditional `GET` request. If importing fails, an
exception will be raised. The end result will be an object of type
`Zend\Feed\Reader\Feed\AbstractFeed`, the core implementations of which are
`Zend\Feed\Reader\Feed\Rss` and `Zend\Feed\Reader\Feed\Atom`. Both objects
support multiple (all existing) versions of these broad feed types.
In the following example, we import an RDF/RSS 1.0 feed and extract some basic
information that can be saved to a database or elsewhere.
```php
$feed = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rdf/');
$data = [
'title' => $feed->getTitle(),
'link' => $feed->getLink(),
'dateModified' => $feed->getDateModified(),
'description' => $feed->getDescription(),
'language' => $feed->getLanguage(),
'entries' => [],
];
foreach ($feed as $entry) {
$edata = [
'title' => $entry->getTitle(),
'description' => $entry->getDescription(),
'dateModified' => $entry->getDateModified(),
'authors' => $entry->getAuthors(),
'link' => $entry->getLink(),
'content' => $entry->getContent(),
];
$data['entries'][] = $edata;
}
```
> ## Importing requires an HTTP client
>
> To import a feed, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
The example above demonstrates `Zend\Feed\Reader\Reader`'s API, and it also
demonstrates some of its internal operation. In reality, the RDF feed selected
does not have any native date or author elements; however it does utilise the
Dublin Core 1.1 module which offers namespaced creator and date elements.
`Zend\Feed\Reader\Reader` falls back on these and similar options if no relevant
native elements exist. If it absolutely cannot find an alternative it will
return `NULL`, indicating the information could not be found in the feed. You
should note that classes implementing `Zend\Feed\Reader\Feed\AbstractFeed` also
implement the SPL `Iterator` and `Countable` interfaces.
Feeds can also be imported from strings or files.
```php
// from a URI
$feed = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rdf/');
// from a String
$feed = Zend\Feed\Reader\Reader::importString($feedXmlString);
// from a file
$feed = Zend\Feed\Reader\Reader::importFile('./feed.xml');
```
## Retrieving Underlying Feed and Entry Sources
`Zend\Feed\Reader\Reader` does its best not to stick you in a narrow confine. If
you need to work on a feed outside of `Zend\Feed\Reader\Reader`, you can extract
the base DOMDocument or DOMElement objects from any class, or even an XML
string containing these. Also provided are methods to extract the current
DOMXPath object (with all core and extension namespaces registered) and the
correct prefix used in all XPath queries for the current feed or entry. The
basic methods to use (on any object) are `saveXml()`, `getDomDocument()`,
`getElement()`, `getXpath()` and `getXpathPrefix()`. These will let you break
free of `Zend\Feed\Reader` and do whatever else you want.
- `saveXml()` returns an XML string containing only the element representing the
current object.
- `getDomDocument()` returns the DOMDocument object representing the entire feed
(even if called from an entry object).
- `getElement()` returns the DOMElement of the current object (i.e. the feed or
current entry).
- `getXpath()` returns the DOMXPath object for the current feed (even if called
from an entry object) with the namespaces of the current feed type and all
loaded extensions pre-registered.
- `getXpathPrefix()` returns the query prefix for the current object (i.e. the
feed or current entry) which includes the correct XPath query path for that
specific feed or entry.
Let's look at an example where a feed might include an RSS extension not
supported by `Zend\Feed\Reader\Reader` out of the box. Notably, you could write
and register an extension (covered later) to do this, but that's not always
warranted for a quick check. You must register any new namespaces on the
DOMXPath object before use unless they are registered by `Zend\Feed\Reader` or
an extension beforehand.
```php
$feed = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rdf/');
$xpathPrefix = $feed->getXpathPrefix();
$xpath = $feed->getXpath();
$xpath->registerNamespace('admin', 'http://webns.net/mvcb/');
$reportErrorsTo = $xpath->evaluate(
'string(' . $xpathPrefix . '/admin:errorReportsTo)'
);
```
> ### Do not register duplicate namespaces
>
> If you register an already registered namespace with a different prefix name
> to that used internally by `Zend\Feed\Reader\Reader`, it will break the
> internal operation of this component.
## Cache Support and Intelligent Requests
### Adding Cache Support to Zend\\Feed\\Reader\\Reader
`Zend\Feed\Reader\Reader` supports using a
[zend-cache](https://github.com/zendframework/zend-cache) storage instance to
cache feeds (as XML) to avoid unnecessary network requests. To add a cache,
create and configure your cache instance, and then tell
`Zend\Feed\Reader\Reader` to use it. The cache key used is
"`Zend\Feed\Reader\\`" followed by the MD5 hash of the feed's URI.
```php
$cache = Zend\Cache\StorageFactory::adapterFactory('Memory');
Zend\Feed\Reader\Reader::setCache($cache);
```
### HTTP Conditional GET Support
The big question often asked when importing a feed frequently is if it has even
changed. With a cache enabled, you can add HTTP Conditional `GET` support to
your arsenal to answer that question.
Using this method, you can request feeds from URIs and include their last known
ETag and Last-Modified response header values with the request (using the
If-None-Match and If-Modified-Since headers). If the feed on the server remains
unchanged, you should receive a 304 response which tells
`Zend\Feed\Reader\Reader` to use the cached version. If a full feed is sent in a
response with a status code of 200, this means the feed has changed and
`Zend\Feed\Reader\Reader` will parse the new version and save it to the cache.
It will also cache the new ETag and Last-Modified header values for future use.
> #### Conditional GET requires a HeaderAwareClientInterface
>
> Conditional GET support only works for `Zend\Feed\Reader\Http\HeaderAwareClientInterface`
> client implementations, as it requires the ability to send HTTP headers.
These "conditional" requests are not guaranteed to be supported by the server
you request a *URI* of, but can be attempted regardless. Most common feed
sources like blogs should however have this supported. To enable conditional
requests, you will need to provide a cache to `Zend\Feed\Reader\Reader`.
```php
$cache = Zend\Cache\StorageFactory::adapterFactory('Memory');
Zend\Feed\Reader\Reader::setCache($cache);
Zend\Feed\Reader\Reader::useHttpConditionalGet();
$feed = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rdf/');
```
In the example above, with HTTP Conditional `GET` requests enabled, the response
header values for ETag and Last-Modified will be cached along with the feed. For
the the cache's lifetime, feeds will only be updated on the cache if a non-304
response is received containing a valid RSS or Atom XML document.
If you intend on managing request headers from outside
`Zend\Feed\Reader\Reader`, you can set the relevant If-None-Matches and
If-Modified-Since request headers via the URI import method.
```php
$lastEtagReceived = '5e6cefe7df5a7e95c8b1ba1a2ccaff3d';
$lastModifiedDateReceived = 'Wed, 08 Jul 2009 13:37:22 GMT';
$feed = Zend\Feed\Reader\Reader::import(
$uri, $lastEtagReceived, $lastModifiedDateReceived
);
```
## Locating Feed URIs from Websites
These days, many websites are aware that the location of their XML feeds is not
always obvious. A small RDF, RSS, or Atom graphic helps when the user is reading
the page, but what about when a machine visits trying to identify where your
feeds are located? To assist in this, websites may point to their feeds using
`<link>` tags in the `<head>` section of their HTML. To take advantage
of this, you can use `Zend\Feed\Reader\Reader` to locate these feeds using the
static `findFeedLinks()` method.
This method calls any URI and searches for the location of RSS, RDF, and Atom
feeds assuming, the website's HTML contains the relevant links. It then returns
a value object where you can check for the existence of a RSS, RDF or Atom feed
URI.
The returned object is an `ArrayObject` subclass called
`Zend\Feed\Reader\FeedSet`, so you can cast it to an array or iterate over it to
access all the detected links. However, as a simple shortcut, you can just grab
the first RSS, RDF, or Atom link using its public properties as in the example
below. Otherwise, each element of the `ArrayObject` is a simple array with the
keys `type` and `uri` where the type is one of "rdf", "rss", or "atom".
```php
$links = Zend\Feed\Reader\Reader::findFeedLinks('http://www.planet-php.net');
if (isset($links->rdf)) {
echo $links->rdf, "\n"; // http://www.planet-php.org/rdf/
}
if (isset($links->rss)) {
echo $links->rss, "\n"; // http://www.planet-php.org/rss/
}
if (isset($links->atom)) {
echo $links->atom, "\n"; // http://www.planet-php.org/atom/
}
```
Based on these links, you can then import from whichever source you wish in the usual manner.
> ### Finding feed links requires an HTTP client
>
> To find feed links, you will need to have an [HTTP client](zend.feed.http-clients)
> available.
>
> If you are not using zend-http, you will need to inject `Reader` with the HTTP
> client. See the [section on providing a client to Reader](http-clients.md#providing-a-client-to-reader).
This quick method only gives you one link for each feed type, but websites may
indicate many links of any type. Perhaps it's a news site with a RSS feed for
each news category. You can iterate over all links using the ArrayObject's
iterator.
```php
$links = Zend\Feed\Reader::findFeedLinks('http://www.planet-php.net');
foreach ($links as $link) {
echo $link['href'], "\n";
}
```
## Attribute Collections
In an attempt to simplify return types, return types from the various feed and
entry level methods may include an object of type
`Zend\Feed\Reader\Collection\AbstractCollection`. Despite the special class name
which I'll explain below, this is just a simple subclass of SPL's `ArrayObject`.
The main purpose here is to allow the presentation of as much data as possible
from the requested elements, while still allowing access to the most relevant
data as a simple array. This also enforces a standard approach to returning such
data which previously may have wandered between arrays and objects.
The new class type acts identically to `ArrayObject` with the sole addition
being a new method `getValues()` which returns a simple flat array containing
the most relevant information.
A simple example of this is `Zend\Feed\Reader\Reader\FeedInterface::getCategories()`.
When used with any RSS or Atom feed, this method will return category data as a
container object called `Zend\Feed\Reader\Collection\Category`. The container
object will contain, per category, three fields of data: term, scheme, and label.
The "term" is the basic category name, often machine readable (i.e. plays nice
with URIs). The scheme represents a categorisation scheme (usually a URI
identifier) also known as a "domain" in RSS 2.0. The "label" is a human readable
category name which supports HTML entities. In RSS 2.0, there is no label
attribute so it is always set to the same value as the term for convenience.
To access category labels by themselves in a simple value array, you might
commit to something like:
```php
$feed = Zend\Feed\Reader\Reader::import('http://www.example.com/atom.xml');
$categories = $feed->getCategories();
$labels = [];
foreach ($categories as $cat) {
$labels[] = $cat['label']
}
```
It's a contrived example, but the point is that the labels are tied up with
other information.
However, the container class allows you to access the "most relevant" data as a
simple array using the `getValues()` method. The concept of "most relevant" is
obviously a judgement call. For categories it means the category labels (not the
terms or schemes) while for authors it would be the authors' names (not their
email addresses or URIs). The simple array is flat (just values) and passed
through `array_unique()` to remove duplication.
```php
$feed = Zend\Feed\Reader\Reader::import('http://www.example.com/atom.xml');
$categories = $feed->getCategories();
$labels = $categories->getValues();
```
The above example shows how to extract only labels and nothing else thus giving
simple access to the category labels without any additional work to extract that
data by itself.
## Retrieving Feed Information
Retrieving information from a feed (we'll cover entries and items in the next
section though they follow identical principals) uses a clearly defined API
which is exactly the same regardless of whether the feed in question is RSS,
RDF, or Atom. The same goes for sub-versions of these standards and we've tested
every single RSS and Atom version. While the underlying feed XML can differ
substantially in terms of the tags and elements they present, they nonetheless
are all trying to convey similar information and to reflect this all the
differences and wrangling over alternative tags are handled internally by
`Zend\Feed\Reader\Reader` presenting you with an identical interface for each.
Ideally, you should not have to care whether a feed is RSS or Atom so long as
you can extract the information you want.
> ### RSS feeds vary widely
>
> While determining common ground between feed types is itself complex, it
> should be noted that *RSS* in particular is a constantly disputed
> "specification". This has its roots in the original RSS 2.0 document, which
> contains ambiguities and does not detail the correct treatment of all
> elements. As a result, this component rigorously applies the RSS 2.0.11
> Specification published by the RSS Advisory Board and its accompanying RSS
> Best Practices Profile. No other interpretation of RSS
> 2.0 will be supported, though exceptions may be allowed where it does not
> directly prevent the application of the two documents mentioned above.
Of course, we don't live in an ideal world, so there may be times the API just
does not cover what you're looking for. To assist you, `Zend\Feed\Reader\Reader`
offers a plugin system which allows you to write extensions to expand the core
API and cover any additional data you are trying to extract from feeds. If
writing another extension is too much trouble, you can simply grab the
underlying DOM or XPath objects and do it by hand in your application. Of
course, we really do encourage writing an extension simply to make it more
portable and reusable, and useful extensions may be proposed to the component
for formal addition.
Below is a summary of the Core API for feeds. You should note it comprises not
only the basic RSS and Atom standards, but also accounts for a number of
included extensions bundled with `Zend\Feed\Reader\Reader`. The naming of these
extension sourced methods remain fairly generic; all Extension methods operate
at the same level as the Core API though we do allow you to retrieve any
specific extension object separately if required.
### Feed Level API Methods
Method | Description
------ | -----------
`getId()` | Returns a unique ID associated with this feed
`getTitle()` | Returns the title of the feed
`getDescription()` | Returns the text description of the feed.
`getLink()` | Returns a URI to the HTML website containing the same or similar information as this feed (i.e. if the feed is from a blog, it should provide the blog's URI where the HTML version of the entries can be read).
`getFeedLink()` | Returns the URI of this feed, which may be the same as the URI used to import the feed. There are important cases where the feed link may differ because the source URI is being updated and is intended to be removed in the future.
`getAuthors()` | Returns an object of type `Zend\Feed\Reader\Collection\Author` which is an `ArrayObject` whose elements are each simple arrays containing any combination of the keys "name", "email" and "uri". Where irrelevant to the source data, some of these keys may be omitted.
`getAuthor(integer $index = 0)` | Returns either the first author known, or with the optional $index parameter any specific index on the array of authors as described above (returning `NULL` if an invalid index).
`getDateCreated()` | Returns the date on which this feed was created. Generally only applicable to Atom, where it represents the date the resource described by an Atom 1.0 document was created. The returned date will be a `DateTime` object.
`getDateModified()` | Returns the date on which this feed was last modified. The returned date will be a `DateTime` object.
`getLastBuildDate()` | Returns the date on which this feed was last built. The returned date will be a `DateTime` object. This is only supported by RSS; Atom feeds will always return `NULL`.
`getLanguage()` | Returns the language of the feed (if defined) or simply the language noted in the XML document.
`getGenerator()` | Returns the generator of the feed, e.g. the software which generated it. This may differ between RSS and Atom since Atom defines a different notation.
`getCopyright()` | Returns any copyright notice associated with the feed.
`getHubs()` | Returns an array of all Hub Server URI endpoints which are advertised by the feed for use with the Pubsubhubbub Protocol, allowing subscriptions to the feed for real-time updates.
`getCategories()` | Returns a `Zend\Feed\Reader\Collection\Category` object containing the details of any categories associated with the overall feed. The supported fields include "term" (the machine readable category name), "scheme" (the categorisation scheme and domain for this category), and "label" (a HTML decoded human readable category name). Where any of the three fields are absent from the field, they are either set to the closest available alternative or, in the case of "scheme", set to `NULL`.
`getImage()` | Returns an array containing data relating to any feed image or logo, or `NULL` if no image found. The resulting array may contain the following keys: uri, link, title, description, height, and width. Atom logos only contain a URI so the remaining metadata is drawn from RSS feeds only.
Given the variety of feeds in the wild, some of these methods will undoubtedly
return `NULL` indicating the relevant information couldn't be located. Where
possible, `Zend\Feed\Reader\Reader` will fall back on alternative elements
during its search. For example, searching an RSS feed for a modification date is
more complicated than it looks. RSS 2.0 feeds should include a `<lastBuildDate>`
tag and/or a `<pubDate>` element. But what if it doesn't? Maybe this is an RSS
1.0 feed? Perhaps it instead has an `<atom:updated>` element with identical
information (Atom may be used to supplement RSS syntax)? Failing that, we
could simply look at the entries, pick the most recent, and use its `<pubDate>`
element. Assuming it exists, that is. Many feeds also use Dublin Core 1.0 or 1.1
`<dc:date>` elements for feeds and entries. Or we could find Atom lurking again.
The point is, `Zend\Feed\Reader\Reader` was designed to know this. When you ask
for the modification date (or anything else), it will run off and search for all
these alternatives until it either gives up and returns `NULL`, or finds an
alternative that should have the right answer.
In addition to the above methods, all feed objects implement methods for
retrieving the DOM and XPath objects for the current feeds as described
earlier. Feed objects also implement the SPL Iterator and Countable
interfaces. The extended API is summarised below.
### Extended Feed API Methods
Method | Description
------ | -----------
`getDomDocument()` | Returns the parent DOMDocument object for the entire source XML document.
`getElement()` | Returns the current feed level DOMElement object.
`saveXml()` | Returns a string containing an XML document of the entire feed element (this is not the original document, but a rebuilt version).
`getXpath()` | Returns the DOMXPath object used internally to run queries on the DOMDocument object (this includes core and extension namespaces pre-registered).
`getXpathPrefix()` | Returns the valid DOM path prefix prepended to all XPath queries matching the feed being queried.
`getEncoding()` | Returns the encoding of the source XML document (note: this cannot account for errors such as the server sending documents in a different encoding). Where not defined, the default UTF-8 encoding of Unicode is applied.
`count()` | Returns a count of the entries or items this feed contains (implements SPL `Countable` interface)
`current()` | Returns either the current entry (using the current index from `key()`).
`key()` | Returns the current entry index.
`next()` | Increments the entry index value by one.
`rewind()` | Resets the entry index to 0.
`valid()` | Checks that the current entry index is valid, i.e. it does not fall below 0 and does not exceed the number of entries existing.
`getExtensions()` | Returns an array of all extension objects loaded for the current feed (note: both feed-level and entry-level extensions exist, and only feed-level extensions are returned here). The array keys are of the form `{ExtensionName}_Feed`.
`getExtension(string $name)` | Returns an extension object for the feed registered under the provided name. This allows more fine-grained access to extensions which may otherwise be hidden within the implementation of the standard API methods.
`getType()` | Returns a static class constant (e.g. `Zend\Feed\Reader\Reader::TYPE_ATOM_03`, i.e. "Atom 0.3"), indicating exactly what kind of feed is being consumed.
## Retrieving Entry/Item Information
Retrieving information for specific entries or items (depending on whether you
speak Atom or RSS) is identical to feed level data. Accessing entries is
simply a matter of iterating over a feed object or using the SPL `Iterator`
interface feed objects implement, and calling the appropriate method on each.
### Entry API Methods
Method | Description
------ | -----------
`getId()` | Returns a unique ID for the current entry.
`getTitle()` | Returns the title of the current entry.
`getDescription()` | Returns a description of the current entry.
`getLink()` | Returns a URI to the HTML version of the current entry.
`getPermaLink()` | Returns the permanent link to the current entry. In most cases, this is the same as using `getLink()`.
`getAuthors()` | Returns an object of type `Zend\Feed\Reader\Collection\Author`, which is an `ArrayObject` whose elements are each simple arrays containing any combination of the keys "name", "email" and "uri". Where irrelevant to the source data, some of these keys may be omitted.
`getAuthor(integer $index = 0)` | Returns either the first author known, or, with the optional `$index` parameter, any specific index on the array of Authors as described above (returning `NULL` if an invalid index).
`getDateCreated()` | Returns the date on which the current entry was created. Generally only applicable to Atom where it represents the date the resource described by an Atom 1.0 document was created.
`getDateModified()` | Returns the date on which the current entry was last modified.
`getContent()` | Returns the content of the current entry (this has any entities reversed if possible, assuming the content type is HTML). The description is returned if a separate content element does not exist.
`getEnclosure()` | Returns an array containing the value of all attributes from a multi-media `<enclosure>` element including as array keys: url, length, type. In accordance with the RSS Best Practices Profile of the RSS Advisory Board, no support is offers for multiple enclosures since such support forms no part of the RSS specification.
`getCommentCount()` | Returns the number of comments made on this entry at the time the feed was last generated.
`getCommentLink()` | Returns a URI pointing to the HTML page where comments can be made on this entry.
`getCommentFeedLink([string $type = ‘atom'|'rss'])` | Returns a URI pointing to a feed of the provided type containing all comments for this entry (type defaults to Atom/RSS depending on current feed type).
`getCategories()` | Returns a `Zend\Feed\Reader\Collection\Category` object containing the details of any categories associated with the entry. The supported fields include "term" (the machine readable category name), "scheme" (the categorisation scheme and domain for this category), and "label" (an HTML-decoded human readable category name). Where any of the three fields are absent from the field, they are either set to the closest available alternative or, in the case of "scheme", set to `NULL`.
The extended API for entries is identical to that for feeds with the exception
of the `Iterator` methods, which are not needed here.
> ### Modified vs Created dates
>
> There is often confusion over the concepts of *modified* and *created* dates.
> In Atom, these are two clearly defined concepts (so knock yourself out) but in
> RSS they are vague. RSS 2.0 defines a single `<pubDate>` element which
> typically refers to the date this entry was published, i.e. a creation date of
> sorts. This is not always the case, and it may change with updates or not. As a
> result, if you really want to check whether an entry has changed, don't rely on
> the results of `getDateModified()`. Instead, consider tracking the MD5 hash of
> three other elements concatenated, e.g. using `getTitle()`, `getDescription()`,
> and `getContent()`. If the entry was truly updated, this hash computation will
> give a different result than previously saved hashes for the same entry. This
> is obviously content oriented, and will not assist in detecting changes to
> other relevant elements. Atom feeds should not require such steps.
> Further muddying the waters, dates in feeds may follow different standards.
> Atom and Dublin Core dates should follow ISO 8601, and RSS dates should
> follow RFC 822 or RFC 2822 (which is also common). Date methods will throw an
> exception if `DateTime` cannot load the date string using one of the above
> standards, or the PHP recognised possibilities for RSS dates.
> ### Validation
>
> The values returned from these methods are not validated. This means users
> must perform validation on all retrieved data including the filtering of any
> HTML such as from `getContent()` before it is output from your application.
> Remember that most feeds come from external sources, and therefore the default
> assumption should be that they cannot be trusted.
### Extended Entry Level API Methods
Method | Description
------ | -----------
`getDomDocument()` | Returns the parent DOMDocument object for the entire feed (not just the current entry).
`getElement()` | Returns the current entry level DOMElement object.
`getXpath()` | Returns the DOMXPath object used internally to run queries on the DOMDocument object (this includes core and extension namespaces pre-registered).
`getXpathPrefix()` | Returns the valid DOM path prefix prepended to all XPath queries matching the entry being queried.
`getEncoding()` | Returns the encoding of the source XML document (note: this cannot account for errors such as the server sending documents in a different encoding). The default encoding applied in the absence of any other is the UTF-8 encoding of Unicode.
`getExtensions()` | Returns an array of all extension objects loaded for the current entry (note: both feed-level and entry-level extensions exist, and only entry-level extensions are returned here). The array keys are in the form `{ExtensionName}Entry`.
`getExtension(string $name)` | Returns an extension object for the entry registered under the provided name. This allows more fine-grained access to extensions which may otherwise be hidden within the implementation of the standard API methods.
`getType()` | Returns a static class constant (e.g. `Zend\Feed\Reader\Reader::TYPE_ATOM_03`, i.e. "Atom 0.3") indicating exactly what kind of feed is being consumed.
## Extending Feed and Entry APIs
Extending `Zend\Feed\Reader\Reader` allows you to add methods at both the feed
and entry level which cover the retrieval of information not already supported
by `Zend\Feed\Reader\Reader`. Given the number of RSS and Atom extensions that
exist, this is a good thing, since `Zend\Feed\Reader\Reader` couldn't possibly
add everything.
There are two types of extensions possible, those which retrieve information
from elements which are immediate children of the root element (e.g.
`<channel>` for RSS or `<feed>` for Atom), and those who retrieve information
from child elements of an entry (e.g. `<item>` for RSS or `<entry>` for Atom).
On the filesystem, these are grouped as classes within a namespace based on the
extension standard's name. For example, internally we have
`Zend\Feed\Reader\Extension\DublinCore\Feed` and
`Zend\Feed\Reader\Extension\DublinCore\Entry` classes which are two extensions
implementing Dublin Core 1.0 and 1.1 support.
Extensions are loaded into `Zend\Feed\Reader\Reader` using an "extension
manager". Extension managers must implement `Zend\Feed\Reader\ExtensionManagerInterface`.
Three implementations exist:
- `Zend\Feed\Reader\StandaloneExtensionManager` is a hard-coded implementation
seeded with all feed and entry implementations. You can extend it to add
extensions, though it's likely easier to copy and paste it, adding your
changes.
- `Zend\Feed\Reader\ExtensionPluginManager` is a `Zend\ServiceManager\AbstractPluginManager`
implementation, `Zend\Feed\Reader\ExtensionManager`; as such, you can extend
it to add more extensions, use a `Zend\ServiceManager\ConfigInterface` instance
to inject it with more extensions, or use its public API for adding services
(e.g., `setService()`, `setFactory()`, etc.). This implementation *does not*
implement `ExtensionManagerInterface`, and must be used with `ExtensionManager`.
- `Zend\Feed\Reader\ExtensionManager` exists for legacy purposes; prior to 2.3,
this was an `AbstractPluginManager` implementation, and the only provided
extension manager. It now implements `ExtensionManagerInterface`, and acts as
a decorator for `ExtensionPluginManager`.
By default, `Zend\Feed\Reader\Reader` composes a `StandaloneExtensionManager`. You
can inject an alternate implementation using `Reader::setExtensionManager()`:
```php
$extensions = new Zend\Feed\Reader\ExtensionPluginManager();
Zend\Feed\Reader\Reader::setExtensionManager(
new ExtensionManager($extensions)
);
```
The shipped implementations all provide the default extensions (so-called
"Core Extensions") used internally by `Zend\Feed\Reader\Reader`. These
include:
Extension | Description
--------- | -----------
DublinCore (Feed and Entry) | Implements support for Dublin Core Metadata Element Set 1.0 and 1.1.
Content (Entry only) | Implements support for Content 1.0.
Atom (Feed and Entry) | Implements support for Atom 0.3 and Atom 1.0.
Slash | Implements support for the Slash RSS 1.0 module.
WellFormedWeb | Implements support for the Well Formed Web CommentAPI 1.0.
Thread | Implements support for Atom Threading Extensions as described in RFC 4685.
Podcast | Implements support for the Podcast 1.0 DTD from Apple.
The core extensions are somewhat special since they are extremely common and
multi-faceted. For example, we have a core extension for Atom. Atom is
implemented as an extension (not just a base class) because it doubles as a
valid RSS module; you can insert Atom elements into RSS feeds. I've even seen
RDF feeds which use a lot of Atom in place of more common extensions like
Dublin Core.
The following is a list of non-Core extensions that are offered, but not registered
by default. If you want to use them, you'll need to
tell `Zend\Feed\Reader\Reader` to load them in advance of importing a feed.
Additional non-Core extensions will be included in future iterations of the
component.
Extension | Description
--------- | -----------
Syndication | Implements Syndication 1.0 support for RSS feeds.
CreativeCommons | An RSS module that adds an element at the `<channel>` or `<item>` level that specifies which Creative Commons license applies.
`Zend\Feed\Reader\Reader` requires you to explicitly register non-Core
extensions in order to expose their API to feed and entry objects. Below, we
register the optional Syndication extension, and discover that it can be
directly called from the entry API without any effort. (Note that
extension names are case sensitive and use camelCasing for multiple terms.)
```php
use Zend\Feed\Reader\Reader;
Reader::registerExtension('Syndication');
$feed = Reader::import('http://rss.slashdot.org/Slashdot/slashdot');
$updatePeriod = $feed->getUpdatePeriod();
```
In the simple example above, we checked how frequently a feed is being updated
using the `getUpdatePeriod()` method. Since it's not part of
`Zend\Feed\Reader\Reader`'s core API, it could only be a method supported by
the newly registered Syndication extension.
As you can also notice, methods provided by extensions are accessible from the
main API using method overloading. As an alternative, you can also directly
access any extension object for a similar result as seen below.
```php
use Zend\Feed\Reader\Reader;
Reader::registerExtension('Syndication');
$feed = Reader::import('http://rss.slashdot.org/Slashdot/slashdot');
$syndication = $feed->getExtension('Syndication');
$updatePeriod = $syndication->getUpdatePeriod();
```
### Writing Zend\\Feed\\Reader Extensions
Inevitably, there will be times when the `Zend\Feed\Reader` API is just
not capable of getting something you need from a feed or entry. You can use the
underlying source objects, like DOMDocument, to get these by hand; however, there
is a more reusable method available: you can write extensions supporting these new
queries.
As an example, let's take the case of a purely fictitious corporation named
Jungle Books. Jungle Books have been publishing a lot of reviews on books they
sell (from external sources and customers), which are distributed as an RSS 2.0
feed. Their marketing department realises that web applications using this feed
cannot currently figure out exactly what book is being reviewed. To make life
easier for everyone, they determine that the geek department needs to extend
RSS 2.0 to include a new element per entry supplying the ISBN-10 or ISBN-13
number of the publication the entry concerns. They define the new `<isbn>`
element quite simply with a standard name and namespace URI:
- Name: JungleBooks 1.0
- Namespace URI: http://example.com/junglebooks/rss/module/1.0/
A snippet of RSS containing this extension in practice could be something
similar to:
```xml
<?xml version="1.0" encoding="utf-8" ?>
<rss version="2.0"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:jungle="http://example.com/junglebooks/rss/module/1.0/">
<channel>
<title>Jungle Books Customer Reviews</title>
<link>http://example.com/junglebooks</link>
<description>Many book reviews!</description>
<pubDate>Fri, 26 Jun 2009 19:15:10 GMT</pubDate>
<jungle:dayPopular>
http://example.com/junglebooks/book/938
</jungle:dayPopular>
<item>
<title>Review Of Flatland: A Romance of Many Dimensions</title>
<link>http://example.com/junglebooks/review/987</link>
<author>Confused Physics Student</author>
<content:encoded>
A romantic square?!
</content:encoded>
<pubDate>Thu, 25 Jun 2009 20:03:28 -0700</pubDate>
<jungle:isbn>048627263X</jungle:isbn>
</item>
</channel>
</rss>
```
Implementing this new ISBN element as a simple entry level extension would
require the following class (using your own namespace).
```php
namespace My\FeedReader\Extension\JungleBooks;
use Zend\Feed\Reader\Extension\AbstractEntry;
class Entry extends AbstractEntry
{
public function getIsbn()
{
if (isset($this->data['isbn'])) {
return $this->data['isbn'];
}
$isbn = $this->xpath->evaluate(
'string(' . $this->getXpathPrefix() . '/jungle:isbn)'
);
if (! $isbn) {
$isbn = null;
}
$this->data['isbn'] = $isbn;
return $this->data['isbn'];
}
protected function registerNamespaces()
{
$this->xpath->registerNamespace(
'jungle',
'http://example.com/junglebooks/rss/module/1.0/'
);
}
}
```
This extension creates a new method `getIsbn()`, which runs an XPath query on
the current entry to extract the ISBN number enclosed by the `<jungle:isbn>`
element. It can optionally store this to the internal non-persistent cache (no
need to keep querying the DOM if it's called again on the same entry). The
value is returned to the caller. At the end we have a protected method (it's
abstract, making it required by implementations) which registers the Jungle
Books namespace for their custom RSS module. While we call this an RSS module,
there's nothing to prevent the same element being used in Atom feeds; all
extensions which use the prefix provided by `getXpathPrefix()` are actually
neutral and work on RSS or Atom feeds with no extra code.
Since this extension is stored outside of zend-feed, you'll need to ensure your
application can autoload it. Once that's in place, you will also need to ensure
your extension manager knows about it, and then register the extension with
`Zend\Feed\Reader\Reader`.
The following example uses `Zend\Feed\Reader\ExtensionPluginManager` to manage
extensions, as it provides the ability to register new extensions without
requiring extension of the plugin manager itself. To use it, first intall
zend-servicemanager:
```bash
$ composer require zendframework/zend-servicemanager
```
From there:
```php
use My\FeedReader\Extension\JungleBooks;
use Zend\Feed\Reader\ExtensionManager;
use Zend\Feed\Reader\ExtensionPluginManager;
use Zend\Feed\Reader\Reader;
$extensions = new ExtensionPluginManager();
$extensions->setInvokableClass('JungleBooks\Entry', JungleBooks\Entry::class);
Reader::setExtensionManager(new ExtensionManager($extensions));
Reader::registerExtension('JungleBooks');
$feed = Reader::import('http://example.com/junglebooks/rss');
// ISBN for whatever book the first entry in the feed was concerned with
$firstIsbn = $feed->current()->getIsbn();
```
Writing a feed extension is not much different. The example feed from earlier
included an unmentioned `<jungle:dayPopular>` element which Jungle Books have
added to their standard to include a link to the day's most popular book (in
terms of visitor traffic). Here's an extension which adds a
`getDaysPopularBookLink()` method to the feel level API.
```php
namespace My\FeedReader\Extension\JungleBooks;
use Zend\Feed\Reader\Extension\AbstractFeed;
class Feed extends AbstractFeed
{
public function getDaysPopularBookLink()
{
if (isset($this->data['dayPopular'])) {
return $this->data['dayPopular'];
}
$dayPopular = $this->xpath->evaluate(
'string(' . $this->getXpathPrefix() . '/jungle:dayPopular)'
);
if (!$dayPopular) {
$dayPopular = null;
}
$this->data['dayPopular'] = $dayPopular;
return $this->data['dayPopular'];
}
protected function registerNamespaces()
{
$this->xpath->registerNamespace(
'jungle',
'http://example.com/junglebooks/rss/module/1.0/'
);
}
}
```
Let's add to the previous example; we'll register the new class with the
extension manager, and then demonstrate using the newly exposed method:
```php
use My\FeedReader\Extension\JungleBooks;
use Zend\Feed\Reader\ExtensionManager;
use Zend\Feed\Reader\ExtensionPluginManager;
use Zend\Feed\Reader\Reader;
$extensions = new ExtensionPluginManager();
$extensions->setInvokableClass('JungleBooks\Entry', JungleBooks\Entry::class);
$extensions->setInvokableClass('JungleBooks\Feed', JungleBooks\Feed::class);
Reader::setExtensionManager(new ExtensionManager($extensions));
Reader::registerExtension('JungleBooks');
$feed = Reader::import('http://example.com/junglebooks/rss');
// URI to the information page of the day's most popular book with visitors
$daysPopularBookLink = $feed->getDaysPopularBookLink();
```
Going through these examples, you'll note that while we need to register the
feed and entry classes separately with the plugin manager, we don't register
them separately when registering the extension with the `Reader`. Extensions
within the same standard may or may not include both a feed and entry class, so
`Zend\Feed\Reader\Reader` only requires you to register the overall parent name,
e.g. JungleBooks, DublinCore, Slash. Internally, it can check at what level
extensions exist and load them up if found. In our case, we have a complete
extension now, spanning the classes `JungleBooks\Feed` and `JungleBooks\Entry`.

161
web/vendor/zendframework/zend-feed/doc/book/security.md vendored Normal file
View file

@ -0,0 +1,161 @@
# Zend\\Feed\\Reader and Security
As with any data coming from a source that is beyond the developer's control,
special attention needs to be given to securing, validating and filtering that
data. Similar to data input to our application by users, data coming from RSS
and Atom feeds should also be considered unsafe and potentially dangerous, as it
allows the delivery of HTML and [xHTML](http://tools.ietf.org/html/rfc4287#section-8.1).
Because data validation and filtration is out of `Zend\Feed`'s scope, this task
is left for implementation by the developer, by using libraries such as
zend-escaper for escaping and [HTMLPurifier](http://www.htmlpurifier.org/) for
validating and filtering feed data.
Escaping and filtering of potentially insecure data is highly recommended before
outputting it anywhere in our application or before storing that data in some
storage engine (be it a simple file or a database.).
## Filtering data using HTMLPurifier
Currently, the best available library for filtering and validating (x)HTML data
in PHP is [HTMLPurifier](http://www.htmlpurifier.org/), and, as such, is the
recommended tool for this task. HTMLPurifier works by filtering out all (x)HTML
from the data, except for the tags and attributes specifically allowed in a
whitelist, and by checking and fixing nesting of tags, ensuring
standards-compliant output.
The following examples will show a basic usage of HTMLPurifier, but developers
are urged to go through and read [HTMLPurifier's documentation](http://www.htmlpurifier.org/docs).
```php
// Setting HTMLPurifier's options
$options = [
// Allow only paragraph tags
// and anchor tags wit the href attribute
[
'HTML.Allowed',
'p,a[href]'
],
// Format end output with Tidy
[
'Output.TidyFormat',
true
],
// Assume XHTML 1.0 Strict Doctype
[
'HTML.Doctype',
'XHTML 1.0 Strict'
],
// Disable cache, but see note after the example
[
'Cache.DefinitionImpl',
null
]
];
// Configuring HTMLPurifier
$config = HTMLPurifier_Config::createDefault();
foreach ($options as $option) {
$config->set($option[0], $option[1]);
}
// Creating a HTMLPurifier with it's config
$purifier = new HTMLPurifier($config);
// Fetch the RSS
try {
$rss = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rss/');
} catch (Zend\Feed\Exception\Reader\RuntimeException $e) {
// feed import failed
echo "Exception caught importing feed: {$e->getMessage()}\n";
exit;
}
// Initialize the channel data array
// See that we're cleaning the description with HTMLPurifier
$channel = [
'title' => $rss->getTitle(),
'link' => $rss->getLink(),
'description' => $purifier->purify($rss->getDescription()),
'items' => [],
];
// Loop over each channel item and store relevant data
// See that we're cleaning the descriptions with HTMLPurifier
foreach ($rss as $item) {
$channel['items'][] = [
'title' => $item->getTitle(),
'link' => $item->getLink(),
'description' => $purifier->purify($item->getDescription()),
];
}
```
> ### Tidy is required
>
> HTMLPurifier is using the PHP [Tidy extension](http://php.net/tidy) to clean
> and repair the final output. If this extension is not available, it will
> silently fail, but its availability has no impact on the library's security.
> ### Caching
>
> For the sake of this example, the HTMLPurifier's cache is disabled, but it is
> recommended to configure caching and use its standalone include file as it can
> improve the performance of HTMLPurifier substantially.
## Escaping data using zend-escaper
To help prevent XSS attacks, Zend Framework provides the [zend-escaper component](https://github.com/zendframework/zend-escaper),
which complies to the current [OWASP recommendations](https://www.owasp.org/index.php/XSS_Prevention_Cheat_Sheet),
and as such, is the recommended tool for escaping HTML tags and attributes,
Javascript, CSS and URLs before outputing any potentially insecure data to the
users.
```php
try {
$rss = Zend\Feed\Reader\Reader::import('http://www.planet-php.net/rss/');
} catch (Zend\Feed\Exception\Reader\RuntimeException $e) {
// feed import failed
echo "Exception caught importing feed: {$e->getMessage()}\n";
exit;
}
// Validate all URIs
$linkValidator = new Zend\Validator\Uri;
$link = null;
if ($linkValidator->isValid($rss->getLink())) {
$link = $rss->getLink();
}
// Escaper used for escaping data
$escaper = new Zend\Escaper\Escaper('utf-8');
// Initialize the channel data array
$channel = [
'title' => $escaper->escapeHtml($rss->getTitle()),
'link' => $escaper->escapeUrl($link),
'description' => $escaper->escapeHtml($rss->getDescription()),
'items' => [],
];
// Loop over each channel item and store relevant data
foreach ($rss as $item) {
$link = null;
if ($linkValidator->isValid($rss->getLink())) {
$link = $item->getLink();
}
$channel['items'][] = [
'title' => $escaper->escapeHtml($item->getTitle()),
'link' => $escaper->escapeUrl($link),
'description' => $escaper->escapeHtml($item->getDescription()),
];
}
```
The feed data is now safe for output to HTML templates. You can, of course, skip
escaping when simply storing the data persistently, but remember to escape it on
output later!
Of course, these are just basic examples, and cannot cover all possible
scenarios that you, as a developer, can, and most likely will, encounter. Your
responsibility is to learn what libraries and tools are at your disposal, and
when and how to use them to secure your web applications.

280
web/vendor/zendframework/zend-feed/doc/book/writer.md vendored Normal file
View file

@ -0,0 +1,280 @@
# Zend\\Feed\\Writer
`Zend\Feed\Writer` is the sibling component to `Zend\Feed\Reader` responsible
for *generating* feeds. It supports the Atom 1.0 specification (RFC 4287) and
RSS 2.0 as specified by the RSS Advisory Board (RSS 2.0.11). It does not deviate
from these standards. It does, however, offer a simple extension system which
allows for any extension and module for either of these two specifications to be
implemented if they are not provided out of the box.
In many ways, `Zend\Feed\Writer` is the inverse of `Zend\Feed\Reader`. Where
`Zend\Reader\Reader` focuses on providing an easy to use architecture fronted by
getter methods, `Zend\Feed\Writer` is fronted by similarly named setters or
mutators. This ensures the API won't pose a learning curve to anyone familiar
with `Zend\Feed\Reader`.
As a result of this design, the rest may even be obvious. Behind the scenes,
data set on any `Zend\Feed\Writer\Writer` instance is translated at render time
onto a DOMDocument object using the necessary feed elements. For each supported
feed type there is both an Atom 1.0 and RSS 2.0 renderer. Using a DOMDocument
class rather than a templating solution has numerous advantages, the most
obvious being the ability to export the DOMDocument for additional processing
and relying on PHP DOM for correct and valid rendering.
## Architecture
The architecture of `Zend\Feed\Writer` is very simple. It has two core sets of
classes: data containers and renderers.
The containers include the `Zend\Feed\Writer\Feed` and `Zend\Feed\Writer\Entry`
classes. The Entry classes can be attached to any Feed class. The sole purpose
of these containers is to collect data about the feed to generate using a simple
interface of setter methods. These methods perform some data validity testing.
For example, it will validate any passed URIs, dates, etc. These checks are not
tied to any of the feed standards definitions. The container objects also
contain methods to allow for fast rendering and export of the final feed, and
these can be reused at will.
In addition to the main data container classes, there are two additional Atom
2.0-specific classes: `Zend\Feed\Writer\Source` and `Zend\Feed\Writer\Deleted`.
The former implements Atom 2.0 source elements which carry source feed metadata
for a specific entry within an aggregate feed (i.e. the current feed is not the
entry's original source). The latter implements the [Atom Tombstones RFC](https://tools.ietf.org/html/rfc6721),
allowing feeds to carry references to entries which have been deleted.
While there are two main data container types, there are four renderers: two
matching container renderers per supported feed type. Each renderer accepts a
container, and, based on its content, attempts to generate valid feed markup. If
the renderer is unable to generate valid feed markup (perhaps due to the
container missing an obligatory data point), it will report this by throwing an
exception. While it is possible to ignore exceptions, this removes the default
safeguard of ensuring you have sufficient data set to render a wholly valid
feed.
To explain this more clearly: you may construct a set of data containers for a
feed where there is a Feed container, into which has been added some Entry
containers and a Deleted container. This forms a data hierarchy resembling a
normal feed. When rendering is performed, this hierarchy has its pieces passed
to relevant renderers, and the partial feeds (all DOMDocuments) are then pieced
together to create a complete feed. In the case of Source or Deleted (Tombstone)
containers, these are rendered only for Atom 2.0 and ignored for RSS.
Due to the system being divided between data containers and renderers,
extensions have more mandatory requirements than their equivalents in the
`Zend\Feed\Reader` subcomponent. A typical extension offering namespaced feed
and entry level elements must itself reflect the exact same architecture: i.e.
it must offer both feed and entry level data containers, and matching renderers.
There is, fortunately, no complex integration work required since all extension
classes are simply registered and automatically used by the core classes. We
cover extensions in more detail at the end of this chapter.
## Getting Started
To use `Zend\Feed\Writer\Writer`, you will provide it with data, and then
trigger the renderer. What follows is an example demonstrating generation of a
minimal Atom 1.0 feed. Each feed or entry uses a separate data container.
```php
use Zend\Feed\Writer\Feed;
/**
* Create the parent feed
*/
$feed = new Feed;
$feed->setTitle("Paddy's Blog");
$feed->setLink('http://www.example.com');
$feed->setFeedLink('http://www.example.com/atom', 'atom');
$feed->addAuthor([
'name' => 'Paddy',
'email' => 'paddy@example.com',
'uri' => 'http://www.example.com',
]);
$feed->setDateModified(time());
$feed->addHub('http://pubsubhubbub.appspot.com/');
/**
* Add one or more entries. Note that entries must
* be manually added once created.
*/
$entry = $feed->createEntry();
$entry->setTitle('All Your Base Are Belong To Us');
$entry->setLink('http://www.example.com/all-your-base-are-belong-to-us');
$entry->addAuthor([
'name' => 'Paddy',
'email' => 'paddy@example.com',
'uri' => 'http://www.example.com',
]);
$entry->setDateModified(time());
$entry->setDateCreated(time());
$entry->setDescription('Exposing the difficulty of porting games to English.');
$entry->setContent(
'I am not writing the article. The example is long enough as is ;).'
);
$feed->addEntry($entry);
/**
* Render the resulting feed to Atom 1.0 and assign to $out.
* You can substitute "atom" with "rss" to generate an RSS 2.0 feed.
*/
$out = $feed->export('atom');
```
The output rendered should be as follows:
```xml
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title type="text">Paddy's Blog</title>
<subtitle type="text">Writing about PC Games since 176 BC.</subtitle>
<updated>2009-12-14T20:28:18+00:00</updated>
<generator uri="http://framework.zend.com" version="1.10.0alpha">
Zend\Feed\Writer
</generator>
<link rel="alternate" type="text/html" href="http://www.example.com"/>
<link rel="self" type="application/atom+xml"
href="http://www.example.com/atom"/>
<id>http://www.example.com</id>
<author>
<name>Paddy</name>
<email>paddy@example.com</email>
<uri>http://www.example.com</uri>
</author>
<link rel="hub" href="http://pubsubhubbub.appspot.com/"/>
<entry>
<title type="html"><![CDATA[All Your Base Are Belong To
Us]]></title>
<summary type="html">
<![CDATA[Exposing the difficultly of porting games to
English.]]>
</summary>
<published>2009-12-14T20:28:18+00:00</published>
<updated>2009-12-14T20:28:18+00:00</updated>
<link rel="alternate" type="text/html"
href="http://www.example.com/all-your-base-are-belong-to-us"/>
<id>http://www.example.com/all-your-base-are-belong-to-us</id>
<author>
<name>Paddy</name>
<email>paddy@example.com</email>
<uri>http://www.example.com</uri>
</author>
<content type="html">
<![CDATA[I am not writing the article.
The example is long enough as is ;).]]>
</content>
</entry>
</feed>
```
This is a perfectly valid Atom 1.0 example. It should be noted that omitting an
obligatory point of data, such as a title, will trigger an exception when
rendering as Atom 1.0. This will differ for RSS 2.0, since a title may be
omitted so long as a description is present. This gives rise to exceptions that
differ between the two standards depending on the renderer in use. By design,
`Zend\Feed\Writer` will not render an invalid feed for either standard
unless the end-user deliberately elects to ignore all exceptions. This built in
safeguard was added to ensure users without in-depth knowledge of the relevant
specifications have a bit less to worry about.
## Setting Feed Data Points
Before you can render a feed, you must first setup the data necessary for the
feed being rendered. This utilises a simple setter style API, which doubles as
a method for validating the data being set. By design, the API closely matches
that for `Zend\Feed\Reader` to avoid undue confusion and uncertainty.
`Zend\Feed\Writer` offers this API via its data container classes
`Zend\Feed\Writer\Feed` and `Zend\Feed\Writer\Entry` (not to mention the Atom
2.0 specific and extension classes). These classes merely store all feed data in
a type-agnostic manner, meaning you may reuse any data container with any
renderer without requiring additional work. Both classes are also amenable to
extensions, meaning that an extension may define its own container classes which
are registered to the base container classes as extensions, and are checked when
any method call triggers the base container's `__call()` method, allowing method
overloading to the extension classes.
Here's a summary of the Core API for Feeds. You should note it comprises not
only the basic RSS and Atom standards, but also accounts for a number of
included extensions bundled with `Zend\Feed\Writer`. The naming of these
extension sourced methods remain fairly generic; all extension methods operate
at the same level as the Core API, though we do allow you to retrieve any
specific extension object separately if required.
The Feed API for data is contained in `Zend\Feed\Writer\Feed`. In addition to the API
detailed below, the class also implements the `Countable` and `Iterator` interfaces.
### Feed API Methods
Method | Description
------ | -----------
`setId()` | Set a unique identifier associated with this feed. For Atom 1.0 this is an `atom:id` element, whereas for RSS 2.0 it is added as a `guid` element. These are optional so long as a link is added; i.e. if no identifier is provided, the link is used.
`setTitle()` | Set the title of the feed.
`setDescription()` | Set the text description of the feed.
`setLink()` | Set a URI to the HTML website containing the same or similar information as this feed (i.e. if the feed is from a blog, it should provide the blog's URI where the HTML version of the entries can be read).
`setFeedLinks()` | Add a link to an XML feed, whether it is to the feed being generated, or an alternate URI pointing to the same feed but in a different format. At a minimum, it is recommended to include a link to the feed being generated so it has an identifiable final URI allowing a client to track its location changes without necessitating constant redirects. The parameter is an array of arrays, where each sub-array contains the keys "type" and "uri". The type should be one of "atom", "rss", or "rdf".
`addAuthors()` | Sets the data for authors. The parameter is an array of array,s where each sub-array may contain the keys "name", "email", and "uri". The "uri" value is only applicable for Atom feeds, since RSS contains no facility to show it. For RSS 2.0, rendering will create two elements: an author element containing the email reference with the name in brackets, and a Dublin Core creator element only containing the name.
`addAuthor()` | Sets the data for a single author following the same array format as described above for a single sub-array.
`setDateCreated()` | Sets the date on which this feed was created. Generally only applicable to Atom, where it represents the date the resource described by an Atom 1.0 document was created. The expected parameter may be a UNIX timestamp or a `DateTime` object.
`setDateModified()` | Sets the date on which this feed was last modified. The expected parameter may be a UNIX timestamp or a `DateTime` object.
`setLastBuildDate()` | Sets the date on which this feed was last build. The expected parameter may be a UNIX timestamp or a `DateTime` object. This will only be rendered for RSS 2.0 feeds, and is automatically rendered as the current date by default when not explicitly set.
`setLanguage()` | Sets the language of the feed. This will be omitted unless set.
`setGenerator()` | Allows the setting of a generator. The parameter should be an array containing the keys "name", "version", and "uri". If omitted a default generator will be added referencing `Zend\Feed\Writer`, the current zend-version version, and the Framework's URI.
`setCopyright()` | Sets a copyright notice associated with the feed.
`addHubs()` | Accepts an array of Pubsubhubbub Hub Endpoints to be rendered in the feed as Atom links so that PuSH Subscribers may subscribe to your feed. Note that you must implement a Pubsubhubbub Publisher in order for real-time updates to be enabled. A Publisher may be implemented using `Zend\Feed\Pubsubhubbub\Publisher`. The method `addHub()` allows adding a single hub at a time.
`addCategories()` | Accepts an array of categories for rendering, where each element is itself an array whose possible keys include "term", "label", and "scheme". The "term" is a typically a category name suitable for inclusion in a URI. The "label" may be a human readable category name supporting special characters (it is HTML encoded during rendering) and is a required key. The "scheme" (called the domain in RSS) is optional, but must be a valid URI. The method `addCategory()` allows adding a single category at a time.
`setImage()` | Accepts an array of image metadata for an RSS image or Atom logo. Atom 1.0 only requires a URI. RSS 2.0 requires a URI, HTML link, and an image title. RSS 2.0 optionally may send a width, height, and image description. To provide these, use an array argument with the following keys: "uri", "link", "title", "description", "height", and "width". The RSS 2.0 HTML link should point to the feed source's HTML page.
`createEntry()` | Returns a new instance of `Zend\Feed\Writer\Entry`. This is the Entry data container. New entries are not automatically assigned to the current feed, so you must explicitly call `addEntry()` to add the entry for rendering.
`addEntry()` | Adds an instance of `Zend\Feed\Writer\Entry` to the current feed container for rendering.
`createTombstone()` | Returns a new instance of `Zend\Feed\Writer\Deleted`. This is the Atom 2.0 Tombstone data container. New entries are not automatically assigned to the current feed, so you must explicitly call `addTombstone()` to add the deleted entry for rendering.
`addTombstone()` | Adds an instance of `Zend\Feed\Writer\Deleted` to the current feed container for rendering.
`removeEntry()` | Accepts a parameter indicating an array index of the entry to remove from the feed.
`export()` | Exports the entire data hierarchy to an XML feed. The method has two parameters. The first is the feed type, one of "atom" or "rss". The second is an optional boolean to set indicating whether or not Exceptions are thrown. The default is `TRUE`.
> #### Retrieval methods
>
> In addition to the setters listed above, `Feed` instances also provide
> matching getters to retrieve data from the `Feed` data container. For
> example, `setImage()` is matched with a `getImage()` method.
## Setting Entry Data Points
Below is a summary of the Core API for entries and items. You should note that
it covers not only the basic RSS and Atom standards, but also a number of
included extensions bundled with `Zend\Feed\Writer`. The naming of these
extension sourced methods remain fairly generic; all extension methods operate
at the same level as the Core API, though we do allow you to retrieve any
specific extension object separately if required.
The Entry *API* for data is contained in `Zend\Feed\Writer\Entry`.
### Entry API Methods
Method | Description
------ | -----------
`setId()` | Set a unique identifier associated with this entry. For Atom 1.0 this is an `atom:id` element, whereas for RSS 2.0 it is added as a `guid` element. These are optional so long as a link is added; i.e. if no identifier is provided, the link is used.
`setTitle()` | Set the title of the entry.
`setDescription()` | Set the text description of the entry.
`setContent()` | Set the content of the entry.
`setLink()` | Set a URI to the HTML website containing the same or similar information as this entry (i.e. if the feed is from a blog, it should provide the blog article's URI where the HTML version of the entry can be read).
`setFeedLinks()` | Add a link to an XML feed, whether it is to the feed being generated, or an alternate URI pointing to the same feed but in a different format. At a minimum, it is recommended to include a link to the feed being generated so it has an identifiable final URI allowing a client to track its location changes without necessitating constant redirects. The parameter is an array of arrays, where each sub-array contains the keys "type" and "uri". The type should be one of "atom", "rss", or "rdf". If a type is omitted, it defaults to the type used when rendering the feed.
`addAuthors()` | Sets the data for authors. The parameter is an array of array,s where each sub-array may contain the keys "name", "email", and "uri". The "uri" value is only applicable for Atom feeds, since RSS contains no facility to show it. For RSS 2.0, rendering will create two elements: an author element containing the email reference with the name in brackets, and a Dublin Core creator element only containing the name.
`addAuthor()` | Sets the data for a single author following the same format as described above for a single sub-array.
`setDateCreated()` | Sets the date on which this entry was created. Generally only applicable to Atom where it represents the date the resource described by an Atom 1.0 document was created. The expected parameter may be a UNIX timestamp or a `DateTime` object. If omitted, the date used will be the current date and time.
`setDateModified()` | Sets the date on which this entry was last modified. The expected parameter may be a UNIX timestamp or a `DateTime` object. If omitted, the date used will be the current date and time.
`setCopyright()` | Sets a copyright notice associated with the entry.
`addCategories()` | Accepts an array of categories for rendering, where each element is itself an array whose possible keys include "term", "label", and "scheme". The "term" is a typically a category name suitable for inclusion in a URI. The "label" may be a human readable category name supporting special characters (it is encoded during rendering) and is a required key. The "scheme" (called the domain in RSS) is optional but must be a valid URI.
`addCategory()` | Sets the data for a single category following the same format as described above for a single sub-array.
`setCommentCount()` | Sets the number of comments associated with this entry. Rendering differs between RSS and Atom 2.0 depending on the element or attribute needed.
`setCommentLink()` | Sets a link to an HTML page containing comments associated with this entry.
`setCommentFeedLink()` | Sets a link to an XML feed containing comments associated with this entry. The parameter is an array containing the keys "uri" and "type", where the type is one of "rdf", "rss", or "atom".
`setCommentFeedLinks()` | Same as `setCommentFeedLink()`, except it accepts an array of arrays, where each subarray contains the expected parameters of `setCommentFeedLink()`.
`setEncoding()` | Sets the encoding of entry text. This will default to UTF-8, which is the preferred encoding.
> #### Retrieval methods
>
> In addition to the setters listed above, `Entry` instances also provide
> matching getters to retrieve data from the `Entry` data container. For
> example, `setContent()` is matched with a `getContent()` method.
## Extensions
- TODO

21
web/vendor/zendframework/zend-feed/mkdocs.yml vendored Normal file
View file

@ -0,0 +1,21 @@
docs_dir: doc/book
site_dir: doc/html
pages:
- index.md
- Introduction: intro.md
- Reader:
- "Zend\\Feed\\Reader": reader.md
- 'HTTP Clients': http-clients.md
- 'Using PSR-7 Clients': psr7-clients.md
- 'Importing Feeds': importing.md
- 'Feed Discovery': find-feeds.md
- 'Consuming RSS Feeds': consuming-rss.md
- 'Consuming Atom Feeds': consuming-atom.md
- 'Consuming Atom Entries': consuming-atom-entry.md
- Security: security.md
- Writer: writer.md
- Pubsubhubbub: pubsubhubbub.md
site_name: zend-feed
site_description: Zend\Feed
repo_url: 'https://github.com/zendframework/zend-feed'
copyright: 'Copyright (c) 2016 <a href="http://www.zend.com/">Zend Technologies USA Inc.</a>'

8
web/vendor/zendframework/zend-feed/phpcs.xml vendored Normal file
View file

@ -0,0 +1,8 @@
<?xml version="1.0"?>
<ruleset name="Zend Framework coding standard">
<rule ref="./vendor/zendframework/zend-coding-standard/ruleset.xml"/>
<!-- Paths to check -->
<file>src</file>
<file>test</file>
</ruleset>

24
web/vendor/zendframework/zend-feed/src/PubSubHubbub/AbstractCallback.php vendored
View file

@ -67,7 +67,7 @@ abstract class AbstractCallback implements CallbackInterface
$options = ArrayUtils::iteratorToArray($options);
}
if (!is_array($options)) {
if (! is_array($options)) {
throw new Exception\InvalidArgumentException('Array or Traversable object'
. 'expected, got ' . gettype($options));
}
@ -137,7 +137,7 @@ abstract class AbstractCallback implements CallbackInterface
*/
public function setHttpResponse($httpResponse)
{
if (!$httpResponse instanceof HttpResponse && !$httpResponse instanceof PhpResponse) {
if (! $httpResponse instanceof HttpResponse && ! $httpResponse instanceof PhpResponse) {
throw new Exception\InvalidArgumentException('HTTP Response object must'
. ' implement one of Zend\Feed\Pubsubhubbub\HttpResponse or'
. ' Zend\Http\PhpEnvironment\Response');
@ -196,8 +196,10 @@ abstract class AbstractCallback implements CallbackInterface
* Attempt to detect the callback URL (specifically the path forward)
* @return string
*/
// @codingStandardsIgnoreStart
protected function _detectCallbackUrl()
{
// @codingStandardsIgnoreEnd
$callbackUrl = '';
if (isset($_SERVER['HTTP_X_ORIGINAL_URL'])) {
$callbackUrl = $_SERVER['HTTP_X_ORIGINAL_URL'];
@ -214,8 +216,8 @@ abstract class AbstractCallback implements CallbackInterface
$callbackUrl = substr($callbackUrl, strlen($schemeAndHttpHost));
}
} elseif (isset($_SERVER['ORIG_PATH_INFO'])) {
$callbackUrl= $_SERVER['ORIG_PATH_INFO'];
if (!empty($_SERVER['QUERY_STRING'])) {
$callbackUrl = $_SERVER['ORIG_PATH_INFO'];
if (! empty($_SERVER['QUERY_STRING'])) {
$callbackUrl .= '?' . $_SERVER['QUERY_STRING'];
}
}
@ -227,9 +229,11 @@ abstract class AbstractCallback implements CallbackInterface
*
* @return string
*/
// @codingStandardsIgnoreStart
protected function _getHttpHost()
{
if (!empty($_SERVER['HTTP_HOST'])) {
// @codingStandardsIgnoreEnd
if (! empty($_SERVER['HTTP_HOST'])) {
return $_SERVER['HTTP_HOST'];
}
$scheme = 'http';
@ -253,19 +257,21 @@ abstract class AbstractCallback implements CallbackInterface
* @param string $header
* @return bool|string
*/
// @codingStandardsIgnoreStart
protected function _getHeader($header)
{
// @codingStandardsIgnoreEnd
$temp = strtoupper(str_replace('-', '_', $header));
if (!empty($_SERVER[$temp])) {
if (! empty($_SERVER[$temp])) {
return $_SERVER[$temp];
}
$temp = 'HTTP_' . strtoupper(str_replace('-', '_', $header));
if (!empty($_SERVER[$temp])) {
if (! empty($_SERVER[$temp])) {
return $_SERVER[$temp];
}
if (function_exists('apache_request_headers')) {
$headers = apache_request_headers();
if (!empty($headers[$header])) {
if (! empty($headers[$header])) {
return $headers[$header];
}
}
@ -277,8 +283,10 @@ abstract class AbstractCallback implements CallbackInterface
*
* @return string|false Raw body, or false if not present
*/
// @codingStandardsIgnoreStart
protected function _getRawBody()
{
// @codingStandardsIgnoreEnd
$body = file_get_contents('php://input');
if (strlen(trim($body)) == 0 && isset($GLOBALS['HTTP_RAW_POST_DATA'])) {
$body = $GLOBALS['HTTP_RAW_POST_DATA'];

14
web/vendor/zendframework/zend-feed/src/PubSubHubbub/HttpResponse.php vendored
View file

@ -60,14 +60,14 @@ class HttpResponse
}
$httpCodeSent = false;
foreach ($this->headers as $header) {
if (!$httpCodeSent && $this->statusCode) {
if (! $httpCodeSent && $this->statusCode) {
header($header['name'] . ': ' . $header['value'], $header['replace'], $this->statusCode);
$httpCodeSent = true;
} else {
header($header['name'] . ': ' . $header['value'], $header['replace']);
}
}
if (!$httpCodeSent) {
if (! $httpCodeSent) {
header('HTTP/1.1 ' . $this->statusCode);
}
}
@ -140,9 +140,11 @@ class HttpResponse
{
$ok = headers_sent($file, $line);
if ($ok && $throw) {
throw new Exception\RuntimeException('Cannot send headers; headers already sent in ' . $file . ', line ' . $line);
throw new Exception\RuntimeException(
'Cannot send headers; headers already sent in ' . $file . ', line ' . $line
);
}
return !$ok;
return ! $ok;
}
/**
@ -154,7 +156,7 @@ class HttpResponse
*/
public function setStatusCode($code)
{
if (!is_int($code) || (100 > $code) || (599 < $code)) {
if (! is_int($code) || (100 > $code) || (599 < $code)) {
throw new Exception\InvalidArgumentException('Invalid HTTP response'
. ' code:' . $code);
}
@ -201,8 +203,10 @@ class HttpResponse
* @param string $name
* @return string
*/
// @codingStandardsIgnoreStart
protected function _normalizeHeader($name)
{
// @codingStandardsIgnoreEnd
$filtered = str_replace(['-', '_'], ' ', (string) $name);
$filtered = ucwords(strtolower($filtered));
$filtered = str_replace(' ', '-', $filtered);

6
web/vendor/zendframework/zend-feed/src/PubSubHubbub/Model/Subscription.php vendored
View file

@ -31,7 +31,7 @@ class Subscription extends AbstractModel implements SubscriptionPersistenceInter
*/
public function setSubscription(array $data)
{
if (!isset($data['id'])) {
if (! isset($data['id'])) {
throw new PubSubHubbub\Exception\InvalidArgumentException(
'ID must be set before attempting a save'
);
@ -66,7 +66,7 @@ class Subscription extends AbstractModel implements SubscriptionPersistenceInter
*/
public function getSubscription($key)
{
if (empty($key) || !is_string($key)) {
if (empty($key) || ! is_string($key)) {
throw new PubSubHubbub\Exception\InvalidArgumentException('Invalid parameter "key"'
.' of "' . $key . '" must be a non-empty string');
}
@ -86,7 +86,7 @@ class Subscription extends AbstractModel implements SubscriptionPersistenceInter
*/
public function hasSubscription($key)
{
if (empty($key) || !is_string($key)) {
if (empty($key) || ! is_string($key)) {
throw new PubSubHubbub\Exception\InvalidArgumentException('Invalid parameter "key"'
.' of "' . $key . '" must be a non-empty string');
}

2
web/vendor/zendframework/zend-feed/src/PubSubHubbub/PubSubHubbub.php vendored
View file

@ -85,7 +85,7 @@ class PubSubHubbub
*/
public static function getHttpClient()
{
if (!isset(static::$httpClient)) {
if (! isset(static::$httpClient)) {
static::$httpClient = new Http\Client;
} else {
static::$httpClient->resetParameters();

22
web/vendor/zendframework/zend-feed/src/PubSubHubbub/Publisher.php vendored
View file

@ -75,7 +75,7 @@ class Publisher
$options = ArrayUtils::iteratorToArray($options);
}
if (!is_array($options)) {
if (! is_array($options)) {
throw new Exception\InvalidArgumentException('Array or Traversable object'
. 'expected, got ' . gettype($options));
}
@ -100,7 +100,7 @@ class Publisher
*/
public function addHubUrl($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. 'URL');
@ -131,7 +131,7 @@ class Publisher
*/
public function removeHubUrl($url)
{
if (!in_array($url, $this->getHubUrls())) {
if (! in_array($url, $this->getHubUrls())) {
return $this;
}
$key = array_search($url, $this->hubUrls);
@ -159,7 +159,7 @@ class Publisher
*/
public function addUpdatedTopicUrl($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. 'URL');
@ -190,7 +190,7 @@ class Publisher
*/
public function removeUpdatedTopicUrl($url)
{
if (!in_array($url, $this->getUpdatedTopicUrls())) {
if (! in_array($url, $this->getUpdatedTopicUrls())) {
return $this;
}
$key = array_search($url, $this->updatedTopicUrls);
@ -219,7 +219,7 @@ class Publisher
*/
public function notifyHub($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. 'URL');
@ -281,7 +281,7 @@ class Publisher
$this->setParameters($name);
return $this;
}
if (empty($name) || !is_string($name)) {
if (empty($name) || ! is_string($name)) {
throw new Exception\InvalidArgumentException('Invalid parameter "name"'
. ' of "' . $name . '" must be a non-empty string');
}
@ -289,7 +289,7 @@ class Publisher
$this->removeParameter($name);
return $this;
}
if (empty($value) || (!is_string($value) && $value !== null)) {
if (empty($value) || (! is_string($value) && $value !== null)) {
throw new Exception\InvalidArgumentException('Invalid parameter "value"'
. ' of "' . $value . '" must be a non-empty string');
}
@ -320,7 +320,7 @@ class Publisher
*/
public function removeParameter($name)
{
if (empty($name) || !is_string($name)) {
if (empty($name) || ! is_string($name)) {
throw new Exception\InvalidArgumentException('Invalid parameter "name"'
. ' of "' . $name . '" must be a non-empty string');
}
@ -348,7 +348,7 @@ class Publisher
*/
public function isSuccess()
{
return !(count($this->errors) != 0);
return ! (count($this->errors) != 0);
}
/**
@ -369,8 +369,10 @@ class Publisher
* @return \Zend\Http\Client
* @throws Exception\RuntimeException
*/
// @codingStandardsIgnoreStart
protected function _getHttpClient()
{
// @codingStandardsIgnoreEnd
$client = PubSubHubbub::getHttpClient();
$client->setMethod(HttpRequest::METHOD_POST);
$client->setOptions([

42
web/vendor/zendframework/zend-feed/src/PubSubHubbub/Subscriber.php vendored
View file

@ -147,7 +147,7 @@ class Subscriber
$options = ArrayUtils::iteratorToArray($options);
}
if (!is_array($options)) {
if (! is_array($options)) {
throw new Exception\InvalidArgumentException('Array or Traversable object'
. 'expected, got ' . gettype($options));
}
@ -193,7 +193,7 @@ class Subscriber
*/
public function setTopicUrl($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
.' of "' . $url . '" must be a non-empty string and a valid'
.' URL');
@ -256,7 +256,7 @@ class Subscriber
*/
public function setCallbackUrl($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. ' URL');
@ -326,7 +326,7 @@ class Subscriber
*/
public function addHubUrl($url)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. ' URL');
@ -357,7 +357,7 @@ class Subscriber
*/
public function removeHubUrl($url)
{
if (!in_array($url, $this->getHubUrls())) {
if (! in_array($url, $this->getHubUrls())) {
return $this;
}
$key = array_search($url, $this->hubUrls);
@ -386,7 +386,7 @@ class Subscriber
*/
public function addAuthentication($url, array $authentication)
{
if (empty($url) || !is_string($url) || !Uri::factory($url)->isValid()) {
if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) {
throw new Exception\InvalidArgumentException('Invalid parameter "url"'
. ' of "' . $url . '" must be a non-empty string and a valid'
. ' URL');
@ -445,7 +445,7 @@ class Subscriber
$this->setParameters($name);
return $this;
}
if (empty($name) || !is_string($name)) {
if (empty($name) || ! is_string($name)) {
throw new Exception\InvalidArgumentException('Invalid parameter "name"'
. ' of "' . $name . '" must be a non-empty string');
}
@ -453,7 +453,7 @@ class Subscriber
$this->removeParameter($name);
return $this;
}
if (empty($value) || (!is_string($value) && $value !== null)) {
if (empty($value) || (! is_string($value) && $value !== null)) {
throw new Exception\InvalidArgumentException('Invalid parameter "value"'
. ' of "' . $value . '" must be a non-empty string');
}
@ -484,7 +484,7 @@ class Subscriber
*/
public function removeParameter($name)
{
if (empty($name) || !is_string($name)) {
if (empty($name) || ! is_string($name)) {
throw new Exception\InvalidArgumentException('Invalid parameter "name"'
. ' of "' . $name . '" must be a non-empty string');
}
@ -602,8 +602,10 @@ class Subscriber
* @return void
* @throws Exception\RuntimeException
*/
// @codingStandardsIgnoreStart
protected function _doRequest($mode)
{
// @codingStandardsIgnoreEnd
$client = $this->_getHttpClient();
$hubs = $this->getHubUrls();
if (empty($hubs)) {
@ -648,8 +650,10 @@ class Subscriber
*
* @return \Zend\Http\Client
*/
// @codingStandardsIgnoreStart
protected function _getHttpClient()
{
// @codingStandardsIgnoreEnd
$client = PubSubHubbub::getHttpClient();
$client->setMethod(HttpRequest::METHOD_POST);
$client->setOptions(['useragent' => 'Zend_Feed_Pubsubhubbub_Subscriber/'
@ -666,9 +670,11 @@ class Subscriber
* @return string
* @throws Exception\InvalidArgumentException
*/
// @codingStandardsIgnoreStart
protected function _getRequestParameters($hubUrl, $mode)
{
if (!in_array($mode, ['subscribe', 'unsubscribe'])) {
// @codingStandardsIgnoreEnd
if (! in_array($mode, ['subscribe', 'unsubscribe'])) {
throw new Exception\InvalidArgumentException('Invalid mode specified: "'
. $mode . '" which should have been "subscribe" or "unsubscribe"');
}
@ -705,7 +711,7 @@ class Subscriber
$params['hub.verify_token'] = $token;
// Note: query string only usable with PuSH 0.2 Hubs
if (!$this->usePathParameter) {
if (! $this->usePathParameter) {
$params['hub.callback'] = $this->getCallbackUrl()
. '?xhub.subscription=' . PubSubHubbub::urlencode($key);
} else {
@ -738,7 +744,9 @@ class Subscriber
'verify_token' => hash('sha256', $params['hub.verify_token']),
'secret' => null,
'expiration_time' => $expires,
'subscription_state' => ($mode == 'unsubscribe')? PubSubHubbub::SUBSCRIPTION_TODELETE : PubSubHubbub::SUBSCRIPTION_NOTVERIFIED,
// @codingStandardsIgnoreStart
'subscription_state' => ($mode == 'unsubscribe') ? PubSubHubbub::SUBSCRIPTION_TODELETE : PubSubHubbub::SUBSCRIPTION_NOTVERIFIED,
// @codingStandardsIgnoreEnd
];
$this->getStorage()->setSubscription($data);
@ -754,9 +762,11 @@ class Subscriber
*
* @return string
*/
// @codingStandardsIgnoreStart
protected function _generateVerifyToken()
{
if (!empty($this->testStaticToken)) {
// @codingStandardsIgnoreEnd
if (! empty($this->testStaticToken)) {
return $this->testStaticToken;
}
return uniqid(rand(), true) . time();
@ -770,8 +780,10 @@ class Subscriber
* @param string $hubUrl The Hub Server URL for which this token will apply
* @return string
*/
// @codingStandardsIgnoreStart
protected function _generateSubscriptionKey(array $params, $hubUrl)
{
// @codingStandardsIgnoreEnd
$keyBase = $params['hub.topic'] . $hubUrl;
$key = md5($keyBase);
@ -784,8 +796,10 @@ class Subscriber
* @param array $params
* @return array
*/
// @codingStandardsIgnoreStart
protected function _urlEncode(array $params)
{
// @codingStandardsIgnoreEnd
$encoded = [];
foreach ($params as $key => $value) {
if (is_array($value)) {
@ -809,8 +823,10 @@ class Subscriber
* @param array $params
* @return array
*/
// @codingStandardsIgnoreStart
protected function _toByteValueOrderedString(array $params)
{
// @codingStandardsIgnoreEnd
$return = [];
uksort($params, 'strnatcmp');
foreach ($params as $key => $value) {

16
web/vendor/zendframework/zend-feed/src/PubSubHubbub/Subscriber/Callback.php vendored
View file

@ -147,7 +147,7 @@ class Callback extends PubSubHubbub\AbstractCallback
'hub_verify_token',
];
foreach ($required as $key) {
if (!array_key_exists($key, $httpGetData)) {
if (! array_key_exists($key, $httpGetData)) {
return false;
}
}
@ -157,11 +157,11 @@ class Callback extends PubSubHubbub\AbstractCallback
return false;
}
if ($httpGetData['hub_mode'] == 'subscribe'
&& !array_key_exists('hub_lease_seconds', $httpGetData)
&& ! array_key_exists('hub_lease_seconds', $httpGetData)
) {
return false;
}
if (!Uri::factory($httpGetData['hub_topic'])->isValid()) {
if (! Uri::factory($httpGetData['hub_topic'])->isValid()) {
return false;
}
@ -169,7 +169,7 @@ class Callback extends PubSubHubbub\AbstractCallback
* Attempt to retrieve any Verification Token Key attached to Callback
* URL's path by our Subscriber implementation
*/
if (!$this->_hasValidVerifyToken($httpGetData)) {
if (! $this->_hasValidVerifyToken($httpGetData)) {
return false;
}
return true;
@ -220,14 +220,16 @@ class Callback extends PubSubHubbub\AbstractCallback
* @param bool $checkValue
* @return bool
*/
// @codingStandardsIgnoreStart
protected function _hasValidVerifyToken(array $httpGetData = null, $checkValue = true)
{
// @codingStandardsIgnoreEnd
$verifyTokenKey = $this->_detectVerifyTokenKey($httpGetData);
if (empty($verifyTokenKey)) {
return false;
}
$verifyTokenExists = $this->getStorage()->hasSubscription($verifyTokenKey);
if (!$verifyTokenExists) {
if (! $verifyTokenExists) {
return false;
}
if ($checkValue) {
@ -250,8 +252,10 @@ class Callback extends PubSubHubbub\AbstractCallback
* @param null|array $httpGetData
* @return false|string
*/
// @codingStandardsIgnoreStart
protected function _detectVerifyTokenKey(array $httpGetData = null)
{
// @codingStandardsIgnoreEnd
/**
* Available when sub keys encoding in Callback URL path
*/
@ -286,8 +290,10 @@ class Callback extends PubSubHubbub\AbstractCallback
*
* @return array|void
*/
// @codingStandardsIgnoreStart
protected function _parseQueryString()
{
// @codingStandardsIgnoreEnd
$params = [];
$queryString = '';
if (isset($_SERVER['QUERY_STRING'])) {

4
web/vendor/zendframework/zend-feed/src/Reader/AbstractEntry.php vendored
View file

@ -141,7 +141,7 @@ abstract class AbstractEntry
*/
public function getXpath()
{
if (!$this->xpath) {
if (! $this->xpath) {
$this->setXpath(new DOMXPath($this->getDomDocument()));
}
return $this->xpath;
@ -207,8 +207,10 @@ abstract class AbstractEntry
*
* @return void
*/
// @codingStandardsIgnoreStart
protected function _loadExtensions()
{
// @codingStandardsIgnoreEnd
$all = Reader::getExtensions();
$feed = $all['entry'];
foreach ($feed as $extension) {

2
web/vendor/zendframework/zend-feed/src/Reader/Collection/Category.php vendored
View file

@ -23,7 +23,7 @@ class Category extends AbstractCollection
{
$categories = [];
foreach ($this->getIterator() as $element) {
if (isset($element['label']) && !empty($element['label'])) {
if (isset($element['label']) && ! empty($element['label'])) {
$categories[] = $element['label'];
} else {
$categories[] = $element['term'];

2
web/vendor/zendframework/zend-feed/src/Reader/Entry/AbstractEntry.php vendored
View file

@ -146,7 +146,7 @@ abstract class AbstractEntry
*/
public function getXpath()
{
if (!$this->xpath) {
if (! $this->xpath) {
$this->setXpath(new DOMXPath($this->getDomDocument()));
}
return $this->xpath;

8
web/vendor/zendframework/zend-feed/src/Reader/Entry/Atom.php vendored
View file

@ -104,7 +104,7 @@ class Atom extends AbstractEntry implements EntryInterface
/**
* Get the entry creation date
*
* @return string
* @return \DateTime
*/
public function getDateCreated()
{
@ -122,7 +122,7 @@ class Atom extends AbstractEntry implements EntryInterface
/**
* Get the entry modification date
*
* @return string
* @return \DateTime
*/
public function getDateModified()
{
@ -199,7 +199,7 @@ class Atom extends AbstractEntry implements EntryInterface
*/
public function getLink($index = 0)
{
if (!array_key_exists('links', $this->data)) {
if (! array_key_exists('links', $this->data)) {
$this->getLinks();
}
@ -269,7 +269,7 @@ class Atom extends AbstractEntry implements EntryInterface
$commentcount = $this->getExtension('Thread')->getCommentCount();
if (!$commentcount) {
if (! $commentcount) {
$commentcount = $this->getExtension('Atom')->getCommentCount();
}

4
web/vendor/zendframework/zend-feed/src/Reader/Entry/EntryInterface.php vendored
View file

@ -38,14 +38,14 @@ interface EntryInterface
/**
* Get the entry creation date
*
* @return string
* @return \DateTime
*/
public function getDateCreated();
/**
* Get the entry modification date
*
* @return string
* @return \DateTime
*/
public function getDateModified();

57
web/vendor/zendframework/zend-feed/src/Reader/Entry/Rss.php vendored
View file

@ -41,8 +41,8 @@ class Rss extends AbstractEntry implements EntryInterface
public function __construct(DOMElement $entry, $entryKey, $type = null)
{
parent::__construct($entry, $entryKey, $type);
$this->xpathQueryRss = '//item[' . ($this->entryKey+1) . ']';
$this->xpathQueryRdf = '//rss:item[' . ($this->entryKey+1) . ']';
$this->xpathQueryRss = '//item[' . ($this->entryKey + 1) . ']';
$this->xpathQueryRdf = '//rss:item[' . ($this->entryKey + 1) . ']';
$manager = Reader\Reader::getExtensionManager();
$extensions = [
@ -92,7 +92,7 @@ class Rss extends AbstractEntry implements EntryInterface
$authors = [];
$authorsDc = $this->getExtension('DublinCore')->getAuthors();
if (!empty($authorsDc)) {
if (! empty($authorsDc)) {
foreach ($authorsDc as $author) {
$authors[] = [
'name' => $author['name']
@ -151,7 +151,7 @@ class Rss extends AbstractEntry implements EntryInterface
$content = $this->getExtension('Content')->getContent();
if (!$content) {
if (! $content) {
$content = $this->getDescription();
}
@ -167,7 +167,7 @@ class Rss extends AbstractEntry implements EntryInterface
/**
* Get the entry's date of creation
*
* @return string
* @return \DateTime
*/
public function getDateCreated()
{
@ -178,7 +178,7 @@ class Rss extends AbstractEntry implements EntryInterface
* Get the entry's date of modification
*
* @throws Exception\RuntimeException
* @return string
* @return \DateTime
*/
public function getDateModified()
{
@ -209,7 +209,8 @@ class Rss extends AbstractEntry implements EntryInterface
'Could not load date due to unrecognised'
.' format (should follow RFC 822 or 2822):'
. $e->getMessage(),
0, $e
0,
$e
);
}
}
@ -218,15 +219,15 @@ class Rss extends AbstractEntry implements EntryInterface
}
}
if (!$date) {
if (! $date) {
$date = $this->getExtension('DublinCore')->getDate();
}
if (!$date) {
if (! $date) {
$date = $this->getExtension('Atom')->getDateModified();
}
if (!$date) {
if (! $date) {
$date = null;
}
@ -256,7 +257,7 @@ class Rss extends AbstractEntry implements EntryInterface
$description = $this->xpath->evaluate('string(' . $this->xpathQueryRdf . '/rss:description)');
}
if (!$description) {
if (! $description) {
$description = $this->getExtension('DublinCore')->getDescription();
}
@ -264,7 +265,7 @@ class Rss extends AbstractEntry implements EntryInterface
$description = $this->getExtension('Atom')->getDescription();
}
if (!$description) {
if (! $description) {
$description = null;
}
@ -296,7 +297,7 @@ class Rss extends AbstractEntry implements EntryInterface
}
}
if (!$enclosure) {
if (! $enclosure) {
$enclosure = $this->getExtension('Atom')->getEnclosure();
}
@ -324,7 +325,7 @@ class Rss extends AbstractEntry implements EntryInterface
$id = $this->xpath->evaluate('string(' . $this->xpathQueryRss . '/guid)');
}
if (!$id) {
if (! $id) {
$id = $this->getExtension('DublinCore')->getId();
}
@ -332,7 +333,7 @@ class Rss extends AbstractEntry implements EntryInterface
$id = $this->getExtension('Atom')->getId();
}
if (!$id) {
if (! $id) {
if ($this->getPermalink()) {
$id = $this->getPermalink();
} elseif ($this->getTitle()) {
@ -355,7 +356,7 @@ class Rss extends AbstractEntry implements EntryInterface
*/
public function getLink($index = 0)
{
if (!array_key_exists('links', $this->data)) {
if (! array_key_exists('links', $this->data)) {
$this->getLinks();
}
@ -386,7 +387,7 @@ class Rss extends AbstractEntry implements EntryInterface
$list = $this->xpath->query($this->xpathQueryRdf . '//rss:link');
}
if (!$list->length) {
if (! $list->length) {
$links = $this->getExtension('Atom')->getLinks();
} else {
foreach ($list as $link) {
@ -470,15 +471,15 @@ class Rss extends AbstractEntry implements EntryInterface
$title = $this->xpath->evaluate('string(' . $this->xpathQueryRdf . '/rss:title)');
}
if (!$title) {
if (! $title) {
$title = $this->getExtension('DublinCore')->getTitle();
}
if (!$title) {
if (! $title) {
$title = $this->getExtension('Atom')->getTitle();
}
if (!$title) {
if (! $title) {
$title = null;
}
@ -500,15 +501,15 @@ class Rss extends AbstractEntry implements EntryInterface
$commentcount = $this->getExtension('Slash')->getCommentCount();
if (!$commentcount) {
if (! $commentcount) {
$commentcount = $this->getExtension('Thread')->getCommentCount();
}
if (!$commentcount) {
if (! $commentcount) {
$commentcount = $this->getExtension('Atom')->getCommentCount();
}
if (!$commentcount) {
if (! $commentcount) {
$commentcount = null;
}
@ -536,11 +537,11 @@ class Rss extends AbstractEntry implements EntryInterface
$commentlink = $this->xpath->evaluate('string(' . $this->xpathQueryRss . '/comments)');
}
if (!$commentlink) {
if (! $commentlink) {
$commentlink = $this->getExtension('Atom')->getCommentLink();
}
if (!$commentlink) {
if (! $commentlink) {
$commentlink = null;
}
@ -562,15 +563,15 @@ class Rss extends AbstractEntry implements EntryInterface
$commentfeedlink = $this->getExtension('WellFormedWeb')->getCommentFeedLink();
if (!$commentfeedlink) {
if (! $commentfeedlink) {
$commentfeedlink = $this->getExtension('Atom')->getCommentFeedLink('rss');
}
if (!$commentfeedlink) {
if (! $commentfeedlink) {
$commentfeedlink = $this->getExtension('Atom')->getCommentFeedLink('rdf');
}
if (!$commentfeedlink) {
if (! $commentfeedlink) {
$commentfeedlink = null;
}

9
web/vendor/zendframework/zend-hydrator/src/Exception/DomainException.php → web/vendor/zendframework/zend-feed/src/Reader/Exception/InvalidHttpClientException.php vendored
View file

@ -7,11 +7,10 @@
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
namespace Zend\Hydrator\Exception;
namespace Zend\Feed\Reader\Exception;
/**
* Domain exception
*/
class DomainException extends \DomainException implements ExceptionInterface
use Zend\Feed\Exception;
class InvalidHttpClientException extends Exception\InvalidArgumentException implements ExceptionInterface
{
}

8
web/vendor/zendframework/zend-feed/src/Reader/Extension/AbstractEntry.php vendored
View file

@ -135,18 +135,18 @@ abstract class AbstractEntry
if ($type === Reader\Reader::TYPE_RSS_10
|| $type === Reader\Reader::TYPE_RSS_090
) {
$this->setXpathPrefix('//rss:item[' . ($this->entryKey + 1) . ']');
$this->setXpathPrefix('//rss:item[' . ((int)$this->entryKey + 1) . ']');
return $this;
}
if ($type === Reader\Reader::TYPE_ATOM_10
|| $type === Reader\Reader::TYPE_ATOM_03
) {
$this->setXpathPrefix('//atom:entry[' . ($this->entryKey + 1) . ']');
$this->setXpathPrefix('//atom:entry[' . ((int)$this->entryKey + 1) . ']');
return $this;
}
$this->setXpathPrefix('//item[' . ($this->entryKey + 1) . ']');
$this->setXpathPrefix('//item[' . ((int)$this->entryKey + 1) . ']');
return $this;
}
@ -186,7 +186,7 @@ abstract class AbstractEntry
*/
public function getXpath()
{
if (!$this->xpath) {
if (! $this->xpath) {
$this->setXpath(new DOMXPath($this->getDomDocument()));
}
return $this->xpath;

30
web/vendor/zendframework/zend-feed/src/Reader/Extension/Atom/Entry.php vendored
View file

@ -51,7 +51,7 @@ class Entry extends Extension\AbstractEntry
$authors = [];
$list = $this->getXpath()->query($this->getXpathPrefix() . '//atom:author');
if (!$list->length) {
if (! $list->length) {
/**
* TODO: Limit query to feed level els only!
*/
@ -61,7 +61,7 @@ class Entry extends Extension\AbstractEntry
if ($list->length) {
foreach ($list as $author) {
$author = $this->getAuthorFromElement($author);
if (!empty($author)) {
if (! empty($author)) {
$authors[] = $author;
}
}
@ -121,7 +121,7 @@ class Entry extends Extension\AbstractEntry
}
}
if (!$content) {
if (! $content) {
$content = $this->getDescription();
}
@ -139,7 +139,7 @@ class Entry extends Extension\AbstractEntry
*/
protected function collectXhtml($xhtml, $prefix)
{
if (!empty($prefix)) {
if (! empty($prefix)) {
$prefix = $prefix . ':';
}
$matches = [
@ -147,7 +147,7 @@ class Entry extends Extension\AbstractEntry
"/<\/" . $prefix . "div>\s*$/"
];
$xhtml = preg_replace($matches, '', $xhtml);
if (!empty($prefix)) {
if (! empty($prefix)) {
$xhtml = preg_replace("/(<[\/]?)" . $prefix . "([a-zA-Z]+)/", '$1$2', $xhtml);
}
return $xhtml;
@ -222,7 +222,7 @@ class Entry extends Extension\AbstractEntry
$description = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/atom:summary)');
if (!$description) {
if (! $description) {
$description = null;
}
@ -271,7 +271,7 @@ class Entry extends Extension\AbstractEntry
$id = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/atom:id)');
if (!$id) {
if (! $id) {
if ($this->getPermalink()) {
$id = $this->getPermalink();
} elseif ($this->getTitle()) {
@ -304,11 +304,11 @@ class Entry extends Extension\AbstractEntry
. ')'
);
if (!$baseUrl) {
if (! $baseUrl) {
$baseUrl = $this->getXpath()->evaluate('string(//@xml:base[1])');
}
if (!$baseUrl) {
if (! $baseUrl) {
$baseUrl = null;
}
@ -325,7 +325,7 @@ class Entry extends Extension\AbstractEntry
*/
public function getLink($index = 0)
{
if (!array_key_exists('links', $this->data)) {
if (! array_key_exists('links', $this->data)) {
$this->getLinks();
}
@ -388,7 +388,7 @@ class Entry extends Extension\AbstractEntry
$title = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/atom:title)');
if (!$title) {
if (! $title) {
$title = null;
}
@ -554,10 +554,10 @@ class Entry extends Extension\AbstractEntry
*/
protected function absolutiseUri($link)
{
if (!Uri::factory($link)->isAbsolute()) {
if (! Uri::factory($link)->isAbsolute()) {
if ($this->getBaseUrl() !== null) {
$link = $this->getBaseUrl() . $link;
if (!Uri::factory($link)->isValid()) {
if (! Uri::factory($link)->isValid()) {
$link = null;
}
}
@ -623,11 +623,11 @@ class Entry extends Extension\AbstractEntry
$prefixAtom03 = $dom->lookupPrefix(Reader\Reader::NAMESPACE_ATOM_03);
$prefixAtom10 = $dom->lookupPrefix(Reader\Reader::NAMESPACE_ATOM_10);
if ($dom->isDefaultNamespace(Reader\Reader::NAMESPACE_ATOM_03)
|| !empty($prefixAtom03)) {
|| ! empty($prefixAtom03)) {
return Reader\Reader::TYPE_ATOM_03;
}
if ($dom->isDefaultNamespace(Reader\Reader::NAMESPACE_ATOM_10)
|| !empty($prefixAtom10)) {
|| ! empty($prefixAtom10)) {
return Reader\Reader::TYPE_ATOM_10;
}
}

28
web/vendor/zendframework/zend-feed/src/Reader/Extension/Atom/Feed.php vendored
View file

@ -53,7 +53,7 @@ class Feed extends Extension\AbstractFeed
if ($list->length) {
foreach ($list as $author) {
$author = $this->getAuthorFromElement($author);
if (!empty($author)) {
if (! empty($author)) {
$authors[] = $author;
}
}
@ -91,7 +91,7 @@ class Feed extends Extension\AbstractFeed
$copyright = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:rights)');
}
if (!$copyright) {
if (! $copyright) {
$copyright = null;
}
@ -175,7 +175,7 @@ class Feed extends Extension\AbstractFeed
$description = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:subtitle)');
}
if (!$description) {
if (! $description) {
$description = null;
}
@ -197,7 +197,7 @@ class Feed extends Extension\AbstractFeed
// TODO: Add uri support
$generator = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:generator)');
if (!$generator) {
if (! $generator) {
$generator = null;
}
@ -219,7 +219,7 @@ class Feed extends Extension\AbstractFeed
$id = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:id)');
if (!$id) {
if (! $id) {
if ($this->getLink()) {
$id = $this->getLink();
} elseif ($this->getTitle()) {
@ -247,11 +247,11 @@ class Feed extends Extension\AbstractFeed
$language = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:lang)');
if (!$language) {
if (! $language) {
$language = $this->xpath->evaluate('string(//@xml:lang[1])');
}
if (!$language) {
if (! $language) {
$language = null;
}
@ -273,7 +273,7 @@ class Feed extends Extension\AbstractFeed
$imageUrl = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:logo)');
if (!$imageUrl) {
if (! $imageUrl) {
$image = null;
} else {
$image = ['uri' => $imageUrl];
@ -297,7 +297,7 @@ class Feed extends Extension\AbstractFeed
$baseUrl = $this->xpath->evaluate('string(//@xml:base[1])');
if (!$baseUrl) {
if (! $baseUrl) {
$baseUrl = null;
}
$this->data['baseUrl'] = $baseUrl;
@ -394,7 +394,7 @@ class Feed extends Extension\AbstractFeed
$title = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/atom:title)');
if (!$title) {
if (! $title) {
$title = null;
}
@ -482,10 +482,10 @@ class Feed extends Extension\AbstractFeed
*/
protected function absolutiseUri($link)
{
if (!Uri::factory($link)->isAbsolute()) {
if (! Uri::factory($link)->isAbsolute()) {
if ($this->getBaseUrl() !== null) {
$link = $this->getBaseUrl() . $link;
if (!Uri::factory($link)->isValid()) {
if (! Uri::factory($link)->isValid()) {
$link = null;
}
}
@ -523,12 +523,12 @@ class Feed extends Extension\AbstractFeed
$prefixAtom03 = $dom->lookupPrefix(Reader\Reader::NAMESPACE_ATOM_03);
$prefixAtom10 = $dom->lookupPrefix(Reader\Reader::NAMESPACE_ATOM_10);
if ($dom->isDefaultNamespace(Reader\Reader::NAMESPACE_ATOM_10)
|| !empty($prefixAtom10)
|| ! empty($prefixAtom10)
) {
return Reader\Reader::TYPE_ATOM_10;
}
if ($dom->isDefaultNamespace(Reader\Reader::NAMESPACE_ATOM_03)
|| !empty($prefixAtom03)
|| ! empty($prefixAtom03)
) {
return Reader\Reader::TYPE_ATOM_03;
}

20
web/vendor/zendframework/zend-feed/src/Reader/Extension/DublinCore/Entry.php vendored
View file

@ -47,13 +47,13 @@ class Entry extends Extension\AbstractEntry
$authors = [];
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc11:creator');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc10:creator');
}
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc11:publisher');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc10:publisher');
}
}
@ -89,7 +89,7 @@ class Entry extends Extension\AbstractEntry
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc11:subject');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc10:subject');
}
@ -133,11 +133,11 @@ class Entry extends Extension\AbstractEntry
$description = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:description)');
if (!$description) {
if (! $description) {
$description = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:description)');
}
if (!$description) {
if (! $description) {
$description = null;
}
@ -159,7 +159,7 @@ class Entry extends Extension\AbstractEntry
$id = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:identifier)');
if (!$id) {
if (! $id) {
$id = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:identifier)');
}
@ -181,11 +181,11 @@ class Entry extends Extension\AbstractEntry
$title = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:title)');
if (!$title) {
if (! $title) {
$title = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:title)');
}
if (!$title) {
if (! $title) {
$title = null;
}
@ -208,7 +208,7 @@ class Entry extends Extension\AbstractEntry
$d = null;
$date = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:date)');
if (!$date) {
if (! $date) {
$date = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:date)');
}

28
web/vendor/zendframework/zend-feed/src/Reader/Extension/DublinCore/Feed.php vendored
View file

@ -47,13 +47,13 @@ class Feed extends Extension\AbstractFeed
$authors = [];
$list = $this->getXpath()->query('//dc11:creator');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->query('//dc10:creator');
}
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->query('//dc11:publisher');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->query('//dc10:publisher');
}
}
@ -89,11 +89,11 @@ class Feed extends Extension\AbstractFeed
$copyright = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:rights)');
if (!$copyright) {
if (! $copyright) {
$copyright = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:rights)');
}
if (!$copyright) {
if (! $copyright) {
$copyright = null;
}
@ -115,11 +115,11 @@ class Feed extends Extension\AbstractFeed
$description = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:description)');
if (!$description) {
if (! $description) {
$description = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:description)');
}
if (!$description) {
if (! $description) {
$description = null;
}
@ -141,7 +141,7 @@ class Feed extends Extension\AbstractFeed
$id = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:identifier)');
if (!$id) {
if (! $id) {
$id = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:identifier)');
}
@ -163,11 +163,11 @@ class Feed extends Extension\AbstractFeed
$language = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:language)');
if (!$language) {
if (! $language) {
$language = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:language)');
}
if (!$language) {
if (! $language) {
$language = null;
}
@ -189,11 +189,11 @@ class Feed extends Extension\AbstractFeed
$title = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:title)');
if (!$title) {
if (! $title) {
$title = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:title)');
}
if (!$title) {
if (! $title) {
$title = null;
}
@ -216,7 +216,7 @@ class Feed extends Extension\AbstractFeed
$d = null;
$date = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc11:date)');
if (!$date) {
if (! $date) {
$date = $this->getXpath()->evaluate('string(' . $this->getXpathPrefix() . '/dc10:date)');
}
@ -242,7 +242,7 @@ class Feed extends Extension\AbstractFeed
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc11:subject');
if (!$list->length) {
if (! $list->length) {
$list = $this->getXpath()->evaluate($this->getXpathPrefix() . '//dc10:subject');
}

14
web/vendor/zendframework/zend-feed/src/Reader/Extension/Podcast/Entry.php vendored
View file

@ -28,7 +28,7 @@ class Entry extends Extension\AbstractEntry
$author = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:author)');
if (!$author) {
if (! $author) {
$author = null;
}
@ -50,7 +50,7 @@ class Entry extends Extension\AbstractEntry
$block = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:block)');
if (!$block) {
if (! $block) {
$block = null;
}
@ -72,7 +72,7 @@ class Entry extends Extension\AbstractEntry
$duration = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:duration)');
if (!$duration) {
if (! $duration) {
$duration = null;
}
@ -94,7 +94,7 @@ class Entry extends Extension\AbstractEntry
$explicit = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:explicit)');
if (!$explicit) {
if (! $explicit) {
$explicit = null;
}
@ -116,7 +116,7 @@ class Entry extends Extension\AbstractEntry
$keywords = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:keywords)');
if (!$keywords) {
if (! $keywords) {
$keywords = null;
}
@ -138,7 +138,7 @@ class Entry extends Extension\AbstractEntry
$subtitle = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:subtitle)');
if (!$subtitle) {
if (! $subtitle) {
$subtitle = null;
}
@ -160,7 +160,7 @@ class Entry extends Extension\AbstractEntry
$summary = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:summary)');
if (!$summary) {
if (! $summary) {
$summary = null;
}

26
web/vendor/zendframework/zend-feed/src/Reader/Extension/Podcast/Feed.php vendored
View file

@ -29,7 +29,7 @@ class Feed extends Extension\AbstractFeed
$author = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:author)');
if (!$author) {
if (! $author) {
$author = null;
}
@ -51,7 +51,7 @@ class Feed extends Extension\AbstractFeed
$block = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:block)');
if (!$block) {
if (! $block) {
$block = null;
}
@ -83,7 +83,7 @@ class Feed extends Extension\AbstractFeed
$children = [];
foreach ($node->childNodes as $childNode) {
if (!($childNode instanceof DOMText)) {
if (! ($childNode instanceof DOMText)) {
$children[$childNode->getAttribute('text')] = null;
}
}
@ -93,7 +93,7 @@ class Feed extends Extension\AbstractFeed
}
}
if (!$categories) {
if (! $categories) {
$categories = null;
}
@ -115,7 +115,7 @@ class Feed extends Extension\AbstractFeed
$explicit = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:explicit)');
if (!$explicit) {
if (! $explicit) {
$explicit = null;
}
@ -137,7 +137,7 @@ class Feed extends Extension\AbstractFeed
$image = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:image/@href)');
if (!$image) {
if (! $image) {
$image = null;
}
@ -159,7 +159,7 @@ class Feed extends Extension\AbstractFeed
$keywords = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:keywords)');
if (!$keywords) {
if (! $keywords) {
$keywords = null;
}
@ -181,7 +181,7 @@ class Feed extends Extension\AbstractFeed
$newFeedUrl = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:new-feed-url)');
if (!$newFeedUrl) {
if (! $newFeedUrl) {
$newFeedUrl = null;
}
@ -206,13 +206,13 @@ class Feed extends Extension\AbstractFeed
$email = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:owner/itunes:email)');
$name = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:owner/itunes:name)');
if (!empty($email)) {
if (! empty($email)) {
$owner = $email . (empty($name) ? '' : ' (' . $name . ')');
} elseif (!empty($name)) {
} elseif (! empty($name)) {
$owner = $name;
}
if (!$owner) {
if (! $owner) {
$owner = null;
}
@ -234,7 +234,7 @@ class Feed extends Extension\AbstractFeed
$subtitle = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:subtitle)');
if (!$subtitle) {
if (! $subtitle) {
$subtitle = null;
}
@ -256,7 +256,7 @@ class Feed extends Extension\AbstractFeed
$summary = $this->xpath->evaluate('string(' . $this->getXpathPrefix() . '/itunes:summary)');
if (!$summary) {
if (! $summary) {
$summary = null;
}

Some files were not shown because too many files have changed in this diff Show more