Jan 05

AMFPHP: methodTable automation

AMFPHP Add comments

Problem: The methodTable property can be a real pain to maintain updated throughout the creation of a service class. It's a lot of coding/writing when dealing with big classes. Changes and additions to the service class require you to update the methodTable which can be very time consuming.

Solution: Automate the creation of the methodTable.

Discussion: When you look at the structure of a methodTable, you'll find the different method names, descriptions, access properties, parameters, etc.

PLAIN TEXT
PHP:
  1. $this->methodTable =  array(
  2.   "getParkTypes" => array(
  3.     "description" => "Returns list of park types",
  4.     "access" => "remote",
  5.     "arguments" => array ("arg1") ),
  6.   "getParksList" => array(
  7.     "description" => "Shows list of parks given a park type",
  8.     "access" => "remote",
  9.     "arguments" => array ("parkType") ),
  10.   "getParkDetails" => array(
  11.     "description" => "Return details on a park give the parkname",
  12.     "access" => "remote",
  13.     "arguments" => array ("parkName")
  14.   )
  15. );

Most of these properties are allready in your code when creating a method. You write down the name of your method and add parameters as your method needs them. So adding them to your methodtable is really double work. In an ideal situation you've also added comments to your code. These can hold a description for the method and, writing a service class, also have its access defined.

PHP 5 now comes with a reflection API which lets you reverse-engineer a class. Using it, we can easily look up the properties we need to add to the methodtable. The method's name and parameters for instance, but also the comment that comes with the method. The description and access property need to be filtered out of the comment.

Putting this all together, we have the ability to create the methodTable in an automated way. After writing a class that does so, the only thing we need to do is call that class in the constructor of our service class.

Following is the source code of the MethodTable class I wrote.
In order to use it, follow these steps.

- include the class in your webservice class

PLAIN TEXT
PHP:
  1. require_once("MethodTable.php");

- In your constructor: call the create method and assign its return value to the methodTable property of your class.

PLAIN TEXT
PHP:
  1. $this->methodTable = MethodTable::create($this);

Here's the source code:

PLAIN TEXT
PHP:
  1. /**
  2. * MethodTable class.
  3. *
  4. * This class uses the Reflection API introduced in PHP 5 to create the methodTable
  5. * property for a service class. In order to create it, the MethodTable::create()
  6. * method must be called in the constructor of the service class.
  7. *
  8. * Example:
  9. *
  10. * require_once("MethodTable.php");
  11. *
  12. * class MyService
  13. * {
  14. * function MyService(){
  15. * $this->methodTable = MethodTable::create($this);
  16. * }
  17. * }
  18. *
  19. * The method's name and parameters will be read from the method signature.
  20. * To add the description and access param to the methodTable, you must write them
  21. * down in the comment of your method using PHPDOC comment syntax.
  22. *
  23. * The description is just plain text.
  24. * The access param uses the @access tag.
  25. *
  26. * Example:
  27. */
  28. /**
  29. * Returns the list of users.
  30. * @access remote
  31. */
  32. /**
  33. *
  34. * @author Christophe Herreman (http://www.herrodius.com)
  35. * @version 1.0
  36. * @since 12/11/2004
  37. */
  38.  
  39. class MethodTable
  40. {
  41. /**
  42. * Creates the methodTable of a service class.
  43. *
  44. * @param $serviceClass The reference to the service class.
  45. * @return Array
  46. */
  47. static public function create($serviceClass){
  48.   $className = get_class($serviceClass);
  49.   $class = new ReflectionClass($className);
  50.   $methods = $class->getMethods();
  51.   $methodTable = array();
  52.  
  53.   foreach($methods as $method){
  54.     $reflectionMethod = new ReflectionMethod($className, $method->name);
  55.     $methodComment = $method->getDocComment();
  56.  
  57.     $methodTableEntry = array();
  58.     $methodTableEntry['access'] = MethodTable::getAccess($methodComment);
  59.     $methodTableEntry['description'] = $reflectionMethod->getDocComment();
  60.     $methodTableEntry['arguments'] = MethodTable::getParameters($reflectionMethod->getParameters());
  61.  
  62.     $methodTable[$method->name] = $methodTableEntry;
  63.   }
  64.  
  65.   return $methodTable;
  66. }
  67.  
  68.  
  69.  
  70. /**
  71. * Returns the access property of a method.
  72. *
  73. * @param $methodComment The comment of the method as returned from the reflection API.
  74. * @return String
  75. */
  76. static private function getAccess($methodComment){
  77.   return MethodTable::getTagComment($methodComment, "@access");
  78. }
  79.  
  80. /**
  81. * Returns the parameters from a ReflectionParameter list.
  82. *
  83. * @param $reflectionParameter An instance of ReflectionParameter.
  84. * @return Array
  85. */
  86. static private function getParameters($reflectionParameter){
  87.   $parameters = array();
  88.  
  89.   foreach($reflectionParameter as $parameter){
  90.     $parameters[] = $parameter->getName();
  91.   }
  92.  
  93.   return $parameters;
  94. }
  95.  
  96.  
  97.  
  98. /**
  99. * Returns the comment next to a tag.
  100. *
  101. * @param $comment The comment of the method.
  102. * @param $tag The tag to return its comment from.
  103. * @return String
  104. */
  105. static private function getTagComment($comment, $tag){
  106.   $tagPosition = strpos ($comment, $tag);
  107.  
  108.   if ($tagPosition === false){
  109.     return;
  110.   }
  111.  
  112.   $comment = trim(substr($comment, $tagPosition + strlen($tag)));
  113.   $tagComment = substr($comment, 0, strpos($comment, chr(13)));
  114.  
  115.   return $tagComment;
  116. }
  117. }

Update: I added this file to the AMFPHP CVS today (10/01/2005).
The project can be viewed at http://www.sourceforge.net/projects/amfphp/

Add to Bloglines - Digg This! - del.icio.us - Stumble It! - Twit This! - Technorati links - Share on Facebook - Feedburner
 

3 Responses to “AMFPHP: methodTable automation”

  1. gerard Says:
    January 9th, 2005 at 7:33 pm

    nice
    maar als ik de code wil kopiëren, worden die regelnummers mee gekopieerd
    wel vervelend :)

  2. Christophe Says:
    January 10th, 2005 at 9:06 pm

    Hallo,

    De file werd toegevoegd aan de AMFPHP CVS. Zie update in post.

    Christophe

  3. Omid Says:
    February 7th, 2008 at 12:56 am

    Perfect guide .I hope you write more about amfphp in future ;)

Leave a Reply

WP Theme & Icons by N.Design Studio
Entries RSS Comments RSS Login