Google_Utils_URITemplate::replace() - Code Metrics - Inspection of "No way to deactivate GA Settings, deactivation but..." - GeoDirectory/geodirectory - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( d99c6b...fb4ca3 )

by Stiofan

created 2016-12-01 19:19 UTC

Google_Utils_URITemplate::replace() C

↳ Parent: Google_Utils_URITemplate

Complexity

Conditions	12
Paths	17

Size

Total Lines	64
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
eloc	42
nc	17
nop	4
dl	0
loc	64
rs	6.0561
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Implementation of levels 1-3 of the URI Template spec.
 * @see http://tools.ietf.org/html/rfc6570
 */
class Google_Utils_URITemplate
{
  const TYPE_MAP = "1";
  const TYPE_LIST = "2";
  const TYPE_SCALAR = "4";

  /**
   * @var $operators array
   * These are valid at the start of a template block to
   * modify the way in which the variables inside are
   * processed.
   */
  private $operators = array(
      "+" => "reserved",
      "/" => "segments",
      "." => "dotprefix",
      "#" => "fragment",
      ";" => "semicolon",
      "?" => "form",
      "&" => "continuation"
  );

  /**
   * @var reserved array
   * These are the characters which should not be URL encoded in reserved
   * strings.
   */
  private $reserved = array(
      "=", ",", "!", "@", "|", ":", "/", "?", "#",
      "[", "]",'$', "&", "'", "(", ")", "*", "+", ";"
  );
  private $reservedEncoded = array(
    "%3D", "%2C", "%21", "%40", "%7C", "%3A", "%2F", "%3F",
    "%23", "%5B", "%5D", "%24", "%26", "%27", "%28", "%29",
    "%2A", "%2B", "%3B"
  );

  public function parse($string, array $parameters)
  {
    return $this->resolveNextSection($string, $parameters);
  }

  /**
   * This function finds the first matching {...} block and
   * executes the replacement. It then calls itself to find
   * subsequent blocks, if any.
   */
  private function resolveNextSection($string, $parameters)
  {
    $start = strpos($string, "{");
    if ($start === false) {
      return $string;
    }
    $end = strpos($string, "}");
    if ($end === false) {
      return $string;
    }
    $string = $this->replace($string, $start, $end, $parameters);
    return $this->resolveNextSection($string, $parameters);
  }

  private function replace($string, $start, $end, $parameters)
  {
    // We know a data block will have {} round it, so we can strip that.
    $data = substr($string, $start + 1, $end - $start - 1);

    // If the first character is one of the reserved operators, it effects
    // the processing of the stream.
    if (isset($this->operators[$data[0]])) {
      $op = $this->operators[$data[0]];
      $data = substr($data, 1);
      $prefix = "";
      $prefix_on_missing = false;

      switch ($op) {
        case "reserved":
          // Reserved means certain characters should not be URL encoded
          $data = $this->replaceVars($data, $parameters, ",", null, true);
          break;
        case "fragment":
          // Comma separated with fragment prefix. Bare values only.
          $prefix = "#";
          $prefix_on_missing = true;
          $data = $this->replaceVars($data, $parameters, ",", null, true);
          break;
        case "segments":
          // Slash separated data. Bare values only.
          $prefix = "/";
          $data =$this->replaceVars($data, $parameters, "/");
          break;
        case "dotprefix":
          // Dot separated data. Bare values only.
          $prefix = ".";
          $prefix_on_missing = true;
          $data = $this->replaceVars($data, $parameters, ".");
          break;
        case "semicolon":
          // Semicolon prefixed and separated. Uses the key name
          $prefix = ";";
          $data = $this->replaceVars($data, $parameters, ";", "=", false, true, false);
          break;
        case "form":
          // Standard URL format. Uses the key name
          $prefix = "?";
          $data = $this->replaceVars($data, $parameters, "&", "=");
          break;
        case "continuation":
          // Standard URL, but with leading ampersand. Uses key name.
          $prefix = "&";
          $data = $this->replaceVars($data, $parameters, "&", "=");
          break;
      }

      // Add the initial prefix character if data is valid.
      if ($data || ($data !== false && $prefix_on_missing)) {
        $data = $prefix . $data;
      }

    } else {
      // If no operator we replace with the defaults.
      $data = $this->replaceVars($data, $parameters);
    }
    // This is chops out the {...} and replaces with the new section.
    return substr($string, 0, $start) . $data . substr($string, $end + 1);
  }

  private function replaceVars(
      $section,
      $parameters,
      $sep = ",",
      $combine = null,
      $reserved = false,
      $tag_empty = false,
      $combine_on_empty = true
  ) {
    if (strpos($section, ",") === false) {
      // If we only have a single value, we can immediately process.
      return $this->combine(
          $section,
          $parameters,
          $sep,
          $combine,
          $reserved,
          $tag_empty,
          $combine_on_empty
      );
    } else {
      // If we have multiple values, we need to split and loop over them.
      // Each is treated individually, then glued together with the
      // separator character.
      $vars = explode(",", $section);
      return $this->combineList(
          $vars,
          $sep,
          $parameters,
          $combine,
          $reserved,
          false, // Never emit empty strings in multi-param replacements
          $combine_on_empty
      );
    }
  }
 
  public function combine(
      $key,
      $parameters,
      $sep,
      $combine,
      $reserved,
      $tag_empty,
      $combine_on_empty
  ) {
    $length = false;
    $explode = false;
    $skip_final_combine = false;
    $value = false;

    // Check for length restriction.
    if (strpos($key, ":") !== false) {
      list($key, $length) = explode(":", $key);
    }
    
    // Check for explode parameter.
    if ($key[strlen($key) - 1] == "*") {
      $explode = true;
      $key = substr($key, 0, -1);
      $skip_final_combine = true;
    }
    
    // Define the list separator.
    $list_sep = $explode ? $sep : ",";
    
    if (isset($parameters[$key])) {
      $data_type = $this->getDataType($parameters[$key]);
      switch ($data_type) {
        case self::TYPE_SCALAR:
          $value = $this->getValue($parameters[$key], $length);
          break;
        case self::TYPE_LIST:
          $values = array();
          foreach ($parameters[$key] as $pkey => $pvalue) {
            $pvalue = $this->getValue($pvalue, $length);
            if ($combine && $explode) {
              $values[$pkey] = $key . $combine . $pvalue;
            } else {
              $values[$pkey] = $pvalue;
            }
          }
          $value = implode($list_sep, $values);
          if ($value == '') {
            return '';
          }
          break;
        case self::TYPE_MAP:
          $values = array();
          foreach ($parameters[$key] as $pkey => $pvalue) {
            $pvalue = $this->getValue($pvalue, $length);
            if ($explode) {
              $pkey = $this->getValue($pkey, $length);
              $values[] = $pkey . "=" . $pvalue; // Explode triggers = combine.
            } else {
              $values[] = $pkey;
              $values[] = $pvalue;
            }
          }
          $value = implode($list_sep, $values);
          if ($value == '') {
            return false;
          }
          break;
      }
    } else if ($tag_empty) {
      // If we are just indicating empty values with their key name, return that.
      return $key;
    } else {
      // Otherwise we can skip this variable due to not being defined.
      return false;
    }

    if ($reserved) {
      $value = str_replace($this->reservedEncoded, $this->reserved, $value);
    }

    // If we do not need to include the key name, we just return the raw
    // value.
    if (!$combine || $skip_final_combine) {
      return $value;
    }
        
    // Else we combine the key name: foo=bar, if value is not the empty string.
    return $key . ($value != '' || $combine_on_empty ? $combine . $value : '');
  }
  
  /**
   * Return the type of a passed in value
   */
  private function getDataType($data)
  {
    if (is_array($data)) {
      reset($data);
      if (key($data) !== 0) {
        return self::TYPE_MAP;
      }
      return self::TYPE_LIST;
    }
    return self::TYPE_SCALAR;
  }
  
  /**
   * Utility function that merges multiple combine calls
   * for multi-key templates.
   */
  private function combineList(
      $vars,
      $sep,
      $parameters,
      $combine,
      $reserved,
      $tag_empty,
      $combine_on_empty
  ) {
    $ret = array();
    foreach ($vars as $var) {
      $response = $this->combine(
          $var,
          $parameters,
          $sep,
          $combine,
          $reserved,
          $tag_empty,
          $combine_on_empty
      );
      if ($response === false) {
        continue;
      }
      $ret[] = $response;
    }
    return implode($sep, $ret);
  }
  
  /**
   * Utility function to encode and trim values
   */
  private function getValue($value, $length)
  {
    if ($length) {
      $value = substr($value, 0, $length);
    }
    $value = rawurlencode($value);
    return $value;
  }
}


1			<?php
2			/*
3			* Copyright 2013 Google Inc.
4			*
5			* Licensed under the Apache License, Version 2.0 (the "License");
6			* you may not use this file except in compliance with the License.
7			* You may obtain a copy of the License at
8			*
9			* http://www.apache.org/licenses/LICENSE-2.0
10			*
11			* Unless required by applicable law or agreed to in writing, software
12			* distributed under the License is distributed on an "AS IS" BASIS,
13			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14			* See the License for the specific language governing permissions and
15			* limitations under the License.
16			*/
17
18			/**
19			* Implementation of levels 1-3 of the URI Template spec.
20			* @see http://tools.ietf.org/html/rfc6570
21			*/
22			class Google_Utils_URITemplate
23			{
24			const TYPE_MAP = "1";
25			const TYPE_LIST = "2";
26			const TYPE_SCALAR = "4";
27
28			/**
29			* @var $operators array
30			* These are valid at the start of a template block to
31			* modify the way in which the variables inside are
32			* processed.
33			*/
34			private $operators = array(
35			"+" => "reserved",
36			"/" => "segments",
37			"." => "dotprefix",
38			"#" => "fragment",
39			";" => "semicolon",
40			"?" => "form",
41			"&" => "continuation"
42			);
43
44			/**
45			* @var reserved array
46			* These are the characters which should not be URL encoded in reserved
47			* strings.
48			*/
49			private $reserved = array(
50			"=", ",", "!", "@", "\|", ":", "/", "?", "#",
51			"[", "]",'$', "&", "'", "(", ")", "*", "+", ";"
52			);
53			private $reservedEncoded = array(
54			"%3D", "%2C", "%21", "%40", "%7C", "%3A", "%2F", "%3F",
55			"%23", "%5B", "%5D", "%24", "%26", "%27", "%28", "%29",
56			"%2A", "%2B", "%3B"
57			);
58
59			public function parse($string, array $parameters)
60			{
61			return $this->resolveNextSection($string, $parameters);
62			}
63
64			/**
65			* This function finds the first matching {...} block and
66			* executes the replacement. It then calls itself to find
67			* subsequent blocks, if any.
68			*/
69			private function resolveNextSection($string, $parameters)
70			{
71			$start = strpos($string, "{");
72			if ($start === false) {
73			return $string;
74			}
75			$end = strpos($string, "}");
76			if ($end === false) {
77			return $string;
78			}
79			$string = $this->replace($string, $start, $end, $parameters);
80			return $this->resolveNextSection($string, $parameters);
81			}
82
83			private function replace($string, $start, $end, $parameters)
84			{
85			// We know a data block will have {} round it, so we can strip that.
86			$data = substr($string, $start + 1, $end - $start - 1);
87
88			// If the first character is one of the reserved operators, it effects
89			// the processing of the stream.
90			if (isset($this->operators[$data[0]])) {
91			$op = $this->operators[$data[0]];
92			$data = substr($data, 1);
93			$prefix = "";
94			$prefix_on_missing = false;
95
96			switch ($op) {
97			case "reserved":
98			// Reserved means certain characters should not be URL encoded
99			$data = $this->replaceVars($data, $parameters, ",", null, true);
100			break;
101			case "fragment":
102			// Comma separated with fragment prefix. Bare values only.
103			$prefix = "#";
104			$prefix_on_missing = true;
105			$data = $this->replaceVars($data, $parameters, ",", null, true);
106			break;
107			case "segments":
108			// Slash separated data. Bare values only.
109			$prefix = "/";
110			$data =$this->replaceVars($data, $parameters, "/");
111			break;
112			case "dotprefix":
113			// Dot separated data. Bare values only.
114			$prefix = ".";
115			$prefix_on_missing = true;
116			$data = $this->replaceVars($data, $parameters, ".");
117			break;
118			case "semicolon":
119			// Semicolon prefixed and separated. Uses the key name
120			$prefix = ";";
121			$data = $this->replaceVars($data, $parameters, ";", "=", false, true, false);
122			break;
123			case "form":
124			// Standard URL format. Uses the key name
125			$prefix = "?";
126			$data = $this->replaceVars($data, $parameters, "&", "=");
127			break;
128			case "continuation":
129			// Standard URL, but with leading ampersand. Uses key name.
130			$prefix = "&";
131			$data = $this->replaceVars($data, $parameters, "&", "=");
132			break;
133			}
134
135			// Add the initial prefix character if data is valid.
136			if ($data \|\| ($data !== false && $prefix_on_missing)) {
137			$data = $prefix . $data;
138			}
139
140			} else {
141			// If no operator we replace with the defaults.
142			$data = $this->replaceVars($data, $parameters);
143			}
144			// This is chops out the {...} and replaces with the new section.
145			return substr($string, 0, $start) . $data . substr($string, $end + 1);
146			}
147
148			private function replaceVars(
149			$section,
150			$parameters,
151			$sep = ",",
152			$combine = null,
153			$reserved = false,
154			$tag_empty = false,
155			$combine_on_empty = true
156			) {
157			if (strpos($section, ",") === false) {
158			// If we only have a single value, we can immediately process.
159			return $this->combine(
160			$section,
161			$parameters,
162			$sep,
163			$combine,
164			$reserved,
165			$tag_empty,
166			$combine_on_empty
167			);
168			} else {
169			// If we have multiple values, we need to split and loop over them.
170			// Each is treated individually, then glued together with the
171			// separator character.
172			$vars = explode(",", $section);
173			return $this->combineList(
174			$vars,
175			$sep,
176			$parameters,
177			$combine,
178			$reserved,
179			false, // Never emit empty strings in multi-param replacements
180			$combine_on_empty
181			);
182			}
183			}
184
185			public function combine(
186			$key,
187			$parameters,
188			$sep,
189			$combine,
190			$reserved,
191			$tag_empty,
192			$combine_on_empty
193			) {
194			$length = false;
195			$explode = false;
196			$skip_final_combine = false;
197			$value = false;
198
199			// Check for length restriction.
200			if (strpos($key, ":") !== false) {
201			list($key, $length) = explode(":", $key);
202			}
203
204			// Check for explode parameter.
205			if ($key[strlen($key) - 1] == "*") {
206			$explode = true;
207			$key = substr($key, 0, -1);
208			$skip_final_combine = true;
209			}
210
211			// Define the list separator.
212			$list_sep = $explode ? $sep : ",";
213
214			if (isset($parameters[$key])) {
215			$data_type = $this->getDataType($parameters[$key]);
216			switch ($data_type) {
217			case self::TYPE_SCALAR:
218			$value = $this->getValue($parameters[$key], $length);
219			break;
220			case self::TYPE_LIST:
221			$values = array();
222			foreach ($parameters[$key] as $pkey => $pvalue) {
223			$pvalue = $this->getValue($pvalue, $length);
224			if ($combine && $explode) {
225			$values[$pkey] = $key . $combine . $pvalue;
226			} else {
227			$values[$pkey] = $pvalue;
228			}
229			}
230			$value = implode($list_sep, $values);
231			if ($value == '') {
232			return '';
233			}
234			break;
235			case self::TYPE_MAP:
236			$values = array();
237			foreach ($parameters[$key] as $pkey => $pvalue) {
238			$pvalue = $this->getValue($pvalue, $length);
239			if ($explode) {
240			$pkey = $this->getValue($pkey, $length);
241			$values[] = $pkey . "=" . $pvalue; // Explode triggers = combine.
242			} else {
243			$values[] = $pkey;
244			$values[] = $pvalue;
245			}
246			}
247			$value = implode($list_sep, $values);
248			if ($value == '') {
249			return false;
250			}
251			break;
252			}
253			} else if ($tag_empty) {
254			// If we are just indicating empty values with their key name, return that.
255			return $key;
256			} else {
257			// Otherwise we can skip this variable due to not being defined.
258			return false;
259			}
260
261			if ($reserved) {
262			$value = str_replace($this->reservedEncoded, $this->reserved, $value);
263			}
264
265			// If we do not need to include the key name, we just return the raw
266			// value.
267			if (!$combine \|\| $skip_final_combine) {
268			return $value;
269			}
270
271			// Else we combine the key name: foo=bar, if value is not the empty string.
272			return $key . ($value != '' \|\| $combine_on_empty ? $combine . $value : '');
273			}
274
275			/**
276			* Return the type of a passed in value
277			*/
278			private function getDataType($data)
279			{
280			if (is_array($data)) {
281			reset($data);
282			if (key($data) !== 0) {
283			return self::TYPE_MAP;
284			}
285			return self::TYPE_LIST;
286			}
287			return self::TYPE_SCALAR;
288			}
289
290			/**
291			* Utility function that merges multiple combine calls
292			* for multi-key templates.
293			*/
294			private function combineList(
295			$vars,
296			$sep,
297			$parameters,
298			$combine,
299			$reserved,
300			$tag_empty,
301			$combine_on_empty
302			) {
303			$ret = array();
304			foreach ($vars as $var) {
305			$response = $this->combine(
306			$var,
307			$parameters,
308			$sep,
309			$combine,
310			$reserved,
311			$tag_empty,
312			$combine_on_empty
313			);
314			if ($response === false) {
315			continue;
316			}
317			$ret[] = $response;
318			}
319			return implode($sep, $ret);
320			}
321
322			/**
323			* Utility function to encode and trim values
324			*/
325			private function getValue($value, $length)
326			{
327			if ($length) {
328			$value = substr($value, 0, $length);
329			}
330			$value = rawurlencode($value);
331			return $value;
332			}
333			}
334

GeoDirectory / geodirectory

Push — master ( d99c6b...fb4ca3 )

Google_Utils_URITemplate::replace() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like