using namespace kyle; - good evening!

Hello everyone (or just hello Kyle, since I don't think anyone else is reading this). Personal project development has been pretty slow lately; I've been pretty busy at work. However, these past two days I have been able to spend some time on my own interests (yay!). I was sitting at my desk at work when I thought to myself how I wish making beautiful code was easier. You have the hassle of writting propery PHPDoc, getter/setters, proper property naming and worrying about the design of all your classes. It takes so much time to do this and to worry wether or not you'll need to go back and modify something later. Then I thought, how cool would it be to have Objective-C's @synthesize on PHP. And having the ability to define parameters in a simple form much like that of C++. After stumbling around in my mind, I wondered how feasable it would be to take an Objective-C/C++ style @interface and convert it to PHP with all PHPDoc, getter/setters, properties, the works. A few hours later, I present to you the pseudo Objective-C code and the resulting PHP code: @interface ClassModel protected: static string name (r+); array *constants (r+); array *properties (r+); array *methods (r+); int type (r+); + (array) *someMethod; @end @interface ClassConstantModel protected: string name (r+); string value (r+); @end @interface ClassPropertyModel protected: int access (r+); string name (r+); string type (r+); string defaultValue (r+); bool isReference (r+); int synthesizedAccess (r+); @end @interface ClassMethodModel protected: int access (r+); string name (r+); bool isStatic (r+); bool isReference (r+); string returnType (r+); array *arguments (r+); @end @interface ClassMethodArgumentModel protected: string name (r+); string type (r+); string defaultValue (r+); bool isReference (r+); @end @interface CodeParser public: - (void) __construct: (string)withContents; protected: string codeContents; array results (r); - (array) findAll; - (array) findIndividual: (int)offset; - (void) parse; @end <?php class ClassModel { /** * Protected Properties */ /** * @param string name */ protected static $_name; /** * @param array constants */ protected $_constants; /** * @param array properties */ protected $_properties; /** * @param array methods */ protected $_methods; /** * @param int type */ protected $_type; /** * @param string $name * @uses self::$_name * @return void */ public static function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } self::$_name = $name; } /** * @uses self::$_name * @return string name */ public static function getName(){ return self::$_name; } /** * @param array $constants * @uses self::$_constants * @return void */ public function setConstants(array $constants){ $this->_constants = $constants; } /** * @uses self::$_constants * @return array constants */ public function &getConstants(){ return $this->_constants; } /** * @param array $properties * @uses self::$_properties * @return void */ public function setProperties(array $properties){ $this->_properties = $properties; } /** * @uses self::$_properties * @return array properties */ public function &getProperties(){ return $this->_properties; } /** * @param array $methods * @uses self::$_methods * @return void */ public function setMethods(array $methods){ $this->_methods = $methods; } /** * @uses self::$_methods * @return array methods */ public function &getMethods(){ return $this->_methods; } /** * @param int $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_int($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return int type */ public function getType(){ return $this->_type; } /** * @return array */ protected static function &_someMethod(){ // Do Something Here } } class ClassConstantModel { /** * Protected Properties */ /** * @param string name */ protected $_name; /** * @param string value */ protected $_value; /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $value * @uses self::$_value * @return void */ public function setValue($value){ if(!(is_string($value))){ throw new Exception('Invalid types supplied to function.'); } $this->_value = $value; } /** * @uses self::$_value * @return string value */ public function getValue(){ return $this->_value; } } class ClassPropertyModel { /** * Protected Properties */ /** * @param int access */ protected $_access; /** * @param string name */ protected $_name; /** * @param string type */ protected $_type; /** * @param string defaultValue */ protected $_defaultValue; /** * @param bool isReference */ protected $_isReference; /** * @param int synthesizedAccess */ protected $_synthesizedAccess; /** * @param int $access * @uses self::$_access * @return void */ public function setAccess($access){ if(!(is_int($access))){ throw new Exception('Invalid types supplied to function.'); } $this->_access = $access; } /** * @uses self::$_access * @return int access */ public function getAccess(){ return $this->_access; } /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_string($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return string type */ public function getType(){ return $this->_type; } /** * @param string $defaultValue * @uses self::$_defaultValue * @return void */ public function setDefaultValue($defaultValue){ if(!(is_string($defaultValue))){ throw new Exception('Invalid types supplied to function.'); } $this->_defaultValue = $defaultValue; } /** * @uses self::$_defaultValue * @return string defaultValue */ public function getDefaultValue(){ return $this->_defaultValue; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } /** * @param int $synthesizedAccess * @uses self::$_synthesizedAccess * @return void */ public function setSynthesizedAccess($synthesizedAccess){ if(!(is_int($synthesizedAccess))){ throw new Exception('Invalid types supplied to function.'); } $this->_synthesizedAccess = $synthesizedAccess; } /** * @uses self::$_synthesizedAccess * @return int synthesizedAccess */ public function getSynthesizedAccess(){ return $this->_synthesizedAccess; } } class ClassMethodModel { /** * Protected Properties */ /** * @param int access */ protected $_access; /** * @param string name */ protected $_name; /** * @param bool isStatic */ protected $_isStatic; /** * @param bool isReference */ protected $_isReference; /** * @param string returnType */ protected $_returnType; /** * @param array arguments */ protected $_arguments; /** * @param int $access * @uses self::$_access * @return void */ public function setAccess($access){ if(!(is_int($access))){ throw new Exception('Invalid types supplied to function.'); } $this->_access = $access; } /** * @uses self::$_access * @return int access */ public function getAccess(){ return $this->_access; } /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param bool $isStatic * @uses self::$_isStatic * @return void */ public function setIsStatic($isStatic){ if(!(is_bool($isStatic))){ throw new Exception('Invalid types supplied to function.'); } $this->_isStatic = $isStatic; } /** * @uses self::$_isStatic * @return bool isStatic */ public function getIsStatic(){ return $this->_isStatic; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } /** * @param string $returnType * @uses self::$_returnType * @return void */ public function setReturnType($returnType){ if(!(is_string($returnType))){ throw new Exception('Invalid types supplied to function.'); } $this->_returnType = $returnType; } /** * @uses self::$_returnType * @return string returnType */ public function getReturnType(){ return $this->_returnType; } /** * @param array $arguments * @uses self::$_arguments * @return void */ public function setArguments(array $arguments){ $this->_arguments = $arguments; } /** * @uses self::$_arguments * @return array arguments */ public function &getArguments(){ return $this->_arguments; } } class ClassMethodArgumentModel { /** * Protected Properties */ /** * @param string name */ protected $_name; /** * @param string type */ protected $_type; /** * @param string defaultValue */ protected $_defaultValue; /** * @param bool isReference */ protected $_isReference; /** * @param string $name * @uses self::$_name * @return void */ public function setName($name){ if(!(is_string($name))){ throw new Exception('Invalid types supplied to function.'); } $this->_name = $name; } /** * @uses self::$_name * @return string name */ public function getName(){ return $this->_name; } /** * @param string $type * @uses self::$_type * @return void */ public function setType($type){ if(!(is_string($type))){ throw new Exception('Invalid types supplied to function.'); } $this->_type = $type; } /** * @uses self::$_type * @return string type */ public function getType(){ return $this->_type; } /** * @param string $defaultValue * @uses self::$_defaultValue * @return void */ public function setDefaultValue($defaultValue){ if(!(is_string($defaultValue))){ throw new Exception('Invalid types supplied to function.'); } $this->_defaultValue = $defaultValue; } /** * @uses self::$_defaultValue * @return string defaultValue */ public function getDefaultValue(){ return $this->_defaultValue; } /** * @param bool $isReference * @uses self::$_isReference * @return void */ public function setIsReference($isReference){ if(!(is_bool($isReference))){ throw new Exception('Invalid types supplied to function.'); } $this->_isReference = $isReference; } /** * @uses self::$_isReference * @return bool isReference */ public function getIsReference(){ return $this->_isReference; } } class CodeParser { /** * Public Properties */ /** * Protected Properties */ /** * @param string codeContents */ protected $_codeContents; /** * @param array results */ protected $_results; /** * @param string $withContents * @return void */ public function __construct($withContents){ if(!(is_string($withContents))){ throw new Exception('Invalid types supplied to function.'); } // Do Something Here } /** * @param string $codeContents * @uses self::$_codeContents * @return void */ protected function _setCodeContents($codeContents){ if(!(is_string($codeContents))){ throw new Exception('Invalid types supplied to function.'); } $this->_codeContents = $codeContents; } /** * @uses self::$_codeContents * @return string codeContents */ protected function _getCodeContents(){ return $this->_codeContents; } /** * @param array $results * @uses self::$_results * @return void */ protected function _setResults(array $results){ $this->_results = $results; } /** * @uses self::$_results * @return array results */ public function getResults(){ return $this->_results; } /** * @return array */ protected function _findAll(){ // Do Something Here } /** * @param int $offset * @return array */ protected function _findIndividual($offset){ if(!(is_int($offset))){ throw new Exception('Invalid types supplied to function.'); } // Do Something Here } /** * @return void */ protected function _parse(){ // Do Something Here } } ?> The code you see is real and was generated by my script. My script is able to understand protected, private, and public method/properties. Static and instance methods/properties. Methods that have referenced arguments, and return references. By default, a property defined will have synthesized methods (getters and setters). The access level of the synthesized methods will be in the same as that of the property. You'll notice things in my psuedo code like "(r+)" or "(r)". This defines what can be done in a public scope. r+ means that get and set will be public regardless of the scope of the property. r means only get will be public, and w means only set will be public. When defining a method, you set it to static using a '+' and instance using '-', just like Objective-C. You define arguments of the method by appending a colin and a list of arguments. eg: + (void) doSomething: (int)someNumber, (array)someArray; When a method has an argument, PHP doesn't automatically type check primatives, only objects. To solve for this, the script will apply type checking to your method. I plan to add a lot more on to this script; things like abstract classes/functions, interface methods, and implements/extends syntax. Once done, I plan to share this script via DonationWare on a website. You can pick your price on it, or if you don't have the money to spare you can use it for free. Until next time!