Mod Rewrite 
Purpose
The mod rewrite library is meant to be a php implementation of mod rewrite. it can read the
same directives given to the apache rewrite engine module and use them to rewrite given urls the
same way as apache would., (*1)
Support
RewriteRule, RewriteCond, RewriteEngine are supported with the caveat that certain
server variables are not implemented yet in the replacements system as well as a bunch of the
more advanced rewriting flags for the RewriteRule directive arent implemented. Adding support
for these features as well as the other directives is pretty straightforward through
extension it just hasn't been done yet. At the moment only the server variables QUERY_STRING,
REQUEST_URI, REQUEST_FILENAME, HTTP_HOST are supported.
Feel free to PR support for more!, (*2)
Usage
Basic
if you just want to use the stock rewriter with a file you just need to use the 2 builders
to build the rewriter and the file compiler, (*3)
<?php
use Giftcards\ModRewrite\RewriterBuilder;
use Giftcards\ModRewriter\Compiler\CompilerBuilder;
use Symfony\Component\HttpFoundation\Request;
$rewriter = RewriterBuilder::create()->build();
$compiler = CompilerBuilder::create()->build();
$request = Request::createFromGlobals();
$file = __DIR__.'/rewrite_rules';
$result = $rewriter->rewrite(
rawurldecode($request->getPathInfo()),
$request,
$compiler->compile(file_get_contents($file))
);
the $result is an instance of Giftcards\ModRewrite\Result you can get the rewritten
url from getUrl() this will be populated whether it was matched and rewritten by a
rule or not. You can get the rule that was matched from getMatchedRule().
the rule contains the rewrite directive as well as the condition directives.
If no rule was matched getMatchedRule() will return null., (*4)
Note: make sure your urls are decoded before passing them to the rewriter since it could cause odd things if it's not decoded, (*5)
Processor
The processor class can be used to process a submitted request along with a matched
result and spit out a result. After processing the request according to the rules
given it will either return a clone of the given request with the query and uri changed
according to the matched rule, or a Symfony\Component\HttpFoundation\Response if the
rule says to return some sort of status code or redirect (R|redirect, F|forbidden, G|gone etc).
You can use these as they are in your application to either the forward a request
or return a response, (*6)
Formatters are the clases that do all the replacing of values in the TestString
and CondPattern in the RewriteCond as well as the Substitution in the RewriteRule
in the default rewriter setup. In the Formatters dir there are a bunch there, (*7)
- ApacheServerVariableFormatter - this class takes the string and does the replacement for the
server variables like HTTP_HOST and REQUEST_URI
- LastPassingConditionFormatter - this class is the one that replaces all the backreferences
from the regex of the last passing condition
- PathInfoFormatter - if you put a dash as the value in any of the 3 formatted values it will replace
it with the url that was passed to be rewritten
- RewriteFormatter - this class is the one that replaces all the backreferences form the
regex from the rule that matched
by default all of these are added to a chain formatter and run in the order they were added
you can add as many formatters as you want they have to implement
Giftcards\ModRewrite\Formatter\FormaterInterface, (*8)
Condition Predicate Checkers
the condition predicate checkers are the classes that after a rule matches are used to check
the conditions attached to the rule.
in the Condition there are a bunch already defined, (*9)
- ExistencePredicateChecker - this is the one that does checks for the -f and -d flags to
see if the file or dir mentioned exists
- FormattingPredicateChecker - this checker gets passed another checker to actually
do the checking with as well as a formatter which it uses to format the test string
as well as the condition pattern before passing it to the real checker. this class allows
for condition backreferences rewrite backreferences etc to be used in these values
- NotPredicateChecker - this class allows for the ! char to be used in a condition
if a ! is there it strips it then passes it to the real checker to do its thing
then returns the opposite of the result
- RegexPredicateChecker - this treats the condition pattern as a regex and does the check
on the test stirng that way
all predicate checkers have a supports method. this allows them to be added to a chain checker
which will check to see if any checkers in the chain support the condition pattern (predicate)
the chain will throw an exception if no supporting checker is found. the chain allows you
to set a default checker to run instead if you dont want an exception thrown. in the default setup
the existence checker is added to the chain, the regex checker is set as the default. the chain
then passed into the not checker which is passed into the formatting checker., (*10)
Wallogit.com
