ComponentManager provides the core functionality for building the component map describing the application configuration. More...

Public Member Functions
	ComponentManager ()
	Creates a new ComponentManager object. More...

	scanComponents ($root, $subdir)
	Scan the specified root and sub-directory for components. More...

	scanAdminPages ($component)
	Builds the administration page map for the specified component. More...

	scanComponentPages ($component)
	Scan and build the compoment page map for the specified component. More...

	scan ($verbosity=0)
	Scans the application home directory and PHP include path and builds the component and administration page map that describe the configuration of the application. More...

	getComponent ($component)
	Retrieve the component definition record for the specified component. More...

	dispatchAction ($process=null)
	Dispatch an incoming user action to the appropriate component handler script. More...

	dispatchLocalAction ($action, $process=null)

Static Public Member Functions
static	scanTrace ($message, $level)

static	findComponentPath ($name)
	Locate the component path for the named component using the standard precedence rules. More...

static	getEventHandlers ()
	Retrieve the event handler map. More...

static	compareByPriority ($item1, $item2)
	Priority comparison callback - not for external use. More...

static	fireEvent ($event, $parameter=null, $mustBeConsumed=false)
	Fire an event to all subscribers as detailed in their manifests. More...

static	fireEventTo ($event, $component, $parameter=null)
	Fire an event to the specificed component. More...

static	displayPage ($identifier, &$continue)

static	enumerateComponentPages ($items)

static	deleteRole ($del_role)

static	setComponentVersion ($component_name)

static	upgradeComponent ($version)

static	componentListTabs ()

static	componentPageTabs ($key)

static	componentFormTabs ($key)

static	setDefaults ()

static	getComponentSignature ()
	Retrieves a unique signature for the application's enabled components, based on their installed version numbers. More...

Public Attributes
	$found = array()

Static Public Attributes
static	$verbosityLevel = 0
	Verbosity level for component scan (same as trace level) More...

static	$plainOutput = false
	Set to true for plain text output during component scan. More...

Detailed Description

ComponentManager provides the core functionality for building the component map describing the application configuration.

It also scans components to build the administration section page map, and provides an event dispatching mechanism allowing PHP or client-side scripts to pass events or perform actions on a component without directly instantiating any classes related to the component.

Author: andy

Definition at line 49 of file component_manager.inc.

Member Function Documentation

◆ compareByPriority()

static ComponentManager::compareByPriority	(	$item1,
		$item2
	)

static

Priority comparison callback - not for external use.

Parameters

array	$item1
array	$item2

Returns: integer comparison value

Definition at line 430 of file component_manager.inc.

      {
           return $item1["priority"] - $item2["priority"];
      }

◆ componentFormTabs()

static ComponentManager::componentFormTabs ( $key )

static

Definition at line 795 of file component_manager.inc.

      {
           $tabs = array( "Definition"        =>   "/admin/component_form",
                          "Component Pages"   =>   "/admin/component_pages",
                          "Version History"   =>   "/admin/component_versions"
           );
      
           $qs = ($key) ? "component_id=$key" : ""; 
           $bar = new TabBar("tabs", $tabs, $qs);
           
           return $bar;
      }

◆ componentListTabs()

static ComponentManager::componentListTabs ( )

static

Definition at line 772 of file component_manager.inc.

      {
           $tabs = array( "Components"        =>   "/admin/components",
                          "Component Pages"   =>   "/admin/component_pages"
                          );
  
           $bar = new TabBar("tabs", $tabs, "");
           $bar->useQueryString = false;
           
           return $bar;
      }

◆ ComponentManager()

ComponentManager::ComponentManager ( )

Creates a new ComponentManager object.

Definition at line 80 of file component_manager.inc.

81 {

82 }

◆ componentPageTabs()

static ComponentManager::componentPageTabs ( $key )

static

Definition at line 784 of file component_manager.inc.

      {
           $tabs = array( "Definition"   =>   "/admin/component_page_form",
                          "Modules"      =>   "/admin/component_page_modules");
      
           $qs = ($key) ? "component_page_id=$key" : ""; 
           $bar = new TabBar("tabs", $tabs, $qs);
           
           return $bar;
      }

◆ deleteRole()

static ComponentManager::deleteRole ( $del_role )

static

Definition at line 730 of file component_manager.inc.

      {
           $constraint = "WHERE role like '%$del_role%'";
           $componentPages = Query::create(ComponentPage, $constraint)->execute();
           
           RoleManager::deleteRoleFromString($componentPages, $del_role);
  
           return $del_role;
           
      }

◆ dispatchAction()

ComponentManager::dispatchAction ( $process = null )

Dispatch an incoming user action to the appropriate component handler script.

Parameters

string $process (optional) process identifier if running as a background process

Definition at line 545 of file component_manager.inc.

      {
           global $script;
           global $isAction;
           $isAction = true;
           
           $component = $this->getComponent($_REQUEST["component"]);
           $action = $_REQUEST["action"];
                
           if (!preg_match("/^[\\w\\d_\\.]+$/", $action))
           {
                throw new FakoliException("Invalid action");
           }
                     
           $this->fireEventTo("PreAction", $component->name, $action);
           
           ob_start();
           
           $this->dispatchActionInternal($process);
           
           $out = ob_get_contents();
           ob_end_clean();
           
           echo $script;
           echo $out;
           
           $this->fireEventTo("PostAction", $component->name, $action);
           
           ComponentManager::fireEvent("RequestComplete");
      }

◆ dispatchLocalAction()

ComponentManager::dispatchLocalAction	(	$action,
		$process = `null`
	)

Definition at line 625 of file component_manager.inc.

      {
           global $method;
           
           trace($action, 3);
           
           list($uri, $queryString) = explode("?", $action);
           
           trace("URI: $uri, Query String: $queryString", 3);
           
           list($empty, $prefix, $component, $action) = explode("/", $uri);
           
           trace("Prefix: $prefix, Component: $component, Action: $action", 3);
           
           if ($prefix != "action") 
           {
                throw new FakoliException("Malformed action handler");
           }
  
           $context = array(
                "_GET"         => $_GET, 
                "_REQUEST"     => $_REQUEST, 
                "_SERVER" => $_SERVER,
                "method"  => $method
           );
           
           parse_str($queryString, $_GET);
           
           //trace("\$_GET: " . json_encode($_GET), 3);
           
           $_SERVER["REQUEST_URI"] = $uri;
           
           $_GET["component"] = $component;
           $_GET["action"] = $action;
           
           $_REQUEST["component"] = $component;
           $_REQUEST["action"] = $action;     
           
           ob_start();
           
           try
           {
                $this->dispatchActionInternal($process);
           }
           catch(Exception $e)
           {
                trace($e->getMessage(), 3);
                echo $e->getMessage();
           }
           
           $output = ob_get_contents();
           ob_end_clean();
  
           //trace(print_r($context, true), 3);
           
           foreach($context as $name => $value)
           {
                $$name = $value;
           }
           
           return $output;
      }

◆ displayPage()

static ComponentManager::displayPage	(		$identifier,
		&	$continue
	)

static

Definition at line 688 of file component_manager.inc.

      {
           global $page_role;
           
           try
           {
                checkIdentifier($identifier);
                
                $page = ComponentPage::findByIdentifier($identifier, "WHERE enabled=1");
                
                // JDG 11/2011 - are templates ever stored with tpl at the end?? 
                $page_template = (preg_match("/tpl$/", $page->template)) ? $page->template : "{$page->template}.tpl";
                $pageView = new ComponentPageView($page, $page_template);
           
                $page_role = $page->role;
                
                if (!checkRole($page->role))
                {
                     LoginManager::storeRedirectPage();
                     redirect("/login");
                }
                
                echo $pageView->drawView();
                
                $continue = false;
           }
           catch(DataNotFoundException $e)
           {
                
           }
           
           return $identifier;
      }

◆ enumerateComponentPages()

static ComponentManager::enumerateComponentPages ( $items )

static

Definition at line 722 of file component_manager.inc.

      {
           $pages = Query::create(ComponentPage, "ORDER BY identifier")->execute();
           
           $items["Component Pages"] = $pages;
           return $items;
      }

◆ findComponentPath()

static ComponentManager::findComponentPath ( $name )

static

Locate the component path for the named component using the standard precedence rules.

Parameters

string $name

Definition at line 333 of file component_manager.inc.

      {
           global $config;
           
           $path .= $config['homedir'] . PATH_SEPARATOR . ini_get("include_path");
  
           if (isset($config["extra_includes"])) $path .= PATH_SEPARATOR . $config["extra_includes"];
           
           $roots = explode(PATH_SEPARATOR, $path);
                
           foreach($roots as $root)
           {
                if ($root == ".") continue;
  
                $path = $root . DIRECTORY_SEPARATOR . "cms" . DIRECTORY_SEPARATOR . "components" . DIRECTORY_SEPARATOR . $name;
                
                if (file_exists($path))
                {
                     if (!file_exists($path.DIRECTORY_SEPARATOR."DEPRECATED")) return $path;
                }
                
                $path = $root . DIRECTORY_SEPARATOR . "components" . DIRECTORY_SEPARATOR . $name;
                
                if (file_exists($path)) 
                {
                     if (!file_exists($path.DIRECTORY_SEPARATOR."DEPRECATED")) return $path;
                }
           }
           
           return null;
      }

◆ fireEvent()

static ComponentManager::fireEvent	(	$event,
		$parameter = `null`,
		$mustBeConsumed = `false`
	)

static

Fire an event to all subscribers as detailed in their manifests.

Parameters

string	$event	the name of the event
array	$parameter	any parameters being passed to the event
boolean	$mustBeConsumed	if set to true, throws FakoliEventNotConsumed if no event handler has indicated consumption of the event by setting $continue to false

Definition at line 442 of file component_manager.inc.

      {
           trace("** Firing event '$event'", 4);
            
           $eventMap = ComponentManager::getEventHandlers();
           
           if (!array_key_exists($event, $eventMap)) 
           {
                trace("No handlers subscribed to '$event'", 4);
                return $parameter;
           }
      
           $continue = true;
           
           foreach($eventMap[$event] as $subscription)
           {
                Fakoli::using($subscription["component"]);
  
                if (is_array($subscription["handler"]))
                {
                     trace("Handling $event with {$subscription["handler"][0]}::{$subscription["handler"][1]}", 4);
                }
                else
                {
                     trace("Handling $event with {$subscription["handler"]}", 4);
                }
                          
                if (!is_callable($subscription["handler"]))
                {
                     if (is_array($subscription["handler"]))
                     {
                          trace("Subscription handler {$subscription["handler"][0]}::{$subscription["handler"][1]} for $event is invalid", 2);
                     }
                     else
                     {
                          trace("Subscription handler $event with {$subscription["handler"]} for $event is invalid", 2);
                     }
  
                     trace(printIncludes(false, true), 3);
                }
                else
                {
                     $parameter = call_user_func_array($subscription["handler"], array($parameter, &$continue));
                }
                if (!$continue) break;
           }
           
           if ($mustBeConsumed && $continue)
           {
                throw new FakoliEventNotConsumed("'$event' not handled by any subscriber");
           }
           
           return $parameter;
      }

◆ fireEventTo()

static ComponentManager::fireEventTo	(	$event,
		$component,
		$parameter = `null`
	)

static

Fire an event to the specificed component.

If the component is not subscribed the event is ignored.

Parameters

string	$event	the name of the event
string	$component	The name of the target component
array	$parameter	any parameters being passed to the event

Definition at line 504 of file component_manager.inc.

      {
           trace("** Firing event '$event' to $component", 4);
            
           $eventMap = ComponentManager::getEventHandlers();
           
           if (!array_key_exists($event, $eventMap)) 
           {
                trace("No handlers subscribed to '$event'", 4);
                return $parameter;
           }
                
           foreach($eventMap[$event] as $subscription)
           {
                if ($component == $subscription["component"])
                {
                     
                     Fakoli::using($subscription["component"]);
      
                     if (is_array($subscription["handler"]))
                     {
                          trace("Handling $event with {$subscription["handler"][0]}::{$subscription["handler"][1]}", 4);
                     }
                     else
                     {
                          trace("Handling $event with {$subscription["handler"]}", 4);
                     }
                               
                     $parameter = call_user_func_array($subscription["handler"], array($parameter, &$continue));
                     break;
                }
           }
           
           return $parameter;  
      }

◆ getComponent()

ComponentManager::getComponent ( $component )

Retrieve the component definition record for the specified component.

Parameters

$component the name of the component

Returns: Component the record for the specified component

Definition at line 370 of file component_manager.inc.

      {
           $components = Fakoli::getComponents();
           
           if (!array_key_exists($component, $components))
           {
                throw new FakoliException("Unrecognized or disabled component '$component'");
           }
           return $components[$component];
      }    

◆ getComponentSignature()

static ComponentManager::getComponentSignature ( )

static

Retrieves a unique signature for the application's enabled components, based on their installed version numbers.

This enables the administrator to determine at a glance if the configuration of two Fakoli servers is the same.

Definition at line 827 of file component_manager.inc.

      {
           $str = "";
           
           $components = Fakoli::getComponents();
           foreach($components as $component)
           {
                $version = ComponentUpdateLog::getLatestVersion($component->name);
                $str .= $component->name.":".$version."|";
           }
           
           return sha1($str);
      }

◆ getEventHandlers()

static ComponentManager::getEventHandlers ( )

static

Retrieve the event handler map.

The map is generated on the first request and cached for future reference.

Returns: array the event handler map

Definition at line 386 of file component_manager.inc.

      {
           $eventMap = Cache::get("fakoli_event_map");
           if ($eventMap) return $eventMap;
           
           ComponentManager::scanTrace("Mapping Event Handlers", 3);
           $components = Query::create(Component, "WHERE enabled=1 ORDER BY priority")->execute();
           
           $eventMap = array();
           
           foreach($components as $component)
           {
                $manifest = $component->loadManifest();
                
                if (!$manifest || !method_exists($manifest, subscribeToEvents)) continue;
      
                $subscriptions = $manifest->subscribeToEvents();
                
                foreach($subscriptions as $event => $handler)
                {
                     $handlerRecord = array("component" => $component->name, "priority" => $component->priority, "handler" => $handler);
                     
                     ComponentManager::scanTrace("  $component->name is subscribing to $event", 3);
                     if (array_key_exists($event, $eventMap))
                     {
                          $eventMap[$event][] = $handlerRecord;
                     }
                     else
                     {
                          $eventMap[$event] = array($handlerRecord);
                     } 
                }
           }
           
           Cache::put("fakoli_event_map", $eventMap);
           return $eventMap;
      }

◆ scan()

ComponentManager::scan ( $verbosity = 0 )

Scans the application home directory and PHP include path and builds the component and administration page map that describe the configuration of the application.

Definition at line 246 of file component_manager.inc.

      {
           global $config;
           
           Fakoli::$scanning = true;
           ComponentManager::$verbosityLevel = $verbosity;
           
           $this->tx = new DataTransaction();
           
           try
           {
                
                $c = new Component();
                $c->joinTransaction($this->tx);
                $c->deleteAll();
           
           
                $p = new AdminPage();
                $p->joinTransaction($this->tx);
                $p->deleteAll();
           
                $cp = new ComponentPage();
                $cp->joinTransaction($this->tx);
                $cp->updateExplicit("SET scanned=0");
                
                $path .= $config['homedir'] . PATH_SEPARATOR . ini_get("include_path");
                
                if (isset($config["extra_includes"])) $path .= PATH_SEPARATOR . $config["extra_includes"];
                
                $roots = explode(PATH_SEPARATOR, $path);
                
                foreach($roots as $root)
                {
                     if ($root == ".") continue;
                     
                     ComponentManager::scanTrace("Scanning $root for components", 2);
                     $this->scanComponents($root, "cms/components");
                     $this->scanComponents($root, "components");
                }
                
                Cache::invalidate("fakoli_components");
                Cache::invalidate("fakoli_admin_menu");
                Cache::invalidate("fakoli_admin_icons");
                Cache::invalidate("fakoli_scripts");
                Cache::invalidate("fakoli_styles");
                Cache::invalidate("fakoli_event_map");
                
                $cp->delete("WHERE scanned=0");
                
                
                $this->tx->commit();
                unset($this->tx);
           
                $components = indexedQuery(Component, "WHERE enabled=1", "name");               
                Cache::put("fakoli_components", $components);
                
                ComponentManager::fireEvent("upgradeComponent");
                
                ComponentManager::fireEvent("ComponentScanComplete");
                
                Fakoli::$scanning = false;
           }
           catch(Exception $e)
           {
                // JDG 6/1/2011 - if fails on ComponentScanComplete
                if(isset($this->tx))
                     $this->tx->rollback();
                unset($this->tx);
                
                Fakoli::$scanning = false;
                
                if (ComponentManager::$verbosityLevel > 0)
                {
                     echo $e->__toString();
                }
                else
                {
                     throw $e;
                }
           }
      }

◆ scanAdminPages()

ComponentManager::scanAdminPages ( $component )

Builds the administration page map for the specified component.

Parameters

$component the component being scanned

Definition at line 166 of file component_manager.inc.

      {
           if (!$component->enabled) return;
           
           $admin = $component->component_path . DIRECTORY_SEPARATOR . "admin";
           
           if (!is_dir($admin)) return;
           
           ComponentManager::scanTrace("== Scanning $admin", 3);
           
           $handle = opendir($admin);
           
           while(false !== ($file = readdir($handle))) 
           {
                if (endsWith($file, ".inc"))
                {
                     $page = new AdminPage();
                     $page->identifier = preg_replace("/\\.inc$/", "", $file);
                     $page->server_path = $admin . DIRECTORY_SEPARATOR . $file;
                     $page->component_id = $component->component_id;
                     $page->joinTransaction($this->tx);
                     $page->save();
                     Cache::invalidate("fakoli_admin_pages_{$page->identifier}");                    
                }
           }
           
      }

◆ scanComponentPages()

ComponentManager::scanComponentPages ( $component )

Scan and build the compoment page map for the specified component.

Parameters

$component the component to be scanned.

Definition at line 198 of file component_manager.inc.

      {
           $pages = $component->component_path . DIRECTORY_SEPARATOR . "pages";
           
           if (!is_dir($pages)) return;
           ComponentManager::scanTrace("== Scanning $pages", 3);
           
           $handle = opendir($pages);
           
           while(false !== ($file = readdir($handle))) 
           {
                if (endsWith($file, ".inc"))
                {
                     $identifier = preg_replace("/\\.inc$/", "", $file);
                     
                     try
                     {
                          $page = Query::create(ComponentPage, "WHERE component=:c AND identifier=:i")
                                    ->bind(":c", $component->name, ":i", $identifier)
                                    ->executeSingle();
                                    
                          $page->scanned = true;
                          $page->server_path = $pages . DIRECTORY_SEPARATOR . $file;
                          $page->filter = new InclusionFilter("component_page_id", "server_path", "scanned");
                          $page->save();
                     }
                     catch(DataNotFoundException $e)
                     {
                          $page = new ComponentPage();
                          $page->page_title = prettify($identifier);
                          $page->identifier = $identifier;
                          $page->component = $component->name;
                          $page->server_path = $pages . DIRECTORY_SEPARATOR . $file;
                          $page->role = "";
                          $page->enabled = true;
                          $page->scanned = true;
                          $page->save();
                     }                             
                }
           }
           
      }

◆ scanComponents()

ComponentManager::scanComponents	(	$root,
		$subdir
	)

Scan the specified root and sub-directory for components.

Parameters

$root
$subdir

Definition at line 90 of file component_manager.inc.

      {
           if (!$root || $root == ".") return;
           
           $path = $root . DIRECTORY_SEPARATOR . str_replace("/", DIRECTORY_SEPARATOR, $subdir);
      
           ComponentManager::scanTrace("Scanning $path", 2);
           
           if (is_dir($path))
           {
                $handle = opendir($path);
                while(false !== ($file = readdir($handle))) 
               {
                $f = $path . DIRECTORY_SEPARATOR . $file;
                $m = $f . DIRECTORY_SEPARATOR . "manifest.inc";
                $d = $f . DIRECTORY_SEPARATOR . "DEPRECATED";
                
                if (is_dir($f))
                {
                     ComponentManager::scanTrace("== Found component '$file'", 3);
                     if (is_file($d))
                     {
                          ComponentManager::scanTrace("**** Deprecated component - ignoring", 3);
                          Cache::invalidate("fakoli_includes_$file");
                          continue;
                     }
                     
                     if ($this->found[$file])
                     {
                          ComponentManager::scanTrace("---- already defined - skipping", 3);
                          continue;
                     }
                     
                     if (!is_file($m))
                     {
                          ComponentManager::scanTrace("== No manifest found. Skipping...", 3);
                          continue;
                     }
                     
                     require_once $m;
                     
                     $cl = Fakoli::getComponentClassRoot($file) . "Manifest";
                     
                     try
                     {
                          ComponentManager::scanTrace("== Instantiating $cl", 3);
                          
                          $manifest = new $cl;
                          $component = $manifest->getComponentDefinition();
                          $component->component_path = sanitizePath($f);
                          $component->joinTransaction($this->tx);
                          $component->save();
                          
                          $this->found[$file] = $component;
                          
                          $this->scanAdminPages($component);
                          $this->scanComponentPages($component);
                     
                     }
                     catch(Exception $e)
                     {
                          ComponentManager::scanTrace("-- Failed to instantiate manifest class. Skipping...", 3);             
                     }
      
                     Cache::invalidate("fakoli_includes_$file");
                }
               }
               
               closedir($handle);
           }
      }

◆ scanTrace()

static ComponentManager::scanTrace	(	$message,
		$level
	)

static

Definition at line 57 of file component_manager.inc.

      {
           global $config;
           
           if ($level <= ComponentManager::$verbosityLevel)
           {
                if (!ComponentManager::$scanLog)
                {
                     ComponentManager::$scanLog = $config['uploadbase'].DIRECTORY_SEPARATOR."component_scan_".date("Ymd-His").".log";
                }
                
                error_log($message."\n", 3, ComponentManager::$scanLog);
                
                echo $message;
                echo (ComponentManager::$plainOutput) ? "\n" : "<br/>";
           }
           
           trace($message, $level);
      }

◆ setComponentVersion()

static ComponentManager::setComponentVersion ( $component_name )

static

Definition at line 741 of file component_manager.inc.

      {
           $components = Query::create(Component, "WHERE name=:component_name")
                ->bind(":component_name", $component_name)
                ->execute();
           
           if(count($components) == 0)
                return;
                
           $component = $components[0];
           
           $latest_version = ComponentUpdateLog::getLatestVersion($component_name);
           
           // To do - set inital values in table for existing components to start
  
           if($latest_version && $latest_version != $component->version)
           {
                $component->version = $latest_version;
                $component->filter = new InclusionFilter("version");
                $component->save(); 
           }
           
      }

◆ setDefaults()

static ComponentManager::setDefaults ( )

static

Definition at line 808 of file component_manager.inc.

      {
           trace("ComponentManager::setDefaults", 3);
           global $config;
           
           $defaultPath = $config['uploadbase'] . DIRECTORY_SEPARATOR . "upgrade_output_path";       
           if (!file_exists($defaultPath)) mkdir($defaultPath);
           
           Settings::setDefaultValue("component", "upgrade_output_path", $defaultPath, "String");
           Settings::setDefaultValue("settings", "enable_inline_editing", false, "Boolean", "Turns on or off inline editing capabilities (for those components that support this option)", "General");
           Settings::setDefaultPermission("settings", "editor_roles", "Roles for whom inline editing controls are to be shown", "admin"); 
      }

◆ upgradeComponent()

static ComponentManager::upgradeComponent ( $version )

static

Definition at line 765 of file component_manager.inc.

      {
           $mgr = new ComponentUpgradeManager();
           $mgr->upgrade($version);
      }    

Member Data Documentation

◆ $found

ComponentManager::$found = array()

Definition at line 51 of file component_manager.inc.

◆ $plainOutput

ComponentManager::$plainOutput = false

static

Set to true for plain text output during component scan.

Definition at line 54 of file component_manager.inc.

◆ $verbosityLevel

ComponentManager::$verbosityLevel = 0

static

Verbosity level for component scan (same as trace level)

Definition at line 53 of file component_manager.inc.

The documentation for this class was generated from the following file:

C:/code/cms.sonjara.com/cms/components/component/component_manager.inc

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

◆ compareByPriority()

◆ componentFormTabs()

◆ componentListTabs()

◆ ComponentManager()

◆ componentPageTabs()

◆ deleteRole()

◆ dispatchAction()

◆ dispatchLocalAction()

◆ displayPage()

◆ enumerateComponentPages()

◆ findComponentPath()

◆ fireEvent()

◆ fireEventTo()

◆ getComponent()

◆ getComponentSignature()

◆ getEventHandlers()

◆ scan()

◆ scanAdminPages()

◆ scanComponentPages()

◆ scanComponents()

◆ scanTrace()

◆ setComponentVersion()

◆ setDefaults()

◆ upgradeComponent()

Member Data Documentation

◆ $found

◆ $plainOutput

◆ $verbosityLevel