Changed php version.

Disregard the last comment about leaving out PHPDocumentor-style annotations.  In retrospect, that would not be a good idea.  I think a better idea would be to specify a custom tag specifically for SCA.  I was thinking about something like @scaExcludeMethod true/false.  If you don't specify it, then it assumes you don't want to exclude and if you do specify it, you can toggle the display.

Apparently you guys already had this in mind, so I finished it:

--- SCA_AnnotationReader.php.orig	2007-08-30 17:50:40.000000000 -0500
+++ SCA_AnnotationReader.php	2007-08-30 17:51:05.000000000 -0500
@@ -222,13 +222,13 @@
                 $methodAnnotations =
                 SCA_AnnotationRules::createEmptyAnnotationArray();
                 $comment = $public_method->getDocComment();
-
+                $isWebMethod = true;
                 /* When the method has a doc comment ....                     */
                 if ( $comment != false ) {
                     $method_reader = new SCA_CommentReader($comment);
-
+                    $isWebMethod = $method_reader->isWebMethod();
                     /* ... and the method a web service method ....           */
-                    if ($method_reader->isWebMethod()) {
+                    if ($isWebMethod) {
                         /* ... decode any method annotations.                 */
                         $methodAnnotations =
                         $method_reader->getMethodAnnotations();
@@ -280,7 +280,8 @@
                 }/* End comment has value                                      */
 
                 /* Save the annotation set indexed by the method name.         */
-                $operations[$public_method->getName()] = $methodAnnotations ;
+                if ($isWebMethod)
+                    $operations[$public_method->getName()] = $methodAnnotations ;
 
             }/* End every method                                               */
 



--- SCA_CommentReader.php.orig	2007-08-30 17:50:55.000000000 -0500
+++ SCA_CommentReader.php	2007-08-30 17:51:10.000000000 -0500
@@ -417,8 +417,8 @@
 
         public function isWebMethod()
         {
-            // currently exposing all methods if the class is a web service
-            // leave this test in place in case we want to change our mind
+            if ($this->_hasAnnotation('webmethod') && ! $this->_getBooleanFollowing('webmethod'))
+                return false;
             return true;
         }

Thanks for the feedback and suggested enhancement.  The current behavior is by design, making use of existing language visibility construct (public, private, etc) to identify those methods which should be available on the Web service.  I'd imagined using delegation in these kinds of scenarios where the Web service is a front-end for the real implementation (still a bit clunky :-( ).

I do have a concern about adding more annotations for cases which are perhaps not in the 80-20 and where there are alternative approach (albeit not ideal).  We did have the intention to also support annotated interfaces and I wonder whether this would be a suitable alternative (I don't think this is supported today).  So, for example, having the @service on the interface and not the implementation would say that only the public methods defined by that interface should be exposed.  Or perhaps having the @service on an implementation identify the service interface (this is how it is handled in SCA Java).

Mine is just one opinion, and for this kind of feature request, I think it would be good to raise it on the phpsoa google group.  I've put a quick post there pointing to this request (see http://groups.google.co.uk/group/phpsoa/browse_thread/thread/1b11c0e6bc0cf441/#).  I hope you'll be happy to follow/contribute to the discussion there.

Thanks again for the feedback.

This bug has been fixed in CVS.

In case this was a documentation problem, the fix will show up at the
end of next Sunday (CET) on pecl.php.net.

In case this was a pecl.php.net website problem, the change will show
up on the website in short time.
 
Thank you for the report, and for helping us make PECL better.

The code/unit tests to support this have now been checked into the FULMAR branch.  The service operations made available can now be controlled by specifying an interface in the @service annotation (e.g @service MyServiceInterface). 

Note, because of the different way in which PHP defines standalone classes versus those which extend classes or implement interfaces, the include for SCA.php much come after the service implementation class declaration.  

For example:

<?php

require 'MyPrivateInterface.php';
require 'MyServiceInterface.php';


/**
 * MyService with a nonServiceMethod
 * @service MyServiceInterface
 *
 */
class MyService implements MyServiceInterface, MyPrivateInterface {

    /**
     * A method that I don't want to appear
     *
     */
    public function nonServiceMethod() {}
    
    /**
     * A private method that should not appear
     *
     */
    private function privateMethod() {}
    
    /**
     * My first service method defined in MyServiceInterface
     *
     * @param string $in1
     * @return float
     */
    public function serviceMethod1($in1) {}
    
    /**
     * My second service method defined in MyServiceInterface
     *
     * @param string $in1
     * @param float $in2
     * @return integer
     */
    public function serviceMethod2($in1, $in2) {}

}

include 'SCA/SCA.php';

?>