netfocusinc\argh\ArgumentParser::yieldArgumentsFromRule()

Complexity

Conditions	25
Paths	4

Size

Total Lines	163
Code Lines	52

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
	public function yieldArgumentsFromRule(Rule $rule, array $tokens): array
	{
		
		// Create an array of new Argument
		// In most cases, a single Rule will create a single Arugment
		// Unless the Rule contains an ARGH_SEMANTICS_FLAGS, which creates an Argument for each flag
		
		$argument = array();

		// Loop through $tokens and define Argument(s) based on the current rules semantics
		$count_tokens = count($tokens);
		
		for($i=1; $i<$count_tokens; $i++)
		{
			$token = $tokens[$i];
			$semantics = $rule->semantics()[$i-1];

			//echo __METHOD__ . ": token: $token (" . Rule::semanticsToString($semantics) . ")\n";

			switch( $semantics )
			{ 
				case ARGH_SEMANTICS_FLAG:
				
					if( $this->parameterCollection->exists($token) )
					{	
						// This Rule will create a single Argument
						if(count($argument)==0) $argument[0] = new Argument($token);								
					}
					else
					{
						// This token does NOT match the flag of any defined parameter
						// This Rule will NOT yield any arguments
						break 2; // Break from this switch and for loop
					}
					
					break;
					
				case ARGH_SEMANTICS_FLAGS:
					
					// Check every character of this $token for a matching parameter 'flag'
					for($j=0; $j<strlen($token); $j++)
					{
						if( $this->parameterCollection->exists( $token{$j} ) )
						{
							// This Rule can only apply to ARGH_TYPE_BOOLEAN Parameters
							if( ARGH_TYPE_BOOLEAN == $this->parameterCollection->get($token{$j})->getParameterType() )
							{
								// Create new Argument for each flag
								if( !array_key_exists($j, $argument) ) $argument[$j] = new Argument($token{$j});
							}
						}
						else
						{
							// A character in $token, does not match a defined Parameter flag
							// This Rule will NOT yield any arguments
							// Undo the creation of new Arguments under this Rule
							$argument = array();
							
							break; // Break from this for loop
						}		
						
					} // END: for($j=0; $j<strlen($token); $j++)
					
					break;
					
				case ARGH_SEMANTICS_NAME:
			
					if( $this->parameterCollection->exists($token) )
					{
						// This Rule will create a single Argument
						if(count($argument)==0) $argument[0] = new Argument($token); 								
					}
					else
					{
						// This token does NOT match the flag of any defined parameter
						// This Rule will NOT yield any arguments
						break 2; // Break from this switch and for loop
					}
			
					break;			
					
				case ARGH_SEMANTICS_VALUE:
				
					// Usually, the Argument will have already been created by another token in this Rule
				
					// If no new Argument created by this Rule yet, create one now
					if(count($argument)==0) $argument[0] = new Argument();
					
					// The new Argument's 'key' should be set by another token in this Rule
					$argument[0]->setValue($token);
					
					break;
					
				case ARGH_SEMANTICS_LIST:
				
					// Usually, the Argument will have already been created by another token in this Rule
				
					// If no new Argument created by this Rule yet, create one now
					if(count($argument)==0) $argument[0] = new Argument();
				
					// Trim brackets from the $token (list)
					$token = trim($token, "[]");
					
					// Explode comma seperated list into elements
					$elements = explode(',', $token);
					
					// Use the $elements array as the 'value' for all new Argument created by this Rule
					// Usually, this will only apply to a single Argument, unless this Rule contains ARGH_SEMANTICS_FLAGS
					foreach($argument as &$a) $a->setValue($elements);
				
					break;
					
				case ARGH_SEMANTICS_COMMAND:
				
					// Check if ParameterCollection contains any commands
					if($this->parameterCollection->hasCommand())
					{
						// Retrieve all ARGH_TYPE_COMMAND Parameters
						$commands = $this->parameterCollection->getCommands();
							
						foreach($commands as $p)
						{
							if($p->hasOptions())
							{
								if( in_array($token, $p->getOptions()) )
								{
									// $token matches an option of this ARGH_TYPE_COMMAND Parameter	
									
				 					// If no new Argument created by this Rule yet, create one now
				 					if(count($argument)==0) $argument[0] = new Argument($p->getName(), $token);
									
									// Stop searching this Parameters options
									break;
									
								} // END: if( in_array($token, $p->options()) )
							} // END: if($p->hasOptions())
						} // END: foreach($commands as $p)
							

					} // END: if($this->parameterCollection->hasCommand())
				
					break;
					
				case ARGH_SEMANTICS_VARIABLE:
					
					// Create a new Argument to hold values
					$argument[0] = new Argument(Parameter::ARGH_NAME_VARIABLE, $token);
					
					break;
					
				default:
				
					throw new ArghException(__CLASS__ . ': Token has unknown semantic meaning.');
			}
			
		} // END: for($j=1; $j<count($matches); $j++)
		
		
		//echo 'Yielded Arguments:' . "\n";
		//print_r($argument);
		
		// Return an array of Arguments yielded by this Rule
		return $argument;
		
}