ResolvableFilesystem::read() - Code Metrics - Inspection of "Resolvable Filesystem" - Gaufrette/extras - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Albin

created 2017-05-29 23:41 UTC

ResolvableFilesystem::read() A

↳ Parent: ResolvableFilesystem

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php

namespace Gaufrette\Extras\Resolvable;

use Gaufrette\FilesystemInterface;

class ResolvableFilesystem implements FilesystemInterface
{
    /** @var FilesystemInterface */
    private $decorated;

    /** @var ResolverInterface */
    private $resolver;

    public function __construct(FilesystemInterface $decorated, ResolverInterface $resolver)
    {
        $this->decorated = $decorated;
        $this->resolver  = $resolver;
    }

    /**
     * @param string $key Object path.
     *
     * @throws UnresolvableObjectException When not able to resolve the object path. Any exception thrown by underlying
     *                                     resolver will be converted to this exception.
     *
     * @return string
     */
    public function resolve($key)
    {
        try {
            return $this->resolver->resolve($key);
        } catch (\Exception $e) {
            throw new UnresolvableObjectException($key, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function has($key)
    {
        return $this->decorated->has($key);
    }

    /**
     * {@inheritdoc}
     */
    public function rename($sourceKey, $targetKey)
    {
        return $this->decorated->rename($sourceKey, $targetKey);
    }

    /**
     * {@inheritdoc}
     */
    public function get($key, $create = false)
    {
        return $this->decorated->get($key, $create);
    }

    /**
     * {@inheritdoc}
     */
    public function write($key, $content, $overwrite = false)
    {
        return $this->decorated->write($key, $content, $overwrite);
    }

    /**
     * {@inheritdoc}
     */
    public function read($key)
    {
        return $this->decorated->read($key);
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)
    {
        return $this->decorated->delete($key);
    }

    /**
     * {@inheritdoc}
     */
    public function keys()
    {
        return $this->decorated->keys();
    }

    /**
     * {@inheritdoc}
     */
    public function listKeys($prefix = '')
    {
        return $this->decorated->listKeys($prefix);
    }

    /**
     * {@inheritdoc}
     */
    public function mtime($key)
    {
        return $this->decorated->mtime($key);
    }

    /**
     * {@inheritdoc}
     */
    public function checksum($key)
    {
        return $this->decorated->checksum($key);
    }

    /**
     * {@inheritdoc}
     */
    public function size($key)
    {
        return $this->decorated->size($key);
    }

    /**
     * {@inheritdoc}
     */
    public function createStream($key)
    {
        return $this->decorated->createStream($key);
    }

    /**
     * {@inheritdoc}
     */
    public function createFile($key)
    {
        return $this->decorated->createFile($key);
    }

    /**
     * {@inheritdoc}
     */
    public function mimeType($key)
    {
        return $this->decorated->mimeType($key);
    }

    /**
     * {@inheritdoc}
     */
    public function isDirectory($key)
    {
        return $this->decorated->isDirectory($key);
    }

    /**
     * {@inheritdoc}
     */
    function __call($name, $arguments)

    {
        return call_user_func_array([$this->decorated, $name], $arguments);
    }
}


1			<?php
2
3			namespace Gaufrette\Extras\Resolvable;
4
5			use Gaufrette\FilesystemInterface;
6
7			class ResolvableFilesystem implements FilesystemInterface
8			{
9			/** @var FilesystemInterface */
10			private $decorated;
11
12			/** @var ResolverInterface */
13			private $resolver;
14
15			public function __construct(FilesystemInterface $decorated, ResolverInterface $resolver)
16			{
17			$this->decorated = $decorated;
18			$this->resolver = $resolver;
19			}
20
21			/**
22			* @param string $key Object path.
23			*
24			* @throws UnresolvableObjectException When not able to resolve the object path. Any exception thrown by underlying
25			* resolver will be converted to this exception.
26			*
27			* @return string
28			*/
29			public function resolve($key)
30			{
31			try {
32			return $this->resolver->resolve($key);
33			} catch (\Exception $e) {
34			throw new UnresolvableObjectException($key, $e);
35			}
36			}
37
38			/**
39			* {@inheritdoc}
40			*/
41			public function has($key)
42			{
43			return $this->decorated->has($key);
44			}
45
46			/**
47			* {@inheritdoc}
48			*/
49			public function rename($sourceKey, $targetKey)
50			{
51			return $this->decorated->rename($sourceKey, $targetKey);
52			}
53
54			/**
55			* {@inheritdoc}
56			*/
57			public function get($key, $create = false)
58			{
59			return $this->decorated->get($key, $create);
60			}
61
62			/**
63			* {@inheritdoc}
64			*/
65			public function write($key, $content, $overwrite = false)
66			{
67			return $this->decorated->write($key, $content, $overwrite);
68			}
69
70			/**
71			* {@inheritdoc}
72			*/
73			public function read($key)
74			{
75			return $this->decorated->read($key);
76			}
77
78			/**
79			* {@inheritdoc}
80			*/
81			public function delete($key)
82			{
83			return $this->decorated->delete($key);
84			}
85
86			/**
87			* {@inheritdoc}
88			*/
89			public function keys()
90			{
91			return $this->decorated->keys();
92			}
93
94			/**
95			* {@inheritdoc}
96			*/
97			public function listKeys($prefix = '')
98			{
99			return $this->decorated->listKeys($prefix);
100			}
101
102			/**
103			* {@inheritdoc}
104			*/
105			public function mtime($key)
106			{
107			return $this->decorated->mtime($key);
108			}
109
110			/**
111			* {@inheritdoc}
112			*/
113			public function checksum($key)
114			{
115			return $this->decorated->checksum($key);
116			}
117
118			/**
119			* {@inheritdoc}
120			*/
121			public function size($key)
122			{
123			return $this->decorated->size($key);
124			}
125
126			/**
127			* {@inheritdoc}
128			*/
129			public function createStream($key)
130			{
131			return $this->decorated->createStream($key);
132			}
133
134			/**
135			* {@inheritdoc}
136			*/
137			public function createFile($key)
138			{
139			return $this->decorated->createFile($key);
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public function mimeType($key)
146			{
147			return $this->decorated->mimeType($key);
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153			public function isDirectory($key)
154			{
155			return $this->decorated->isDirectory($key);
156			}
157
158			/**
159			* {@inheritdoc}
160			*/
161			function __call($name, $arguments)
			0 ignored issues – show Best Practice introduced 2017-05-29 23:43 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
162			{
163			return call_user_func_array([$this->decorated, $name], $arguments);
164			}
165			}
166

Gaufrette / extras

Pull Request — master (#1)

ResolvableFilesystem::read() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like