PK do?VJ
composer.locknu W+A {
"hash": "0c8700d2d0b5c329c9bfdef6853e60b5",
"packages": [
],
"packages-dev": [
{
"name": "icecave/archer",
"version": "0.2.1",
"source": {
"type": "git",
"url": "https://github.com/IcecaveStudios/archer.git",
"reference": "0.2.1"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/IcecaveStudios/archer/zipball/0.2.1",
"reference": "0.2.1",
"shasum": ""
},
"require": {
"phake/phake": ">=1.0,<2.0",
"php": ">=5.3",
"symfony/console": ">=2.0,<3.0",
"symfony/process": ">=2.0,<3.0"
},
"suggest": {
"ext-openssl": "OpenSSL is required to encrypt GitHub OAuth tokens for artifact publication."
},
"bin": [
"bin/archer",
"bin/woodhouse"
],
"type": "library",
"autoload": {
"psr-0": {
"Icecave\\Archer": "lib"
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Erin Millard",
"email": "ezzatron@gmail.com",
"homepage": "http://ezzatron.com/"
},
{
"name": "James Harris",
"email": "james.harris@icecave.com.au"
}
],
"description": "PHP testing and continuous integration by convention.",
"homepage": "https://github.com/IcecaveStudios/archer",
"keywords": [
"artifacts",
"coverage",
"phake",
"phpunit",
"test",
"testing",
"unit"
],
"time": "2013-02-27 04:42:20"
},
{
"name": "phake/phake",
"version": "v1.0.3",
"source": {
"type": "git",
"url": "git://github.com/mlively/Phake.git",
"reference": "v1.0.3"
},
"dist": {
"type": "zip",
"url": "https://github.com/mlively/Phake/zipball/v1.0.3",
"reference": "v1.0.3",
"shasum": ""
},
"require": {
"php": ">=5.2.0"
},
"type": "library",
"autoload": {
"classmap": [
"src"
]
},
"notification-url": "https://packagist.org/downloads/",
"include-path": [
"src"
],
"license": [
"BSD"
],
"authors": [
{
"name": "Mike Lively",
"email": "m@digitalsandwich.com"
}
],
"description": "The Phake mock testing library",
"homepage": "https://github.com/mlively/Phake",
"keywords": [
"mock",
"testing"
],
"time": "2012-05-14 08:06:51"
},
{
"name": "symfony/console",
"version": "v2.2.0",
"target-dir": "Symfony/Component/Console",
"source": {
"type": "git",
"url": "https://github.com/symfony/Console.git",
"reference": "v2.2.0"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/symfony/Console/zipball/v2.2.0",
"reference": "v2.2.0",
"shasum": ""
},
"require": {
"php": ">=5.3.3"
},
"type": "library",
"extra": {
"branch-alias": {
"dev-master": "2.2-dev"
}
},
"autoload": {
"psr-0": {
"Symfony\\Component\\Console\\": ""
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Fabien Potencier",
"email": "fabien@symfony.com"
},
{
"name": "Symfony Community",
"homepage": "http://symfony.com/contributors"
}
],
"description": "Symfony Console Component",
"homepage": "http://symfony.com",
"time": "2013-03-01 06:43:14"
},
{
"name": "symfony/process",
"version": "v2.2.0",
"target-dir": "Symfony/Component/Process",
"source": {
"type": "git",
"url": "https://github.com/symfony/Process.git",
"reference": "v2.2.0-RC3"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/symfony/Process/zipball/v2.2.0-RC3",
"reference": "v2.2.0-RC3",
"shasum": ""
},
"require": {
"php": ">=5.3.3"
},
"type": "library",
"extra": {
"branch-alias": {
"dev-master": "2.2-dev"
}
},
"autoload": {
"psr-0": {
"Symfony\\Component\\Process\\": ""
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Fabien Potencier",
"email": "fabien@symfony.com"
},
{
"name": "Symfony Community",
"homepage": "http://symfony.com/contributors"
}
],
"description": "Symfony Process Component",
"homepage": "http://symfony.com",
"time": "2013-02-18 21:28:10"
}
],
"aliases": [
],
"minimum-stability": "stable",
"stability-flags": [
]
}
PK do?V(3} LICENSEnu W+A Copyright © 2013 Erin Millard
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
PK do?V݄S[ [ CONTRIBUTING.mdnu W+A # Contributing
**Pops** is open source software; contributions from the community are
encouraged. Please take a moment to read these guidelines before submitting
changes.
### Code style
All PHP code must adhere to the
[PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)
standards.
### Branching and pull requests
As a guideline, please follow this process:
1. [Fork the repository](https://help.github.com/articles/fork-a-repo).
2. Create a topic branch for the change:
* New features should branch from **develop**.
* Bug fixes to existing versions should branch from **master**.
* Please ensure the branch is clearly labelled as a feature or fix.
3. Make the relevant changes.
4. [Squash](http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages)
commits if necessary.
4. Submit a pull request to the **develop** branch.
Please note this is a general guideline only. For more information on the
branching structure please see the
[git-flow cheatsheet](http://danielkummer.github.com/git-flow-cheatsheet/).
PK do?V*: :
composer.jsonnu W+A {
"name": "eloquent/pops",
"description": "PHP object proxy system.",
"keywords": ["object","proxy","escaping"],
"homepage": "https://github.com/eloquent/pops",
"license": "MIT",
"authors": [
{
"name": "Erin Millard",
"email": "ezzatron@gmail.com",
"homepage": "http://ezzatron.com/"
}
],
"require": {
"php": ">=5.3.0"
},
"require-dev": {
"icecave/archer": "~0.2"
},
"autoload": {
"psr-0": {
"Eloquent\\Pops": "src"
}
}
}
PK do?VOCv v CHANGELOG.mdnu W+A # Pops changelog
### 3.1.1
* [Archer](https://github.com/IcecaveStudios/archer) integration
* Implemented changelog
PK do?V{K6 README.mdnu W+A # Pops
*PHP Object Proxy System.*
[![Build Status]](http://travis-ci.org/eloquent/pops)
[![Test Coverage]](http://eloquent-software.com/pops/artifacts/tests/coverage/)
## Installation
Available as [Composer](http://getcomposer.org/) package
[eloquent/pops](https://packagist.org/packages/eloquent/pops).
## What is Pops?
Pops is a system for wrapping PHP objects in other objects to modify their
behaviour.
A Pops proxy will, as much as possible, imitate the object it wraps. It passes
along method calls and returns the underlying result, and allows transparent
access to properties (for both setting and getting).
Pops is the underlying system behind [Liberator](https://github.com/eloquent/liberator).
## Creating proxies
Let's write a simple proxy that converts everything to uppercase. Here we have a
class:
```php
class Confusion
{
public function wat()
{
return "What is this? I don't even...";
}
public $derp = 'Has anyone really been far even as decided to use even?';
}
```
And here is our proxy:
```php
use Eloquent\Pops\ProxyObject;
class UppercaseProxyObject extends ProxyObject
{
public function popsCall($method, array &$arguments)
{
return strtoupper(parent::popsCall($method, $arguments));
}
public function __get($property)
{
return strtoupper(parent::__get($property));
}
}
```
We use popsCall() here rather than __call() to get around PHP limitations to do
with passing arguments by reference. See [below](#calling-methods-with-by-reference-parameters)
for a depper explanation.
Now when we access `wat()` and `$derp` both normally, and through our proxy, we
can see the effect:
```php
$confusion = new Confusion;
$proxy = new UppercaseProxyObject($confusion);
echo $confusion->wat(); // outputs "What is this? I don't even..."
echo $proxy->wat(); // outputs "WHAT IS THIS? I DON'T EVEN..."
echo $confusion->derp; // outputs 'Has anyone really been far even as decided to use even?'
echo $proxy->derp; // outputs 'HAS ANYONE REALLY BEEN FAR EVEN AS DECIDED TO USE EVEN?'
```
## Recursive proxies
Pops proxies can be applied to any value recursively. This comes in handy when
designing, for example, an output escaper (similar to Symfony).
Here's an example of how such a system could be created for escaping HTML
output:
```php
namespace OutputEscaper;
use Eloquent\Pops\Pops;
use Eloquent\Pops\ProxyArray;
use Eloquent\Pops\ProxyClass;
use Eloquent\Pops\ProxyObject;
use Eloquent\Pops\ProxyPrimitive;
/**
* Escapes output for use in HTML.
*/
class OutputEscaperProxy extends Pops
{
/**
* The class to use when proxying arrays.
*
* @return string
*/
static protected function proxyArrayClass()
{
return __NAMESPACE__.'\OutputEscaperProxyArray';
}
/**
* The class to use when proxying classes.
*
* @return string
*/
static protected function proxyClassClass()
{
return __NAMESPACE__.'\OutputEscaperProxyClass';
}
/**
* The class to use when proxying objects.
*
* @return string
*/
static protected function proxyObjectClass()
{
return __NAMESPACE__.'\OutputEscaperProxyObject';
}
/**
* The class to use when proxying primitives.
*
* @return string
*/
static protected function proxyPrimitiveClass()
{
return __NAMESPACE__.'\OutputEscaperProxyPrimitive';
}
}
/**
* Wraps an array to escape any sub-values for use in HTML.
*/
class OutputEscaperProxyArray extends ProxyArray
{
/**
* The class to use when proxying sub-values.
*
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\OutputEscaperProxy';
}
}
/**
* Wraps a class to escape any sub-values for use in HTML.
*/
class OutputEscaperProxyClass extends ProxyClass
{
/**
* The class to use when proxying sub-values.
*
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\OutputEscaperProxy';
}
}
/**
* Wraps an object to escape any sub-values for use in HTML.
*/
class OutputEscaperProxyObject extends ProxyObject
{
/**
* The class to use when proxying sub-values.
*
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\OutputEscaperProxy';
}
}
/**
* Wraps a primitive to escape its value for use in HTML.
*/
class OutputEscaperProxyPrimitive extends ProxyPrimitive
{
/**
* Returns the HTML-escaped version of this primitive.
*
* @return string
*/
public function __toString()
{
return htmlspecialchars(
(string) $this->popsPrimitive,
ENT_QUOTES,
'UTF-8'
);
}
}
```
The output escaper can now be used like so:
```php
use OutputEscaper\OutputEscaperProxy;
use Eloquent\Pops\Safe\SafeProxy;
$list = new ArrayIterator(array(
'foo',
'bar',
'',
SafeProxy::proxy('ooh...'),
));
$proxy = OutputEscaperProxy::proxy($list, true);
echo '
'.PHP_EOL;
foreach ($proxy as $item) {
echo '- '.$item.'
'.PHP_EOL;
}
echo '
';
```
Which would output:
```html
- foo
- bar
- <script>alert(document.cookie);</script>
- ooh...
```
Note that the above example should **NOT** be used in production. Output
escaping is a complex issue that should not be taken lightly.
### Excluding values from recursion
Note that in the above example, the last list item was wrapped in a *Safe*
proxy. When Pops applies its proxies, it will skip anything marked as safe in
this manner.
## Calling methods with by-reference parameters
Because of PHP limitations, methods with arguments that are passed by reference
must be called in a special way.
To explain futher, let's assume our class from before also has a method which
accepts a reference:
```php
class Confusion
{
public function butWho(&$wasPhone)
{
$wasPhone = 'Hello? Yes this is dog.';
}
}
```
This method cannot be proxied normally because the $wasPhone argument is passed
by reference. The correct way to call the above butWho() method through a Pops
proxy looks like this:
```php
$proxy = Pops::proxy(new Confusion);
$wasPhone = null;
$arguments = array(&$wasPhone);
$proxy->popsCall('butWho', $arguments);
echo $wasPhone; // outputs 'Hello? Yes this is dog.'
```
Note that there **must** be a variable for the $wasPhone argument, and there
**must** be a variable for the arguments themselves. Neither can be passed
directly as a value. The arguments must also contain a **reference** to
$wasPhone argument.
[Build Status]: https://raw.github.com/eloquent/pops/gh-pages/artifacts/images/icecave/regular/build-status.png
[Test Coverage]: https://raw.github.com/eloquent/pops/gh-pages/artifacts/images/icecave/regular/coverage.png
PK do?V2 ! src/Eloquent/Pops/ProxyObject.phpnu W+A popsObject = $object;
$this->popsRecursive = $recursive;
}
/**
* @return object
*/
public function popsObject()
{
return $this->popsObject;
}
/**
* @param string $method
* @param array &$arguments
*
* @return mixed
*/
public function popsCall($method, array &$arguments)
{
return $this->popsProxySubValue(
call_user_func_array(array($this->popsObject, $method), $arguments)
);
}
/**
* @param string $method
* @param array $arguments
*
* @return mixed
*/
public function __call($method, array $arguments)
{
return $this->popsCall($method, $arguments);
}
/**
* @param string $property
* @param mixed $value
*/
public function __set($property, $value)
{
$this->popsObject->$property = $value;
}
/**
* @param string $property
*
* @return mixed
*/
public function __get($property)
{
return $this->popsProxySubValue(
$this->popsObject->$property
);
}
/**
* @param string $property
*
* @return boolean
*/
public function __isset($property)
{
return isset($this->popsObject->$property);
}
/**
* @param string $property
*/
public function __unset($property)
{
unset($this->popsObject->$property);
}
/**
* @param string $property
* @param mixed $value
*/
public function offsetSet($property, $value)
{
$this->__call('offsetSet', func_get_args());
}
/**
* @param string $property
*
* @return mixed
*/
public function offsetGet($property)
{
return $this->__call('offsetGet', func_get_args());
}
/**
* @param string $property
*
* @return boolean
*/
public function offsetExists($property)
{
return $this->__call('offsetExists', func_get_args());
}
/**
* @param string $property
*/
public function offsetUnset($property)
{
$this->__call('offsetUnset', func_get_args());
}
/**
* @return integer
*/
public function count()
{
return $this->__call('count', array());
}
/**
* @return mixed
*/
public function current()
{
return $this->popsProxySubValue(
$this->popsInnerIterator()->current()
);
}
/**
* @return scalar
*/
public function key()
{
return $this->popsInnerIterator()->key();
}
public function next()
{
$this->popsInnerIterator()->next();
}
public function rewind()
{
$this->popsInnerIterator()->rewind();
}
/**
* @return boolean
*/
public function valid()
{
return $this->popsInnerIterator()->valid();
}
/**
* @return string
*/
public function __toString()
{
return (string) $this->__call('__toString', array());
}
/**
* @return mixed
*/
public function __invoke()
{
if (!method_exists($this->popsObject, '__invoke')) {
throw new BadMethodCallException(
'Call to undefined method '.
get_class($this->popsObject).'::__invoke()'
);
}
return $this->popsProxySubValue(
call_user_func_array($this->popsObject, func_get_args())
);
}
/**
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\Pops';
}
/**
* @return Iterator
*/
protected function popsInnerIterator()
{
if (null !== $this->popsInnerIterator) {
return $this->popsInnerIterator;
}
if ($this->popsObject instanceof Iterator) {
$this->popsInnerIterator = $this->popsObject;
} elseif ($this->popsObject instanceof IteratorAggregate) {
$this->popsInnerIterator = $this->popsObject->getIterator();
} else {
throw new LogicException(
'Proxied object is not an instance of Traversable'
);
}
return $this->popsInnerIterator;
}
/**
* @param mixed $value
*
* @return mixed
*/
protected function popsProxySubValue($value)
{
if ($this->popsRecursive) {
$popsClass = static::popsProxyClass();
return $popsClass::proxy($value, true);
}
return $value;
}
/**
* @var object
*/
protected $popsObject;
/**
* @var boolean
*/
protected $popsRecursive;
/**
* @var Iterator
*/
protected $popsInnerIterator;
}
PK do?V ) src/Eloquent/Pops/Safe/SafeProxyArray.phpnu W+A newInstanceArgs(func_get_args());
}
/**
* @param string $class
* @param boolean $recursive
*
* @return ProxyClass
*/
public static function proxyClass($class, $recursive = null)
{
$proxyClassClass = new ReflectionClass(static::proxyClassClass());
return $proxyClassClass->newInstanceArgs(func_get_args());
}
/**
* @param string $class
* @param boolean $recursive
* @param string $proxyClass
*
* @return string
*/
public static function proxyClassStatic(
$class,
$recursive = null,
$proxyClass = null
) {
$method = static::proxyClassClass().'::popsGenerateStaticClassProxy';
return call_user_func_array($method, func_get_args());
}
/**
* @param object $object
* @param boolean $recursive
*
* @return ProxyObject
*/
public static function proxyObject($object, $recursive = null)
{
$class = new ReflectionClass(static::proxyObjectClass());
return $class->newInstanceArgs(func_get_args());
}
/**
* @param mixed $primitive
*
* @return ProxyPrimitive
*/
public static function proxyPrimitive($primitive)
{
$class = new ReflectionClass(static::proxyPrimitiveClass());
return $class->newInstanceArgs(func_get_args());
}
/**
* @return string
*/
protected static function proxyArrayClass()
{
return __NAMESPACE__.'\ProxyArray';
}
/**
* @return string
*/
protected static function proxyClassClass()
{
return __NAMESPACE__.'\ProxyClass';
}
/**
* @return string
*/
protected static function proxyObjectClass()
{
return __NAMESPACE__.'\ProxyObject';
}
/**
* @return string
*/
protected static function proxyPrimitiveClass()
{
return __NAMESPACE__.'\ProxyPrimitive';
}
}
PK do?V2
2
src/Eloquent/Pops/ProxyArray.phpnu W+A popsArray = $array;
$this->popsRecursive = $recursive;
$this->popsInnerIterator = new ArrayIterator($this->popsArray);
}
/**
* @return array
*/
public function popsArray()
{
return $this->popsArray;
}
/**
* @param string $property
* @param mixed $value
*/
public function offsetSet($property, $value)
{
$this->popsArray[$property] = $value;
}
/**
* @param string $property
*
* @return mixed
*/
public function offsetGet($property)
{
return $this->popsProxySubValue(
$this->popsArray[$property]
);
}
/**
* @param string $property
*
* @return boolean
*/
public function offsetExists($property)
{
return isset($this->popsArray[$property]);
}
/**
* @param string $property
*/
public function offsetUnset($property)
{
unset($this->popsArray[$property]);
}
/**
* @return integer
*/
public function count()
{
return count($this->popsArray);
}
/**
* @return mixed
*/
public function current()
{
return $this->popsProxySubValue(
$this->popsInnerIterator->current()
);
}
/**
* @return scalar
*/
public function key()
{
return $this->popsInnerIterator->key();
}
public function next()
{
$this->popsInnerIterator->next();
}
public function rewind()
{
$this->popsInnerIterator->rewind();
}
/**
* @return boolean
*/
public function valid()
{
return $this->popsInnerIterator->valid();
}
/**
* @return string
*/
public function __toString()
{
return (string) $this->popsProxySubValue(
(string) $this->popsArray
);
}
/**
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\Pops';
}
/**
* @param mixed $value
*
* @return mixed
*/
protected function popsProxySubValue($value)
{
if ($this->popsRecursive) {
$popsClass = static::popsProxyClass();
return $popsClass::proxy($value, true);
}
return $value;
}
/**
* @var array
*/
protected $popsArray;
/**
* @var boolean
*/
protected $popsRecursive;
/**
* @var Iterator
*/
protected $popsInnerIterator;
}
PK do?VF src/Eloquent/Pops/ProxyClass.phpnu W+A popsClass = $class;
$this->popsRecursive = $recursive;
}
/**
* @return string
*/
public function popsClass()
{
return $this->popsClass;
}
/**
* @param string $method
* @param array &$arguments
*
* @return mixed
*/
public function popsCall($method, array &$arguments)
{
return static::popsProxySubValue(
call_user_func_array($this->popsClass.'::'.$method, $arguments),
$this->popsRecursive
);
}
/**
* @param string $method
* @param array $arguments
*
* @return mixed
*/
public function __call($method, array $arguments)
{
return $this->popsCall($method, $arguments);
}
/**
* @param string $property
* @param mixed $value
*/
public function __set($property, $value)
{
$class = $this->popsClass;
$class::$$property = $value;
}
/**
* @param string $property
*
* @return mixed
*/
public function __get($property)
{
$class = $this->popsClass;
return static::popsProxySubValue(
$class::$$property,
$this->popsRecursive
);
}
/**
* @param string $property
*
* @return boolean
*/
public function __isset($property)
{
$class = $this->popsClass;
return isset($class::$$property);
}
/**
* @param string $property
*/
public function __unset($property)
{
$class = $this->popsClass;
$class::$$property = null;
}
/**
* @return string
*/
protected static function popsProxyClass()
{
return __NAMESPACE__.'\Pops';
}
/**
* @param mixed $value
* @param boolean $recursive
*
* @return mixed
*/
protected static function popsProxySubValue($value, $recursive)
{
if ($recursive) {
$popsClass = static::popsProxyClass();
return $popsClass::proxy($value, true);
}
return $value;
}
/**
* @param string $originalClass
* @param boolean $recursive
* @param string $proxyClass
*
* @return string
*/
protected static function popsStaticClassProxyDefinition(
$originalClass,
$recursive,
&$proxyClass
) {
$proxyClass = static::popsStaticClassProxyDefinitionProxyClass(
$originalClass,
$proxyClass
);
return
static::popsStaticClassProxyDefinitionHeader(
$proxyClass
).
' { '.
static::popsStaticClassProxyDefinitionBody(
$originalClass,
$recursive
).
' }'
;
}
/**
* @param string $originalClass
* @param string $proxyClass
*
* @return string
*/
protected static function popsStaticClassProxyDefinitionProxyClass(
$originalClass,
$proxyClass
) {
if (null === $proxyClass) {
$originalClassParts = explode('\\', $originalClass);
$proxyClassPrefix = array_pop($originalClassParts).'_Pops_';
$proxyClassNamespace = implode('\\', $originalClassParts);
$proxyClass = uniqid($proxyClassPrefix);
if ($proxyClassNamespace) {
$proxyClass = $proxyClassNamespace.'\\'.$proxyClass;
}
}
return $proxyClass;
}
/**
* @param string $proxyClass
*
* @return string
*/
protected static function popsStaticClassProxyDefinitionHeader($proxyClass)
{
$proxyClassParts = explode('\\', $proxyClass);
$proxyClass = array_pop($proxyClassParts);
$proxyClassNamespace = implode('\\', $proxyClassParts);
$header = 'class '.$proxyClass.' extends \\'.get_called_class();
if ($proxyClassNamespace) {
$header = 'namespace '.$proxyClassNamespace.'; '.$header;
}
return $header;
}
/**
* @param string $originalClass
* @param boolean $recursive
*
* @return string
*/
protected static function popsStaticClassProxyDefinitionBody(
$originalClass,
$recursive
) {
return
'protected static $popsStaticOriginalClass = '.
var_export($originalClass, true).';'.
' protected static $popsStaticRecursive = '.
var_export($recursive, true).';'
;
}
/**
* @var string
*/
protected static $popsStaticOriginalClass;
/**
* @var string
*/
protected static $popsStaticRecursive;
/**
* @var array
*/
protected static $popsStaticProxies = array();
/**
* @var string
*/
protected $popsClass;
/**
* @var boolean
*/
protected $popsRecursive;
}
PK do?VN * * src/Eloquent/Pops/Proxy.phpnu W+A popsPrimitive = $primitive;
}
/**
* @return object
*/
public function popsPrimitive()
{
return $this->popsPrimitive;
}
/**
* @return string
*/
public function __toString()
{
return (string) $this->popsPrimitive;
}
/**
* @var mixed
*/
protected $popsPrimitive;
}
PK do?V vendor/nu PK do?VJ
composer.locknu W+A PK do?V(3} LICENSEnu W+A PK do?V݄S[ [ Z CONTRIBUTING.mdnu W+A PK do?V*: :
" composer.jsonnu W+A PK do?VOCv v k% CHANGELOG.mdnu W+A PK do?V{K6 &