	Source Code Coverage
	Designed for use with PHPUnit, Xdebug and Phing.

Methods: 15

LOC: 371

Statements: 106

Legend:

executednot executeddead code

Source file

Statements

Methods

Total coverage

V06.php

100.0%

93.3%

99.2%

<?php
/**
 * V6.php
 * 08-Nov-2011
 *
 * PHP Version 5
 *
 * @category Services
 * @package  Services_Openstreetmap
 * @author   Ken Guest <kguest@php.net>
 * @license  BSD http://www.opensource.org/licenses/bsd-license.php
 * @version  Release: @package_version@
 * @link     V6.php
 */

/**
 * Services_Openstreetmap_API_V06
 *
 * @category Services
 * @package  Services_Openstreetmap
 * @author   Ken Guest <kguest@php.net>
 * @license  BSD http://www.opensource.org/licenses/bsd-license.php
 * @link     API_V06.php
 */
class Services_Openstreetmap_API_V06
{
    /**
     * Elements supported by the API (v0.6).
     * Used for validation purposes.
     * @var array
     * @internal
     */
    protected $elements = array('changeset', 'node', 'relation', 'way');

    protected $transport = null;

    protected $config = null;

    /**
     * Counter for assigning IDs to [newly] created objects.
     * @var int
     * @internal
     */
    protected $newId = -1;

    /**
     * Set Config object
     *
     * @param Services_Openstreetmap_Config $config Config object.
     *
     * @return Services_Openstreetmap_API_V06
     */
    public function setConfig(Services_Openstreetmap_Config $config)
    {
        $this->config = $config;
        return $this;
    }

    /**
     * Get current Config object
     *
     * @return Services_Openstreetmap_Config
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * Set the Transport instance.
     *
     * @param Services_Openstreetmap_Transport $transport Transport instance.
     *
     * @return Services_Openstreetmap_Config
     */
    public function setTransport($transport)
    {
        $this->transport = $transport;
        return $this;
    }

    /**
     * Retrieve the current Transport instance.
     *
     * @return Services_Openstreetmap_Transport.
     */
    public function getTransport()
    {
        return $this->transport;
    }

    /**
     * Get details of specified relation, optionally specify which version of
     * the relation to be retrieved.
     *
     * <pre>
     * $r = $osm->getRelation(1234567);
     * $r = $osm->getRelation(1234567, 2);
     * </pre>
     *
     * @param mixed $relationID ID of relation
     * @param mixed $version    [optional] version of relation
     *
     * @return string
     */
    public function getRelation($relationID, $version = null)
    {
        return $this->getTransport()->getObject('relation', $relationID, $version);
    }

    /**
     * Return an array of specified relations
     *
     * <pre>
     * $relations = $osm->getRelations($relationId, $relation2Id);
     * </pre>
     *
     * @return array
     */
    public function getRelations()
    {
        return $this->getTransport()->getObjects(
            'relation',
            Services_Openstreetmap::getIDs(func_get_args())
        );
    }

    /**
     * Get details of specified changeset
     *
     * <code>
     * $changeset = $osm->getChangeset(123456);
     * </code>
     *
     * @param string $id      numeric ID of changeset
     * @param string $version optional
     *
     * @return string
     */
    public function getChangeset($id, $version = null)
    {
        return $this->getTransport()->getObject('changeset', $id, $version);
    }

    /**
     * Create a changeset, used to transmit changes (creation, updates, deletion)
     * to the server. Username and password must be set.
     *
     * <code>
     * $config = array('user' => 'fred@example.net', 'password' => 'wilma4eva');
     * $osm = new Services_Openstreetmap($config);
     * $changeset = $osm->createChangeset();
     * </code>
     *
     * @param boolean $atomic atomic changeset?
     *
     * @return Services_Openstreetmap_Changeset
     * @see setConfig
     */
    public function createChangeset($atomic = true)
    {
        $changeset = new Services_Openstreetmap_Changeset($atomic);
        $changeset->setTransport($this->getTransport());
        $changeset->setConfig($this->getConfig());
        return $changeset;
    }

    /**
     * searchChangesets
     *
     * @param array $criteria Array of Services_Openstreetmap_Criterion objects.
     *
     * @return Services_Openstreetmap_Changesets
     */
    public function searchChangesets(array $criteria)
    {
        $types = array();
        foreach ($criteria as $criterion) {
            $types[] = $criterion->type();
        }

        if (array_search('user', $types) !== false
            && array_search('display_name', $types) !== false
        ) {
            throw new Services_Openstreetmap_InvalidArgumentException(
                'Can\'t supply both user and display_name criteria'
            );
        }

        return $this->getTransport()->searchObjects('changeset', $criteria);
    }

    /**
     * Create and return a Services_Openstreetmap_Node
     *
     * <code>
     * $node = $osm->createNode($lat, $lon, array('building' => 'yes'));
     * </code>
     *
     * @param float $latitude  Latitude of node
     * @param float $longitude Longitude of node
     * @param array $tags      Array of key->value tag pairs.
     *
     * @return Services_Openstreetmap_Node
     */
    public function createNode($latitude, $longitude, array $tags = array())
    {
        $node = new Services_Openstreetmap_Node();
        $config = $this->getConfig();
        $apiVersion = $config->getValue('api_version');
        $userAgent  = $config->getValue('User-Agent');
        $xml = "<?xml version='1.0' encoding='UTF-8'?>
<osm version='{$apiVersion}' generator='{$userAgent}'>
<node lat='{$latitude}' lon='{$longitude}' version='1'/></osm>";
        $node->setLat($latitude);
        $node->setLon($longitude);
        $node->setXml(simplexml_load_string($xml));
        $node->setId($this->newId--);
        $node->setTag('created_by', $userAgent);
        if (!empty($tags)) {
            foreach ($tags as $key => $value) {
                $node->setTag($key, $value);
            }
        }
        return $node;
    }

    /**
     * Get a Services_Openstreetmap_User object for the [current] user.
     *
     * May return false if the user could not be found for any reason.
     *
     * @see setConfig
     *
     * @return Services_Openstreetmap_User
     */
    public function getUser()
    {
        $config = $this->getConfig()->asArray();
        $url = $config['server']
             . 'api/'
             . $config['api_version']
             . '/user/details';
        $user = $config['user'];
        $password = $config['password'];
        try {
            $response = $this->getTransport()->getResponse(
                $url,
                HTTP_Request2::METHOD_GET,
                $user,
                $password
            );
        } catch (Services_Openstreetmap_Exception $ex) {
            switch ($ex->getCode()) {
            case Services_Openstreetmap_Transport::NOT_FOUND:
            case Services_Openstreetmap_Transport::UNAUTHORISED:
            case Services_Openstreetmap_Transport::GONE:
                return false;
            default:
                throw $ex;
            }
        }
        $url = $config['server'] . 'api/'
             . $config['api_version']
             . '/user/preferences';
        try {
            $prefs = $this->getTransport()->getResponse(
                $url,
                HTTP_Request2::METHOD_GET,
                $user,
                $password
            );
        } catch (Services_Openstreetmap_Exception $ex) {
            switch ($ex->getCode()) {
            case Services_Openstreetmap_Transport::NOT_FOUND:
            case Services_Openstreetmap_Transport::UNAUTHORISED:
            case Services_Openstreetmap_Transport::GONE:
                return false;
            default:
                throw $ex;
            }
        }
        $obj = new Services_Openstreetmap_User();
        $obj->setXml(simplexml_load_string($response->getBody()));
        $obj->setPreferencesXml($prefs->getBody());
        return $obj;
    }

    /**
     * Get details of specified way
     *
     * @param mixed $wayID   wayID
     * @param mixed $version [optional] version of way
     *
     * @return string
     */
    public function getWay($wayID, $version = null)
    {
        $way = $this->getTransport()->getObject('way', $wayID, $version);
        if ($way !== false) {
            $way->setTransport($this->getTransport());
            $way->setConfig($this->getConfig());
        }
        return $way;
    }

    /**
     * Return an array of specified ways.
     *
     * <pre>
     * $ways = $osm->getWays($wayId, $way2Id);
     * </pre>
     *
     * @return array
     */
    public function getWays()
    {
        return $this->getTransport()->getObjects(
            'way',
            Services_Openstreetmap::getIDs(func_get_args())
        );
    }

    /**
     * Get details of specified node
     *
     * <code>
     * $osm = new Services_Openstreetmap();
     * var_dump($osm->getNode(52245107));
     * </code>
     *
     * @param string $nodeID  nodeID
     * @param mixed  $version [optional] version of node
     *
     * @return string
     */
    public function getNode($nodeID, $version = null)
    {
        $node = $this->getTransport()->getObject('node', $nodeID, $version);
        if ($node !== false) {
            $node->setTransport($this->getTransport());
            $node->setConfig($this->getConfig());
        }
        return $node;
    }

    /**
     * Return an array of specified nodes.
     *
     * <code>
     * $osm = new Services_Openstreetmap();
     * var_dump($osm->getNodes(52245107, 52245108));
     * </code>
     * Or
     * <code>
     * $osm = new Services_Openstreetmap();
     * var_dump($osm->getNodes(array(52245107, 52245108)));
     * </code>
     *
     * @return Services_Openstreetmap_Nodes
     */
    public function getNodes()
    {
        return $this->getTransport()->getObjects(
            'node',
            Services_Openstreetmap::getIDs(func_get_args())
        );
    }
}

?>

Report generated at 2012-01-31T21:54:36Z

1		<?php
2		/**
3		* V6.php
4		* 08-Nov-2011
5		*
6		* PHP Version 5
7		*
8		* @category Services
9		* @package Services_Openstreetmap
10		* @author Ken Guest <kguest@php.net>
11		* @license BSD http://www.opensource.org/licenses/bsd-license.php
12		* @version Release: @package_version@
13		* @link V6.php
14		*/
15
16		/**
17		* Services_Openstreetmap_API_V06
18		*
19		* @category Services
20		* @package Services_Openstreetmap
21		* @author Ken Guest <kguest@php.net>
22		* @license BSD http://www.opensource.org/licenses/bsd-license.php
23		* @link API_V06.php
24		*/
25		class Services_Openstreetmap_API_V06
26		{
27		/**
28		* Elements supported by the API (v0.6).
29		* Used for validation purposes.
30		* @var array
31		* @internal
32		*/
33		protected $elements = array('changeset', 'node', 'relation', 'way');
34
35		protected $transport = null;
36
37		protected $config = null;
38
39		/**
40		* Counter for assigning IDs to [newly] created objects.
41		* @var int
42		* @internal
43		*/
44		protected $newId = -1;
45
46		/**
47		* Set Config object
48		*
49		* @param Services_Openstreetmap_Config $config Config object.
50		*
51		* @return Services_Openstreetmap_API_V06
52		*/
53		public function setConfig(Services_Openstreetmap_Config $config)
54		{
55	80	$this->config = $config;
56	80	return $this;
57		}
58
59		/**
60		* Get current Config object
61		*
62		* @return Services_Openstreetmap_Config
63		*/
64		public function getConfig()
65		{
66	34	return $this->config;
67		}
68
69		/**
70		* Set the Transport instance.
71		*
72		* @param Services_Openstreetmap_Transport $transport Transport instance.
73		*
74		* @return Services_Openstreetmap_Config
75		*/
76		public function setTransport($transport)
77		{
78	80	$this->transport = $transport;
79	80	return $this;
80		}
81
82		/**
83		* Retrieve the current Transport instance.
84		*
85		* @return Services_Openstreetmap_Transport.
86		*/
87		public function getTransport()
88		{
89	46	return $this->transport;
90		}
91
92		/**
93		* Get details of specified relation, optionally specify which version of
94		* the relation to be retrieved.
95		*
96		* <pre>
97		* $r = $osm->getRelation(1234567);
98		* $r = $osm->getRelation(1234567, 2);
99		* </pre>
100		*
101		* @param mixed $relationID ID of relation
102		* @param mixed $version [optional] version of relation
103		*
104		* @return string
105		*/
106		public function getRelation($relationID, $version = null)
107		{
108	1	return $this->getTransport()->getObject('relation', $relationID, $version);
109		}
110
111		/**
112		* Return an array of specified relations
113		*
114		* <pre>
115		* $relations = $osm->getRelations($relationId, $relation2Id);
116		* </pre>
117		*
118		* @return array
119		*/
120		public function getRelations()
121		{
122	2	return $this->getTransport()->getObjects(
123	2	'relation',
124	2	Services_Openstreetmap::getIDs(func_get_args())
125	2	);
126		}
127
128		/**
129		* Get details of specified changeset
130		*
131		* <code>
132		* $changeset = $osm->getChangeset(123456);
133		* </code>
134		*
135		* @param string $id numeric ID of changeset
136		* @param string $version optional
137		*
138		* @return string
139		*/
140		public function getChangeset($id, $version = null)
141		{
142	2	return $this->getTransport()->getObject('changeset', $id, $version);
143		}
144
145		/**
146		* Create a changeset, used to transmit changes (creation, updates, deletion)
147		* to the server. Username and password must be set.
148		*
149		* <code>
150		* $config = array('user' => 'fred@example.net', 'password' => 'wilma4eva');
151		* $osm = new Services_Openstreetmap($config);
152		* $changeset = $osm->createChangeset();
153		* </code>
154		*
155		* @param boolean $atomic atomic changeset?
156		*
157		* @return Services_Openstreetmap_Changeset
158		* @see setConfig
159		*/
160		public function createChangeset($atomic = true)
161		{
162	10	$changeset = new Services_Openstreetmap_Changeset($atomic);
163	10	$changeset->setTransport($this->getTransport());
164	10	$changeset->setConfig($this->getConfig());
165	10	return $changeset;
166		}
167
168		/**
169		* searchChangesets
170		*
171		* @param array $criteria Array of Services_Openstreetmap_Criterion objects.
172		*
173		* @return Services_Openstreetmap_Changesets
174		*/
175		public function searchChangesets(array $criteria)
176		{
177	6	$types = array();
178	6	foreach ($criteria as $criterion) {
179	6	$types[] = $criterion->type();
180	6	}
181
182	6	if (array_search('user', $types) !== false
183	6	&& array_search('display_name', $types) !== false
184	6	) {
185	1	throw new Services_Openstreetmap_InvalidArgumentException(
186		'Can\'t supply both user and display_name criteria'
187	1	);
188	1	}
189
190	5	return $this->getTransport()->searchObjects('changeset', $criteria);
191		}
192
193		/**
194		* Create and return a Services_Openstreetmap_Node
195		*
196		* <code>
197		* $node = $osm->createNode($lat, $lon, array('building' => 'yes'));
198		* </code>
199		*
200		* @param float $latitude Latitude of node
201		* @param float $longitude Longitude of node
202		* @param array $tags Array of key->value tag pairs.
203		*
204		* @return Services_Openstreetmap_Node
205		*/
206		public function createNode($latitude, $longitude, array $tags = array())
207		{
208	10	$node = new Services_Openstreetmap_Node();
209	10	$config = $this->getConfig();
210	10	$apiVersion = $config->getValue('api_version');
211	10	$userAgent = $config->getValue('User-Agent');
212		$xml = "<?xml version='1.0' encoding='UTF-8'?>
213	10	<osm version='{$apiVersion}' generator='{$userAgent}'>
214	10	<node lat='{$latitude}' lon='{$longitude}' version='1'/></osm>";
215	10	$node->setLat($latitude);
216	7	$node->setLon($longitude);
217	4	$node->setXml(simplexml_load_string($xml));
218	4	$node->setId($this->newId--);
219	4	$node->setTag('created_by', $userAgent);
220	4	if (!empty($tags)) {
221	3	foreach ($tags as $key => $value) {
222	3	$node->setTag($key, $value);
223	3	}
224	3	}
225	4	return $node;
226		}
227
228		/**
229		* Get a Services_Openstreetmap_User object for the [current] user.
230		*
231		* May return false if the user could not be found for any reason.
232		*
233		* @see setConfig
234		*
235		* @return Services_Openstreetmap_User
236		*/
237		public function getUser()
238		{
239	3	$config = $this->getConfig()->asArray();
240	3	$url = $config['server']
241		. 'api/'
242	3	. $config['api_version']
243	3	. '/user/details';
244	3	$user = $config['user'];
245	3	$password = $config['password'];
246		try {
247	3	$response = $this->getTransport()->getResponse(
248	3	$url,
249	3	HTTP_Request2::METHOD_GET,
250	3	$user,
251		$password
252	3	);
253	3	} catch (Services_Openstreetmap_Exception $ex) {
254		switch ($ex->getCode()) {
255		case Services_Openstreetmap_Transport::NOT_FOUND:
256		case Services_Openstreetmap_Transport::UNAUTHORISED:
257		case Services_Openstreetmap_Transport::GONE:
258		return false;
259		default:
260		throw $ex;
261		}
262		}
263	3	$url = $config['server'] . 'api/'
264	3	. $config['api_version']
265	3	. '/user/preferences';
266		try {
267	3	$prefs = $this->getTransport()->getResponse(
268	3	$url,
269	3	HTTP_Request2::METHOD_GET,
270	3	$user,
271		$password
272	3	);
273	3	} catch (Services_Openstreetmap_Exception $ex) {
274		switch ($ex->getCode()) {
275		case Services_Openstreetmap_Transport::NOT_FOUND:
276		case Services_Openstreetmap_Transport::UNAUTHORISED:
277		case Services_Openstreetmap_Transport::GONE:
278		return false;
279		default:
280		throw $ex;
281		}
282		}
283	3	$obj = new Services_Openstreetmap_User();
284	3	$obj->setXml(simplexml_load_string($response->getBody()));
285	3	$obj->setPreferencesXml($prefs->getBody());
286	3	return $obj;
287		}
288
289		/**
290		* Get details of specified way
291		*
292		* @param mixed $wayID wayID
293		* @param mixed $version [optional] version of way
294		*
295		* @return string
296		*/
297		public function getWay($wayID, $version = null)
298		{
299	10	$way = $this->getTransport()->getObject('way', $wayID, $version);
300	10	if ($way !== false) {
301	10	$way->setTransport($this->getTransport());
302	10	$way->setConfig($this->getConfig());
303	10	}
304	10	return $way;
305		}
306
307		/**
308		* Return an array of specified ways.
309		*
310		* <pre>
311		* $ways = $osm->getWays($wayId, $way2Id);
312		* </pre>
313		*
314		* @return array
315		*/
316		public function getWays()
317		{
318	3	return $this->getTransport()->getObjects(
319	3	'way',
320	3	Services_Openstreetmap::getIDs(func_get_args())
321	3	);
322		}
323
324		/**
325		* Get details of specified node
326		*
327		* <code>
328		* $osm = new Services_Openstreetmap();
329		* var_dump($osm->getNode(52245107));
330		* </code>
331		*
332		* @param string $nodeID nodeID
333		* @param mixed $version [optional] version of node
334		*
335		* @return string
336		*/
337		public function getNode($nodeID, $version = null)
338		{
339	12	$node = $this->getTransport()->getObject('node', $nodeID, $version);
340	11	if ($node !== false) {
341	9	$node->setTransport($this->getTransport());
342	9	$node->setConfig($this->getConfig());
343	9	}
344	11	return $node;
345		}
346
347		/**
348		* Return an array of specified nodes.
349		*
350		* <code>
351		* $osm = new Services_Openstreetmap();
352		* var_dump($osm->getNodes(52245107, 52245108));
353		* </code>
354		* Or
355		* <code>
356		* $osm = new Services_Openstreetmap();
357		* var_dump($osm->getNodes(array(52245107, 52245108)));
358		* </code>
359		*
360		* @return Services_Openstreetmap_Nodes
361		*/
362		public function getNodes()
363		{
364	6	return $this->getTransport()->getObjects(
365	6	'node',
366	6	Services_Openstreetmap::getIDs(func_get_args())
367	6	);
368		}
369		}
370
371		?>

Source Code Coverage