PHP Debug::increment方法代码示例

 /**
  * Parse a block of YAML into PHP
  *
  * @param string  $yaml  YAML-formatted string to parse
  * @param string  $mode  Parsing mode to use
  * @return array
  */
 public static function parse($yaml, $mode = null)
 {
     // start measuring
     $hash = Debug::markStart('parsing', 'yaml');
     $mode = $mode ? $mode : self::getMode();
     switch ($mode) {
         case 'loose':
             $result = Spyc::YAMLLoad($yaml);
             break;
         case 'strict':
             $result = sYAML::parse($yaml);
             break;
         case 'transitional':
             try {
                 $result = sYaml::parse($yaml);
             } catch (Exception $e) {
                 Log::error($e->getMessage() . ' Falling back to loose mode.', 'core', 'yaml');
                 $result = Spyc::YAMLLoad($yaml);
             }
             break;
         default:
             // check for new lines, is this a file?
             $has_newline = strpos($yaml, "\n") !== false;
             if (!$has_newline && File::exists($yaml)) {
                 // seems like it is
                 $yaml = File::get($yaml);
             }
             $result = Statamic\Dipper\Dipper::parse($yaml);
     }
     // end measuring
     Debug::markEnd($hash);
     Debug::increment('parses', 'yaml');
     return $result;
 }

 /**
  * Parse a block of YAML into PHP
  *
  * @param string  $yaml  YAML-formatted string to parse
  * @param string  $mode  Parsing mode to use
  * @return array
  */
 public static function parse($yaml, $mode = null)
 {
     // start measuring
     $hash = Debug::markStart('parsing', 'yaml');
     $mode = $mode ? $mode : self::getMode();
     switch ($mode) {
         case 'loose':
             $result = Spyc::YAMLLoad($yaml);
             break;
         case 'strict':
             $result = sYAML::parse($yaml);
             break;
         case 'transitional':
             try {
                 $result = sYaml::parse($yaml);
             } catch (Exception $e) {
                 Log::error($e->getMessage() . ' Falling back to loose mode.', 'core', 'yaml');
                 $result = Spyc::YAMLLoad($yaml);
             }
             break;
         default:
             $result = Spyc::YAMLLoad($yaml);
     }
     // end measuring
     Debug::markEnd($hash);
     Debug::increment('parses', 'yaml');
     return $result;
 }

 public function partial()
 {
     $start = time();
     $src = $this->fetchParam('src', null, null, false, false);
     $extensions = array(".html", ".md", ".markdown", ".textile");
     $html = null;
     // measurement
     $hash = Debug::markStart('partials', $src, $start);
     Debug::increment('partials', $src);
     if ($src) {
         foreach ($extensions as $extension) {
             $full_src = Path::assemble(BASE_PATH, $this->theme_root, 'partials', ltrim($src . $extension, '/'));
             if (File::exists($full_src)) {
                 Statamic_View::$_dataStore = $this->attributes + Statamic_View::$_dataStore;
                 if ($this->fetchParam('use_context', false, false, true, false)) {
                     // to use context, we only want to pass the attributes as
                     // the current data, as those will override into the context
                     // set of data; if we were to include all of ::$_dataStore,
                     // we run into the issue where all of the global-level variables
                     // are overriding variables in context, when the variables in
                     // context are more accurate scope-wise at this point in the parse
                     $html = Parse::contextualTemplate(file_get_contents($full_src), $this->attributes, $this->context, array('statamic_view', 'callback'), true);
                 } else {
                     $html = Parse::template(file_get_contents($full_src), Statamic_View::$_dataStore);
                 }
                 // parse contents if needed
                 if ($extension == ".md" || $extension == ".markdown") {
                     $html = Parse::markdown($html);
                 } elseif ($extension == ".textile") {
                     $html = Parse::textile($html);
                 }
             }
         }
         if (Config::get('enable_smartypants', TRUE)) {
             $html = Parse::smartypants($html);
         }
     }
     Debug::markEnd($hash);
     return $html;
 }

 /**
  * Builds a file with YAML front-matter
  *
  * @param array  $data  Front-matter data
  * @param string  $content  Content
  * @return string
  */
 public static function buildContent(array $data, $content)
 {
     Debug::increment('content', 'files_built');
     $file_content = "---\n";
     $file_content .= preg_replace('/\\A^---\\s/ism', "", YAML::dump($data));
     $file_content .= "---\n";
     $file_content .= $content;
     return $file_content;
 }

 /**
  * Empty the specified directory of all files and folders.
  *
  * @param  string|array  $directory folder(s) to empty
  * @return void
  */
 public static function wipe($directory)
 {
     Debug::increment('folders', 'emptied');
     self::delete($directory, TRUE);
 }

 /**
  * Parses a conditions string
  *
  * @param string  $conditions  Conditions to parse
  * @return array
  */
 public static function conditions($conditions)
 {
     // start measuring
     $hash = Debug::markStart('parsing', 'conditions');
     Debug::increment('parses', 'condition_statements');
     $replacement = '__TEMP_COMMA_' . substr(md5(time()), 0, 12) . '__';
     $conditions = explode(",", str_replace('\\,', $replacement, $conditions));
     $output = array();
     foreach ($conditions as $condition) {
         Debug::increment('parses', 'conditions');
         $result = Parse::condition(str_replace($replacement, ',', $condition));
         $output[$result['key']] = $result['value'];
     }
     // end measuring
     Debug::markEnd($hash);
     return $output;
 }

 /**
  * Takes a scope-notated key and finds the value for it in the given
  * array or object.
  *
  * @param  string       $key     Dot-notated key to find
  * @param  array|object $data    Array or object to search
  * @param  mixed        $default Default value to use if not found
  * @return mixed
  */
 protected function getVariable($key, $data, $default = null)
 {
     // <statamic>
     // detect modifiers
     $modifiers = null;
     if (strpos($key, "|") !== false) {
         $parts = explode("|", $key);
         $key = $parts[0];
         $modifiers = array_splice($parts, 1);
     }
     // </statamic>
     if (strpos($key, $this->scopeGlue) === false) {
         $parts = explode('.', $key);
     } else {
         $parts = explode($this->scopeGlue, $key);
     }
     foreach ($parts as $key_part) {
         if (is_array($data)) {
             if (!array_key_exists($key_part, $data)) {
                 return $default;
             }
             $data = $data[$key_part];
         } elseif (is_object($data)) {
             if (!isset($data->{$key_part})) {
                 return $default;
             }
             $data = $data->{$key_part};
         } else {
             return $default;
         }
     }
     // <statamic>
     // execute modifier chain
     if ($modifiers) {
         foreach ($modifiers as $mod) {
             $now = time();
             if (strpos($mod, ":") === false) {
                 $modifier = $mod;
                 $modifier_params = array();
             } else {
                 $parts = explode(":", $mod);
                 $modifier = $parts[0];
                 $modifier_params = array_splice($parts, 1);
             }
             $hash = \Debug::markStart('modifiers', $modifier, $now);
             try {
                 // load modifier
                 $modifier_obj = \Resource::loadModifier(\Parse::modifierAlias($modifier));
                 // ensure method exists
                 if (!method_exists($modifier_obj, "index")) {
                     throw new \Exception("Improperly formatted modifier object.");
                 }
                 // call method
                 $data = $modifier_obj->index($data, $modifier_params);
                 \Debug::increment('modifiers', $modifier);
             } catch (\Exception $e) {
                 // do nothing
             }
             \Debug::markEnd($hash);
         }
     }
     // </statamic>
     return $data;
 }

 /**
  * callback
  * Attempts to load a plugin?
  *
  * @param string $name
  * @param array $attributes
  * @param string $content
  * @param array $context
  * @return string
  * @throws Exception
  */
 public static function callback($name, $attributes, $content, $context = array())
 {
     $now = time();
     $output = false;
     $pos = strpos($name, ':');
     # single function plugins
     if ($pos === false) {
         $plugin = $name;
         $call = "index";
     } else {
         $plugin = substr($name, 0, $pos);
         $call = substr($name, $pos + 1);
     }
     // mark start of debug timing
     $hash = Debug::markStart('plugins', $plugin . ':' . $call, $now);
     // if nothing to call, abort
     if (!$call) {
         Debug::markEnd($hash);
         return null;
     }
     try {
         // will throw an exception if resource isn't available
         $plugin_obj = Resource::loadPlugin($plugin);
         if (!is_callable(array($plugin_obj, $call))) {
             throw new Exception('Method not callable.');
         }
         $plugin_obj->attributes = $attributes;
         $plugin_obj->content = $content;
         $plugin_obj->context = $context;
         Debug::increment('plugins', $plugin);
         $output = call_user_func(array($plugin_obj, $call));
         if (is_array($output)) {
             $output = Parse::template($content, $output);
         }
     } catch (\Slim\Exception\Stop $e) {
         // allow plugins to halt the app
         throw $e;
     } catch (ResourceNotFoundException $e) {
         // resource not found, do nothing
     } catch (Exception $e) {
         // everything else, do nothing if debug is off
         if (Config::get('debug')) {
             throw $e;
         }
     }
     Debug::markEnd($hash);
     return $output;
 }