I often find myself needing a configuration module of some sort -- for
storing application parameters, bootstrapping, template variables, what have
you. I typically will either:
- Create a PHP file that creates and returns an array, and suck that in
via include, or
- Create an INI file and suck it in via
parse_ini_file, or
- Create an XML file and suck it in via
SimpleXML.
The first method gives great flexibility of structure and types, but isn't
portable to other languages (well, not easily; you could turn it into JSON,
or serialize it, etc). The second method (INI files) is handy because the
syntax is so concise, and can translate to other projects in other languages
easily if necessary; however, you can only easily go two levels deep (using
[sections] in the file). The third method is very portable, and allows
nested structures -- but doesn't allow usage of many specific PHP types.
I find, however, that each has their place. The problem, however, is: once I
bring them into my project, how can I access them? Better yet, would there
be a way to bring in configurations of many types and still access them all
in the same way?
Not happy with solutions out there, I did the only logical thing: I
reinvented the wheel, and added some new tread of my own.
The solution started out as
Phly_Config,
which was going to be a generic storage container with several adapters for
loading configurations. However, in talking with
Paul, he noticed two tools
emerging. To quote him:
- A general-purpose array/object/struct implementation.
- Config adapters to push data into the struct.
I got to thinking about it, and decided he was right -- and so
Phly_Struct
was born.
Now that I've hyped it up, just what do the tools offer? I think examples
sum it up best. First, Phly_Struct:
$array =
array( 'key1 => 'value1
',
'key2 =>
array( 'subkey1' =>
array( 'subsubkey1' =>
'subsubvalue1',
'subsubkey2' =>
'subsubvalue2' ),
'subkey2' =>
'subvalue2' ),
'key3' =>
'value3');
$struct =
new Phly_Struct
($array);
echo 'The value of the second subkey is ' .
$struct->
key2->
subkey2;
$struct->
key3 =
'Some new value!';
$struct->
key2->
subkey1->
subsubkey1 =
'I am a third level value';
// Let's loop over values...foreach ($struct->
key2 as $key =>
$value) { if (is_scalar($value)) { echo "Key $key: $value\n";
}}// Let's grab a sub array to pass elsewhere$subarray =
$struct->
key2->
subkey1->
toArray();
As you can see, Phly_Struct provides object oriented access to values. You
can retrieve and set them just as you would object properties. Additionally,
since it implements the SPL Iterator,
you can loop over a Phly_Struct just like you would an array.
Now let's turn to Phly_Config:
$array =
array( 'key1 => 'value1
',
'key2 =>
array( 'subkey1' =>
array( 'subsubkey1' =>
'subsubvalue1',
'subsubkey2' =>
'subsubvalue2' ),
'subkey2' =>
'subvalue2' ),
'key3' =>
'value3');
// Load an in-memory array into the configPhly_Config::
load($array);
// Grab configuration; Phly_Config is a singleton, so this can be done at any// time, and any configurations loaded will be available$config = Phly_Config::
getInstance();
// Load an INI file into the config, under the namespace 'ini'Phly_Config::
load('/path/to/some/config.ini',
'ini');
// Load an XML file into the config, under the namespace 'xml'Phly_Config::
load('/path/to/some/config.xml',
'xml');
// Load a PHP file returning an array into the config, under the namespace 'php'Phly_Config::
load('/path/to/some/config.php',
'php');
// By default, values are retrieved from the 'default' namespace, which is used// if no namespace was specified when loading a config:echo 'I am the third value: ' .
$config->
key3;
// Now grab the db host from the 'ini' namespace$host =
$config->
ini->
db->
host;
// Set the db host in the xml config namespace$config->
xml->
db->
host =
$host;
// Let's get back the whole db array from the xml config namespace$db_data =
$config->
xml->
db->
toArray();
Since Phly_Config simply loads configuration structures into Phly_Structs,
you get all the syntactic yumminess of that class for free. Additionally,
since Phly_Config is a singleton class, you can load configurations at
different points in the code, and have access to those values anywhere else.
Now, you can set values with Phly_Config. However, they will only
affect the current instance; nothing gets written back to the configuration
files at this point. Typically, configuration is a one way street; you want
to load configuration data and access it from your program, but not change
it. I may in the future add implementations for writing configurations, or
at least spitting out the formatted output. In the meantime, you can always
serialize the object either with PHP or as JSON.
Comments, bugfixes, and other feedback always welcome!
