Merge pull request php-annotations#94 from php-annotations/stop-inheritance

Don't inherit class/property/method annotations after finding `@stop` annotation on class level

Author: Alexander Obuhovich

src/annotations/AnnotationManager.php

@@ -83,6 +83,7 @@ class AnnotationManager
         'throws'         => false,
         'type'           => 'mindplay\annotations\standard\TypeAnnotation',
         'usage'          => 'mindplay\annotations\UsageAnnotation',
+        'stop'           => 'mindplay\annotations\StopAnnotation',
         'uses'           => false,
         'var'            => 'mindplay\annotations\standard\VarAnnotation',
         'version'        => false,
@@ -247,19 +248,10 @@ protected function getAnnotations($class_name, $member_type = self::MEMBER_CLASS
 
         if (!isset($this->initialized[$key])) {
             $annotations = array();
+            $classAnnotations = array();
 
             if ($member_type !== self::MEMBER_CLASS) {
-                $this->getAnnotations($class_name, self::MEMBER_CLASS);
-            }
-
-            if ($parent = get_parent_class($class_name)) {
-                if ($parent !== __NAMESPACE__ . '\Annotation') {
-                    foreach ($this->getAnnotations($parent, $member_type, $member_name) as $annotation) {
-                        if ($this->getUsage(get_class($annotation))->inherited) {
-                            $annotations[] = $annotation;
-                        }
-                    }
-                }
+                $classAnnotations = $this->getAnnotations($class_name, self::MEMBER_CLASS);
             }
 
             $reflection = new \ReflectionClass($class_name);
@@ -268,6 +260,8 @@ protected function getAnnotations($class_name, $member_type = self::MEMBER_CLASS
                 $file = $this->getAnnotationFile($reflection->getFileName());
             }
 
+            $inherit = true; // inherit parent annotations unless directed not to
+
             if (isset($file) && isset($file->data[$key])) {
                 foreach ($file->data[$key] as $spec) {
                     $name = $spec['#name']; // currently unused
@@ -293,6 +287,30 @@ protected function getAnnotations($class_name, $member_type = self::MEMBER_CLASS
 
                     $annotations[] = $annotation;
                 }
+
+                if ($member_type === self::MEMBER_CLASS) {
+                    $classAnnotations = $annotations;
+                }
+            }
+
+            foreach ($classAnnotations as $classAnnotation) {
+                if ($classAnnotation instanceof StopAnnotation) {
+                    $inherit = false; // do not inherit parent annotations
+                }
+            }
+
+            if ($inherit && $parent = get_parent_class($class_name)) {
+                $parent_annotations = array();
+
+                if ($parent !== __NAMESPACE__ . '\Annotation') {
+                    foreach ($this->getAnnotations($parent, $member_type, $member_name) as $annotation) {
+                        if ($this->getUsage(get_class($annotation))->inherited) {
+                            $parent_annotations[] = $annotation;
+                        }
+                    }
+                }
+
+                $annotations = array_merge($parent_annotations, $annotations);
             }
 
             $this->annotations[$key] = $this->applyConstraints($annotations, $member_type);

src/annotations/StopAnnotation.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * This file is part of the php-annotation framework.
+ *
+ * (c) Rasmus Schultz <[email protected]>
+ *
+ * This software is licensed under the GNU LGPL license
+ * for more information, please see:
+ *
+ * <https://github.com/mindplay-dk/php-annotations>
+ */
+
+namespace mindplay\annotations;
+
+/**
+ * This Annotation indicates that parent class should not be parsed for annotations.
+ *
+ * @usage('class'=>true)
+ */
+class StopAnnotation extends Annotation
+{
+
+
+}

test/suite/Annotations.case.php

@@ -196,6 +196,67 @@ public function run()
     }
 }
 
+/**
+ * @Note('class-first')
+ */
+class FirstClass
+{
+    /**
+     * @var string
+     * @Note('prop-first')
+     */
+    protected $prop;
+
+    /**
+     * @Note('method-first')
+     */
+    protected function someMethod()
+    {
+
+    }
+}
+
+/**
+ * @Note('class-second')
+ * @stop
+ */
+class SecondClass extends FirstClass
+{
+    /**
+     * @var string
+     * @Note('prop-second')
+     */
+    protected $prop;
+
+    /**
+     * @Note('method-second')
+     */
+    protected function someMethod()
+    {
+
+    }
+}
+
+/**
+ * @Note('class-third')
+ */
+class ThirdClass extends SecondClass
+{
+    /**
+     * @var string
+     * @Note('prop-third')
+     */
+    protected $prop;
+
+    /**
+     * @Note('method-third')
+     */
+    protected function someMethod()
+    {
+
+    }
+}
+
 
 /**
  * Test that using an core class will not break parsing.

test/suite/Annotations.test.php

@@ -743,6 +743,57 @@ protected function assertApplyConstrains(array &$annotations, $memberType)
         $this->check(count($annotations) > 0);
     }
 
+    public function testStopAnnotationPreventsClassLevelAnnotationInheritance()
+    {
+        $annotations = Annotations::ofClass('SecondClass', '@note');
+        $this->check(count($annotations) === 1, 'class level annotation after own "@stop" not present');
+        $this->check($annotations[0]->note === 'class-second', 'non-inherited annotation goes first');
+
+        $annotations = Annotations::ofClass('ThirdClass', '@note');
+        $this->check(count($annotations) === 2, 'class level annotation after parent "@stop" not present');
+        $this->check($annotations[0]->note === 'class-second', 'inherited annotation goes first');
+        $this->check($annotations[1]->note === 'class-third', 'non-inherited annotation goes second');
+    }
+
+    public function testStopAnnotationPreventsPropertyLevelAnnotationInheritance()
+    {
+        $annotations = Annotations::ofProperty('SecondClass', 'prop', '@note');
+        $this->check(count($annotations) === 1, 'property level annotation after own "@stop" not present');
+        $this->check($annotations[0]->note === 'prop-second', 'non-inherited annotation goes first');
+
+        $annotations = Annotations::ofProperty('ThirdClass', 'prop', '@note');
+        $this->check(count($annotations) === 2, 'property level annotation after parent "@stop" not present');
+        $this->check($annotations[0]->note === 'prop-second', 'inherited annotation goes first');
+        $this->check($annotations[1]->note === 'prop-third', 'non-inherited annotation goes second');
+    }
+
+    public function testStopAnnotationPreventsMethodLevelAnnotationInheritance()
+    {
+        $annotations = Annotations::ofMethod('SecondClass', 'someMethod', '@note');
+        $this->check(count($annotations) === 1, 'method level annotation after own "@stop" not present');
+        $this->check($annotations[0]->note === 'method-second', 'non-inherited annotation goes first');
+
+        $annotations = Annotations::ofMethod('ThirdClass', 'someMethod', '@note');
+        $this->check(count($annotations) === 2, 'method level annotation after parent "@stop" not present');
+        $this->check($annotations[0]->note === 'method-second', 'inherited annotation goes first');
+        $this->check($annotations[1]->note === 'method-third', 'non-inherited annotation goes second');
+    }
+
+    public function testDirectAccessToClassIgnoresStopAnnotation()
+    {
+        $annotations = Annotations::ofClass('FirstClass', '@note');
+        $this->check(count($annotations) === 1);
+        $this->check($annotations[0]->note === 'class-first');
+
+        $annotations = Annotations::ofProperty('FirstClass', 'prop', '@note');
+        $this->check(count($annotations) === 1);
+        $this->check($annotations[0]->note === 'prop-first');
+
+        $annotations = Annotations::ofMethod('FirstClass', 'someMethod', '@note');
+        $this->check(count($annotations) === 1);
+        $this->check($annotations[0]->note === 'method-first');
+    }
+
     protected function testFilterUnresolvedAnnotationClass()
     {
         $annotations = Annotations::ofClass('TestBase', false);