Help with bootstrap and regex for PHP - php

Question

I am working on a new PHP framework for personal use in future projects, and
below is my planned file structure so far. I just need some help with some regex for my .htaccess file and some help for how I can load the files I want.
Basically, any "folder" after the domain should load from my "module" folder.
I would like to have it load www.domain.com/account/ from www.domain.com/module/account/. I also want it in that format for any other folder I have under modules. All folders/files under "module" should load as if it were in the top level.
In this example though in my module/account/ folder, if I have a file called home.php then I should be able to access it with www.domain.com/account/home instead of www.domain.com/module/account/home.php, and www.domain.com/module/user/register.php would actually be accessed by www.domain.com/user/register
I hope this makes sense and appreciate any help and any advice. I mainly need help with the .htaccess file to make this folder structure work. I have not decided if all files should be accessed though a single index file or if I should just include a bootstrap type file into every page. The bootstrap file would set up all variables, config options, as well as auto load all class files and create objects needed.
myFramework/
--/assets/
--------/css/
--------/images/
--------/javascript/
--/includes/
---------/classes/
---------/config/
---------/language/
---------/header.php
---------/footer.php
--/module/
--------/account/
----------------/create.php
----------------/login.php
----------------/logout.php
----------------/settings.php
----------------/editprofile.php
--------/admin/
--------/blog/
--------/forums/
--------/messages/
--------/users/
--index.php

Answer 1

The answer from jasonbar is actually almost there. All it lacks is dealing with the .php extension as you described:
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_URI} !^/module
RewriteCond %{REQUEST_URI} [.]php$
RewriteRule (.*)[.]php$ /module/$1
That being said, I'd strongly encourage you to consider a front controller paradigm (as you eluded to in your problem description) as doing so allows for much greater control, encourages an MVC approach, etc. =o)
EDIT:
I corrected a few neglected points and added proper processing of the PHP extension. Note that the [L] argument at the end causes further processing to cease, making these code blocks useful as logical structures within your .htaccess file (i.e. by preventing any processing that follows); remove that argument if such functionality is not desired.
I've also added a line to specifically check that the php file being requested actually exists.
RewriteEngine On
# if the uri matches a directory in the module dir, redirect to that. Disable
# this block if you don't wish to have either directory browsing or to have the
# default apache file load.
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{DOCUMENT_ROOT}/module%{REQUEST_URI} -d
RewriteCond %{REQUEST_URI} !^/includes
RewriteCond %{REQUEST_URI} !^/assets
RewriteCond %{REQUEST_URI} !^/module
RewriteRule (.*) /module/$1 [L]
# if the uri matches a file sans the .php extension in the module directory,
# then redirect to that.
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{DOCUMENT_ROOT}/module%{REQUEST_URI}.php -f
RewriteCond %{REQUEST_URI} !^/includes
RewriteCond %{REQUEST_URI} !^/assets
RewriteCond %{REQUEST_URI} !^/module
RewriteRule (.*) /module/$1.php [L]
EDIT:
To also allow files that end in ".php" to be served from the module directory, add the following to your .htaccess file:
# if the uri matches a file with the .php extension in the module directory,
# then redirect to that.
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{DOCUMENT_ROOT}/module%{REQUEST_URI} -f
RewriteCond %{REQUEST_URI} !^/includes
RewriteCond %{REQUEST_URI} !^/assets
RewriteCond %{REQUEST_URI} !^/module
# note that the following line restricts access to php files only. comment out
# the following line to allow any existing file under module director to be
# accessed (or modify the following to allow other file extensions to be read)
RewriteCond %{REQUEST_URI} [.]php$
RewriteRule (.*) /module/$1 [L]

Answer 2

I'd try to solve this in PHP itself, if it were up to me. Just create a .htaccess file that maps every possible request to a single file (probably index.php), and determine what to do from there. That gives you an opportunity to do all kinds of bootstrapping and logging before delegating the request to whatever piece of code should handle that request. You could even include and use a micro framework such as Limonade to accomplish what you want. Here's an example:
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d # if the requested directory does not exist,
RewriteCond %{REQUEST_FILENAME} !-f # and the requested file does not exist,
RewriteRule ^ index.php # map everything to index.php.
Then, in index.php, you can do a wide variety of things to make sure you get the correct response. The simplest way to use a "controller like structure", would be to include a framework such as Limonade, and use it. An example:
<?php
require_once 'vendor/limonade.php';
dispatch( 'account/home', 'accountHome' );
function accountHome( ) {
require_once 'modules/account/home.php';
}
run( );
Obviously, that is just a suggestion. Alternatively, you could just make use of an even simpler system, although I guess you'd have to write that yourself. That way you can say, if the file exists in the modules directory, just include this file, and that's that.
<?php
$path = isset( $_SERVER['PATH_INFO'] ) ? trim( $_SERVER['PATH_INFO'], '/' ) : null;
if( $path !== null ) {
$filename = 'module/' . $path . '.php'; /** $path could be account/home */
if( file_exists( $filename ) ) {
require_once $filename;
}
else {
require_once 'error.php';
}
}
else {
require_once 'home.php';
}
That's it. Fully functional and all. You could benefit from using a library that sorts this all out for you though.

Answer 3

After reading your requirements, I have come up with the following solution:
RewriteCond %{REQUEST_URI} !^/includes
RewriteCond %{REQUEST_URI} !^/assets
RewriteCond %{REQUEST_URI} !^/module
RewriteCond %{REQUEST_URI} !^/index\.php
RewriteRule (.*)(\.php)?$ /module/$1
I have verified this works with the following URL patterns using Apache 2.2:
Redirects to module folder:
http://local.sandbox.com/account/home.php?t=t
http://local.sandbox.com/account/home.php
http://local.sandbox.com/account/home.php/?t=t
http://local.sandbox.com/account/home?t=t
http://local.sandbox.com/account/home/?t=t
http://local.sandbox.com/account/home/
http://local.sandbox.com/account/home
http://local.sandbox.com/user/register
http://local.sandbox.com/user/register.php
http://local.sandbox.com/user/register?t=t
http://local.sandbox.com/user/register.php?t=t
Doesn't redirect as these URI's are excluded:
http://local.sandbox.com/includes/header.php
http://local.sandbox.com/includes/header.php?t=t
http://local.sandbox.com/index.php?t=t
http://local.sandbox.com/?t=t
Note that the RewriteCondition is essentially an AND consisting of NOT conditions, so any folder or file that you want to exclude from the rewrite rule must be added as a NOT condition.
The module rule is inclusive, meaning that any new folders you place in the module folder will automatically be subject to your rewrite requirements.

Answer 4

If I understand you, this should work. The conditions will cause it to redirect only when the requested resource isn't a real file / directory and when it isn't already requested from the module directory.
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_URI} !^/module
RewriteRule (.*) /module/$1

Answer 5

I'm developing a PHP framework with a collegue so this really caught my attention.
Our .htaccess makes a minimal amount of assumptions. It looks like this:
DirectoryIndex index.php
RewriteEngine on
RewriteBase /
RewriteCond %{REQUEST_URI} \.png$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} \.gif$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} \.jpg$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} \.js$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} \.pdf$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} \.css$
RewriteRule ^(.*)$ $1 [QSA,L]
RewriteCond %{REQUEST_URI} ^/favicon*
RewriteRule ^(.*)$ favicon.ico [QSA,L]
#RewriteCond %{REQUEST_FILENAME} !-f
#RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php?$1 [QSA,L]
index.php in turn, looks like this:
<?php
namespace System;
try
{
ob_start();
$Indium = include 'src/bootstrap/IndiumFactory.php';
$Indium->run();
}
catch (\Exception $e) // catch errors and display/log
{
Error::indium_exception_handler($e);
Error::render_error_page();
}
IndiumFactory is the bootstrapper which sets up the environment. Indium is the name of our framework. IndiumFactory is autogenerated from a set of config files.
Maybe I should clarify that Indium has a mechanism for loading and calling the correct controller class with the rest of REQUEST_URI as the arguments. Our forms rely on POST:ed data, so we can impose rather strict rules/filters on the URI.