NodeManager::createPath() - Code Metrics - sulu-io/sulu-document-manager - Measure and Improve Code Quality continuously with Scrutinizer

NodeManager::createPath() A
last analyzed 2015-12-18 14:57 UTC

↳ Parent: NodeManager

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
c	4
b	0
f	0
dl	0
loc	17
rs	9.4286
cc	3
eloc	11
nc	3
nop	1

<?php

/*
 * This file is part of Sulu.
 *
 * (c) MASSIVE ART WebServices GmbH
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Sulu\Component\DocumentManager;

use PHPCR\NodeInterface;
use PHPCR\RepositoryException;
use PHPCR\SessionInterface;
use PHPCR\Util\NodeHelper;
use PHPCR\Util\UUIDHelper;
use Sulu\Component\DocumentManager\Exception\DocumentNotFoundException;

/**
 * The node manager is responsible for talking to the PHPCR
 * implementation.
 */
class NodeManager
{
    /**
     * @var SessionInterface
     */
    private $session;

    /**
     * @param SessionInterface $session
     */
    public function __construct(SessionInterface $session)
    {
        $this->session = $session;
    }

    /**
     * Find a document with the given path or UUID.
     *
     * @param string $identifier UUID or path
     *
     * @return NodeInterface
     *
     * @throws DocumentNotFoundException
     */
    public function find($identifier)
    {
        try {
            if (UUIDHelper::isUUID($identifier)) {
                return $this->session->getNodeByIdentifier($identifier);
            }

            return $this->session->getNode($identifier);
        } catch (RepositoryException $e) {
            throw new DocumentNotFoundException(sprintf(
                'Could not find document with ID or path "%s"', $identifier
            ), null, $e);
        }
    }

    /**
     * Determine if a node exists at the specified path or if a UUID is given,
     * then if a node with the UUID exists.
     *
     * @param string $identifier
     *
     * @return bool
     */
    public function has($identifier)
    {
        $this->normalizeToPath($identifier);
        try {
            $this->find($identifier);

            return true;
        } catch (DocumentNotFoundException $e) {
            return false;
        }
    }

    /**
     * Remove the document with the given path or UUID.
     *
     * @param string $identifier ID or path
     */
    public function remove($identifier)
    {
        $identifier = $this->normalizeToPath($identifier);
        $this->session->removeItem($identifier);
    }

    /**
     * Move the document with the given path or ID to the path
     * of the destination document (as a child).
     *
     * @param string $srcId
     * @param string $destId
     * @param string $name
     */
    public function move($srcId, $destId, $name)
    {
        $srcPath = $this->normalizeToPath($srcId);
        $parentDestPath = $this->normalizeToPath($destId);
        $destPath = $parentDestPath . '/' . $name;

        $this->session->move($srcPath, $destPath);
    }

    /**
     * Copy the document with the given path or ID to the path
     * of the destination document (as a child).
     *
     * @param string $srcId
     * @param string $destId
     * @param string $name
     *
     * @return string
     */
    public function copy($srcId, $destId, $name)
    {
        $workspace = $this->session->getWorkspace();
        $srcPath = $this->normalizeToPath($srcId);
        $parentDestPath = $this->normalizeToPath($destId);
        $destPath = $parentDestPath . '/' . $name;

        $workspace->copy($srcPath, $destPath);

        return $destPath;
    }

    /**
     * Save all pending changes currently recorded in this Session.
     */
    public function save()
    {
        $this->session->save();
    }

    /**
     * Clear the current session.
     */
    public function clear()
    {
        $this->session->refresh(false);
    }

    /**
     * Create a path.
     *
     * @param string $path
     *
     * @return NodeInterface
     */
    public function createPath($path)
    {
        $current = $this->session->getRootNode();

        $segments = preg_split('#/#', $path, null, PREG_SPLIT_NO_EMPTY);
        foreach ($segments as $segment) {
            if ($current->hasNode($segment)) {
                $current = $current->getNode($segment);
            } else {
                $current = $current->addNode($segment);
                $current->addMixin('mix:referenceable');
                $current->setProperty('jcr:uuid', UUIDHelper::generateUUID());
            }
        }

        return $current;
    }

    /**
     * Purge the workspace.
     */
    public function purgeWorkspace()
    {
        NodeHelper::purgeWorkspace($this->session);
    }

    /**
     * Normalize the given path or ID to a path.
     *
     * @param string $identifier
     *
     * @return string
     */
    private function normalizeToPath($identifier)
    {
        if (UUIDHelper::isUUID($identifier)) {
            $identifier = $this->session->getNodeByIdentifier($identifier)->getPath();
        }

        return $identifier;
    }
}


1			<?php
2
3			/*
4			* This file is part of Sulu.
5			*
6			* (c) MASSIVE ART WebServices GmbH
7			*
8			* This source file is subject to the MIT license that is bundled
9			* with this source code in the file LICENSE.
10			*/
11
12			namespace Sulu\Component\DocumentManager;
13
14			use PHPCR\NodeInterface;
15			use PHPCR\RepositoryException;
16			use PHPCR\SessionInterface;
17			use PHPCR\Util\NodeHelper;
18			use PHPCR\Util\UUIDHelper;
19			use Sulu\Component\DocumentManager\Exception\DocumentNotFoundException;
20
21			/**
22			* The node manager is responsible for talking to the PHPCR
23			* implementation.
24			*/
25			class NodeManager
26			{
27			/**
28			* @var SessionInterface
29			*/
30			private $session;
31
32			/**
33			* @param SessionInterface $session
34			*/
35			public function __construct(SessionInterface $session)
36			{
37			$this->session = $session;
38			}
39
40			/**
41			* Find a document with the given path or UUID.
42			*
43			* @param string $identifier UUID or path
44			*
45			* @return NodeInterface
46			*
47			* @throws DocumentNotFoundException
48			*/
49			public function find($identifier)
50			{
51			try {
52			if (UUIDHelper::isUUID($identifier)) {
53			return $this->session->getNodeByIdentifier($identifier);
54			}
55
56			return $this->session->getNode($identifier);
57			} catch (RepositoryException $e) {
58			throw new DocumentNotFoundException(sprintf(
59			'Could not find document with ID or path "%s"', $identifier
60			), null, $e);
61			}
62			}
63
64			/**
65			* Determine if a node exists at the specified path or if a UUID is given,
66			* then if a node with the UUID exists.
67			*
68			* @param string $identifier
69			*
70			* @return bool
71			*/
72			public function has($identifier)
73			{
74			$this->normalizeToPath($identifier);
75			try {
76			$this->find($identifier);
77
78			return true;
79			} catch (DocumentNotFoundException $e) {
80			return false;
81			}
82			}
83
84			/**
85			* Remove the document with the given path or UUID.
86			*
87			* @param string $identifier ID or path
88			*/
89			public function remove($identifier)
90			{
91			$identifier = $this->normalizeToPath($identifier);
92			$this->session->removeItem($identifier);
93			}
94
95			/**
96			* Move the document with the given path or ID to the path
97			* of the destination document (as a child).
98			*
99			* @param string $srcId
100			* @param string $destId
101			* @param string $name
102			*/
103			public function move($srcId, $destId, $name)
104			{
105			$srcPath = $this->normalizeToPath($srcId);
106			$parentDestPath = $this->normalizeToPath($destId);
107			$destPath = $parentDestPath . '/' . $name;
108
109			$this->session->move($srcPath, $destPath);
110			}
111
112			/**
113			* Copy the document with the given path or ID to the path
114			* of the destination document (as a child).
115			*
116			* @param string $srcId
117			* @param string $destId
118			* @param string $name
119			*
120			* @return string
121			*/
122			public function copy($srcId, $destId, $name)
123			{
124			$workspace = $this->session->getWorkspace();
125			$srcPath = $this->normalizeToPath($srcId);
126			$parentDestPath = $this->normalizeToPath($destId);
127			$destPath = $parentDestPath . '/' . $name;
128
129			$workspace->copy($srcPath, $destPath);
130
131			return $destPath;
132			}
133
134			/**
135			* Save all pending changes currently recorded in this Session.
136			*/
137			public function save()
138			{
139			$this->session->save();
140			}
141
142			/**
143			* Clear the current session.
144			*/
145			public function clear()
146			{
147			$this->session->refresh(false);
148			}
149
150			/**
151			* Create a path.
152			*
153			* @param string $path
154			*
155			* @return NodeInterface
156			*/
157			public function createPath($path)
158			{
159			$current = $this->session->getRootNode();
160
161			$segments = preg_split('#/#', $path, null, PREG_SPLIT_NO_EMPTY);
162			foreach ($segments as $segment) {
163			if ($current->hasNode($segment)) {
164			$current = $current->getNode($segment);
165			} else {
166			$current = $current->addNode($segment);
167			$current->addMixin('mix:referenceable');
168			$current->setProperty('jcr:uuid', UUIDHelper::generateUUID());
169			}
170			}
171
172			return $current;
173			}
174
175			/**
176			* Purge the workspace.
177			*/
178			public function purgeWorkspace()
179			{
180			NodeHelper::purgeWorkspace($this->session);
181			}
182
183			/**
184			* Normalize the given path or ID to a path.
185			*
186			* @param string $identifier
187			*
188			* @return string
189			*/
190			private function normalizeToPath($identifier)
191			{
192			if (UUIDHelper::isUUID($identifier)) {
193			$identifier = $this->session->getNodeByIdentifier($identifier)->getPath();
194			}
195
196			return $identifier;
197			}
198			}
199

sulu-io / sulu-document-manager

NodeManager::createPath() A last analyzed 2015-12-18 14:57 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

NodeManager::createPath() A
last analyzed 2015-12-18 14:57 UTC