Changelog History
-
v2.4.0 Changes
March 21, 2018What's Changed
- ➕ Added support for PHP Parser 4 and PHP 7.2.
-
v2.3.0 Changes
December 07, 2016What's Changed
- ➕ Added support for PHP Parser 3 and PHP 7.1.
- Identify failed serialization with signature option.
-
v2.2.0 Changes
December 05, 2015What's Changed
- ➕ Added support for PHP 7.
- ➕ Added support for version 2.x of @nikic's PHP Parser.
- ➕ Added a
bindTo()
method toSerializableClosure
to match Closure's interface. - Replaced vendored
hash_equals()
implementation with the one insymfony/polyfill-php56
. - 🛠 Fixed an issue that caused the "class" value of some closures' locations to be reported incorrectly.
- 🛠 Fixed an issue with some edge cases related the closure binding and scope during unserialization.
- 🛠 Fixed an unserialization issue where SuperClosures in user variables were not being unboxed.
- 👌 Improved error handling in the
Serializer
when the data being unserialized is invalid.
Credits
- Top Contributors
- @msarca of the
opis/closure
project for new discussions, ideas, and motivations.
Lessons Learned
👀 > It's
ParseError
notParseException
. -
v2.1.0 Changes
March 12, 2015- ➕ Adds support for signing serialized closures.
- Fixes #44, which prevents errors when using
var_dump()
orprint_r()
on unserialized closures.
-
v2.0.0 Changes
January 27, 2015- Serializes closure bindings
- Serializes recursive closures
- ➕ Added Serializer object
- Main class to interact with for serializing closures
- Has special method for wrapping closures within an array/object
- 🔄 Changed the
ClosureParser
intoClosureAnalyzer
- There are two kinds of analyzers:
AstAnalyzer
- Uses PHPParser library; many featuresTokenAnalyzer
- Usestoken_get_all()
; fast- Analyzers return an array of data about a closure
- ✂ Removed
Jeremeamia
from the namespace - Adopted PSR-4
- Requires PHP 5.4+
-
v2.0.0-beta.1 Changes
January 20, 2015👀 There are lots of big changes again, but I'm finally happy with the project's structure. There is some more testing and docs to do, but there shouldn't be any drastic changes at this point forward. Please see the README on the master branch for the latest information.
-
v2.0.0-alpha2 Changes
February 05, 2014🔄 Changelog
- 📜 There are are now 2 parses supported
- AST Parser – Implemented with the
nikic/PHPParser
library. This parser is the most robust and allows you to
0️⃣ resolve magic constants and fully-qualified class names in your closure. This is the default parser. - Token Parser – Implemented using the code from the old
jeremeamia/FunctionParser
library. This library was
👉 used in a previous version of SuperClosure, and has been ported back in. While it does not handle all edge cases
like resolving magic constants, it is MUCH faster (at least an order of magnitude).
- AST Parser – Implemented with the
- You can now serialize closure bindings – If you are using closures in PHP 5.4+, closures are bound to an object and
scope such that you can reference$this
inside of a closure. Unserialized closures from version 1 of SuperClosure
needed to be rebound to an object manually to prevent failure in functions containing$this
, but this version can
🖐 handle bindings just fine. - 📜 The ability to turn features on and off – Closure parser objects accept an array of options that can allow you to
🐎 configure the capability vs. performance of your closure serialization. If you don't want to serialize closure
bindings or resolve magic constants, you can turn those features off.- Along with this is a option called
turbo_mode
that turns all the non-essential features off, This will make
closure serialization much faster, but is the least robust at handling edge cases.
- Along with this is a option called
- The easy
SuperClosure\serialize()
function – If you have installed SuperClosure via Composer, then the
SuperClosure\serialize()
function will automagically be available. This allows you to easily serialize the closure
with out have to import/use any of the classes from the library directly. This function also allows you to specify the
📜 options for the parser. - 🚚 I removed
Jeremeamia
from the namespace. However, there is a class alias automatically
specified for theSerializableClosure
class to
maintain some backwards compatibility. You can use eitherSuperClosure\SerializableClosure
or
Jeremeamia\SuperClosure\SerializableClosure
. - 📦 The package is now PSR-4 compliant.
Is everything different and broken?
It depends. Mostly no.
If you were just using the
SerializableClosure
object, then it should work exactly the same way as before.$closure = new SerializableClosure($closure);$serialized = serialize($closure);
📜 If you were relying directly on the
ClosureParser
object, then you will have breaking changes for sure. They likely
will not be difficult to fix though since SuperClosure is still a small library. Just keep in mind that there is now
📜 more than one type of parser available.Examples
use SuperClosure\SerializableClosure;use SuperClosure\ClosureParser\Options;use SuperClosure\ClosureParser\Ast\AstParser;use SuperClosure\ClosureParser\Token\TokenParser;// TRADITIONAL MODE (Same as in v1.0; uses "ROBUST MODE")$closure = new SerializableClosure($closure);$serialized = serialize($closure);// ROBUST MODE (i.e., SLOW MODE) (Uses the AST parser with all features on)$serialized = SuperClosure\serialize($closure);// TURBO MODE (Uses the token parser, with all features off)$serialized = SuperClosure\serialize($closure, array(Options::TURBO\_MODE =\> true));// The rest are examples of mixing and matching features//-------------------------------------------------------// Does everything else, but ignores closure bindings// This is perfect for functions in PHP 5.4+ that are declared in a class, but do not reference `$this`$serialized = SuperClosure\serialize($closure, array(Options::HANDLE\_CLOSURE\_BINDINGS =\> false,));// Uses the Token parser implicitly, by disabling the features unique to the AST parser$serialized = SuperClosure\serialize($closure, array(Options::HANDLE\_MAGIC\_CONSTANTS =\> false,Options::HANDLE\_CLASS\_NAMES=\> false,));// Uses the Token parser explicitly$serialized = SuperClosure\serialize($closure, new TokenParser);// This is equivalent to TURBO MODE. ZOOOOOOM!!!$options = new Options(array(Options::VALIDATE\_TOKENS =\> false));$serialized = SuperClosure\serialize($closure, new TokenParser($options)));
TODO
- ✅ Unit Tests - I removed all of the previous unit tests due to the extreme changes. However, I currently have a
✅ suite of integration tests that exercise the code nicely and show how it handles different scenarios. I plan on adding
🚀 the unit tests back before the stable release. - 📚 Documentation - A lot of the docblocks are missing, incomplete, or out of date. I'll work on fixing these us
🚀 before the stable release as well.
- 📜 There are are now 2 parses supported
-
v2.0-alpha1 Changes
January 14, 2014SuperClosure is getting an overhaul!
🔄 Changelog
- 📜 There are are now 2 parses supported
- AST Parser – Implemented with the
nikic/PHPParser
library. This parser is the most robust and allows you to
0️⃣ resolve magic constants and fully-qualified class names in your closure. This is the default parser. - Token Parser – Implemented using the code from the old
jeremeamia/FunctionParser
library. This library was
👉 used in a previous version of SuperClosure, and has been ported back in. While it does not handle all edge cases
like resolving magic constants, it is MUCH faster (at least an order of magnitude).
- AST Parser – Implemented with the
- You can now serialize closure bindings – If you are using closures in PHP 5.4+, closures are bound to an object and
scope such that you can reference$this
inside of a closure. Unserialized closures from version 1 of SuperClosure
needed to be rebound to an object manually to prevent failure in functions containing$this
, but this version can
🖐 handle bindings just fine. - 📜 The ability to turn features on and off – Closure parser objects accept an array of options that can allow you to
🐎 configure the capability vs. performance of your closure serialization. If you don't want to serialize closure
bindings or resolve magic constants, you can turn those features off.- Along with this is a option called
turbo_mode
that turns all the non-essential features off, This will make
closure serialization much faster, but is the least robust at handling edge cases.
- Along with this is a option called
- The easy
serialize_closure()
function – If you have installed SuperClosure via Composer, then the
serialize_closure()
function will automagically be available. This allows you to easily serialize the closure with
out have to import/use any of the classes from the library directly. This function also allows you to specify the
📜 options for the parser. - 📦 The package is now PSR-4 compliant. As soon as TravisCI is ready and Jordi (Composer author) gives the PHP world the
🚚 green light, I'll remove the providedautoload.php
in favor of Composer's PSR-4 support.
Is everything different and broken?
It depends. Mostly no.
If you were just using the
SerializableClosure
object, then it should work exactly the same way as before.$closure = new SerializableClosure($closure);$serialized = serialize($closure);
📜 If you were relying directly on the
ClosureParser
object, then you will have breaking changes for sure. They likely will not be difficult to fix though since SuperClosure is still a small library. Just keep in mind that there is now more than one type of parser available.Examples
// ROBUST MODE (i.e., SLOW MODE) (Uses the AST parser with all features on)$serialized = serialize\_closure($closure);// TURBO MODE (Uses the token parser, with all features off)$serialized = serialize\_closure($closure, array(SC\_TURBO\_MODE =\> true));// The rest are examples of mixing and matching features//-------------------------------------------------------// Does everything else, but ignores closure bindings// This is perfect for functions in PHP 5.4+ that are declared in a class, but do not reference `$this`$serialized = serialize\_closure($closure, array(SC\_HANDLE\_CLOSURE\_BINDINGS =\> false,));// Uses the Token parser explicitly$serialized = serialize\_closure($closure, array(SC\_PARSER\_CLASS =\> SC\_PARSER\_TOKEN,));// Uses the Token parser implicitly, by disabling the features unique to the AST parser$serialized = serialize\_closure($closure, array(SC\_HANDLE\_MAGIC\_CONSTANTS =\> false,SC\_HANDLE\_CLASS\_NAMES=\> false,));// This is equivalent to TURBO MODE. ZOOOOOOM!!!$serialized = serialize\_closure($closure, array(SC\_PARSER\_CLASS=\> SC\_PARSER\_TOKEN,SC\_VALIDATE\_TOKENS =\> false,));
TODO
- ✅ Unit Tests - I removed all of the previous unit tests due to the extreme changes. However, I currently have a
✅ suite of integration tests that exercise the code nicely and show how it handles different scenarios. - Collect Feedback - I've made a lot of changes. I'd love to hear what you think. Do you like the changes? Do the
0️⃣ config settings make sense? Do the config defaults work well? Let me know if you have any suggestions,
feedback, ideas, complaints, etc.
- 📜 There are are now 2 parses supported
-
v1.0.2 Changes
January 12, 2015Note: This is the final 1.x release.
- Fixed #23, where "Undefined Variable Error" was being thrown for used variables whose that had a value of
null
.
- Fixed #23, where "Undefined Variable Error" was being thrown for used variables whose that had a value of
-
v1.0.1 Changes
October 09, 2013- 🚀 Updated Composer dependencies to use a tagged release of PHP Parser.
- ⚡️ Updated the
SerializableClosure
class to be easier to extend.