The Registry Package

use Joomla\Registry\Registry;

$registry = new Registry;

// Set a value in the registry.
$registry->set('foo', 'bar');

// Get a value from the registry;
$value = $registry->get('foo');

Load config by Registry

use Joomla\Registry\Registry;

$registry = new Registry;

// Load by string
$registry->loadString('{"foo" : "bar"}');

$registry->loadString('<root></root>', 'xml');

// Load by object or array
$registry->loadObject($object);
$registry->loadArray($array);

// Load by file
$registry->loadFile($root . '/config/config.json', 'json');

Accessing a Registry by getter & setter

Get value

$registry->get('foo');

// Get a non-exists value and return default
$registry->get('foo', 'default');

// OR

$registry->get('foo') ?: 'default';

Set value

// Set value
$registry->set('bar', $value);

// Sets a default value if not already assigned.
$registry->def('bar', $default);

Accessing children value by path

$json = '{
	"parent" : {
		"child" : "Foo"
	}
}';

$registry = new Registry($json);

$registry->get('parent.child'); // return 'Foo'

$registry->set('parent.child', $value);

Accessing a Registry as an Array

The Registry class implements ArrayAccess so the properties of the registry can be accessed as an array. Consider the following examples:

// Set a value in the registry.
$registry['foo'] = 'bar';

// Get a value from the registry;
$value = $registry['foo'];

// Check if a key in the registry is set.
if (isset($registry['foo']))
{
	echo 'Say bar.';
}

Merge Registry

Using load* methods to merge two config files.

$json1 = '{
    "field" : {
        "keyA" : "valueA",
        "keyB" : "valueB"
    }
}';

$json2 = '{
    "field" : {
        "keyB" : "a new valueB"
    }
}';

$registry->loadString($json1);
$registry->loadString($json2);

Output

Array(
    field => Array(
        keyA => valueA
        keyB => a new valueB
    )
)

Merge another Registry

$object1 = '{
	"foo" : "foo value",
	"bar" : {
		"bar1" : "bar value 1",
		"bar2" : "bar value 2"
	}
}';

$object2 = '{
	"foo" : "foo value",
	"bar" : {
		"bar2" : "new bar value 2"
	}
}';

$registry1 = new Registry(json_decode($object1));
$registry2 = new Registry(json_decode($object2));

$registry1->merge($registry2);

If you just want to merge first level, do not hope recursive:

$registry1->merge($registry2, false); // Set param 2 to false that Registry will only merge first level

Dump to file.

$registry->toString();

$registry->toString('xml');

$registry->toString('ini');

Dump to one dimension

$array = array(
    'flower' => array(
        'sunflower' => 'light',
        'sakura' => 'samurai'
    )
);

$registry = new Registry($array);

// Make data to one dimension

$flatted = $registry->flatten();

print_r($flatted);

The result:

Array
(
    [flower.sunflower] => light
    [flower.sakura] => samurai
)

Using YAML

Add Symfony YAML component in composer.json

{
	"require-dev": {
		"symfony/yaml": "~2.0"
	}
}

Using yaml format

$registry->loadFile($yamlFile, 'yaml');

$registry->loadString('foo: bar', 'yaml');

// Convert to string
$registry->toString('yaml');

Using XML

Keep in mind that due to XML complexity, special format must be kept when loading into Registry. By default, the parent XML element should be named "registry" and all child elements should be named "node". The nodes should include a "name" attribute, for the name of the value. The nodes can be optionally filtered with a "type" attribute. Valid types are:

array
boolean
double
integer
object (default)
string

Loading input

<?xml version="1.0"?>
<registry>
	<node name="foo_1" type="string">bar</node>
	<node name="foo_2" type="boolean">1</node>
	<node name="foo_3" type="integer">42</node>
	<node name="foo_4" type="double">3.1415</node>
	<node name="foo_5" type="object">
		<node name="foo_5_a" type="string">value</node>
	</node>
	<node name="foo_6" type="array">
		<node name="foo_6_a" type="string">value</node>
	</node>
</registry>

with Registry

$registry = new Registry;

// Load file or string
$registry->loadFile($xmlFile, 'xml');
$registry->loadString($xmlString, 'xml');

Outputs

Array(
	foo_1 => bar
	foo_2 => 1
	foo_3 => 42
	foo_4 => 3.1415
	foo_5 => Array(
		foo_5_a => value
	)
	foo_6 => Array(
		foo_6_a => value
	)
)

The names of the XML import nodes can be customised using options. For example:

$registry = new Registry(array(
    'name' => 'data',
    'nodeName' => 'value'
));

$registry->loadString('<data><value name="foo" type="string">bar</value></data>, 'xml');

Custom Formats

To load your own custom format you must implement the Joomla\Registry\FormatInterface. This can then be loaded through the Joomla\Registry\Factory class. To load a custom format not provided by Joomla then you can load it by using

Factory::getFormat($type, $options)

In this scenario $type contains the format (and class) name. Whilst $options is an array with the key format_namespace which contains the namespace that the format is in.

Installation via Composer

Add "joomla/registry": "~1.0" to the require block in your composer.json and then run composer install.

{
	"require": {
		"joomla/registry": "~1.0"
	}
}

Alternatively, you can simply run the following from the command line:

composer require joomla/registry "~1.0"

andrepereiradasilva / registry Goto Github PK

registry's Introduction