Class yii\apidoc\models\Context

                public function addFile($fileName)
{
    $this->files[$fileName] = sha1_file($fileName);
}

            

                public function getReflectionProject()
{
    $files = [];
    foreach ($this->files as $fileName => $hash) {
        $files[] = new LocalFile($fileName);
    }
    $projectFactory = ProjectFactory::createInstance();
    $docBlockFactory = DocBlockFactory::createInstance();
    $priority = 1200;
    $projectFactory->addStrategy(new ClassConstantFactory($docBlockFactory, new PrettyPrinter()), $priority);
    $projectFactory->addStrategy(new PropertyFactory($docBlockFactory, new PrettyPrinter()), $priority);
    return $projectFactory->create('ApiDoc', $files);
}

            

                public function getType($type)
{
    $type = ltrim($type, '\\');
    if (isset($this->classes[$type])) {
        return $this->classes[$type];
    }
    if (isset($this->interfaces[$type])) {
        return $this->interfaces[$type];
    }
    if (isset($this->traits[$type])) {
        return $this->traits[$type];
    }
    return null;
}

            

                protected function handleClassInheritance($class)
{
    $parents = $this->getParents($class);
    if (!$parents) {
        return;
    }
    $attrNames = ['events', 'constants', 'properties', 'methods'];
    foreach ($parents as $parent) {
        $parent = $this->classes[$parent->name];
        foreach ($attrNames as $attrName) {
            foreach ($parent->$attrName as $item) {
                if (
                    isset($class->$attrName[$item->name]) &&
                    !isset($this->traits[$class->$attrName[$item->name]->definedBy])
                ) {
                    continue;
                }
                $class->$attrName[$item->name] = $item;
            }
        }
    }
}

            

                protected function handlePropertyFeature($class)
{
    if (!$this->isSubclassOf($class, 'yii\base\BaseObject')) {
        return;
    }
    foreach ($class->getPublicMethods() as $name => $method) {
        if ($method->isStatic) {
            continue;
        }
        if (!strncmp($name, 'get', 3) && strlen($name) > 3 && $this->hasNonOptionalParams($method)) {
            $propertyName = '$' . lcfirst(substr($method->name, 3));
            $property = isset($class->properties[$propertyName]) ? $class->properties[$propertyName] : null;
            if ($property && $property->getter === null && $property->setter === null) {
                $this->errors[] = [
                    'line' => $property->startLine,
                    'file' => $class->sourceFile,
                    'message' => "Property $propertyName conflicts with a defined getter {$method->name} in {$class->name}.",
                ];
            } else {
                // Override the setter-defined property if it exists already
                $class->properties[$propertyName] = new PropertyDoc(null, $this, [
                    'name' => $propertyName,
                    'fullName' => "$class->name::$propertyName",
                    'definedBy' => $method->definedBy,
                    'sourceFile' => $class->sourceFile,
                    'visibility' => 'public',
                    'isStatic' => false,
                    'type' => $method->returnType,
                    'types' => $method->returnTypes,
                    'shortDescription' => BaseDoc::extractFirstSentence($method->return),
                    'description' => $method->return,
                    'since' => $method->since,
                    'getter' => $method,
                    'setter' => isset($property->setter) ? $property->setter : null,
                    // TODO set default value
                ]);
            }
        }
        if (!strncmp($name, 'set', 3) && strlen($name) > 3 && $this->hasNonOptionalParams($method, 1)) {
            $propertyName = '$' . lcfirst(substr($method->name, 3));
            $property = isset($class->properties[$propertyName]) ? $class->properties[$propertyName] : null;
            if ($property) {
                if ($property->getter === null && $property->setter === null) {
                    $this->errors[] = [
                        'line' => $property->startLine,
                        'file' => $class->sourceFile,
                        'message' => "Property $propertyName conflicts with a defined setter {$method->name} in {$class->name}.",
                    ];
                } else {
                    // Just set the setter
                    $property->setter = $method;
                }
            } else {
                $param = $this->getFirstNotOptionalParameter($method);
                $class->properties[$propertyName] = new PropertyDoc(null, $this, [
                    'name' => $propertyName,
                    'fullName' => "$class->name::$propertyName",
                    'definedBy' => $method->definedBy,
                    'sourceFile' => $class->sourceFile,
                    'visibility' => 'public',
                    'isStatic' => false,
                    'type' => $param->type,
                    'types' => $param->types,
                    'shortDescription' => BaseDoc::extractFirstSentence($param->description),
                    'description' => $param->description,
                    'since' => $method->since,
                    'setter' => $method,
                ]);
            }
        }
    }
}

            

                protected function handleTraitInheritance($class)
{
    foreach ($class->traits as $traitName) {
        if (!isset($this->traits[$traitName])) {
            continue;
        }
        $trait = $this->traits[$traitName];
        $trait->usedBy[] = $class->name;
        foreach ($trait->properties as $property) {
            if (!isset($class->properties[$property->name])) {
                $class->properties[$property->name] = $property;
            }
        }
        foreach ($trait->methods as $method) {
            if (!isset($class->methods[$method->name])) {
                $class->methods[$method->name] = $method;
            }
        }
    }
}

            

                protected function inheritDocs($class)
{
    // inherit for properties
    foreach ($class->properties as $p) {
        if ($p->hasTag('inheritdoc') && ($inheritTag = $p->getFirstTag('inheritdoc')) !== null) {
            $inheritedProperty = $this->inheritPropertyRecursive($p, $class);
            if (!$inheritedProperty) {
                $this->errors[] = [
                    'line' => $p->startLine,
                    'file' => $class->sourceFile,
                    'message' => "Property {$p->name} has no parent to inherit from in {$class->name}.",
                ];
                continue;
            }
            // set all properties that are empty.
            foreach (['shortDescription', 'type', 'types', 'since'] as $property) {
                if (empty($p->$property) || is_string($p->$property) && trim($p->$property) === '') {
                    // only copy @since if the package names are equal (or missing)
                    if ($property === 'since' && $p->getPackageName() !== $inheritedProperty->getPackageName()) {
                        continue;
                    }
                    $p->$property = $inheritedProperty->$property;
                }
            }
            // descriptions will be concatenated.
            $p->description = implode("\n\n", [
                trim($p->description),
                trim($inheritedProperty->description),
                $inheritTag->getDescription(),
            ]);
            $p->removeTag('inheritdoc');
        }
    }
    // inherit for methods
    foreach ($class->methods as $m) {
        if ($m->hasTag('inheritdoc') && ($inheritTag = $m->getFirstTag('inheritdoc')) !== null) {
            $inheritedMethod = $this->inheritMethodRecursive($m, $class);
            if (!$inheritedMethod) {
                $this->errors[] = [
                    'line' => $m->startLine,
                    'file' => $class->sourceFile,
                    'message' => "Method {$m->name} has no parent to inherit from in {$class->name}.",
                ];
                continue;
            }
            // set all properties that are empty.
            foreach (['shortDescription', 'return', 'returnType', 'returnTypes', 'exceptions', 'since'] as $property) {
                if (empty($m->$property) || is_string($m->$property) && trim($m->$property) === '') {
                    // only copy @since if the package names are equal (or missing)
                    if ($property === 'since' && $m->getPackageName() !== $inheritedMethod->getPackageName()) {
                        continue;
                    }
                    $m->$property = $inheritedMethod->$property;
                }
            }
            // descriptions will be concatenated.
            $m->description = implode("\n\n", [
                trim($m->description),
                trim($inheritedMethod->description),
                $inheritTag->getDescription(),
            ]);
            foreach ($m->params as $i => $param) {
                if (!isset($inheritedMethod->params[$i])) {
                    $this->errors[] = [
                        'line' => $m->startLine,
                        'file' => $class->sourceFile,
                        'message' => "Method param $i does not exist in parent method, @inheritdoc not possible in {$m->name} in {$class->name}.",
                    ];
                    continue;
                }
                if (empty($param->description) || trim($param->description) === '') {
                    $param->description = $inheritedMethod->params[$i]->description;
                }
                if (empty($param->type) || trim($param->type) === '') {
                    $param->type = $inheritedMethod->params[$i]->type;
                }
                if (empty($param->types)) {
                    $param->types = $inheritedMethod->params[$i]->types;
                }
            }
            $m->removeTag('inheritdoc');
        }
    }
}

            

                protected function isSubclassOf($classA, $classB)
{
    if (is_object($classB)) {
        $classB = $classB->name;
    }
    if ($classA->name == $classB) {
        return true;
    }
    while ($classA->parentClass !== null && isset($this->classes[$classA->parentClass])) {
        $classA = $this->classes[$classA->parentClass];
        if ($classA->name == $classB) {
            return true;
        }
    }
    return false;
}

            

                public function processFiles()
{
    $projectFiles = $this->getReflectionProject()->getFiles();
    foreach ($this->files as $fileName => $hash) {
        $reflection = $projectFiles[$fileName];
        $this->parseFile($reflection, $fileName);
    }
}

            

                public function updateReferences()
{
    // update all subclass references
    foreach ($this->classes as $class) {
        $className = $class->name;
        while (isset($this->classes[$class->parentClass])) {
            $class = $this->classes[$class->parentClass];
            $class->subclasses[] = $className;
        }
    }
    // update interfaces of subclasses
    foreach ($this->classes as $class) {
        $this->updateSubclassInterfacesTraits($class);
    }
    // update implementedBy and usedBy for traits
    foreach ($this->classes as $class) {
        $this->handleTraitInheritance($class);
    }
    foreach ($this->interfaces as $interface) {
        foreach ($interface->parentInterfaces as $pInterface) {
            if (isset($this->interfaces[$pInterface])) {
                $this->interfaces[$pInterface]->implementedBy[] = $interface->name;
            }
        }
    }
    // inherit docs
    foreach ($this->classes as $class) {
        $this->inheritDocs($class);
    }
    // inherit properties, methods, constants and events from parent classes
    foreach ($this->classes as $class) {
        $this->handleClassInheritance($class);
    }
    // update implementedBy and usedBy for interfaces
    foreach ($this->classes as $class) {
        foreach ($class->interfaces as $interface) {
            if (!isset($this->interfaces[$interface])) {
                continue;
            }
            $this->interfaces[$interface]->implementedBy[] = $class->name;
            if (!$class->isAbstract) {
                continue;
            }
            // add not implemented interface methods
            foreach ($this->interfaces[$interface]->methods as $method) {
                if (!isset($class->methods[$method->name])) {
                    $class->methods[$method->name] = $method;
                }
            }
        }
    }
    foreach ($this->interfaces as $interface) {
        $this->updateSubInterfaceInheritance($interface);
    }
    // add properties from getters and setters
    foreach ($this->classes as $class) {
        $this->handlePropertyFeature($class);
    }
    // TODO reference exceptions to methods where they are thrown
}

            

                protected function updateSubInterfaceInheritance($interface)
{
    foreach ($interface->implementedBy as $name) {
        if (!isset($this->interfaces[$name])) {
            continue;
        }
        $subInterface = $this->interfaces[$name];
        $subInterface->methods = array_merge($interface->methods, $subInterface->methods);
        $this->updateSubInterfaceInheritance($subInterface);
    }
}

            

                protected function updateSubclassInheritance($class)
{
    foreach ($class->subclasses as $subclass) {
        $subclass = $this->classes[$subclass];
        $subclass->events = array_merge($class->events, $subclass->events);
        $subclass->constants = array_merge($class->constants, $subclass->constants);
        $subclass->properties = array_merge($class->properties, $subclass->properties);
        $subclass->methods = array_merge($class->methods, $subclass->methods);
        $this->updateSubclassInheritance($subclass);
    }
}

            

                protected function updateSubclassInterfacesTraits($class)
{
    foreach ($class->subclasses as $subclass) {
        $subclass = $this->classes[$subclass];
        $subclass->interfaces = array_unique(array_merge($subclass->interfaces, $class->interfaces));
        $subclass->traits = array_unique(array_merge($subclass->traits, $class->traits));
        $this->updateSubclassInterfacesTraits($subclass);
    }
}