AnyDataset::save() - Code Metrics - Inspection of "New Major 4.0" - byjg/anydataset - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Joao

created 2018-11-24 15:04 UTC

AnyDataset::save() A

↳ Parent: AnyDataset

Complexity

Conditions	4
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4.1755

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	7
cts	9
cp	0.7778
rs	9.7333
c	0
b	0
f	0
cc	4
nc	5
nop	1
crap	4.1755

<?php

namespace ByJG\AnyDataset\Core;

use ByJG\AnyDataset\Core\Exception\DatabaseException;
use ByJG\Util\XmlUtil;
use InvalidArgumentException;

/**
 * AnyDataset is a simple way to store data using only XML file.
 * Your structure is hierarquical and each "row" contains "fields" but these structure can vary for each row.
 * Anydataset files have extension ".anydata.xml" and have many classes to put and get data into anydataset xml file.
 * Anydataset class just read and write files. To search elements you need use AnyIterator
 * and IteratorFilter. Each row have a class Row.

 * XML Structure
 * <code>
 * <anydataset>
 *    <row>
 *        <field name="fieldname1">value of fieldname 1</field>
 *        <field name="fieldname2">value of fieldname 2</field>
 *        <field name="fieldname3">value of fieldname 3</field>
 *    </row>
 *    <row>
 *        <field name="fieldname1">value of fieldname 1</field>
 *        <field name="fieldname4">value of fieldname 4</field>
 *    </row>
 * </anydataset>
 * </code>

 * How to use:
 * <code>
 * $any = new AnyDataset();
 * </code>

 *
*@see Row
 * @see AnyIterator
 * @see IteratorFilter

 */
class AnyDataset
{

    /**
     * Internal structure represent the current Row
     *
     * @var Row[]
     */
    private $collection;

    /**
     * Current node anydataset works
     * @var int
     */
    private $currentRow;

    /**
     * Path to anydataset file
     * @var string
     */
    private $path;

    /**
     * @param string $file
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    public function __construct($file = null)
    {
        $this->collection = array();
        $this->currentRow = -1;

        $this->path = null;
        if (!is_null($file)) {
            if (!is_string($file)) {
                throw new \InvalidArgumentException('I expected a string as a file name');
            }

            $ext = pathinfo($file, PATHINFO_EXTENSION);
            if (empty($ext)) {
                $file .= '.anydata.xml';
            }
            $this->path = $file;

            $this->createFrom($this->path);
        }
    }

    /**
     * Private method used to read and populate anydataset class from specified file
     *
     * @param string $filepath Path and Filename to be read
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    private function createFrom($filepath)
    {
        if (file_exists($filepath)) {
            $anyDataSet = XmlUtil::createXmlDocumentFromFile($filepath);
            $this->collection = array();

            $rows = $anyDataSet->getElementsByTagName("row");
            foreach ($rows as $row) {
                $sr = new Row();
                $fields = $row->getElementsByTagName("field");
                foreach ($fields as $field) {
                    $attr = $field->attributes->getNamedItem("name");
                    if (is_null($attr)) {
                        throw new \InvalidArgumentException('Malformed anydataset file ' . basename($filepath));
                    }

                    $sr->addField($attr->nodeValue, $field->nodeValue);
                }
                $sr->acceptChanges();
                $this->collection[] = $sr;
            }
            $this->currentRow = count($this->collection) - 1;
        }
    }

    /**
     * Returns the AnyDataset XML representative structure.
     *
     * @return string XML String
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    public function xml()
    {
        return $this->getAsDom()->saveXML();
    }

    /**
     * Returns the AnyDataset XmlDocument representive object
     *
     * @return \DOMDocument XmlDocument object
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    public function getAsDom()
    {
        $anyDataSet = XmlUtil::createXmlDocumentFromStr("<anydataset></anydataset>");
        $nodeRoot = $anyDataSet->getElementsByTagName("anydataset")->item(0);
        foreach ($this->collection as $sr) {
            $row = $sr->getAsDom();
            $nodeRow = $row->getElementsByTagName("row")->item(0);
            $newRow = XmlUtil::createChild($nodeRoot, "row");
            XmlUtil::addNodeFromNode($newRow, $nodeRow);
        }

        return $anyDataSet;
    }

    /**
     * @param string $file
     * @throws DatabaseException
     * @throws \ByJG\Util\Exception\XmlUtilException
     */
    public function save($file = null)
    {
        if (!is_null($file)) {
            if (!is_string($file)) {
                throw new InvalidArgumentException('Invalid file name');
            }

            $this->path = $file;
        }

        if (is_null($this->path)) {
            throw new DatabaseException("No such file path to save anydataset");
        }

        XmlUtil::saveXmlDocument($this->getAsDom(), $this->path);
    }

    /**
     * Append one row to AnyDataset.
     *
     * @param Row $singleRow
     * @return void
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function appendRow($singleRow = null)
    {
        if (!is_null($singleRow)) {
            if ($singleRow instanceof Row) {
                $this->collection[] = $singleRow;
                $singleRow->acceptChanges();
            } elseif (is_array($singleRow)) {
                $this->collection[] = new Row($singleRow);
            } else {
                throw new InvalidArgumentException("You must pass an array or a Row object");
            }
        } else {
            $singleRow = new Row();
            $this->collection[] = $singleRow;
            $singleRow->acceptChanges();
        }
        $this->currentRow = count($this->collection) - 1;
    }

    /**
     * Enter description here...
     *
     * @param GenericIterator $iterator
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function import($iterator)
    {
        foreach ($iterator as $singleRow) {
            $this->appendRow($singleRow);
        }
    }

    /**
     * Insert one row before specified position.
     *
     * @param int $rowNumber
     * @param mixed $row
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function insertRowBefore($rowNumber, $row = null)
    {
        if ($rowNumber > count($this->collection)) {
            $this->appendRow($row);
        } else {
            $singleRow = $row;
            if (!($row instanceof Row)) {
                $singleRow = new Row($row);
            }
            array_splice($this->collection, $rowNumber, 0, '');
            $this->collection[$rowNumber] = $singleRow;
        }
    }

    /**
     *
     * @param mixed $row
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function removeRow($row = null)
    {
        if (is_null($row)) {
            $row = $this->currentRow;
        }
        if ($row instanceof Row) {
            $iPos = 0;
            foreach ($this->collection as $sr) {
                if ($sr->toArray() == $row->toArray()) {
                    $this->removeRow($iPos);
                    break;
                }
                $iPos++;
            }
            return;
        }

        if ($row == 0) {
            $this->collection = array_slice($this->collection, 1);
        } else {
            $this->collection = array_slice($this->collection, 0, $row) + array_slice($this->collection, $row);
        }
    }

    /**
     * Add a single string field to an existing row
     *
     * @param string $name - Field name
     * @param string $value - Field value
     * @return void
     * @throws \ByJG\Serializer\Exception\InvalidArgumentException
     */
    public function addField($name, $value)
    {
        if ($this->currentRow < 0) {
            $this->appendRow();
        }
        $this->collection[$this->currentRow]->addField($name, $value);
    }

    /**
     * Get an Iterator filtered by an IteratorFilter
     * @param IteratorFilter $itf
     * @return GenericIterator
     */
    public function getIterator(IteratorFilter $itf = null)
    {
        if (is_null($itf)) {
            return new AnyIterator($this->collection);
        }

        return new AnyIterator($itf->match($this->collection));
    }

    /**
     * @desc
     * @param IteratorFilter $itf
     * @param string $fieldName
     * @return array
     */
    public function getArray($itf, $fieldName)
    {
        $iterator = $this->getIterator($itf);
        $result = array();
        while ($iterator->hasNext()) {
            $singleRow = $iterator->moveNext();
            $result [] = $singleRow->get($fieldName);
        }
        return $result;
    }

    /**
     *
     * @param string $field
     * @return void
     */
    public function sort($field)
    {
        if (count($this->collection) == 0) {
            return;
        }

        $this->collection = $this->quickSortExec($this->collection, $field);

        return;
    }

    /**
     * @param Row[] $seq
     * @param $field
     * @return array
     */
    protected function quickSortExec($seq, $field)
    {
        if (!count($seq)) {
            return $seq;
        }

        $key = $seq[0];
        $left = $right = array();

        $cntSeq = count($seq);
        for ($i = 1; $i < $cntSeq; $i ++) {
            if ($seq[$i]->get($field) <= $key->get($field)) {
                $left[] = $seq[$i];
            } else {
                $right[] = $seq[$i];
            }
        }

        return array_merge(
            $this->quickSortExec($left, $field),
            [ $key ],
            $this->quickSortExec($right, $field)
        );
    }
}


1		<?php
2
3		namespace ByJG\AnyDataset\Core;
4
5		use ByJG\AnyDataset\Core\Exception\DatabaseException;
6		use ByJG\Util\XmlUtil;
7		use InvalidArgumentException;
8
9		/**
10		* AnyDataset is a simple way to store data using only XML file.
11		* Your structure is hierarquical and each "row" contains "fields" but these structure can vary for each row.
12		* Anydataset files have extension ".anydata.xml" and have many classes to put and get data into anydataset xml file.
13		* Anydataset class just read and write files. To search elements you need use AnyIterator
14		* and IteratorFilter. Each row have a class Row.
15
16		* XML Structure
17		* <code>
18		* <anydataset>
19		* <row>
20		* <field name="fieldname1">value of fieldname 1</field>
21		* <field name="fieldname2">value of fieldname 2</field>
22		* <field name="fieldname3">value of fieldname 3</field>
23		* </row>
24		* <row>
25		* <field name="fieldname1">value of fieldname 1</field>
26		* <field name="fieldname4">value of fieldname 4</field>
27		* </row>
28		* </anydataset>
29		* </code>
30
31		* How to use:
32		* <code>
33		* $any = new AnyDataset();
34		* </code>
35
36		*
37		*@see Row
38		* @see AnyIterator
39		* @see IteratorFilter
40
41		*/
42		class AnyDataset
43		{
44
45		/**
46		* Internal structure represent the current Row
47		*
48		* @var Row[]
49		*/
50		private $collection;
51
52		/**
53		* Current node anydataset works
54		* @var int
55		*/
56		private $currentRow;
57
58		/**
59		* Path to anydataset file
60		* @var string
61		*/
62		private $path;
63
64		/**
65		* @param string $file
66		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
67		* @throws \ByJG\Util\Exception\XmlUtilException
68		*/
69	14	public function __construct($file = null)
70		{
71	14	$this->collection = array();
72	14	$this->currentRow = -1;
73
74	14	$this->path = null;
75	14	if (!is_null($file)) {
76	7	if (!is_string($file)) {
77		throw new \InvalidArgumentException('I expected a string as a file name');
78		}
79
80	7	$ext = pathinfo($file, PATHINFO_EXTENSION);
81	7	if (empty($ext)) {
82	7	$file .= '.anydata.xml';
83		}
84	7	$this->path = $file;
85
86	7	$this->createFrom($this->path);
87		}
88	14	}
89
90		/**
91		* Private method used to read and populate anydataset class from specified file
92		*
93		* @param string $filepath Path and Filename to be read
94		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
95		* @throws \ByJG\Util\Exception\XmlUtilException
96		*/
97	7	private function createFrom($filepath)
98		{
99	7	if (file_exists($filepath)) {
100	7	$anyDataSet = XmlUtil::createXmlDocumentFromFile($filepath);
101	7	$this->collection = array();
102
103	7	$rows = $anyDataSet->getElementsByTagName("row");
104	7	foreach ($rows as $row) {
105	7	$sr = new Row();
106	7	$fields = $row->getElementsByTagName("field");
107	7	foreach ($fields as $field) {
108	7	$attr = $field->attributes->getNamedItem("name");
109	7	if (is_null($attr)) {
110		throw new \InvalidArgumentException('Malformed anydataset file ' . basename($filepath));
111		}
112
113	7	$sr->addField($attr->nodeValue, $field->nodeValue);
114		}
115	7	$sr->acceptChanges();
116	7	$this->collection[] = $sr;
117		}
118	7	$this->currentRow = count($this->collection) - 1;
119		}
120	7	}
121
122		/**
123		* Returns the AnyDataset XML representative structure.
124		*
125		* @return string XML String
126		* @throws \ByJG\Util\Exception\XmlUtilException
127		*/
128	1	public function xml()
129		{
130	1	return $this->getAsDom()->saveXML();
131		}
132
133		/**
134		* Returns the AnyDataset XmlDocument representive object
135		*
136		* @return \DOMDocument XmlDocument object
137		* @throws \ByJG\Util\Exception\XmlUtilException
138		*/
139	2	public function getAsDom()
140		{
141	2	$anyDataSet = XmlUtil::createXmlDocumentFromStr("<anydataset></anydataset>");
142	2	$nodeRoot = $anyDataSet->getElementsByTagName("anydataset")->item(0);
143	2	foreach ($this->collection as $sr) {
144	2	$row = $sr->getAsDom();
145	2	$nodeRow = $row->getElementsByTagName("row")->item(0);
146	2	$newRow = XmlUtil::createChild($nodeRoot, "row");
147	2	XmlUtil::addNodeFromNode($newRow, $nodeRow);
148		}
149
150	2	return $anyDataSet;
151		}
152
153		/**
154		* @param string $file
155		* @throws DatabaseException
156		* @throws \ByJG\Util\Exception\XmlUtilException
157		*/
158	1	public function save($file = null)
159		{
160	1	if (!is_null($file)) {
161	1	if (!is_string($file)) {
162		throw new InvalidArgumentException('Invalid file name');
163		}
164
165	1	$this->path = $file;
166		}
167
168	1	if (is_null($this->path)) {
169		throw new DatabaseException("No such file path to save anydataset");
170		}
171
172	1	XmlUtil::saveXmlDocument($this->getAsDom(), $this->path);
173	1	}
174
175		/**
176		* Append one row to AnyDataset.
177		*
178		* @param Row $singleRow
179		* @return void
180		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
181		*/
182	9	public function appendRow($singleRow = null)
183		{
184	9	if (!is_null($singleRow)) {
185	3	if ($singleRow instanceof Row) {
186	2	$this->collection[] = $singleRow;
187	2	$singleRow->acceptChanges();
188	2	} elseif (is_array($singleRow)) {
189	2	$this->collection[] = new Row($singleRow);
190		} else {
191	3	throw new InvalidArgumentException("You must pass an array or a Row object");
192		}
193		} else {
194	6	$singleRow = new Row();
195	6	$this->collection[] = $singleRow;
196	6	$singleRow->acceptChanges();
197		}
198	9	$this->currentRow = count($this->collection) - 1;
199	9	}
200
201		/**
202		* Enter description here...
203		*
204		* @param GenericIterator $iterator
205		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
206		*/
207	1	public function import($iterator)
208		{
209	1	foreach ($iterator as $singleRow) {
210	1	$this->appendRow($singleRow);
211		}
212	1	}
213
214		/**
215		* Insert one row before specified position.
216		*
217		* @param int $rowNumber
218		* @param mixed $row
219		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
220		*/
221	1	public function insertRowBefore($rowNumber, $row = null)
222		{
223	1	if ($rowNumber > count($this->collection)) {
224		$this->appendRow($row);
225		} else {
226	1	$singleRow = $row;
227	1	if (!($row instanceof Row)) {
228	1	$singleRow = new Row($row);
229		}
230	1	array_splice($this->collection, $rowNumber, 0, '');
231	1	$this->collection[$rowNumber] = $singleRow;
232		}
233	1	}
234
235		/**
236		*
237		* @param mixed $row
238		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
239		*/
240	2	public function removeRow($row = null)
241		{
242	2	if (is_null($row)) {
243		$row = $this->currentRow;
244		}
245	2	if ($row instanceof Row) {
246		$iPos = 0;
247		foreach ($this->collection as $sr) {
248		if ($sr->toArray() == $row->toArray()) {
249		$this->removeRow($iPos);
250		break;
251		}
252		$iPos++;
253		}
254		return;
255		}
256
257	2	if ($row == 0) {
258	1	$this->collection = array_slice($this->collection, 1);
259		} else {
260	1	$this->collection = array_slice($this->collection, 0, $row) + array_slice($this->collection, $row);
261		}
262	2	}
263
264		/**
265		* Add a single string field to an existing row
266		*
267		* @param string $name - Field name
268		* @param string $value - Field value
269		* @return void
270		* @throws \ByJG\Serializer\Exception\InvalidArgumentException
271		*/
272	5	public function addField($name, $value)
273		{
274	5	if ($this->currentRow < 0) {
275	2	$this->appendRow();
276		}
277	5	$this->collection[$this->currentRow]->addField($name, $value);
278	5	}
279
280		/**
281		* Get an Iterator filtered by an IteratorFilter
282		* @param IteratorFilter $itf
283		* @return GenericIterator
284		*/
285	13	public function getIterator(IteratorFilter $itf = null)
286		{
287	13	if (is_null($itf)) {
288	13	return new AnyIterator($this->collection);
289		}
290
291		return new AnyIterator($itf->match($this->collection));
292		}
293
294		/**
295		* @desc
296		* @param IteratorFilter $itf
297		* @param string $fieldName
298		* @return array
299		*/
300	1	public function getArray($itf, $fieldName)
301		{
302	1	$iterator = $this->getIterator($itf);
303	1	$result = array();
304	1	while ($iterator->hasNext()) {
305	1	$singleRow = $iterator->moveNext();
306	1	$result [] = $singleRow->get($fieldName);
307		}
308	1	return $result;
309		}
310
311		/**
312		*
313		* @param string $field
314		* @return void
315		*/
316	1	public function sort($field)
317		{
318	1	if (count($this->collection) == 0) {
319		return;
320		}
321
322	1	$this->collection = $this->quickSortExec($this->collection, $field);
323
324	1	return;
325		}
326
327		/**
328		* @param Row[] $seq
329		* @param $field
330		* @return array
331		*/
332	1	protected function quickSortExec($seq, $field)
333		{
334	1	if (!count($seq)) {
335	1	return $seq;
336		}
337
338	1	$key = $seq[0];
339	1	$left = $right = array();
340
341	1	$cntSeq = count($seq);
342	1	for ($i = 1; $i < $cntSeq; $i ++) {
343	1	if ($seq[$i]->get($field) <= $key->get($field)) {
344	1	$left[] = $seq[$i];
345		} else {
346	1	$right[] = $seq[$i];
347		}
348		}
349
350	1	return array_merge(
351	1	$this->quickSortExec($left, $field),
352	1	[ $key ],
353	1	$this->quickSortExec($right, $field)
354		);
355		}
356		}
357

byjg / anydataset

Pull Request — master (#8)

AnyDataset::save() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like