Dereferencer::prepareArguments() - Code Metrics - Inspection of "Fixes for namespace" - thephpleague/json-reference - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#14)

unknown

created 2017-11-23 21:55 UTC

Dereferencer::prepareArguments() A

↳ Parent: Dereferencer

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	2
dl	0
loc	10
ccs	7
cts	7
cp	1
crap	2
rs	9.4285
c	0
b	0
f	0

<?php

namespace Activerules\JsonReference;

use Activerules\JsonReference\ReferenceSerializer\SafeReferenceSerializer;
use Activerules\JsonReference\ScopeResolver\JsonSchemaScopeResolver;
use Activerules\JsonReference\ScopeResolver\NullScopeResolver;

final class Dereferencer implements DereferencerInterface
{
    /**
     * @var LoaderManager
     */
    private $loaderManager;

    /**
     * @var ScopeResolverInterface
     */
    private $scopeResolver;

    /**
     * @var ReferenceSerializerInterface
     */
    private $referenceSerializer;

    /**
     * Create a new Dereferencer.
     *
     * @param ScopeResolverInterface                             $scopeResolver
     * @param \Activerules\JsonReference\ReferenceSerializerInterface $referenceSerializer
     */
    public function __construct(
        ScopeResolverInterface $scopeResolver = null,
        ReferenceSerializerInterface $referenceSerializer = null
    ) {
        $this->scopeResolver       = $scopeResolver ?: new NullScopeResolver();
        $this->referenceSerializer = $referenceSerializer ?: new SafeReferenceSerializer();
        $this->loaderManager       = new LoaderManager();

        Reference::setDereferencerInstance($this);
    }

    /**
     * Create a new dereferencer configured for dereferencing JSON Schema Draft4 schemas.
     *
     * @return \Activerules\JsonReference\Dereferencer
     */
    public static function draft4()
    {
        return new self(new JsonSchemaScopeResolver(JsonSchemaScopeResolver::KEYWORD_DRAFT_4));
    }

    /**
     * Create a new dereferencer configured for dereferencing JSON Schema Draft6 schemas.
     *
     * @return \Activerules\JsonReference\Dereferencer
     */
    public static function draft6()
    {
        return new self(new JsonSchemaScopeResolver(JsonSchemaScopeResolver::KEYWORD_DRAFT_6));
    }

    /**
     * {@inheritdoc}
     */
    public function dereference($schema, $uri = '')
    {
        return $this->crawl($schema, $uri, function ($schema, $pointer, $ref, $scope) {
            $resolved = new Reference($ref, $scope, is_internal_ref($ref) ? $schema : null);
            return merge_ref($schema, $resolved, $pointer);
        });
    }

    /**
     * @param object|string $schema
     * @param string        $uri
     *
     * @return array
     */
    private function prepareArguments($schema, $uri)
    {
        if (is_string($schema)) {
            $uri    = $schema;
            $schema = resolve_fragment($uri, $this->loadExternalRef($uri));
            $uri    = strip_fragment($uri);
        }

        return [$schema, $uri];
    }

    /**
     * @return LoaderManager
     */
    public function getLoaderManager()
    {
        return $this->loaderManager;
    }

    /**
     * @param \Activerules\JsonReference\LoaderManager $loaderManager
     *
     * @return \Activerules\JsonReference\Dereferencer
     */
    public function setLoaderManager(LoaderManager $loaderManager)
    {
        $this->loaderManager = $loaderManager;

        return $this;
    }

    /**
     * @return \Activerules\JsonReference\ScopeResolverInterface
     */
    public function getScopeResolver()
    {
        return $this->scopeResolver;
    }

    /**
     * @param \Activerules\JsonReference\ScopeResolverInterface $scopeResolver
     *
     * @return \Activerules\JsonReference\Dereferencer
     */
    public function setScopeResolver(ScopeResolverInterface $scopeResolver)
    {
        $this->scopeResolver = $scopeResolver;

        return $this;
    }

    /**
     * @return \Activerules\JsonReference\ReferenceSerializerInterface
     */
    public function getReferenceSerializer()
    {
        return $this->referenceSerializer;
    }

    /**
     * @param \Activerules\JsonReference\ReferenceSerializerInterface $referenceSerializer
     *
     * @return \Activerules\JsonReference\Dereferencer
     */
    public function setReferenceSerializer(ReferenceSerializerInterface $referenceSerializer)
    {
        $this->referenceSerializer = $referenceSerializer;

        return $this;
    }

    /**
     * @param string|object $schema
     * @param string        $uri
     * @param callable      $resolver
     *
     * @return object
     */
    private function crawl($schema, $uri, callable $resolver)
    {
        list($schema, $uri) = $this->prepareArguments($schema, $uri);

        foreach (schema_extract($schema, 'Activerules\JsonReference\is_ref') as $pointer => $ref) {
            $scope = $this->scopeResolver->resolve($schema, $pointer, $uri);

            $schema = $resolver($schema, $pointer, $ref, $scope);
        }

        return $schema;
    }

    /**
     * Load an external ref and return the JSON object.
     *
     * @param string $reference
     *
     * @return object
     */
    private function loadExternalRef($reference)
    {
        list($prefix, $path) = parse_external_ref($reference);
        return $this->loaderManager->getLoader($prefix)->load($path);
    }
}


1		<?php
2
3		namespace Activerules\JsonReference;
4
5		use Activerules\JsonReference\ReferenceSerializer\SafeReferenceSerializer;
6		use Activerules\JsonReference\ScopeResolver\JsonSchemaScopeResolver;
7		use Activerules\JsonReference\ScopeResolver\NullScopeResolver;
8
9		final class Dereferencer implements DereferencerInterface
10		{
11		/**
12		* @var LoaderManager
13		*/
14		private $loaderManager;
15
16		/**
17		* @var ScopeResolverInterface
18		*/
19		private $scopeResolver;
20
21		/**
22		* @var ReferenceSerializerInterface
23		*/
24		private $referenceSerializer;
25
26		/**
27		* Create a new Dereferencer.
28		*
29		* @param ScopeResolverInterface $scopeResolver
30		* @param \Activerules\JsonReference\ReferenceSerializerInterface $referenceSerializer
31		*/
32	54	public function __construct(
33		ScopeResolverInterface $scopeResolver = null,
34		ReferenceSerializerInterface $referenceSerializer = null
35		) {
36	54	$this->scopeResolver = $scopeResolver ?: new NullScopeResolver();
37	54	$this->referenceSerializer = $referenceSerializer ?: new SafeReferenceSerializer();
38	54	$this->loaderManager = new LoaderManager();
39
40	54	Reference::setDereferencerInstance($this);
41	54	}
42
43		/**
44		* Create a new dereferencer configured for dereferencing JSON Schema Draft4 schemas.
45		*
46		* @return \Activerules\JsonReference\Dereferencer
47		*/
48	2	public static function draft4()
49		{
50	2	return new self(new JsonSchemaScopeResolver(JsonSchemaScopeResolver::KEYWORD_DRAFT_4));
51		}
52
53		/**
54		* Create a new dereferencer configured for dereferencing JSON Schema Draft6 schemas.
55		*
56		* @return \Activerules\JsonReference\Dereferencer
57		*/
58		public static function draft6()
59		{
60		return new self(new JsonSchemaScopeResolver(JsonSchemaScopeResolver::KEYWORD_DRAFT_6));
61		}
62
63		/**
64		* {@inheritdoc}
65		*/
66		public function dereference($schema, $uri = '')
67		{
68	52	return $this->crawl($schema, $uri, function ($schema, $pointer, $ref, $scope) {
69	48	$resolved = new Reference($ref, $scope, is_internal_ref($ref) ? $schema : null);
70	48	return merge_ref($schema, $resolved, $pointer);
71	52	});
72		}
73
74		/**
75		* @param object\|string $schema
76		* @param string $uri
77		*
78		* @return array
79		*/
80	52	private function prepareArguments($schema, $uri)
81		{
82	52	if (is_string($schema)) {
83	48	$uri = $schema;
84	48	$schema = resolve_fragment($uri, $this->loadExternalRef($uri));
85	44	$uri = strip_fragment($uri);
86	22	}
87
88	50	return [$schema, $uri];
89		}
90
91		/**
92		* @return LoaderManager
93		*/
94	10	public function getLoaderManager()
95		{
96	10	return $this->loaderManager;
97		}
98
99		/**
100		* @param \Activerules\JsonReference\LoaderManager $loaderManager
101		*
102		* @return \Activerules\JsonReference\Dereferencer
103		*/
104		public function setLoaderManager(LoaderManager $loaderManager)
105		{
106		$this->loaderManager = $loaderManager;
107
108		return $this;
109		}
110
111		/**
112		* @return \Activerules\JsonReference\ScopeResolverInterface
113		*/
114		public function getScopeResolver()
115		{
116		return $this->scopeResolver;
117		}
118
119		/**
120		* @param \Activerules\JsonReference\ScopeResolverInterface $scopeResolver
121		*
122		* @return \Activerules\JsonReference\Dereferencer
123		*/
124		public function setScopeResolver(ScopeResolverInterface $scopeResolver)
125		{
126		$this->scopeResolver = $scopeResolver;
127
128		return $this;
129		}
130
131		/**
132		* @return \Activerules\JsonReference\ReferenceSerializerInterface
133		*/
134	16	public function getReferenceSerializer()
135		{
136	16	return $this->referenceSerializer;
137		}
138
139		/**
140		* @param \Activerules\JsonReference\ReferenceSerializerInterface $referenceSerializer
141		*
142		* @return \Activerules\JsonReference\Dereferencer
143		*/
144	8	public function setReferenceSerializer(ReferenceSerializerInterface $referenceSerializer)
145		{
146	8	$this->referenceSerializer = $referenceSerializer;
147
148	8	return $this;
149		}
150
151		/**
152		* @param string\|object $schema
153		* @param string $uri
154		* @param callable $resolver
155		*
156		* @return object
157		*/
158	52	private function crawl($schema, $uri, callable $resolver)
159		{
160	52	list($schema, $uri) = $this->prepareArguments($schema, $uri);
161
162	50	foreach (schema_extract($schema, 'Activerules\JsonReference\is_ref') as $pointer => $ref) {
163	48	$scope = $this->scopeResolver->resolve($schema, $pointer, $uri);
164
165	48	$schema = $resolver($schema, $pointer, $ref, $scope);
166	24	}
167
168	48	return $schema;
169		}
170
171		/**
172		* Load an external ref and return the JSON object.
173		*
174		* @param string $reference
175		*
176		* @return object
177		*/
178	48	private function loadExternalRef($reference)
179		{
180	48	list($prefix, $path) = parse_external_ref($reference);
181	46	return $this->loaderManager->getLoader($prefix)->load($path);
182		}
183		}
184

thephpleague / json-reference

Pull Request — master (#14)

Dereferencer::prepareArguments() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like