Dereferencer::draft6() - Code Metrics - Inspection of "Support multiple decoders" - thephpleague/json-reference - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

unknown

created 2017-10-16 19:04 UTC

Dereferencer::draft6() A

↳ Parent: Dereferencer

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace League\JsonReference;

use League\JsonReference\ReferenceSerializer\SafeReferenceSerializer;
use League\JsonReference\ScopeResolver\JsonSchemaScopeResolver;
use League\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 \League\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 \League\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 \League\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 \League\JsonReference\LoaderManager $loaderManager
     *
     * @return \League\JsonReference\Dereferencer
     */
    public function setLoaderManager(LoaderManager $loaderManager)
    {
        $this->loaderManager = $loaderManager;

        return $this;
    }

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

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

        return $this;
    }

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

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

thephpleague / json-reference

Pull Request — master (#12)

Dereferencer::draft6() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like