Language::createWithRules() - Code Metrics - netfocusinc/argh - Measure and Improve Code Quality continuously with Scrutinizer

Language::createWithRules() B
last analyzed 2019-04-30 21:52 UTC

↳ Parent: Language

Complexity

Conditions	1
Paths	1

Size

Total Lines	167
Code Lines	77

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	77
nc	1
nop	0
dl	0
loc	167
rs	8.5018
c	0
b	0
f	0

How to fix Long Method

<?php
	
/**
	* Language.php
	*/
	
namespace netfocusinc\argh;

//
// CONVENIENCE DEFINITIONS
//

// Syntax Contants
define('ARGH_SYNTAX_FLAG', Rule::ARGH_SYNTAX_FLAG, true);
define('ARGH_SYNTAX_FLAGS', Rule::ARGH_SYNTAX_FLAGS, true);
define('ARGH_SYNTAX_NAME', Rule::ARGH_SYNTAX_NAME, true);
define('ARGH_SYNTAX_VALUE', Rule::ARGH_SYNTAX_VALUE, true);
define('ARGH_SYNTAX_LIST', Rule::ARGH_SYNTAX_LIST, true);
define('ARGH_SYNTAX_COMMAND', Rule::ARGH_SYNTAX_COMMAND, true);
define('ARGH_SYNTAX_QUOTED', Rule::ARGH_SYNTAX_QUOTED, true);
define('ARGH_SYNTAX_VARIABLE', Rule::ARGH_SYNTAX_VARIABLE, true);

// Semantic Contants
define('ARGH_SEMANTICS_FLAG', Rule::ARGH_SEMANTICS_FLAG, true);
define('ARGH_SEMANTICS_FLAGS', Rule::ARGH_SEMANTICS_FLAGS, true);
define('ARGH_SEMANTICS_NAME', Rule::ARGH_SEMANTICS_NAME, true);
define('ARGH_SEMANTICS_VALUE', Rule::ARGH_SEMANTICS_VALUE, true);
define('ARGH_SEMANTICS_LIST', Rule::ARGH_SEMANTICS_LIST, true);
define('ARGH_SEMANTICS_COMMAND', Rule::ARGH_SEMANTICS_COMMAND, true);
define('ARGH_SEMANTICS_VARIABLE', Rule::ARGH_SEMANTICS_VARIABLE, true);

/**
	* Langugage is a set of Rules (with Syntax and Semantics) used to interpret command line arguments.
	*
	* The Language class manages the Rules used to interpret command line arguments during parsing.
	* This class is a container for Rules, and features convenience methods for constructing a language complete with a set of standard rules.
	*
	* @api
	* 
	* @author Benjamin Hough
	*
	* @since 1.0.0
	*/
class Language
{	
	
	//
	// PRIVATE PROPERTIES
	//
	
	/** @var array An array of Rules */
	private $rules; // array of Rule(s)
	
	//
	// STATIC METHODS
	//
	
	/**
		* Creates a Language, complete with a set of Rules used for interpreting command line arguments
		*
		* This is the main function to use when creating a new Langugage.
		*
		* @since 1.0.0
		*
		* @return Language
		*/
	public static function createWithRules()
	{
		// Create a new Language instance
		$language = new self();
		
		//
		// Add a standard set of Rules
		//
		
		// Hyphenated Flag with List
		$language->addRule(new Rule(
				'Hyphenated Flag with List',
				'-f [one, two, three]',
				'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+\[(' . ARGH_SYNTAX_LIST . ')\]$/i',
				[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_LIST]
			)
		);
		
		// Double Hyphenated Flag with List
		$language->addRule(new Rule(
				'Double Hyphenated Name with List',
				'--key=[one, two, three]',
				'/^\-\-(' . ARGH_SYNTAX_NAME . ')=\[(' . ARGH_SYNTAX_LIST . ')\]$/i',
				[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_LIST]
			)
		);
		
		// Hyphenated Flag with Quoted Value
		$language->addRule(new Rule(
				'Hyphenated Flag with Quoted Value',
				'-f \'Hello World\'',
				'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
				[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_VALUE]
			)
		);
		
		// Double Hyphenated Key with Quoted Value
		$language->addRule(new Rule(
				'Double Hyphenated Name with Quoted Value',
				'--key=\'quoted value\'',
				'/^\-\-(' . ARGH_SYNTAX_NAME . ')=\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
				[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
			)
		);
		
		// Hyphenated Flag with Value
		$language->addRule(new Rule(
				'Hyphenated Flag with Value',
				'-f value',
				'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+(' . ARGH_SYNTAX_VALUE . ')$/i',
				[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_VALUE]
			)
		);
		
		/*
		// Command with Naked Subcommand
		$language->addRule(new Rule(
				'Command with Naked Subcommand',
				'cmd sub',
				'/^(' . ARGH_SYNTAX_COMMAND . ')[\s]+(' . ARGH_SYNTAX_COMMAND . ')$/i',
				[ARGH_SEMANTICS_COMMAND, ARGH_SEMANTICS_SUB]
			)
		);
		*/
		
		// Hyphenated Key with Value
		$language->addRule(new Rule(
				'Hyphenated Name with Value',
				'-key value',
				'/^\-(' . ARGH_SYNTAX_NAME . ') (' . ARGH_SYNTAX_VALUE . ')$/i',
				[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
			)
		);
		
		// Double Hyphenated Key with Value
		$language->addRule(new Rule(
				'Double Hyphenated Name with Value',
				'--key=value',
				'/^\-\-(' . ARGH_SYNTAX_NAME . ')=(' . ARGH_SYNTAX_VALUE . ')$/i',
				[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
			)
		);
		
		// Double Hyphenated Boolean Key
		$language->addRule(new Rule(
				'Double Hyphenated Boolean Key',
				'--key',
				'/^\-\-(' . ARGH_SYNTAX_NAME . ')$/i',
				[ARGH_SEMANTICS_NAME]
			)
		);
		
		// Hyphenated Boolean Name
		$language->addRule(new Rule(
				'Hyphenated Boolean Key',
				'-key',
				'/^\-(' . ARGH_SYNTAX_NAME . ')$/i',
				[ARGH_SEMANTICS_NAME]
			)
		);
		
		// Hyphenated Boolean Flag
		$language->addRule(new Rule(
				'Hyphenated Boolean Flag',
				'-f',
				'/^\-(' . ARGH_SYNTAX_FLAG . ')$/i',
				[ARGH_SEMANTICS_FLAG]
			)
		);
		
		// Hyphenated Multi Flag
		$language->addRule(new Rule(
				'Hyphenated Multi Flag',
				'-xvf',
				'/^\-(' . ARGH_SYNTAX_FLAGS . ')$/i',
				[ARGH_SEMANTICS_FLAGS]
			)
		);
		
		/*
		// Command with Delimited Subcommand
		$language->addRule(new Rule(
				'Command with Delimited Subcommand',
				'cmd:sub',
				'/^(' . ARGH_SYNTAX_COMMAND . '):(' . ARGH_SYNTAX_COMMAND . ')$/i',
				[ARGH_SEMANTICS_COMMAND, ARGH_SEMANTICS_SUB]
			)
		);
		*/
		
		// Command
		$language->addRule(new Rule(
				'Command',
				'cmd',
				'/^(' . ARGH_SYNTAX_COMMAND . ')$/i',
				[ARGH_SEMANTICS_COMMAND]
			)
		);
		
		// Naked Multi Flag
		$language->addRule(new Rule(
				'Naked Multi Flag',
				'xvf',
				'/^(' . ARGH_SYNTAX_FLAGS . ')$/i',
				[ARGH_SEMANTICS_FLAGS]
			)
		);
		
		// Quoted Naked Variable
		$language->addRule(new Rule(
				'Quoted Naked Variable',
				'value',
				'/^\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
				[ARGH_SEMANTICS_VARIABLE]
			)
		);
		
		// Naked Variable
		$language->addRule(new Rule(
				'Naked Variable',
				'value',
				'/^(' . ARGH_SYNTAX_VARIABLE . ')$/i',
				[ARGH_SEMANTICS_VARIABLE]
			)
		);
		
		return $language;
	}
	
	//
	// PUBLIC METHODS
	//
	
	/**
		* Langugage Constructor
		*
		* The preferred way of constructing a new Language, is with the static createWithRules() method.
		* This constructor is useful for creating custom languages, with non-standard rule sets.
		*
		* @since 1.0.0
		*
		* @throws Exception
		*/
	public function __construct()
	{
		try
		{
			// Create an array of Rules
			$this->rules = array();
		}
		catch(\Exception $e)
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
		{
			throw($e);
		}
		
	} // END: __construct()
	
	/**
		* Returns the set of Rules maintained by this Language.
		*
		* @since 1.0.0
		*
		* @return array An array of Rules
		*/
	public function rules()
	{
		return $this->rules;
	}
	
	/**
		* Adds a Rule to the set of rules maintained by this Language.
		*
		* @since 1.0.0
		*
		* @param $rule Rule
		*/
	public function addRule(Rule $rule)
	{
		$this->rules[] = $rule;
	}
	
}


1			<?php
2
3			/**
4			* Language.php
5			*/
6
7			namespace netfocusinc\argh;
8
9			//
10			// CONVENIENCE DEFINITIONS
11			//
12
13			// Syntax Contants
14			define('ARGH_SYNTAX_FLAG', Rule::ARGH_SYNTAX_FLAG, true);
15			define('ARGH_SYNTAX_FLAGS', Rule::ARGH_SYNTAX_FLAGS, true);
16			define('ARGH_SYNTAX_NAME', Rule::ARGH_SYNTAX_NAME, true);
17			define('ARGH_SYNTAX_VALUE', Rule::ARGH_SYNTAX_VALUE, true);
18			define('ARGH_SYNTAX_LIST', Rule::ARGH_SYNTAX_LIST, true);
19			define('ARGH_SYNTAX_COMMAND', Rule::ARGH_SYNTAX_COMMAND, true);
20			define('ARGH_SYNTAX_QUOTED', Rule::ARGH_SYNTAX_QUOTED, true);
21			define('ARGH_SYNTAX_VARIABLE', Rule::ARGH_SYNTAX_VARIABLE, true);
22
23			// Semantic Contants
24			define('ARGH_SEMANTICS_FLAG', Rule::ARGH_SEMANTICS_FLAG, true);
25			define('ARGH_SEMANTICS_FLAGS', Rule::ARGH_SEMANTICS_FLAGS, true);
26			define('ARGH_SEMANTICS_NAME', Rule::ARGH_SEMANTICS_NAME, true);
27			define('ARGH_SEMANTICS_VALUE', Rule::ARGH_SEMANTICS_VALUE, true);
28			define('ARGH_SEMANTICS_LIST', Rule::ARGH_SEMANTICS_LIST, true);
29			define('ARGH_SEMANTICS_COMMAND', Rule::ARGH_SEMANTICS_COMMAND, true);
30			define('ARGH_SEMANTICS_VARIABLE', Rule::ARGH_SEMANTICS_VARIABLE, true);
31
32			/**
33			* Langugage is a set of Rules (with Syntax and Semantics) used to interpret command line arguments.
34			*
35			* The Language class manages the Rules used to interpret command line arguments during parsing.
36			* This class is a container for Rules, and features convenience methods for constructing a language complete with a set of standard rules.
37			*
38			* @api
39			*
40			* @author Benjamin Hough
41			*
42			* @since 1.0.0
43			*/
44			class Language
45			{
46
47			//
48			// PRIVATE PROPERTIES
49			//
50
51			/** @var array An array of Rules */
52			private $rules; // array of Rule(s)
53
54			//
55			// STATIC METHODS
56			//
57
58			/**
59			* Creates a Language, complete with a set of Rules used for interpreting command line arguments
60			*
61			* This is the main function to use when creating a new Langugage.
62			*
63			* @since 1.0.0
64			*
65			* @return Language
66			*/
67			public static function createWithRules()
68			{
69			// Create a new Language instance
70			$language = new self();
71
72			//
73			// Add a standard set of Rules
74			//
75
76			// Hyphenated Flag with List
77			$language->addRule(new Rule(
78			'Hyphenated Flag with List',
79			'-f [one, two, three]',
80			'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+\[(' . ARGH_SYNTAX_LIST . ')\]$/i',
81			[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_LIST]
82			)
83			);
84
85			// Double Hyphenated Flag with List
86			$language->addRule(new Rule(
87			'Double Hyphenated Name with List',
88			'--key=[one, two, three]',
89			'/^\-\-(' . ARGH_SYNTAX_NAME . ')=\[(' . ARGH_SYNTAX_LIST . ')\]$/i',
90			[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_LIST]
91			)
92			);
93
94			// Hyphenated Flag with Quoted Value
95			$language->addRule(new Rule(
96			'Hyphenated Flag with Quoted Value',
97			'-f \'Hello World\'',
98			'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
99			[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_VALUE]
100			)
101			);
102
103			// Double Hyphenated Key with Quoted Value
104			$language->addRule(new Rule(
105			'Double Hyphenated Name with Quoted Value',
106			'--key=\'quoted value\'',
107			'/^\-\-(' . ARGH_SYNTAX_NAME . ')=\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
108			[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
109			)
110			);
111
112			// Hyphenated Flag with Value
113			$language->addRule(new Rule(
114			'Hyphenated Flag with Value',
115			'-f value',
116			'/^\-(' . ARGH_SYNTAX_FLAG . ')[\s]+(' . ARGH_SYNTAX_VALUE . ')$/i',
117			[ARGH_SEMANTICS_FLAG, ARGH_SEMANTICS_VALUE]
118			)
119			);
120
121			/*
122			// Command with Naked Subcommand
123			$language->addRule(new Rule(
124			'Command with Naked Subcommand',
125			'cmd sub',
126			'/^(' . ARGH_SYNTAX_COMMAND . ')[\s]+(' . ARGH_SYNTAX_COMMAND . ')$/i',
127			[ARGH_SEMANTICS_COMMAND, ARGH_SEMANTICS_SUB]
128			)
129			);
130			*/
131
132			// Hyphenated Key with Value
133			$language->addRule(new Rule(
134			'Hyphenated Name with Value',
135			'-key value',
136			'/^\-(' . ARGH_SYNTAX_NAME . ') (' . ARGH_SYNTAX_VALUE . ')$/i',
137			[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
138			)
139			);
140
141			// Double Hyphenated Key with Value
142			$language->addRule(new Rule(
143			'Double Hyphenated Name with Value',
144			'--key=value',
145			'/^\-\-(' . ARGH_SYNTAX_NAME . ')=(' . ARGH_SYNTAX_VALUE . ')$/i',
146			[ARGH_SEMANTICS_NAME, ARGH_SEMANTICS_VALUE]
147			)
148			);
149
150			// Double Hyphenated Boolean Key
151			$language->addRule(new Rule(
152			'Double Hyphenated Boolean Key',
153			'--key',
154			'/^\-\-(' . ARGH_SYNTAX_NAME . ')$/i',
155			[ARGH_SEMANTICS_NAME]
156			)
157			);
158
159			// Hyphenated Boolean Name
160			$language->addRule(new Rule(
161			'Hyphenated Boolean Key',
162			'-key',
163			'/^\-(' . ARGH_SYNTAX_NAME . ')$/i',
164			[ARGH_SEMANTICS_NAME]
165			)
166			);
167
168			// Hyphenated Boolean Flag
169			$language->addRule(new Rule(
170			'Hyphenated Boolean Flag',
171			'-f',
172			'/^\-(' . ARGH_SYNTAX_FLAG . ')$/i',
173			[ARGH_SEMANTICS_FLAG]
174			)
175			);
176
177			// Hyphenated Multi Flag
178			$language->addRule(new Rule(
179			'Hyphenated Multi Flag',
180			'-xvf',
181			'/^\-(' . ARGH_SYNTAX_FLAGS . ')$/i',
182			[ARGH_SEMANTICS_FLAGS]
183			)
184			);
185
186			/*
187			// Command with Delimited Subcommand
188			$language->addRule(new Rule(
189			'Command with Delimited Subcommand',
190			'cmd:sub',
191			'/^(' . ARGH_SYNTAX_COMMAND . '):(' . ARGH_SYNTAX_COMMAND . ')$/i',
192			[ARGH_SEMANTICS_COMMAND, ARGH_SEMANTICS_SUB]
193			)
194			);
195			*/
196
197			// Command
198			$language->addRule(new Rule(
199			'Command',
200			'cmd',
201			'/^(' . ARGH_SYNTAX_COMMAND . ')$/i',
202			[ARGH_SEMANTICS_COMMAND]
203			)
204			);
205
206			// Naked Multi Flag
207			$language->addRule(new Rule(
208			'Naked Multi Flag',
209			'xvf',
210			'/^(' . ARGH_SYNTAX_FLAGS . ')$/i',
211			[ARGH_SEMANTICS_FLAGS]
212			)
213			);
214
215			// Quoted Naked Variable
216			$language->addRule(new Rule(
217			'Quoted Naked Variable',
218			'value',
219			'/^\'(' . ARGH_SYNTAX_QUOTED . ')\'$/i',
220			[ARGH_SEMANTICS_VARIABLE]
221			)
222			);
223
224			// Naked Variable
225			$language->addRule(new Rule(
226			'Naked Variable',
227			'value',
228			'/^(' . ARGH_SYNTAX_VARIABLE . ')$/i',
229			[ARGH_SEMANTICS_VARIABLE]
230			)
231			);
232
233			return $language;
234			}
235
236			//
237			// PUBLIC METHODS
238			//
239
240			/**
241			* Langugage Constructor
242			*
243			* The preferred way of constructing a new Language, is with the static createWithRules() method.
244			* This constructor is useful for creating custom languages, with non-standard rule sets.
245			*
246			* @since 1.0.0
247			*
248			* @throws Exception
249			*/
250			public function __construct()
251			{
252			try
253			{
254			// Create an array of Rules
255			$this->rules = array();
256			}
257			catch(\Exception $e)
			0 ignored issues – show Unused Code introduced 2019-04-30 21:52 UTC by Report Bug Copy Issue Report `catch (\Exception $e)` is not reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
258			{
259			throw($e);
260			}
261
262			} // END: __construct()
263
264			/**
265			* Returns the set of Rules maintained by this Language.
266			*
267			* @since 1.0.0
268			*
269			* @return array An array of Rules
270			*/
271			public function rules()
272			{
273			return $this->rules;
274			}
275
276			/**
277			* Adds a Rule to the set of rules maintained by this Language.
278			*
279			* @since 1.0.0
280			*
281			* @param $rule Rule
282			*/
283			public function addRule(Rule $rule)
284			{
285			$this->rules[] = $rule;
286			}
287
288			}
289

netfocusinc / argh

Language::createWithRules() B last analyzed 2019-04-30 21:52 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

Language::createWithRules() B
last analyzed 2019-04-30 21:52 UTC