Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "private", "function", "getArtifactPath", "(", "Transformation", "$", "transformation", ")", "{", "return", "$", "transformation", "->", "getArtifact", "(", ")", "?", "$", "transformation", "->", "getTransformer", "(", ")", "->", "getTarget", "(", ")", ".", "DIRECTORY_SEPARATOR", ".", "$", "transformation", "->", "getArtifact", "(", ")", ":", "null", ";", "}" ]

[ "Returns", "the", "path", "to", "the", "location", "where", "the", "artifact", "should", "be", "written", "or", "null", "to", "automatically", "detect", "the", "location", "using", "the", "router", "." ]

[ "protected", "function", "configure", "(", ")", ":", "void", "{", "$", "this", "->", "setAliases", "(", "[", "'transform'", "]", ")", "->", "setDescription", "(", "'Converts the PHPDocumentor structure file to documentation'", ")", "->", "setHelp", "(", "\n <<<TEXT\n This task will execute the transformation rules described in the given\n template (defaults to 'responsive') with the given source (defaults to\n output/structure.xml) and writes these to the target location (defaults to\n 'output').\n \n It is possible for the user to receive additional information using the\n verbose option or stop additional information using the quiet option. Please\n take note that the quiet option also disables logging to file.\nTEXT", ")", ";", "$", "this", "->", "addOption", "(", "'source'", ",", "'s'", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'Path where the XML source file is located (optional)'", ")", ";", "$", "this", "->", "addOption", "(", "'target'", ",", "'t'", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'Path where to store the generated output (optional)'", ")", ";", "$", "this", "->", "addOption", "(", "'template'", ",", "null", ",", "InputOption", "::", "VALUE_OPTIONAL", "|", "InputOption", "::", "VALUE_IS_ARRAY", ",", "'Name of the template to use (optional)'", ")", ";", "parent", "::", "configure", "(", ")", ";", "}" ]

[ "Initializes", "this", "command", "and", "sets", "the", "name", "description", "options", "and", "arguments", "." ]

[ "protected", "function", "execute", "(", "InputInterface", "$", "input", ",", "OutputInterface", "$", "output", ")", ":", "int", "{", "$", "pipeLine", "=", "$", "this", "->", "pipeline", ";", "$", "pipeLine", "(", "$", "input", "->", "getOptions", "(", ")", ")", ";", "return", "0", ";", "}" ]

[ "Executes", "the", "business", "logic", "involved", "with", "this", "command", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "constantDescriptor", "=", "new", "ConstantDescriptor", "(", ")", ";", "$", "constantDescriptor", "->", "setName", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "constantDescriptor", "->", "setValue", "(", "$", "data", "->", "getValue", "(", ")", ")", ";", "// Reflection library formulates namespace as global but this is not wanted for phpDocumentor itself", "$", "constantDescriptor", "->", "setNamespace", "(", "substr", "(", "(", "string", ")", "$", "data", "->", "getFqsen", "(", ")", ",", "0", ",", "-", "strlen", "(", "$", "data", "->", "getName", "(", ")", ")", "-", "static", "::", "SEPARATOR_SIZE", ")", ")", ";", "$", "constantDescriptor", "->", "setFullyQualifiedStructuralElementName", "(", "$", "data", "->", "getFqsen", "(", ")", ")", ";", "$", "this", "->", "assembleDocBlock", "(", "$", "data", "->", "getDocBlock", "(", ")", ",", "$", "constantDescriptor", ")", ";", "$", "constantDescriptor", "->", "setLine", "(", "$", "data", "->", "getLocation", "(", ")", "->", "getLineNumber", "(", ")", ")", ";", "return", "$", "constantDescriptor", ";", "}" ]

[ "Creates", "a", "Descriptor", "from", "the", "provided", "data", "." ]

[ "protected", "function", "setValueAndCheckIfModified", "(", "$", "propertyName", ",", "$", "value", ")", "{", "if", "(", "$", "this", "->", "{", "$", "propertyName", "}", "!==", "$", "value", ")", "{", "$", "this", "->", "isModified", "=", "true", ";", "}", "$", "this", "->", "{", "$", "propertyName", "}", "=", "$", "value", ";", "}" ]

[ "Sets", "a", "property", "s", "value", "and", "if", "it", "differs", "from", "the", "previous", "then", "mark", "these", "settings", "as", "modified", "." ]

[ "public", "function", "load", "(", "$", "nameOrPath", ")", "{", "$", "template", "=", "$", "this", "->", "factory", "->", "get", "(", "$", "nameOrPath", ")", ";", "/** @var Transformation $transformation */", "foreach", "(", "$", "template", "as", "$", "transformation", ")", "{", "/** @var WriterAbstract $writer */", "$", "writer", "=", "$", "this", "->", "writerCollection", "[", "$", "transformation", "->", "getWriter", "(", ")", "]", ";", "if", "(", "$", "writer", ")", "{", "$", "writer", "->", "checkRequirements", "(", ")", ";", "}", "}", "$", "this", "[", "$", "template", "->", "getName", "(", ")", "]", "=", "$", "template", ";", "}" ]

[ "Loads", "a", "template", "with", "the", "given", "name", "or", "file", "path", "." ]

[ "public", "function", "getTransformations", "(", ")", "{", "$", "result", "=", "[", "]", ";", "foreach", "(", "$", "this", "as", "$", "template", ")", "{", "foreach", "(", "$", "template", "as", "$", "transformation", ")", "{", "$", "result", "[", "]", "=", "$", "transformation", ";", "}", "}", "return", "$", "result", ";", "}" ]

[ "Returns", "a", "list", "of", "all", "transformations", "contained", "in", "the", "templates", "of", "this", "collection", "." ]

[ "public", "function", "filter", "(", "$", "value", ")", "{", "if", "(", "$", "value", "instanceof", "VisibilityInterface", "&&", "!", "$", "this", "->", "builder", "->", "isVisibilityAllowed", "(", "$", "value", "->", "getVisibility", "(", ")", ")", ")", "{", "return", "null", ";", "}", "return", "$", "value", ";", "}" ]

[ "Filter", "Descriptor", "with", "based", "on", "visibility", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "classDescriptor", "=", "new", "ClassDescriptor", "(", ")", ";", "$", "classDescriptor", "->", "setFullyQualifiedStructuralElementName", "(", "$", "data", "->", "getFqsen", "(", ")", ")", ";", "$", "classDescriptor", "->", "setName", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "classDescriptor", "->", "setPackage", "(", "$", "this", "->", "extractPackageFromDocBlock", "(", "$", "data", "->", "getDocBlock", "(", ")", ")", "?", ":", "$", "this", "->", "getBuilder", "(", ")", "->", "getDefaultPackage", "(", ")", ")", ";", "$", "classDescriptor", "->", "setLine", "(", "$", "data", "->", "getLocation", "(", ")", "->", "getLineNumber", "(", ")", ")", ";", "$", "classDescriptor", "->", "setParent", "(", "$", "data", "->", "getParent", "(", ")", ")", ";", "$", "classDescriptor", "->", "setAbstract", "(", "$", "data", "->", "isAbstract", "(", ")", ")", ";", "$", "classDescriptor", "->", "setFinal", "(", "$", "data", "->", "isFinal", "(", ")", ")", ";", "$", "classDescriptor", "->", "setNamespace", "(", "substr", "(", "(", "string", ")", "$", "data", "->", "getFqsen", "(", ")", ",", "0", ",", "-", "strlen", "(", "$", "data", "->", "getName", "(", ")", ")", "-", "1", ")", ")", ";", "foreach", "(", "$", "data", "->", "getInterfaces", "(", ")", "as", "$", "interfaceClassName", ")", "{", "$", "classDescriptor", "->", "getInterfaces", "(", ")", "->", "set", "(", "(", "string", ")", "$", "interfaceClassName", ",", "$", "interfaceClassName", ")", ";", "}", "$", "this", "->", "assembleDocBlock", "(", "$", "data", "->", "getDocBlock", "(", ")", ",", "$", "classDescriptor", ")", ";", "$", "this", "->", "addConstants", "(", "$", "data", "->", "getConstants", "(", ")", ",", "$", "classDescriptor", ")", ";", "$", "this", "->", "addProperties", "(", "$", "data", "->", "getProperties", "(", ")", ",", "$", "classDescriptor", ")", ";", "$", "this", "->", "addMethods", "(", "$", "data", "->", "getMethods", "(", ")", ",", "$", "classDescriptor", ")", ";", "$", "this", "->", "addUses", "(", "$", "data", "->", "getUsedTraits", "(", ")", ",", "$", "classDescriptor", ")", ";", "return", "$", "classDescriptor", ";", "}" ]

[ "Creates", "a", "Descriptor", "from", "the", "provided", "data", "." ]

[ "protected", "function", "addConstants", "(", "array", "$", "constants", ",", "ClassDescriptor", "$", "classDescriptor", ")", ":", "void", "{", "foreach", "(", "$", "constants", "as", "$", "constant", ")", "{", "$", "constantDescriptor", "=", "$", "this", "->", "getBuilder", "(", ")", "->", "buildDescriptor", "(", "$", "constant", ")", ";", "if", "(", "$", "constantDescriptor", "instanceof", "ConstantDescriptor", ")", "{", "$", "constantDescriptor", "->", "setParent", "(", "$", "classDescriptor", ")", ";", "$", "classDescriptor", "->", "getConstants", "(", ")", "->", "set", "(", "$", "constantDescriptor", "->", "getName", "(", ")", ",", "$", "constantDescriptor", ")", ";", "}", "}", "}" ]

[ "Registers", "the", "child", "constants", "with", "the", "generated", "Class", "Descriptor", "." ]

[ "public", "function", "register", "(", "string", "$", "name", ",", "TemplateInterface", "$", "templateEngine", ")", ":", "void", "{", "Assert", "::", "stringNotEmpty", "(", "$", "name", ")", ";", "$", "this", "->", "engines", "[", "$", "name", "]", "=", "$", "templateEngine", ";", "}" ]

[ "Associates", "a", "human", "-", "readable", "/", "simplified", "name", "with", "a", "class", "name", "representing", "a", "template", "engine", "." ]

[ "public", "function", "get", "(", "string", "$", "name", ")", ":", "TemplateInterface", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "engines", "[", "$", "name", "]", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "'Template engine \"'", ".", "$", "name", ".", "'\" is not known or registered'", ")", ";", "}", "return", "$", "this", "->", "engines", "[", "$", "name", "]", ";", "}" ]

[ "Returns", "a", "new", "instance", "of", "the", "template", "engine", "belonging", "to", "the", "given", "name", "." ]

[ "private", "function", "constructExamplePath", "(", "string", "$", "directory", ",", "string", "$", "file", ")", ":", "string", "{", "return", "rtrim", "(", "$", "directory", ",", "'\\\\/'", ")", ".", "DIRECTORY_SEPARATOR", ".", "$", "file", ";", "}" ]

[ "Returns", "a", "path", "to", "the", "example", "file", "in", "the", "given", "directory", ".." ]

[ "private", "function", "getExamplePathFromSource", "(", "string", "$", "file", ")", ":", "string", "{", "return", "sprintf", "(", "'%s%s%s'", ",", "trim", "(", "$", "this", "->", "getSourceDirectory", "(", ")", ",", "'\\\\/'", ")", ",", "DIRECTORY_SEPARATOR", ",", "trim", "(", "$", "file", ",", "'\"'", ")", ")", ";", "}" ]

[ "Get", "example", "filepath", "based", "on", "sourcecode", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "Assert", "::", "isInstanceOf", "(", "$", "data", ",", "Example", "::", "class", ")", ";", "$", "descriptor", "=", "new", "ExampleDescriptor", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "descriptor", "->", "setFilePath", "(", "(", "string", ")", "$", "data", "->", "getFilePath", "(", ")", ")", ";", "$", "descriptor", "->", "setStartingLine", "(", "$", "data", "->", "getStartingLine", "(", ")", ")", ";", "$", "descriptor", "->", "setLineCount", "(", "$", "data", "->", "getLineCount", "(", ")", ")", ";", "$", "descriptor", "->", "setDescription", "(", "$", "data", "->", "getDescription", "(", ")", ")", ";", "$", "descriptor", "->", "setExample", "(", "$", "this", "->", "finder", "->", "find", "(", "$", "data", ")", ")", ";", "return", "$", "descriptor", ";", "}" ]

[ "Creates", "a", "new", "Descriptor", "from", "the", "given", "Reflector", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "descriptor", "=", "new", "NamespaceDescriptor", "(", ")", ";", "$", "descriptor", "->", "setName", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "descriptor", "->", "setFullyQualifiedStructuralElementName", "(", "$", "data", "->", "getFqsen", "(", ")", ")", ";", "$", "namespace", "=", "substr", "(", "(", "string", ")", "$", "data", "->", "getFqsen", "(", ")", ",", "0", ",", "-", "strlen", "(", "$", "data", "->", "getName", "(", ")", ")", "-", "1", ")", ";", "$", "descriptor", "->", "setNamespace", "(", "$", "namespace", "===", "''", "?", "'\\\\'", ":", "$", "namespace", ")", ";", "return", "$", "descriptor", ";", "}" ]

[ "Creates", "a", "Descriptor", "from", "the", "provided", "data", "." ]

[ "public", "function", "match", "(", "$", "node", ")", "{", "/** @var RouterAbstract $router */", "foreach", "(", "clone", "$", "this", "as", "$", "router", ")", "{", "$", "rule", "=", "$", "router", "->", "match", "(", "$", "node", ")", ";", "if", "(", "$", "rule", ")", "{", "return", "$", "rule", ";", "}", "}", "return", "null", ";", "}" ]

[ "Tries", "to", "match", "the", "given", "node", "with", "a", "rule", "defined", "in", "one", "of", "the", "routers", "." ]

[ "protected", "function", "addSummary", "(", "\\", "DOMElement", "$", "node", ",", "DescriptorAbstract", "$", "element", ")", "{", "$", "node", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'description'", ")", ")", "->", "appendChild", "(", "new", "\\", "DOMText", "(", "$", "element", "->", "getSummary", "(", ")", ")", ")", ";", "}" ]

[ "Adds", "the", "short", "description", "of", "$docblock", "to", "the", "given", "node", "as", "description", "field", "." ]

[ "protected", "function", "addTags", "(", "\\", "DOMElement", "$", "docBlock", ",", "$", "descriptor", ")", "{", "foreach", "(", "$", "descriptor", "->", "getTags", "(", ")", "as", "$", "tagGroup", ")", "{", "if", "(", "!", "$", "tagGroup", ")", "{", "continue", ";", "}", "foreach", "(", "$", "tagGroup", "as", "$", "tag", ")", "{", "$", "this", "->", "tagConverter", "->", "convert", "(", "$", "docBlock", ",", "$", "tag", ")", ";", "}", "}", "}" ]

[ "Adds", "each", "tag", "to", "the", "XML", "Node", "representing", "the", "DocBlock", "." ]

[ "protected", "function", "assembleDocBlock", "(", "$", "docBlock", ",", "$", "target", ")", "{", "if", "(", "!", "$", "docBlock", ")", "{", "return", ";", "}", "$", "target", "->", "setSummary", "(", "$", "docBlock", "->", "getSummary", "(", ")", ")", ";", "$", "target", "->", "setDescription", "(", "$", "docBlock", "->", "getDescription", "(", ")", ")", ";", "/** @var DocBlock\\Tag $tag */", "foreach", "(", "$", "docBlock", "->", "getTags", "(", ")", "as", "$", "tag", ")", "{", "$", "tagDescriptor", "=", "$", "this", "->", "builder", "->", "buildDescriptor", "(", "$", "tag", ")", ";", "// allow filtering of tags", "if", "(", "!", "$", "tagDescriptor", ")", "{", "continue", ";", "}", "$", "target", "->", "getTags", "(", ")", "->", "get", "(", "$", "tag", "->", "getName", "(", ")", ",", "new", "Collection", "(", ")", ")", "->", "add", "(", "$", "tagDescriptor", ")", ";", "}", "}" ]

[ "Assemble", "DocBlock", "." ]

[ "protected", "function", "extractPackageFromDocBlock", "(", "$", "docBlock", ")", "{", "$", "packageTags", "=", "$", "docBlock", "?", "$", "docBlock", "->", "getTagsByName", "(", "'package'", ")", ":", "[", "]", ";", "if", "(", "count", "(", "$", "packageTags", ")", "===", "0", ")", "{", "return", "null", ";", "}", "/** @var DocBlock\\Tags\\Generic $tag */", "$", "tag", "=", "reset", "(", "$", "packageTags", ")", ";", "return", "trim", "(", "(", "string", ")", "$", "tag", "->", "getDescription", "(", ")", ")", ";", "}" ]

[ "Extracts", "the", "package", "from", "the", "DocBlock", "." ]

[ "public", "function", "get", "(", "$", "nameOrPath", ")", "{", "return", "$", "this", "->", "createTemplateFromXml", "(", "$", "this", "->", "fetchTemplateXmlFromPath", "(", "$", "this", "->", "pathResolver", "->", "resolve", "(", "$", "nameOrPath", ")", ")", ")", ";", "}" ]

[ "Attempts", "to", "find", "construct", "and", "return", "a", "template", "object", "with", "the", "given", "template", "name", "or", "(", "relative", "/", "absolute", ")", "path", "." ]

[ "public", "function", "getAllNames", "(", ")", "{", "/** @var \\RecursiveDirectoryIterator $files */", "$", "files", "=", "new", "\\", "DirectoryIterator", "(", "$", "this", "->", "getTemplatePath", "(", ")", ")", ";", "$", "template_names", "=", "[", "]", ";", "while", "(", "$", "files", "->", "valid", "(", ")", ")", "{", "$", "name", "=", "$", "files", "->", "getBasename", "(", ")", ";", "// skip abstract files", "if", "(", "!", "$", "files", "->", "isDir", "(", ")", "||", "in_array", "(", "$", "name", ",", "[", "'.'", ",", "'..'", "]", ",", "true", ")", ")", "{", "$", "files", "->", "next", "(", ")", ";", "continue", ";", "}", "$", "template_names", "[", "]", "=", "$", "name", ";", "$", "files", "->", "next", "(", ")", ";", "}", "return", "$", "template_names", ";", "}" ]

[ "Returns", "a", "list", "of", "all", "template", "names", "." ]

[ "protected", "function", "createTemplateFromXml", "(", "$", "xml", ")", "{", "/** @var Template $template */", "$", "template", "=", "$", "this", "->", "serializer", "->", "deserialize", "(", "$", "xml", ",", "'phpDocumentor\\Transformer\\Template'", ",", "'xml'", ")", ";", "$", "template", "->", "propagateParameters", "(", ")", ";", "return", "$", "template", ";", "}" ]

[ "Creates", "and", "returns", "a", "template", "object", "based", "on", "the", "provided", "template", "definition", "." ]

[ "public", "function", "parse", "(", "ProjectDescriptorBuilder", "$", "builder", ",", "array", "$", "files", ")", "{", "$", "this", "->", "startTimingTheParsePhase", "(", ")", ";", "$", "this", "->", "forceRebuildIfSettingsHaveModified", "(", "$", "builder", ")", ";", "$", "event", "=", "PreParsingEvent", "::", "createInstance", "(", "$", "this", ")", ";", "assert", "(", "$", "event", "instanceof", "PreParsingEvent", ")", ";", "Dispatcher", "::", "getInstance", "(", ")", "->", "dispatch", "(", "'parser.pre'", ",", "$", "event", "->", "setFileCount", "(", "count", "(", "$", "files", ")", ")", ")", ";", "/** @var \\phpDocumentor\\Reflection\\Php\\Project $project */", "$", "project", "=", "$", "this", "->", "projectFactory", "->", "create", "(", "ProjectDescriptorBuilder", "::", "DEFAULT_PROJECT_NAME", ",", "$", "files", ")", ";", "$", "this", "->", "logAfterParsingAllFiles", "(", ")", ";", "/*\n * TODO: This should be moved to some view adapter layer when\n * we are removing the descriptors from the application.\n * because we are now partly migrating to the new reflection component\n * we are transforming back to the original structure.\n */", "$", "builder", "->", "build", "(", "$", "project", ")", ";", "return", "$", "builder", "->", "getProjectDescriptor", "(", ")", ";", "}" ]

[ "Iterates", "through", "the", "given", "files", "feeds", "them", "to", "the", "builder", "." ]

[ "private", "function", "forceRebuildIfSettingsHaveModified", "(", "ProjectDescriptorBuilder", "$", "builder", ")", "{", "if", "(", "$", "builder", "->", "getProjectDescriptor", "(", ")", "->", "getSettings", "(", ")", "->", "isModified", "(", ")", ")", "{", "$", "this", "->", "setForced", "(", "true", ")", ";", "$", "this", "->", "log", "(", "'One of the project\\'s settings have changed, forcing a complete rebuild'", ",", "LogLevel", "::", "NOTICE", ")", ";", "}", "}" ]

[ "Checks", "if", "the", "settings", "of", "the", "project", "have", "changed", "and", "forces", "a", "complete", "rebuild", "if", "they", "have", "." ]

[ "private", "function", "logAfterParsingAllFiles", "(", ")", "{", "if", "(", "!", "$", "this", "->", "stopwatch", ")", "{", "return", ";", "}", "$", "event", "=", "$", "this", "->", "stopwatch", "->", "stop", "(", "'parser.parse'", ")", ";", "$", "this", "->", "log", "(", "'Elapsed time to parse all files: '", ".", "round", "(", "$", "event", "->", "getDuration", "(", ")", "/", "1000", ",", "2", ")", ".", "'s'", ")", ";", "$", "this", "->", "log", "(", "'Peak memory usage: '", ".", "round", "(", "$", "event", "->", "getMemory", "(", ")", "/", "1024", "/", "1024", ",", "2", ")", ".", "'M'", ")", ";", "}" ]

[ "Writes", "the", "complete", "parsing", "cycle", "to", "log", "." ]

[ "public", "function", "filter", "(", "$", "value", ")", "{", "if", "(", "$", "value", ")", "{", "$", "namespace", "=", "$", "value", "->", "getNamespace", "(", ")", "===", "''", "?", "'\\\\'", ".", "$", "this", "->", "namespacePrefix", ":", "$", "value", "->", "getNamespace", "(", ")", ";", "$", "value", "->", "setNamespace", "(", "$", "this", "->", "namespaceFromLegacyNamespace", "(", "$", "namespace", ",", "$", "value", "->", "getName", "(", ")", ")", ")", ";", "$", "value", "->", "setName", "(", "$", "this", "->", "classNameFromLegacyNamespace", "(", "$", "value", "->", "getName", "(", ")", ")", ")", ";", "}", "return", "$", "value", ";", "}" ]

[ "Overrides", "the", "name", "and", "namespace", "of", "an", "element", "with", "a", "separated", "version", "of", "the", "class", "name", "." ]

[ "private", "function", "namespaceFromLegacyNamespace", "(", "$", "namespace", ",", "$", "className", ")", "{", "$", "qcn", "=", "str_replace", "(", "'_'", ",", "'\\\\'", ",", "$", "className", ")", ";", "$", "lastBackslash", "=", "strrpos", "(", "$", "qcn", ",", "'\\\\'", ")", ";", "if", "(", "$", "lastBackslash", ")", "{", "$", "namespace", "=", "rtrim", "(", "$", "namespace", ",", "'\\\\'", ")", ".", "'\\\\'", ".", "substr", "(", "$", "qcn", ",", "0", ",", "$", "lastBackslash", ")", ";", "}", "return", "$", "namespace", ";", "}" ]

[ "Extracts", "the", "namespace", "from", "the", "class", "name", "." ]

[ "private", "function", "classNameFromLegacyNamespace", "(", "$", "className", ")", "{", "$", "lastUnderscore", "=", "strrpos", "(", "$", "className", ",", "'_'", ")", ";", "if", "(", "$", "lastUnderscore", ")", "{", "$", "className", "=", "substr", "(", "$", "className", ",", "$", "lastUnderscore", "+", "1", ")", ";", "}", "return", "$", "className", ";", "}" ]

[ "Extracts", "the", "class", "name", "without", "prefix", "from", "the", "full", "class", "name", "." ]

[ "public", "function", "execute", "(", "ProjectDescriptor", "$", "project", ")", ":", "void", "{", "/** @var Collection|DescriptorAbstract[] $elementCollection */", "$", "this", "->", "elementCollection", "=", "$", "project", "->", "getIndexes", "(", ")", "->", "get", "(", "'elements'", ")", ";", "foreach", "(", "$", "this", "->", "elementCollection", "as", "$", "descriptor", ")", "{", "$", "this", "->", "resolveSeeAndLinkTags", "(", "$", "descriptor", ")", ";", "}", "}" ]

[ "Iterates", "through", "each", "element", "in", "the", "project", "and", "replaces", "its", "inline" ]

[ "private", "function", "resolveSeeAndLinkTags", "(", "DescriptorAbstract", "$", "descriptor", ")", ":", "void", "{", "// store descriptor to use it in the resolveTag method", "$", "this", "->", "descriptor", "=", "$", "descriptor", ";", "$", "descriptor", "->", "setDescription", "(", "preg_replace_callback", "(", "self", "::", "REGEX_INLINE_LINK_OR_SEE_TAG", ",", "[", "$", "this", ",", "'resolveTag'", "]", ",", "$", "descriptor", "->", "getDescription", "(", ")", ")", ")", ";", "}" ]

[ "Resolves", "all", "@see", "and", "@link", "tags", "in", "the", "description", "of", "the", "given", "descriptor", "to", "their", "markdown", "representation", "." ]

[ "private", "function", "resolveTag", "(", "array", "$", "match", ")", "{", "$", "tagReflector", "=", "$", "this", "->", "createLinkOrSeeTagFromRegexMatch", "(", "$", "match", ")", ";", "if", "(", "!", "$", "tagReflector", "instanceof", "See", "&&", "!", "$", "tagReflector", "instanceof", "Link", ")", "{", "return", "$", "match", ";", "}", "$", "link", "=", "$", "this", "->", "getLinkText", "(", "$", "tagReflector", ")", ";", "$", "description", "=", "(", "string", ")", "$", "tagReflector", "->", "getDescription", "(", ")", ";", "if", "(", "$", "this", "->", "isUrl", "(", "$", "link", ")", ")", "{", "return", "$", "this", "->", "generateMarkdownLink", "(", "$", "link", ",", "$", "description", "?", ":", "$", "link", ")", ";", "}", "$", "link", "=", "$", "this", "->", "resolveQsen", "(", "$", "link", ")", ";", "$", "element", "=", "$", "this", "->", "findElement", "(", "$", "link", ")", ";", "if", "(", "!", "$", "element", ")", "{", "return", "(", "string", ")", "$", "link", ";", "}", "return", "$", "this", "->", "resolveElement", "(", "$", "element", ",", "$", "link", ",", "$", "description", ")", ";", "}" ]

[ "Resolves", "an", "individual", "tag", "indicated", "by", "the", "results", "of", "the", "Regex", "used", "to", "extract", "tags", "." ]

[ "private", "function", "createLinkOrSeeTagFromRegexMatch", "(", "array", "$", "match", ")", ":", "Tag", "{", "list", "(", "$", "completeMatch", ",", "$", "tagName", ",", "$", "tagContent", ")", "=", "$", "match", ";", "$", "fqsenResolver", "=", "new", "FqsenResolver", "(", ")", ";", "$", "tagFactory", "=", "new", "StandardTagFactory", "(", "$", "fqsenResolver", ")", ";", "$", "descriptionFactory", "=", "new", "DescriptionFactory", "(", "$", "tagFactory", ")", ";", "$", "tagFactory", "->", "addService", "(", "$", "descriptionFactory", ")", ";", "$", "tagFactory", "->", "addService", "(", "new", "TypeResolver", "(", "$", "fqsenResolver", ")", ")", ";", "switch", "(", "$", "tagName", ")", "{", "case", "'see'", ":", "return", "See", "::", "create", "(", "$", "tagContent", ",", "$", "fqsenResolver", ",", "$", "descriptionFactory", ",", "$", "this", "->", "createDocBlockContext", "(", ")", ")", ";", "case", "'link'", ":", "return", "Link", "::", "create", "(", "$", "tagContent", ",", "$", "descriptionFactory", ",", "$", "this", "->", "createDocBlockContext", "(", ")", ")", ";", "}", "}" ]

[ "Creates", "a", "Tag", "Reflector", "from", "the", "given", "array", "of", "tag", "line", "tag", "name", "and", "tag", "content", "." ]

[ "private", "function", "resolveElement", "(", "DescriptorAbstract", "$", "element", ",", "$", "link", ",", "?", "string", "$", "description", "=", "null", ")", ":", "string", "{", "$", "rule", "=", "$", "this", "->", "router", "->", "match", "(", "$", "element", ")", ";", "if", "(", "$", "rule", ")", "{", "$", "url", "=", "'..'", ".", "$", "rule", "->", "generate", "(", "$", "element", ")", ";", "$", "link", "=", "$", "this", "->", "generateMarkdownLink", "(", "$", "url", ",", "$", "description", "?", ":", "(", "string", ")", "$", "link", ")", ";", "}", "return", "$", "link", ";", "}" ]

[ "Generates", "a", "Markdown", "link", "to", "the", "given", "Descriptor", "or", "returns", "the", "link", "text", "if", "no", "route", "to", "the", "Descriptor", "could", "be", "matched", "." ]

[ "private", "function", "getLinkText", "(", "Tag", "$", "tagReflector", ")", ":", "?", "string", "{", "if", "(", "$", "tagReflector", "instanceof", "See", ")", "{", "return", "(", "string", ")", "$", "tagReflector", "->", "getReference", "(", ")", ";", "}", "if", "(", "$", "tagReflector", "instanceof", "Link", ")", "{", "return", "(", "string", ")", "$", "tagReflector", "->", "getLink", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "Returns", "the", "link", "for", "the", "given", "reflector", "." ]

[ "private", "function", "createDocBlockContext", "(", ")", ":", "Context", "{", "$", "file", "=", "$", "this", "->", "descriptor", "->", "getFile", "(", ")", ";", "$", "namespaceAliases", "=", "$", "file", "?", "$", "file", "->", "getNamespaceAliases", "(", ")", "->", "getAll", "(", ")", ":", "[", "]", ";", "foreach", "(", "$", "namespaceAliases", "as", "$", "alias", "=>", "$", "fqsen", ")", "{", "$", "namespaceAliases", "[", "$", "alias", "]", "=", "(", "string", ")", "$", "fqsen", ";", "}", "return", "new", "Context", "(", "(", "string", ")", "$", "this", "->", "descriptor", "->", "getNamespace", "(", ")", ",", "$", "namespaceAliases", ")", ";", "}" ]

[ "Creates", "a", "DocBlock", "context", "containing", "the", "namespace", "and", "aliases", "for", "the", "current", "descriptor", "." ]

[ "public", "function", "isVisibilityAllowed", "(", "$", "visibility", ")", "{", "switch", "(", "$", "visibility", ")", "{", "case", "'public'", ":", "$", "visibility", "=", "Settings", "::", "VISIBILITY_PUBLIC", ";", "break", ";", "case", "'protected'", ":", "$", "visibility", "=", "Settings", "::", "VISIBILITY_PROTECTED", ";", "break", ";", "case", "'private'", ":", "$", "visibility", "=", "Settings", "::", "VISIBILITY_PRIVATE", ";", "break", ";", "case", "'internal'", ":", "$", "visibility", "=", "Settings", "::", "VISIBILITY_INTERNAL", ";", "break", ";", "}", "return", "$", "this", "->", "getProjectDescriptor", "(", ")", "->", "isVisibilityAllowed", "(", "$", "visibility", ")", ";", "}" ]

[ "Verifies", "whether", "the", "given", "visibility", "is", "allowed", "to", "be", "included", "in", "the", "Descriptors", "." ]

[ "public", "function", "buildDescriptor", "(", "$", "data", ")", "{", "$", "assembler", "=", "$", "this", "->", "getAssembler", "(", "$", "data", ")", ";", "if", "(", "!", "$", "assembler", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Unable to build a Descriptor; the provided data did not match any Assembler '", ".", "get_class", "(", "$", "data", ")", ")", ";", "}", "if", "(", "$", "assembler", "instanceof", "Builder", "\\", "AssemblerAbstract", ")", "{", "$", "assembler", "->", "setBuilder", "(", "$", "this", ")", ";", "}", "// create Descriptor and populate with the provided data", "$", "descriptor", "=", "$", "assembler", "->", "create", "(", "$", "data", ")", ";", "if", "(", "!", "$", "descriptor", ")", "{", "return", "null", ";", "}", "return", "(", "!", "is_array", "(", "$", "descriptor", ")", "&&", "(", "!", "$", "descriptor", "instanceof", "Collection", ")", ")", "?", "$", "this", "->", "filterDescriptor", "(", "$", "descriptor", ")", ":", "$", "this", "->", "filterEachDescriptor", "(", "$", "descriptor", ")", ";", "}" ]

[ "Takes", "the", "given", "data", "and", "attempts", "to", "build", "a", "Descriptor", "from", "it", "." ]

[ "private", "function", "filterEachDescriptor", "(", "$", "descriptor", ")", "{", "$", "descriptors", "=", "new", "Collection", "(", ")", ";", "foreach", "(", "$", "descriptor", "as", "$", "key", "=>", "$", "item", ")", "{", "$", "item", "=", "$", "this", "->", "filterDescriptor", "(", "$", "item", ")", ";", "if", "(", "!", "$", "item", ")", "{", "continue", ";", "}", "$", "descriptors", "[", "$", "key", "]", "=", "$", "item", ";", "}", "return", "$", "descriptors", ";", "}" ]

[ "Filters", "each", "descriptor", "validates", "them", "stores", "the", "validation", "results", "and", "returns", "a", "collection", "of", "transmuted", "objects", "." ]

[ "protected", "function", "filterDescriptor", "(", "Descriptor", "$", "descriptor", ")", "{", "if", "(", "!", "$", "descriptor", "instanceof", "Filterable", ")", "{", "return", "$", "descriptor", ";", "}", "// filter the descriptor; this may result in the descriptor being removed!", "$", "descriptor", "=", "$", "this", "->", "filter", "(", "$", "descriptor", ")", ";", "if", "(", "!", "$", "descriptor", ")", "{", "return", "null", ";", "}", "return", "$", "descriptor", ";", "}" ]

[ "Filters", "a", "descriptor", "validates", "it", "stores", "the", "validation", "results", "and", "returns", "the", "transmuted", "object", "or", "null", "if", "it", "is", "supposed", "to", "be", "removed", "." ]

[ "public", "function", "process", "(", "\\", "DOMDocument", "$", "xml", ")", "{", "// matches:", "// - [email protected]", "// - <[email protected]>", "// - Some Name <[email protected]>", "// ignores leading and trailing whitespace", "// requires angled brackets when a name is given (that's what the", "// two (?(1)) conditions do)", "// requires closing angled bracket if email address is given with an", "// opening angled bracket but no name (that's what the (?(3))", "// condition is for)", "$", "regex", "=", "'#^\\s*(?P<name>[^<]+?)?\\s*((?(1)<|<?)(?:mailto:)?'", ".", "'(?P<email>\\b[a-z0-9._%-]+@[a-z0-9.-]+\\.[a-z]{2,4}\\b)'", ".", "'(?(1)>|(?(3)>|>?)))\\s*$#u'", ";", "$", "xpath", "=", "new", "\\", "DOMXPath", "(", "$", "xml", ")", ";", "$", "nodes", "=", "$", "xpath", "->", "query", "(", "'//tag[@name=\"author\"]/@description'", ")", ";", "/** @var \\DOMElement $node */", "foreach", "(", "$", "nodes", "as", "$", "node", ")", "{", "// FIXME: #193", "if", "(", "preg_match", "(", "$", "regex", ",", "$", "node", "->", "nodeValue", ",", "$", "matches", ")", ")", "{", "if", "(", "$", "matches", "[", "'name'", "]", ")", "{", "$", "value", "=", "$", "matches", "[", "'name'", "]", ";", "}", "else", "{", "// in case there were <> but no name... this cleans up the", "// output a bit", "$", "value", "=", "$", "matches", "[", "'email'", "]", ";", "}", "$", "node", "->", "nodeValue", "=", "$", "value", ";", "/** @var \\DOMElement $parentNode */", "$", "parentNode", "=", "$", "node", "->", "parentNode", ";", "$", "parentNode", "->", "setAttribute", "(", "'link'", ",", "'mailto:'", ".", "$", "matches", "[", "'email'", "]", ")", ";", "}", "}", "return", "$", "xml", ";", "}" ]

[ "Find", "all", "return", "tags", "that", "contain", "self", "or", "$this", "and", "replace", "those", "terms", "for", "the", "name", "of", "the", "current", "class", "type", "." ]

[ "public", "function", "execute", "(", "Command", "$", "command", ",", "callable", "$", "next", ")", "{", "$", "filename", "=", "$", "command", "->", "getFile", "(", ")", "->", "path", "(", ")", ";", "$", "this", "->", "log", "(", "'Starting to parse file: '", ".", "$", "filename", ",", "LogLevel", "::", "INFO", ")", ";", "try", "{", "return", "$", "next", "(", "$", "command", ")", ";", "}", "catch", "(", "Exception", "$", "e", ")", "{", "$", "this", "->", "log", "(", "' Unable to parse file \"'", ".", "$", "filename", ".", "'\", an error was detected: '", ".", "$", "e", "->", "getMessage", "(", ")", ",", "LogLevel", "::", "ALERT", ")", ";", "}", "return", "null", ";", "}" ]

[ "Executes", "this", "middle", "ware", "class", "." ]

[ "public", "static", "function", "getInstance", "(", "string", "$", "name", "=", "'default'", ")", ":", "self", "{", "if", "(", "!", "isset", "(", "self", "::", "$", "instances", "[", "$", "name", "]", ")", ")", "{", "self", "::", "setInstance", "(", "$", "name", ",", "new", "self", "(", ")", ")", ";", "}", "return", "self", "::", "$", "instances", "[", "$", "name", "]", ";", "}" ]

[ "Returns", "a", "named", "instance", "of", "the", "Event", "Dispatcher", "." ]

[ "public", "static", "function", "setInstance", "(", "string", "$", "name", ",", "self", "$", "instance", ")", ":", "void", "{", "self", "::", "$", "instances", "[", "$", "name", "]", "=", "$", "instance", ";", "}" ]

[ "Sets", "a", "names", "instance", "of", "the", "Event", "Dispatcher", "." ]

[ "public", "function", "execute", "(", "Command", "$", "command", ",", "callable", "$", "next", ")", "{", "$", "itemName", "=", "$", "this", "->", "getItemName", "(", "$", "command", "->", "getFile", "(", ")", "->", "path", "(", ")", ")", ";", "$", "item", "=", "$", "this", "->", "dataStore", "->", "getItem", "(", "$", "itemName", ")", ";", "if", "(", "$", "item", "->", "isMiss", "(", ")", "||", "$", "this", "->", "parser", "->", "isForced", "(", ")", ")", "{", "return", "$", "this", "->", "updateCache", "(", "$", "command", ",", "$", "next", ",", "$", "item", ")", ";", "}", "/** @var File $cachedFile */", "$", "cachedFile", "=", "$", "item", "->", "get", "(", ")", ";", "if", "(", "$", "cachedFile", "===", "null", ")", "{", "return", "$", "this", "->", "updateCache", "(", "$", "command", ",", "$", "next", ",", "$", "item", ")", ";", "}", "if", "(", "$", "cachedFile", "->", "getHash", "(", ")", "!==", "$", "command", "->", "getFile", "(", ")", "->", "md5", "(", ")", ")", "{", "return", "$", "this", "->", "updateCache", "(", "$", "command", ",", "$", "next", ",", "$", "item", ")", ";", "}", "return", "$", "cachedFile", ";", "}" ]

[ "Executes", "this", "middle", "ware", "class", ".", "A", "middle", "ware", "class", "MUST", "return", "a", "File", "object", "or", "call", "the", "$next", "callable", "." ]

[ "public", "function", "transform", "(", "ProjectDescriptor", "$", "project", ",", "Transformation", "$", "transformation", ")", ":", "void", "{", "$", "template_path", "=", "$", "this", "->", "getTemplatePath", "(", "$", "transformation", ")", ";", "$", "finder", "=", "new", "Pathfinder", "(", ")", ";", "$", "nodes", "=", "$", "finder", "->", "find", "(", "$", "project", ",", "$", "transformation", "->", "getQuery", "(", ")", ")", ";", "foreach", "(", "$", "nodes", "as", "$", "node", ")", "{", "if", "(", "!", "$", "node", ")", "{", "continue", ";", "}", "$", "destination", "=", "$", "this", "->", "getDestinationPath", "(", "$", "node", ",", "$", "transformation", ")", ";", "if", "(", "$", "destination", "===", "false", ")", "{", "continue", ";", "}", "$", "environment", "=", "$", "this", "->", "initializeEnvironment", "(", "$", "project", ",", "$", "transformation", ",", "$", "destination", ")", ";", "$", "environment", "->", "addGlobal", "(", "'node'", ",", "$", "node", ")", ";", "$", "html", "=", "$", "environment", "->", "render", "(", "substr", "(", "$", "transformation", "->", "getSource", "(", ")", ",", "strlen", "(", "$", "template_path", ")", ")", ")", ";", "file_put_contents", "(", "$", "destination", ",", "$", "html", ")", ";", "}", "}" ]

[ "This", "method", "combines", "the", "ProjectDescriptor", "and", "the", "given", "target", "template", "and", "creates", "a", "static", "html", "page", "at", "the", "artifact", "location", "." ]

[ "protected", "function", "initializeEnvironment", "(", "ProjectDescriptor", "$", "project", ",", "Transformation", "$", "transformation", ",", "string", "$", "destination", ")", ":", "Twig_Environment", "{", "$", "callingTemplatePath", "=", "$", "this", "->", "getTemplatePath", "(", "$", "transformation", ")", ";", "$", "baseTemplatesPath", "=", "$", "transformation", "->", "getTransformer", "(", ")", "->", "getTemplates", "(", ")", "->", "getTemplatesPath", "(", ")", ";", "$", "templateFolders", "=", "[", "$", "baseTemplatesPath", ".", "'/..'", ".", "DIRECTORY_SEPARATOR", ".", "$", "callingTemplatePath", ",", "// http://twig.sensiolabs.org/doc/recipes.html#overriding-a-template-that-also-extends-itself", "$", "baseTemplatesPath", ",", "]", ";", "// get all invoked template paths, they overrule the calling template path", "/** @var \\phpDocumentor\\Transformer\\Template $template */", "foreach", "(", "$", "transformation", "->", "getTransformer", "(", ")", "->", "getTemplates", "(", ")", "as", "$", "template", ")", "{", "$", "path", "=", "$", "baseTemplatesPath", ".", "DIRECTORY_SEPARATOR", ".", "$", "template", "->", "getName", "(", ")", ";", "array_unshift", "(", "$", "templateFolders", ",", "$", "path", ")", ";", "}", "// Clone twig because otherwise we cannot re-set the extensions on this twig environment on every run of this", "// writer", "$", "env", "=", "clone", "$", "this", "->", "twig", ";", "$", "env", "->", "setLoader", "(", "new", "Twig_Loader_Filesystem", "(", "$", "templateFolders", ")", ")", ";", "$", "this", "->", "addPhpDocumentorExtension", "(", "$", "project", ",", "$", "transformation", ",", "$", "destination", ",", "$", "env", ")", ";", "$", "this", "->", "addExtensionsFromTemplateConfiguration", "(", "$", "transformation", ",", "$", "project", ",", "$", "env", ")", ";", "return", "$", "env", ";", "}" ]

[ "Initializes", "the", "Twig", "environment", "with", "the", "template", "base", "extension", "and", "additionally", "defined", "extensions", "." ]

[ "protected", "function", "addPhpDocumentorExtension", "(", "ProjectDescriptor", "$", "project", ",", "Transformation", "$", "transformation", ",", "string", "$", "destination", ",", "Twig_Environment", "$", "twigEnvironment", ")", ":", "void", "{", "$", "base_extension", "=", "new", "Extension", "(", "$", "project", ",", "$", "transformation", ")", ";", "$", "base_extension", "->", "setDestination", "(", "substr", "(", "$", "destination", ",", "strlen", "(", "$", "transformation", "->", "getTransformer", "(", ")", "->", "getTarget", "(", ")", ")", "+", "1", ")", ")", ";", "$", "base_extension", "->", "setRouters", "(", "$", "this", "->", "routers", ")", ";", "$", "twigEnvironment", "->", "addExtension", "(", "$", "base_extension", ")", ";", "}" ]

[ "Adds", "the", "phpDocumentor", "base", "extension", "to", "the", "Twig", "Environment", "." ]

[ "protected", "function", "getTemplatePath", "(", "Transformation", "$", "transformation", ")", ":", "string", "{", "$", "parts", "=", "preg_split", "(", "'[\\\\\\\\|/]'", ",", "$", "transformation", "->", "getSource", "(", ")", ")", ";", "return", "$", "parts", "[", "0", "]", ".", "DIRECTORY_SEPARATOR", ".", "$", "parts", "[", "1", "]", ";", "}" ]

[ "Returns", "the", "path", "belonging", "to", "the", "template", "." ]

[ "public", "function", "process", "(", "\\", "DOMDocument", "$", "xml", ")", "{", "$", "xpath", "=", "new", "\\", "DOMXPath", "(", "$", "xml", ")", ";", "$", "nodes", "=", "$", "xpath", "->", "query", "(", "'/project/file/class/docblock/tag[@name=\"property\"]'", ".", "'|/project/file/class/docblock/tag[@name=\"property-read\"]'", ".", "'|/project/file/class/docblock/tag[@name=\"property-write\"]'", ")", ";", "/** @var \\DOMElement $node */", "foreach", "(", "$", "nodes", "as", "$", "node", ")", "{", "$", "class", "=", "$", "node", "->", "parentNode", "->", "parentNode", ";", "$", "property", "=", "new", "\\", "DOMElement", "(", "'property'", ")", ";", "$", "class", "->", "appendChild", "(", "$", "property", ")", ";", "$", "property", "->", "setAttribute", "(", "'final'", ",", "'false'", ")", ";", "$", "property", "->", "setAttribute", "(", "'static'", ",", "'false'", ")", ";", "$", "property", "->", "setAttribute", "(", "'visibility'", ",", "'public'", ")", ";", "$", "property", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "property", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'name'", ",", "$", "node", "->", "getAttribute", "(", "'variable'", ")", ")", ")", ";", "$", "property", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'default'", ")", ")", ";", "$", "docblock", "=", "new", "\\", "DOMElement", "(", "'docblock'", ")", ";", "$", "property", "->", "appendChild", "(", "$", "docblock", ")", ";", "$", "docblock", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'description'", ",", "$", "node", "->", "getAttribute", "(", "'description'", ")", ")", ")", ";", "$", "docblock", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'long-description'", ")", ")", ";", "$", "var_tag", "=", "new", "\\", "DOMElement", "(", "'tag'", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "var_tag", ")", ";", "$", "var_tag", "->", "setAttribute", "(", "'name'", ",", "'var'", ")", ";", "$", "var_tag", "->", "setAttribute", "(", "'description'", ",", "$", "node", "->", "getAttribute", "(", "'description'", ")", ")", ";", "$", "var_tag", "->", "setAttribute", "(", "'type'", ",", "$", "node", "->", "getAttribute", "(", "'type'", ")", ")", ";", "$", "var_tag", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "var_tag_type", "=", "new", "\\", "DOMElement", "(", "'type'", ",", "$", "node", "->", "getAttribute", "(", "'type'", ")", ")", ";", "$", "var_tag", "->", "appendChild", "(", "$", "var_tag_type", ")", ";", "$", "var_tag_type", "->", "setAttribute", "(", "'by_reference'", ",", "'false'", ")", ";", "$", "magic_tag", "=", "new", "\\", "DOMElement", "(", "'tag'", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "magic_tag", ")", ";", "$", "magic_tag", "->", "setAttribute", "(", "'name'", ",", "'magic'", ")", ";", "$", "magic_tag", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "node", "->", "parentNode", "->", "removeChild", "(", "$", "node", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "node", ")", ";", "}", "return", "$", "xml", ";", "}" ]

[ "Find", "all", "return", "tags", "that", "contain", "self", "or", "$this", "and", "replace", "those", "terms", "for", "the", "name", "of", "the", "current", "class", "type", "." ]

[ "public", "function", "convert", "(", "\\", "DOMElement", "$", "parent", ",", "MethodDescriptor", "$", "method", ")", "{", "$", "fullyQualifiedNamespaceName", "=", "$", "method", "->", "getNamespace", "(", ")", "instanceof", "NamespaceDescriptor", "?", "$", "method", "->", "getNamespace", "(", ")", "->", "getFullyQualifiedStructuralElementName", "(", ")", ":", "$", "parent", "->", "getAttribute", "(", "'namespace'", ")", ";", "$", "child", "=", "new", "\\", "DOMElement", "(", "'method'", ")", ";", "$", "parent", "->", "appendChild", "(", "$", "child", ")", ";", "$", "child", "->", "setAttribute", "(", "'final'", ",", "var_export", "(", "$", "method", "->", "isFinal", "(", ")", ",", "true", ")", ")", ";", "$", "child", "->", "setAttribute", "(", "'abstract'", ",", "var_export", "(", "$", "method", "->", "isAbstract", "(", ")", ",", "true", ")", ")", ";", "$", "child", "->", "setAttribute", "(", "'static'", ",", "var_export", "(", "$", "method", "->", "isStatic", "(", ")", ",", "true", ")", ")", ";", "$", "child", "->", "setAttribute", "(", "'visibility'", ",", "$", "method", "->", "getVisibility", "(", ")", ")", ";", "$", "child", "->", "setAttribute", "(", "'namespace'", ",", "$", "fullyQualifiedNamespaceName", ")", ";", "$", "child", "->", "setAttribute", "(", "'line'", ",", "(", "string", ")", "$", "method", "->", "getLine", "(", ")", ")", ";", "$", "child", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'name'", ",", "$", "method", "->", "getName", "(", ")", ")", ")", ";", "$", "child", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'full_name'", ",", "$", "method", "->", "getFullyQualifiedStructuralElementName", "(", ")", ")", ")", ";", "$", "this", "->", "docBlockConverter", "->", "convert", "(", "$", "child", ",", "$", "method", ")", ";", "foreach", "(", "$", "method", "->", "getArguments", "(", ")", "as", "$", "argument", ")", "{", "$", "this", "->", "argumentConverter", "->", "convert", "(", "$", "child", ",", "$", "argument", ")", ";", "}", "return", "$", "child", ";", "}" ]

[ "Export", "the", "given", "reflected", "method", "definition", "to", "the", "provided", "parent", "element", "." ]

[ "public", "function", "getAllErrors", "(", ")", "{", "$", "errors", "=", "$", "this", "->", "getErrors", "(", ")", ";", "$", "types", "=", "$", "this", "->", "getClasses", "(", ")", "->", "merge", "(", "$", "this", "->", "getInterfaces", "(", ")", ")", "->", "merge", "(", "$", "this", "->", "getTraits", "(", ")", ")", ";", "$", "elements", "=", "$", "this", "->", "getFunctions", "(", ")", "->", "merge", "(", "$", "this", "->", "getConstants", "(", ")", ")", "->", "merge", "(", "$", "types", ")", ";", "foreach", "(", "$", "elements", "as", "$", "element", ")", "{", "if", "(", "!", "$", "element", ")", "{", "continue", ";", "}", "$", "errors", "=", "$", "errors", "->", "merge", "(", "$", "element", "->", "getErrors", "(", ")", ")", ";", "}", "foreach", "(", "$", "types", "as", "$", "element", ")", "{", "if", "(", "!", "$", "element", ")", "{", "continue", ";", "}", "foreach", "(", "$", "element", "->", "getMethods", "(", ")", "as", "$", "item", ")", "{", "if", "(", "!", "$", "item", ")", "{", "continue", ";", "}", "$", "errors", "=", "$", "errors", "->", "merge", "(", "$", "item", "->", "getErrors", "(", ")", ")", ";", "}", "if", "(", "method_exists", "(", "$", "element", ",", "'getConstants'", ")", ")", "{", "foreach", "(", "$", "element", "->", "getConstants", "(", ")", "as", "$", "item", ")", "{", "if", "(", "!", "$", "item", ")", "{", "continue", ";", "}", "$", "errors", "=", "$", "errors", "->", "merge", "(", "$", "item", "->", "getErrors", "(", ")", ")", ";", "}", "}", "if", "(", "method_exists", "(", "$", "element", ",", "'getProperties'", ")", ")", "{", "foreach", "(", "$", "element", "->", "getProperties", "(", ")", "as", "$", "item", ")", "{", "if", "(", "!", "$", "item", ")", "{", "continue", ";", "}", "$", "errors", "=", "$", "errors", "->", "merge", "(", "$", "item", "->", "getErrors", "(", ")", ")", ";", "}", "}", "}", "return", "$", "errors", ";", "}" ]

[ "Returns", "a", "list", "of", "all", "errors", "in", "this", "file", "and", "all", "its", "child", "elements", "." ]

[ "protected", "function", "configure", "(", ")", "{", "$", "this", "->", "addOption", "(", "'target'", ",", "'t'", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'target location for output'", ",", "'build'", ")", "->", "addOption", "(", "'input-format'", ",", "'i'", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'which input format does the documentation sources have?'", ",", "'rst'", ")", "->", "addOption", "(", "'title'", ",", "null", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'The title of this document'", ",", "'Scrybe'", ")", "->", "addOption", "(", "'template'", ",", "null", ",", "InputOption", "::", "VALUE_OPTIONAL", ",", "'which template should be used to generate the documentation?'", ",", "'default'", ")", "->", "addArgument", "(", "'source'", ",", "InputArgument", "::", "IS_ARRAY", "|", "InputArgument", "::", "REQUIRED", ",", "'One or more files or directories to fetch files from'", ")", ";", "$", "this", "->", "setHelp", "(", "\n <<<DESCRIPTION\nGenerates reference documentation as {$this->output_format}.\n\nYou can define the type of files use as input using the <info>--input-format</info>\nof <info>-i</info> option.\n\nDESCRIPTION", ")", ";", "}" ]

[ "Configures", "the", "options", "and", "default", "help", "text", "." ]

[ "protected", "function", "execute", "(", "InputInterface", "$", "input", ",", "OutputInterface", "$", "output", ")", "{", "$", "this", "->", "getHelper", "(", "'phpdocumentor_logger'", ")", "->", "connectOutputToLogging", "(", "$", "output", ",", "$", "this", ")", ";", "$", "converter", "=", "$", "this", "->", "getConverter", "(", "$", "input", ")", ";", "$", "converter", "->", "setOption", "(", "'title'", ",", "$", "input", "->", "getOption", "(", "'title'", ")", ")", ";", "$", "output", "->", "writeln", "(", "'Collect all documents'", ")", ";", "$", "files", "=", "$", "this", "->", "buildCollection", "(", "$", "input", "->", "getArgument", "(", "'source'", ")", ",", "$", "converter", "->", "getDefinition", "(", ")", "->", "getInputFormat", "(", ")", "->", "getExtensions", "(", ")", ")", ";", "$", "output", "->", "writeln", "(", "'Converting documents'", ")", ";", "$", "files", "=", "$", "converter", "->", "convert", "(", "$", "files", ",", "$", "this", "->", "getTemplate", "(", "$", "input", ")", ")", ";", "$", "output", "->", "writeln", "(", "'Writing converted documents to disk'", ")", ";", "$", "this", "->", "writeToDisk", "(", "$", "files", ",", "$", "input", "->", "getOption", "(", "'target'", ")", ")", ";", "$", "output", "->", "writeln", "(", "'Writing assets to disk'", ")", ";", "$", "converter", "->", "getAssets", "(", ")", "->", "copyTo", "(", "$", "input", "->", "getOption", "(", "'target'", ")", ")", ";", "}" ]

[ "Execute", "the", "transformation", "process", "to", "an", "output", "format", "as", "defined", "in", "the", "$output_format", "class", "variable", "." ]

[ "protected", "function", "getTemplate", "(", "InputInterface", "$", "input", ")", "{", "$", "template", "=", "$", "this", "->", "getTemplateFactory", "(", ")", "->", "get", "(", "'twig'", ")", ";", "$", "template", "->", "setName", "(", "$", "input", "->", "getOption", "(", "'template'", ")", ")", ";", "return", "$", "template", ";", "}" ]

[ "Returns", "a", "template", "object", "based", "off", "the", "human", "-", "readable", "template", "name", "." ]

[ "protected", "function", "getConverter", "(", "InputInterface", "$", "input", ")", "{", "return", "$", "this", "->", "getConverterFactory", "(", ")", "->", "get", "(", "$", "input", "->", "getOption", "(", "'input-format'", ")", ",", "$", "this", "->", "output_format", ")", ";", "}" ]

[ "Returns", "the", "converter", "for", "this", "operation", "." ]

[ "protected", "function", "visitSection", "(", "\\", "DOMNode", "$", "root", ",", "\\", "ezcDocumentRstNode", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "ezcDocumentRstSectionNode", "||", "$", "node", "instanceof", "ezcDocumentRstDocumentNode", ")", "{", "if", "(", "$", "node", "->", "depth", "===", "1", ")", "{", "$", "toc", "=", "$", "this", "->", "getTableOfContents", "(", ")", ";", "$", "file", "=", "$", "toc", "[", "$", "this", "->", "getFilenameWithoutExtension", "(", ")", "]", ";", "$", "file", "->", "setName", "(", "$", "this", "->", "nodeToString", "(", "$", "node", "->", "title", ")", ")", ";", "}", "else", "{", "// find nearest parent pointer depth-wise", "$", "parent_depth", "=", "$", "node", "->", "depth", "-", "1", ";", "while", "(", "!", "isset", "(", "$", "this", "->", "entry_pointers", "[", "$", "parent_depth", "]", ")", "&&", "$", "parent_depth", ">", "0", ")", "{", "--", "$", "parent_depth", ";", "}", "$", "parent", "=", "$", "this", "->", "entry_pointers", "[", "$", "parent_depth", "]", ";", "$", "heading", "=", "new", "TableOfContents", "\\", "Heading", "(", "$", "parent", ")", ";", "$", "heading", "->", "setName", "(", "$", "this", "->", "nodeToString", "(", "$", "node", "->", "title", ")", ")", ";", "$", "heading", "->", "setSlug", "(", "$", "node", "->", "reference", ")", ";", "$", "parent", "->", "addChild", "(", "$", "heading", ")", ";", "// set as last indexed heading", "$", "this", "->", "last_heading", "=", "$", "heading", ";", "// add as new entry pointer", "array_splice", "(", "$", "this", "->", "entry_pointers", ",", "$", "parent_depth", "+", "1", ",", "count", "(", "$", "this", "->", "entry_pointers", ")", ",", "[", "$", "heading", "]", ")", ";", "}", "}", "parent", "::", "visitSection", "(", "$", "root", ",", "$", "node", ")", ";", "}" ]

[ "Visitor", "for", "the", "section", "heading", "used", "to", "populate", "the", "TableOfContents", "." ]

[ "public", "function", "addFileToLastHeading", "(", "TableOfContents", "\\", "File", "$", "file", ")", "{", "$", "this", "->", "last_heading", "->", "addChild", "(", "$", "file", ")", ";", "$", "file", "->", "setParent", "(", "$", "this", "->", "last_heading", ")", ";", "}" ]

[ "Adds", "a", "TableOfContents", "File", "object", "to", "the", "last", "heading", "that", "was", "discovered", "." ]

[ "public", "function", "process", "(", "\\", "DOMDocument", "$", "xml", ")", "{", "$", "xpath", "=", "new", "\\", "DOMXPath", "(", "$", "xml", ")", ";", "$", "nodes", "=", "$", "xpath", "->", "query", "(", "'/project/file/class/docblock/tag[@name=\"method\"]'", ")", ";", "/** @var \\DOMElement $node */", "foreach", "(", "$", "nodes", "as", "$", "node", ")", "{", "$", "class", "=", "$", "node", "->", "parentNode", "->", "parentNode", ";", "$", "method", "=", "new", "\\", "DOMElement", "(", "'method'", ")", ";", "$", "class", "->", "appendChild", "(", "$", "method", ")", ";", "// set basic information", "$", "method", "->", "setAttribute", "(", "'final'", ",", "'false'", ")", ";", "$", "method", "->", "setAttribute", "(", "'static'", ",", "'false'", ")", ";", "$", "method", "->", "setAttribute", "(", "'visibility'", ",", "'public'", ")", ";", "$", "method", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "method", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'name'", ",", "$", "node", "->", "getAttribute", "(", "'method_name'", ")", ")", ")", ";", "// fill docblock", "$", "docblock", "=", "new", "\\", "DOMElement", "(", "'docblock'", ")", ";", "$", "method", "->", "appendChild", "(", "$", "docblock", ")", ";", "$", "docblock", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'description'", ",", "$", "node", "->", "getAttribute", "(", "'description'", ")", ")", ")", ";", "$", "docblock", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'long-description'", ")", ")", ";", "// for each argument; create an @param tag and an argument element", "/** @var \\DOMElement $argument */", "foreach", "(", "$", "node", "->", "getElementsByTagName", "(", "'argument'", ")", "as", "$", "argument", ")", "{", "$", "param_tag", "=", "new", "\\", "DOMElement", "(", "'tag'", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "param_tag", ")", ";", "$", "param_tag", "->", "setAttribute", "(", "'name'", ",", "'param'", ")", ";", "$", "param_tag", "->", "setAttribute", "(", "'type'", ",", "$", "argument", "->", "getElementsByTagName", "(", "'type'", ")", "->", "item", "(", "0", ")", "->", "nodeValue", ")", ";", "$", "param_tag", "->", "setAttribute", "(", "'variable'", ",", "$", "argument", "->", "getElementsByTagName", "(", "'name'", ")", "->", "item", "(", "0", ")", "->", "nodeValue", ")", ";", "$", "param_tag", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "types", "=", "explode", "(", "'|'", ",", "$", "argument", "->", "getElementsByTagName", "(", "'type'", ")", "->", "item", "(", "0", ")", "->", "nodeValue", ")", ";", "foreach", "(", "$", "types", "as", "$", "type", ")", "{", "$", "type_element", "=", "new", "\\", "DOMElement", "(", "'type'", ",", "$", "type", ")", ";", "$", "param_tag", "->", "appendChild", "(", "$", "type_element", ")", ";", "}", "$", "argument_element", "=", "$", "argument", "->", "cloneNode", "(", "true", ")", ";", "$", "method", "->", "appendChild", "(", "$", "argument_element", ")", ";", "}", "// add a tag 'magic'", "$", "magic_tag", "=", "new", "\\", "DOMElement", "(", "'tag'", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "magic_tag", ")", ";", "$", "magic_tag", "->", "setAttribute", "(", "'name'", ",", "'magic'", ")", ";", "$", "magic_tag", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "// add a @return tag", "$", "return_tag", "=", "new", "\\", "DOMElement", "(", "'tag'", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "return_tag", ")", ";", "$", "return_tag", "->", "setAttribute", "(", "'name'", ",", "'return'", ")", ";", "$", "return_tag", "->", "setAttribute", "(", "'line'", ",", "$", "node", "->", "getAttribute", "(", "'line'", ")", ")", ";", "$", "return_tag", "->", "setAttribute", "(", "'type'", ",", "$", "node", "->", "getAttribute", "(", "'type'", ")", ")", ";", "// add type sub elements to the param", "foreach", "(", "explode", "(", "'|'", ",", "$", "node", "->", "getAttribute", "(", "'type'", ")", ")", "as", "$", "type", ")", "{", "$", "type_element", "=", "new", "\\", "DOMElement", "(", "'type'", ",", "$", "type", ")", ";", "$", "return_tag", "->", "appendChild", "(", "$", "type_element", ")", ";", "}", "// remove the tag, it is unneeded", "$", "node", "->", "parentNode", "->", "removeChild", "(", "$", "node", ")", ";", "$", "docblock", "->", "appendChild", "(", "$", "node", ")", ";", "}", "return", "$", "xml", ";", "}" ]

[ "Find", "all", "return", "tags", "that", "contain", "self", "or", "$this", "and", "replace", "those", "terms", "for", "the", "name", "of", "the", "current", "class", "type", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "descriptor", "=", "new", "VarDescriptor", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "descriptor", "->", "setDescription", "(", "$", "data", "->", "getDescription", "(", ")", ")", ";", "$", "descriptor", "->", "setVariableName", "(", "$", "data", "->", "getVariableName", "(", ")", ")", ";", "$", "descriptor", "->", "setType", "(", "AssemblerAbstract", "::", "deduplicateTypes", "(", "$", "data", "->", "getType", "(", ")", ")", ")", ";", "return", "$", "descriptor", ";", "}" ]

[ "Creates", "a", "new", "Descriptor", "from", "the", "given", "Reflector", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "traitDescriptor", "=", "new", "TraitDescriptor", "(", ")", ";", "$", "traitDescriptor", "->", "setFullyQualifiedStructuralElementName", "(", "$", "data", "->", "getFqsen", "(", ")", ")", ";", "$", "traitDescriptor", "->", "setName", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "traitDescriptor", "->", "setLine", "(", "$", "data", "->", "getLocation", "(", ")", "->", "getLineNumber", "(", ")", ")", ";", "$", "traitDescriptor", "->", "setPackage", "(", "$", "this", "->", "extractPackageFromDocBlock", "(", "$", "data", "->", "getDocBlock", "(", ")", ")", "?", ":", "''", ")", ";", "// Reflection library formulates namespace as global but this is not wanted for phpDocumentor itself", "$", "traitDescriptor", "->", "setNamespace", "(", "substr", "(", "(", "string", ")", "$", "data", "->", "getFqsen", "(", ")", ",", "0", ",", "-", "strlen", "(", "$", "data", "->", "getName", "(", ")", ")", "-", "1", ")", ")", ";", "$", "this", "->", "assembleDocBlock", "(", "$", "data", "->", "getDocBlock", "(", ")", ",", "$", "traitDescriptor", ")", ";", "$", "this", "->", "addProperties", "(", "$", "data", "->", "getProperties", "(", ")", ",", "$", "traitDescriptor", ")", ";", "$", "this", "->", "addMethods", "(", "$", "data", "->", "getMethods", "(", ")", ",", "$", "traitDescriptor", ")", ";", "return", "$", "traitDescriptor", ";", "}" ]

[ "Creates", "a", "Descriptor", "from", "the", "provided", "data", "." ]

[ "protected", "function", "addProperties", "(", "array", "$", "properties", ",", "TraitDescriptor", "$", "traitDescriptor", ")", ":", "void", "{", "foreach", "(", "$", "properties", "as", "$", "property", ")", "{", "$", "propertyDescriptor", "=", "$", "this", "->", "getBuilder", "(", ")", "->", "buildDescriptor", "(", "$", "property", ")", ";", "if", "(", "$", "propertyDescriptor", "instanceof", "PropertyDescriptor", ")", "{", "$", "propertyDescriptor", "->", "setParent", "(", "$", "traitDescriptor", ")", ";", "$", "traitDescriptor", "->", "getProperties", "(", ")", "->", "set", "(", "$", "propertyDescriptor", "->", "getName", "(", ")", ",", "$", "propertyDescriptor", ")", ";", "}", "}", "}" ]

[ "Registers", "the", "child", "properties", "with", "the", "generated", "Trait", "Descriptor", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "descriptor", "=", "new", "DeprecatedDescriptor", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "descriptor", "->", "setDescription", "(", "$", "data", "->", "getDescription", "(", ")", ")", ";", "$", "descriptor", "->", "setVersion", "(", "$", "data", "->", "getVersion", "(", ")", ")", ";", "return", "$", "descriptor", ";", "}" ]

[ "Creates", "a", "new", "Descriptor", "from", "the", "given", "Reflector", "." ]

[ "public", "function", "create", "(", "$", "data", ")", "{", "$", "descriptor", "=", "new", "ReturnDescriptor", "(", "$", "data", "->", "getName", "(", ")", ")", ";", "$", "descriptor", "->", "setDescription", "(", "$", "data", "->", "getDescription", "(", ")", ")", ";", "$", "descriptor", "->", "setType", "(", "AssemblerAbstract", "::", "deduplicateTypes", "(", "$", "data", "->", "getType", "(", ")", ")", ")", ";", "return", "$", "descriptor", ";", "}" ]

[ "Creates", "a", "new", "Descriptor", "from", "the", "given", "Reflector", "." ]

[ "public", "function", "setVersion", "(", "string", "$", "version", ")", "{", "if", "(", "!", "preg_match", "(", "'/^\\d+\\.\\d+\\.\\d+$/'", ",", "$", "version", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Version number is invalid; '", ".", "$", "version", ".", "' does not match '", ".", "'x.x.x (where x is a number)'", ")", ";", "}", "$", "this", "->", "version", "=", "$", "version", ";", "}" ]

[ "Sets", "the", "version", "number", "for", "this", "template", "." ]

[ "public", "function", "offsetSet", "(", "$", "offset", ",", "$", "value", ")", "{", "if", "(", "!", "$", "value", "instanceof", "Transformation", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'\\phpDocumentor\\Transformer\\Template may only contain items of '", ".", "'type \\phpDocumentor\\Transformer\\Transformation'", ")", ";", "}", "$", "this", "->", "transformations", "[", "$", "offset", "]", "=", "$", "value", ";", "}" ]

[ "Sets", "a", "transformation", "at", "the", "given", "offset", "." ]

[ "public", "function", "propagateParameters", "(", ")", "{", "foreach", "(", "$", "this", "->", "transformations", "as", "$", "transformation", ")", "{", "$", "transformation", "->", "setParameters", "(", "array_merge", "(", "$", "transformation", "->", "getParameters", "(", ")", ",", "$", "this", "->", "getParameters", "(", ")", ")", ")", ";", "}", "}" ]

[ "Pushes", "the", "parameters", "of", "this", "template", "into", "the", "transformations", "." ]

[ "public", "function", "get", "(", "string", "$", "input_format", ",", "string", "$", "output_format", ")", ":", "ConverterInterface", "{", "$", "definition", "=", "$", "this", "->", "definition_factory", "->", "get", "(", "$", "input_format", ",", "$", "output_format", ")", ";", "foreach", "(", "$", "this", "->", "converters", "as", "$", "class", "=>", "$", "formats", ")", "{", "if", "(", "[", "$", "input_format", ",", "$", "output_format", "]", "===", "$", "formats", ")", "{", "$", "assets", "=", "new", "Metadata", "\\", "Assets", "(", ")", ";", "$", "assets", "->", "setLogger", "(", "$", "this", "->", "logger", ")", ";", "$", "toc", "=", "new", "Metadata", "\\", "TableOfContents", "(", ")", ";", "$", "glossary", "=", "new", "Metadata", "\\", "Glossary", "(", ")", ";", "/** @var ConverterInterface $converter */", "$", "converter", "=", "new", "$", "class", "(", "$", "definition", ",", "$", "assets", ",", "$", "toc", ",", "$", "glossary", ")", ";", "$", "converter", "->", "setLogger", "(", "$", "this", "->", "logger", ")", ";", "return", "$", "converter", ";", "}", "}", "throw", "new", "ConverterNotFoundException", "(", "'No converter could be found to convert from '", ".", "$", "input_format", ".", "' to '", ".", "$", "output_format", ")", ";", "}" ]

[ "Retrieves", "a", "new", "instance", "of", "the", "converter", "necessary", "to", "convert", "the", "give", "input", "format", "to", "the", "given", "output", "format", "." ]

[ "public", "function", "getSupportedInputFormats", "(", "string", "$", "given_output_format", ")", ":", "array", "{", "$", "result", "=", "[", "]", ";", "foreach", "(", "$", "this", "->", "converters", "as", "$", "formats", ")", "{", "list", "(", "$", "input_format", ",", "$", "output_format", ")", "=", "$", "formats", ";", "if", "(", "$", "given_output_format", "===", "$", "output_format", ")", "{", "$", "result", "[", "]", "=", "$", "input_format", ";", "}", "}", "return", "$", "result", ";", "}" ]

[ "Returns", "a", "list", "of", "supported", "input", "formats", "for", "the", "given", "output", "format", "." ]

[ "public", "function", "getSourceAsPath", "(", ")", ":", "string", "{", "// externally loaded templates set this parameter so that template", "// resources may be placed in the same folder as the template.", "if", "(", "$", "this", "->", "getParameter", "(", "'template_path'", ")", "!==", "null", ")", "{", "$", "path", "=", "rtrim", "(", "$", "this", "->", "getParameter", "(", "'template_path'", ")", "->", "getValue", "(", ")", ",", "'/\\\\'", ")", ";", "if", "(", "file_exists", "(", "$", "path", ".", "DIRECTORY_SEPARATOR", ".", "$", "this", "->", "source", ")", ")", "{", "return", "$", "path", ".", "DIRECTORY_SEPARATOR", ".", "$", "this", "->", "source", ";", "}", "}", "// counter a BC break that we introduced in 2.0 stable; we removed the notion of global assets", "// to be able to provide composer integration", "// TODO: remove in version 3.0", "if", "(", "strpos", "(", "$", "this", "->", "source", ",", "'templates/'", ")", "!==", "0", ")", "{", "$", "this", "->", "source", "=", "'templates/abstract/'", ".", "$", "this", "->", "source", ";", "trigger_error", "(", "'Using shared assets in a template is deprecated and will be removed in version 3.0'", ",", "E_USER_DEPRECATED", ")", ";", "}", "// check whether the file exists in the phpDocumentor project directory.", "if", "(", "file_exists", "(", "__DIR__", ".", "'/../../../'", ".", "$", "this", "->", "source", ")", ")", "{", "return", "__DIR__", ".", "'/../../../'", ".", "$", "this", "->", "source", ";", "}", "// in case of a composer installation", "if", "(", "file_exists", "(", "__DIR__", ".", "'/../../../../templates'", ")", ")", "{", "return", "__DIR__", ".", "'/../../../../'", ".", "$", "this", "->", "source", ";", "}", "// TODO: replace this as it breaks the component stuff", "// we should ditch the idea of a global set of files to fetch and have", "// a variable / injection for the global templates folder and inject", "// that here.", "$", "file", "=", "__DIR__", ".", "'/../../../data/'", ".", "$", "this", "->", "source", ";", "if", "(", "!", "file_exists", "(", "$", "file", ")", ")", "{", "throw", "new", "Exception", "(", "'The source path does not exist: '", ".", "$", "file", ")", ";", "}", "return", "$", "file", ";", "}" ]

[ "Returns", "the", "source", "as", "a", "path", "instead", "of", "a", "regular", "value", "." ]

[ "public", "function", "getParameter", "(", "$", "name", ")", ":", "?", "Parameter", "{", "/** @var Parameter $parameter */", "foreach", "(", "$", "this", "->", "parameters", "as", "$", "parameter", ")", "{", "if", "(", "$", "parameter", "->", "getKey", "(", ")", "===", "$", "name", ")", "{", "return", "$", "parameter", ";", "}", "}", "return", "null", ";", "}" ]

[ "Returns", "a", "specific", "parameter", "or", "$default", "if", "none", "exists", "." ]

[ "public", "function", "getType", "(", ")", ":", "?", "Type", "{", "if", "(", "$", "this", "->", "type", "===", "null", "&&", "$", "this", "->", "getInheritedElement", "(", ")", "!==", "null", ")", "{", "$", "this", "->", "setType", "(", "$", "this", "->", "getInheritedElement", "(", ")", "->", "getType", "(", ")", ")", ";", "}", "return", "$", "this", "->", "type", ";", "}" ]

[ "{" ]

[ "public", "function", "populate", "(", "ProjectDescriptor", "$", "projectDescriptor", ")", ":", "void", "{", "$", "this", "->", "loadCacheItemAsSettings", "(", "$", "projectDescriptor", ",", "self", "::", "KEY_SETTINGS", ")", ";", "foreach", "(", "$", "this", "->", "getCache", "(", ")", "as", "$", "key", ")", "{", "$", "this", "->", "loadCacheItemAsFile", "(", "$", "projectDescriptor", ",", "$", "key", ")", ";", "}", "}" ]

[ "Returns", "the", "Project", "Descriptor", "from", "the", "cache", "." ]

[ "public", "function", "save", "(", "ProjectDescriptor", "$", "projectDescriptor", ")", ":", "void", "{", "$", "keys", "=", "[", "]", ";", "$", "cache", "=", "$", "this", "->", "getCache", "(", ")", ";", "foreach", "(", "$", "cache", "as", "$", "key", ")", "{", "$", "keys", "[", "]", "=", "$", "key", ";", "}", "// store the settings for this Project Descriptor", "$", "cache", "->", "setItem", "(", "self", "::", "KEY_SETTINGS", ",", "$", "projectDescriptor", "->", "getSettings", "(", ")", ")", ";", "// store cache items", "$", "usedKeys", "=", "[", "self", "::", "KEY_SETTINGS", "]", ";", "foreach", "(", "$", "projectDescriptor", "->", "getFiles", "(", ")", "as", "$", "file", ")", "{", "$", "key", "=", "self", "::", "FILE_PREFIX", ".", "md5", "(", "$", "file", "->", "getPath", "(", ")", ")", ";", "$", "usedKeys", "[", "]", "=", "$", "key", ";", "$", "cache", "->", "setItem", "(", "$", "key", ",", "$", "file", ")", ";", "}", "// remove any keys that are no longer used.", "$", "invalidatedKeys", "=", "array_diff", "(", "$", "keys", ",", "$", "usedKeys", ")", ";", "if", "(", "$", "invalidatedKeys", ")", "{", "$", "cache", "->", "removeItems", "(", "$", "invalidatedKeys", ")", ";", "}", "if", "(", "$", "cache", "instanceof", "OptimizableInterface", ")", "{", "$", "cache", "->", "optimize", "(", ")", ";", "}", "}" ]

[ "Stores", "a", "Project", "Descriptor", "in", "the", "Cache", "." ]

[ "public", "function", "toDocbook", "(", "\\", "DOMDocument", "$", "document", ",", "\\", "DOMElement", "$", "root", ")", "{", "$", "this", "->", "storeAsset", "(", ")", ";", "parent", "::", "toDocbook", "(", "$", "document", ",", "$", "root", ")", ";", "}" ]

[ "Converts", "the", "Image", "directive", "to", "aDocBook", "image", "tag", "." ]

[ "public", "function", "toXhtml", "(", "\\", "DOMDocument", "$", "document", ",", "\\", "DOMElement", "$", "root", ")", "{", "$", "this", "->", "storeAsset", "(", ")", ";", "parent", "::", "toXhtml", "(", "$", "document", ",", "$", "root", ")", ";", "}" ]

[ "Converts", "the", "Image", "directive", "to", "an", "<img", "/", ">", "tag", "." ]

[ "protected", "function", "storeAsset", "(", ")", "{", "if", "(", "!", "$", "this", "->", "visitor", "instanceof", "Discover", ")", "{", "return", ";", "}", "$", "assets", "=", "$", "this", "->", "getAssetManager", "(", ")", ";", "$", "project_root", "=", "$", "assets", "->", "getProjectRoot", "(", ")", ";", "$", "asset_path", "=", "trim", "(", "$", "this", "->", "node", "->", "parameters", ")", ";", "$", "file_path", "=", "$", "this", "->", "visitor", "->", "getDocument", "(", ")", "->", "getFile", "(", ")", "->", "getRealPath", "(", ")", ";", "// get source path", "$", "source", "=", "(", "$", "asset_path", "[", "0", "]", "!==", "'/'", ")", "?", "dirname", "(", "$", "file_path", ")", ".", "'/'", ".", "$", "asset_path", ":", "$", "project_root", ".", "$", "asset_path", ";", "// get destination path", "$", "destination", "=", "(", "$", "asset_path", "[", "0", "]", "!==", "'/'", ")", "?", "substr", "(", "dirname", "(", "$", "file_path", ")", ".", "'/'", ".", "$", "asset_path", ",", "strlen", "(", "$", "project_root", ")", ")", ":", "substr", "(", "$", "asset_path", ",", "1", ")", ";", "// set asset", "$", "assets", "->", "set", "(", "$", "source", ",", "$", "destination", ")", ";", "}" ]

[ "Stores", "the", "asset", "in", "the", "asset", "manager", "." ]

[ "public", "function", "execute", "(", "ProjectDescriptor", "$", "project", ")", ":", "void", "{", "$", "markerTerms", "=", "$", "project", "->", "getSettings", "(", ")", "->", "getMarkers", "(", ")", ";", "foreach", "(", "$", "project", "->", "getFiles", "(", ")", "as", "$", "file", ")", "{", "$", "marker_data", "=", "[", "]", ";", "$", "matches", "=", "[", "]", ";", "preg_match_all", "(", "'~//[\\s]*('", ".", "implode", "(", "'|'", ",", "$", "markerTerms", ")", ".", "')\\:?[\\s]*(.*)~'", ",", "$", "file", "->", "getSource", "(", ")", ",", "$", "matches", ",", "PREG_SET_ORDER", "|", "PREG_OFFSET_CAPTURE", ")", ";", "foreach", "(", "$", "matches", "as", "$", "match", ")", "{", "list", "(", "$", "before", ")", "=", "str_split", "(", "$", "file", "->", "getSource", "(", ")", ",", "$", "match", "[", "1", "]", "[", "1", "]", ")", ";", "// fetches all the text before the match", "$", "line_number", "=", "strlen", "(", "$", "before", ")", "-", "strlen", "(", "str_replace", "(", "\"\\n\"", ",", "''", ",", "$", "before", ")", ")", "+", "1", ";", "$", "marker_data", "[", "]", "=", "[", "'type'", "=>", "trim", "(", "$", "match", "[", "1", "]", "[", "0", "]", ",", "'@'", ")", ",", "'line'", "=>", "$", "line_number", ",", "$", "match", "[", "2", "]", "[", "0", "]", "]", ";", "}", "$", "file", "->", "setMarkers", "(", "new", "Collection", "(", "$", "marker_data", ")", ")", ";", "}", "}" ]

[ "Scans", "the", "files", "for", "markers", "and", "records", "them", "in", "the", "markers", "property", "of", "a", "file", "." ]

[ "public", "function", "toXhtml", "(", "\\", "DOMDocument", "$", "document", ",", "\\", "DOMElement", "$", "root", ")", "{", "$", "content", "=", "''", ";", "/** @var \\ezcDocumentRstToken $token */", "foreach", "(", "$", "this", "->", "node", "->", "tokens", "as", "$", "token", ")", "{", "$", "content", ".=", "$", "token", "->", "content", ";", "}", "$", "content", "=", "rtrim", "(", "$", "content", ",", "\"\\n\"", ")", ";", "$", "pre", "=", "$", "document", "->", "createElement", "(", "'pre'", ")", ";", "$", "root", "->", "appendChild", "(", "$", "pre", ")", ";", "$", "code", "=", "$", "document", "->", "createElement", "(", "'code'", ",", "$", "content", ")", ";", "$", "pre", "->", "appendChild", "(", "$", "code", ")", ";", "}" ]

[ "Transform", "directive", "to", "HTML" ]

[ "public", "function", "register", "(", "Container", "$", "app", ")", ":", "void", "{", "/** @var Collection $writerCollection */", "$", "writerCollection", "=", "$", "app", "[", "'transformer.writer.collection'", "]", ";", "$", "twigWriter", "=", "new", "Writer", "\\", "Twig", "(", "$", "app", "[", "\\", "Twig", "\\", "Environment", "::", "class", "]", ")", ";", "$", "writerCollection", "[", "'twig'", "]", "=", "$", "twigWriter", ";", "}" ]

[ "Registers", "services", "on", "the", "given", "app", "." ]

[ "public", "function", "convert", "(", "\\", "DOMElement", "$", "parent", ",", "ArgumentDescriptor", "$", "argument", ")", "{", "$", "child", "=", "new", "\\", "DOMElement", "(", "'argument'", ")", ";", "$", "parent", "->", "appendChild", "(", "$", "child", ")", ";", "$", "child", "->", "setAttribute", "(", "'line'", ",", "(", "string", ")", "$", "argument", "->", "getLine", "(", ")", ")", ";", "$", "child", "->", "setAttribute", "(", "'by_reference'", ",", "var_export", "(", "$", "argument", "->", "isByReference", "(", ")", ",", "true", ")", ")", ";", "$", "child", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'name'", ",", "$", "argument", "->", "getName", "(", ")", ")", ")", ";", "$", "child", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'default'", ")", ")", "->", "appendChild", "(", "new", "\\", "DOMText", "(", "(", "string", ")", "$", "argument", "->", "getDefault", "(", ")", ")", ")", ";", "$", "child", "->", "appendChild", "(", "new", "\\", "DOMElement", "(", "'type'", ",", "(", "string", ")", "$", "argument", "->", "getType", "(", ")", ")", ")", ";", "return", "$", "child", ";", "}" ]

[ "Exports", "the", "given", "reflection", "object", "to", "the", "parent", "XML", "element", "." ]

[ "public", "function", "transform", "(", "ProjectDescriptor", "$", "project", ",", "Transformation", "$", "transformation", ")", "{", "$", "artifact", "=", "$", "this", "->", "getDestinationPath", "(", "$", "transformation", ")", ";", "$", "this", "->", "checkForSpacesInPath", "(", "$", "artifact", ")", ";", "$", "this", "->", "xml", "=", "new", "\\", "DOMDocument", "(", "'1.0'", ",", "'utf-8'", ")", ";", "$", "this", "->", "xml", "->", "formatOutput", "=", "true", ";", "$", "document_element", "=", "new", "\\", "DOMElement", "(", "'project'", ")", ";", "$", "this", "->", "xml", "->", "appendChild", "(", "$", "document_element", ")", ";", "$", "document_element", "->", "setAttribute", "(", "'title'", ",", "$", "project", "->", "getName", "(", ")", ")", ";", "$", "document_element", "->", "setAttribute", "(", "'version'", ",", "Application", "::", "VERSION", "(", ")", ")", ";", "$", "this", "->", "buildPartials", "(", "$", "document_element", ",", "$", "project", ")", ";", "$", "transformer", "=", "$", "transformation", "->", "getTransformer", "(", ")", ";", "foreach", "(", "$", "project", "->", "getFiles", "(", ")", "as", "$", "file", ")", "{", "$", "this", "->", "buildFile", "(", "$", "document_element", ",", "$", "file", ",", "$", "transformer", ")", ";", "}", "$", "this", "->", "finalize", "(", "$", "project", ")", ";", "file_put_contents", "(", "$", "artifact", ",", "$", "this", "->", "xml", "->", "saveXML", "(", ")", ")", ";", "}" ]

[ "This", "method", "generates", "the", "AST", "output" ]

[ "protected", "function", "finalize", "(", "ProjectDescriptor", "$", "projectDescriptor", ")", "{", "// TODO: move all these behaviours to a central location for all template parsers", "$", "behaviour", "=", "new", "AuthorTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "CoversTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "IgnoreTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "InternalTag", "(", "$", "projectDescriptor", "->", "isVisibilityAllowed", "(", "ProjectDescriptor", "\\", "Settings", "::", "VISIBILITY_INTERNAL", ")", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "LicenseTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "MethodTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "ParamTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "PropertyTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "ReturnTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "UsesTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "behaviour", "=", "new", "VarTag", "(", ")", ";", "$", "behaviour", "->", "process", "(", "$", "this", "->", "xml", ")", ";", "$", "this", "->", "buildPackageTree", "(", "$", "this", "->", "xml", ")", ";", "$", "this", "->", "buildNamespaceTree", "(", "$", "this", "->", "xml", ")", ";", "$", "this", "->", "buildDeprecationList", "(", "$", "this", "->", "xml", ")", ";", "}" ]

[ "Finalizes", "the", "processing", "and", "executing", "all", "post", "-", "processing", "actions", "." ]

[ "protected", "function", "buildDeprecationList", "(", "\\", "DOMDocument", "$", "dom", ")", "{", "$", "nodes", "=", "$", "this", "->", "getNodeListForTagBasedQuery", "(", "$", "dom", ",", "'deprecated'", ")", ";", "$", "node", "=", "new", "\\", "DOMElement", "(", "'deprecated'", ")", ";", "$", "dom", "->", "documentElement", "->", "appendChild", "(", "$", "node", ")", ";", "$", "node", "->", "setAttribute", "(", "'count'", ",", "(", "string", ")", "$", "nodes", "->", "length", ")", ";", "}" ]

[ "Adds", "a", "node", "to", "the", "xml", "for", "deprecations", "and", "the", "count", "value" ]

[ "protected", "function", "getNodeListForTagBasedQuery", "(", "$", "dom", ",", "$", "marker", ")", "{", "$", "xpath", "=", "new", "\\", "DOMXPath", "(", "$", "dom", ")", ";", "$", "query", "=", "'/project/file/markers/'", ".", "$", "marker", ".", "'|'", ";", "$", "query", ".=", "'/project/file/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/class/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/class/*/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/interface/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/interface/*/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/function/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]|'", ";", "$", "query", ".=", "'/project/file/constant/docblock/tag[@name=\"'", ".", "$", "marker", ".", "'\"]'", ";", "return", "$", "xpath", "->", "query", "(", "$", "query", ")", ";", "}" ]

[ "Build", "a", "tag", "based", "query", "string", "and", "return", "result" ]

[ "protected", "function", "configureConverterFromInputOptions", "(", "$", "converter", ",", "$", "input", ")", "{", "if", "(", "!", "$", "converter", "instanceof", "ToLatexInterface", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'The converter used to process '", ".", "$", "input", "->", "getOption", "(", "'input-format'", ")", ".", "' should implement the '", ".", "'phpDocumentor\\Plugin\\Scrybe\\Converter\\ToPdfInterface'", ")", ";", "}", "$", "converter", "->", "setTitle", "(", "$", "input", "->", "getOption", "(", "'title'", ")", ")", ";", "$", "converter", "->", "setAuthor", "(", "$", "input", "->", "getOption", "(", "'author'", ")", ")", ";", "$", "converter", "->", "setCoverLogo", "(", "$", "input", "->", "getOption", "(", "'cover-logo'", ")", ")", ";", "$", "converter", "->", "setTableOfContents", "(", "$", "input", "->", "getOption", "(", "'toc'", ")", "!==", "'false'", ")", ";", "}" ]

[ "Configures", "the", "converter", "with", "the", "options", "provided", "by", "the", "Input", "options", "." ]

[ "public", "function", "generate", "(", "$", "node", ",", "$", "directorySeparator", "=", "DIRECTORY_SEPARATOR", ")", "{", "$", "webserverPath", "=", "$", "this", "->", "rule", "->", "generate", "(", "$", "node", ")", ";", "return", "$", "webserverPath", "===", "false", "?", "false", ":", "str_replace", "(", "'/'", ",", "$", "directorySeparator", ",", "$", "webserverPath", ")", ";", "}" ]

[ "Generates", "an", "URL", "for", "the", "given", "node", "." ]

[ "public", "function", "create", "(", "array", "$", "paths", ",", "array", "$", "ignore", ",", "array", "$", "extensions", ")", ":", "SpecificationInterface", "{", "$", "pathSpec", "=", "null", ";", "foreach", "(", "$", "paths", "as", "$", "path", ")", "{", "$", "pathSpec", "=", "$", "this", "->", "orSpec", "(", "$", "this", "->", "inPath", "(", "$", "path", ")", ",", "$", "pathSpec", ")", ";", "}", "$", "ignoreSpec", "=", "null", ";", "if", "(", "isset", "(", "$", "ignore", "[", "'paths'", "]", ")", ")", "{", "foreach", "(", "$", "ignore", "[", "'paths'", "]", "as", "$", "path", ")", "{", "$", "ignoreSpec", "=", "$", "this", "->", "orSpec", "(", "$", "this", "->", "inPath", "(", "$", "path", ")", ",", "$", "ignoreSpec", ")", ";", "}", "}", "if", "(", "isset", "(", "$", "ignore", "[", "'hidden'", "]", ")", "&&", "$", "ignore", "[", "'hidden'", "]", "===", "true", ")", "{", "$", "ignoreSpec", "=", "$", "this", "->", "orSpec", "(", "new", "IsHidden", "(", ")", ",", "$", "ignoreSpec", ")", ";", "}", "return", "$", "this", "->", "andSpec", "(", "$", "pathSpec", ",", "$", "this", "->", "andSpec", "(", "new", "HasExtension", "(", "$", "extensions", ")", ",", "$", "this", "->", "notSpec", "(", "$", "ignoreSpec", ")", ")", ")", ";", "}" ]

[ "Creates", "a", "SpecificationInterface", "object", "based", "on", "the", "ignore", "and", "extension", "parameters", "." ]

[ "private", "function", "orSpec", "(", "SpecificationInterface", "$", "or", ",", "SpecificationInterface", "$", "spec", "=", "null", ")", ":", "SpecificationInterface", "{", "if", "(", "$", "spec", "===", "null", ")", "{", "return", "$", "or", ";", "}", "return", "new", "OrSpecification", "(", "$", "spec", ",", "$", "or", ")", ";", "}" ]

[ "Will", "return", "an", "OrSpecification", "when", "$or", "and", "$spec", "are", "both", "not", "null", "." ]

[ "private", "function", "buildVersion", "(", "SimpleXMLElement", "$", "version", ")", ":", "array", "{", "$", "apis", "=", "[", "]", ";", "$", "guides", "=", "[", "]", ";", "foreach", "(", "$", "version", "->", "children", "(", ")", "as", "$", "child", ")", "{", "switch", "(", "$", "child", "->", "getName", "(", ")", ")", "{", "case", "'api'", ":", "$", "apis", "[", "]", "=", "$", "this", "->", "buildApi", "(", "$", "child", ")", ";", "break", ";", "case", "'guide'", ":", "$", "guides", "[", "]", "=", "$", "this", "->", "buildGuide", "(", "$", "child", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "$", "version", "=", "[", "'folder'", "=>", "(", "string", ")", "$", "version", "->", "folder", ",", "]", ";", "if", "(", "count", "(", "$", "apis", ")", ">", "0", ")", "{", "$", "version", "[", "'api'", "]", "=", "$", "apis", ";", "}", "if", "(", "count", "(", "$", "guides", ")", ">", "0", ")", "{", "$", "version", "[", "'guide'", "]", "=", "$", "guides", ";", "}", "return", "$", "version", ";", "}" ]

[ "Builds", "the", "versions", "part", "of", "the", "array", "from", "the", "configuration", "xml", "." ]

[ "private", "function", "buildApi", "(", "SimpleXMLElement", "$", "api", ")", ":", "array", "{", "$", "extensions", "=", "[", "]", ";", "foreach", "(", "$", "api", "->", "extensions", "->", "children", "(", ")", "as", "$", "extension", ")", "{", "if", "(", "(", "string", ")", "$", "extension", "!==", "''", ")", "{", "$", "extensions", "[", "]", "=", "(", "string", ")", "$", "extension", ";", "}", "}", "$", "ignoreHidden", "=", "filter_var", "(", "$", "api", "->", "ignore", "->", "attributes", "(", ")", "->", "hidden", ",", "FILTER_VALIDATE_BOOLEAN", ")", ";", "return", "[", "'format'", "=>", "(", "(", "string", ")", "$", "api", "->", "attributes", "(", ")", "->", "format", ")", "?", ":", "'php'", ",", "'source'", "=>", "[", "'dsn'", "=>", "(", "(", "string", ")", "$", "api", "->", "source", "->", "attributes", "(", ")", "->", "dsn", ")", "?", ":", "'file://.'", ",", "'paths'", "=>", "(", "(", "array", ")", "$", "api", "->", "source", "->", "path", ")", "?", ":", "[", "'.'", "]", ",", "]", ",", "'ignore'", "=>", "[", "'hidden'", "=>", "$", "ignoreHidden", ",", "'paths'", "=>", "(", "array", ")", "$", "api", "->", "ignore", "->", "path", ",", "]", ",", "'extensions'", "=>", "$", "extensions", ",", "'visibility'", "=>", "(", "array", ")", "$", "api", "->", "visibility", ",", "'default-package-name'", "=>", "(", "(", "string", ")", "$", "api", "->", "{", "'default-package-name'", "}", ")", "?", ":", "'Default'", ",", "'markers'", "=>", "(", "array", ")", "$", "api", "->", "markers", "->", "children", "(", ")", "->", "marker", ",", "]", ";", "}" ]

[ "Builds", "the", "api", "part", "of", "the", "array", "from", "the", "configuration", "xml", "." ]

[ "private", "function", "buildGuide", "(", "SimpleXMLElement", "$", "guide", ")", ":", "array", "{", "return", "[", "'format'", "=>", "(", "(", "string", ")", "$", "guide", "->", "attributes", "(", ")", "->", "format", ")", "?", ":", "'rst'", ",", "'source'", "=>", "[", "'dsn'", "=>", "(", "(", "string", ")", "$", "guide", "->", "source", "->", "attributes", "(", ")", "->", "dsn", ")", "?", ":", "'file://.'", ",", "'paths'", "=>", "(", "(", "array", ")", "$", "guide", "->", "source", "->", "path", ")", "?", ":", "[", "''", "]", ",", "]", ",", "]", ";", "}" ]

[ "Builds", "the", "guide", "part", "of", "the", "array", "from", "the", "configuration", "xml", "." ]

[ "private", "function", "buildTemplate", "(", "SimpleXMLElement", "$", "template", ")", ":", "array", "{", "if", "(", "(", "array", ")", "$", "template", "===", "[", "]", ")", "{", "return", "$", "this", "->", "defaultTemplate", "(", ")", ";", "}", "$", "attributes", "=", "[", "]", ";", "foreach", "(", "$", "template", "->", "attributes", "(", ")", "as", "$", "attribute", ")", "{", "$", "attributes", "[", "$", "attribute", "->", "getName", "(", ")", "]", "=", "(", "string", ")", "$", "attribute", ";", "}", "return", "$", "attributes", ";", "}" ]

[ "Builds", "the", "template", "part", "of", "the", "array", "from", "the", "configuration", "xml", "." ]

[ "private", "function", "validate", "(", "SimpleXMLElement", "$", "phpDocumentor", ")", ":", "void", "{", "libxml_clear_errors", "(", ")", ";", "$", "priorSetting", "=", "libxml_use_internal_errors", "(", "true", ")", ";", "$", "dom", "=", "new", "\\", "DOMDocument", "(", ")", ";", "$", "domElement", "=", "dom_import_simplexml", "(", "$", "phpDocumentor", ")", ";", "$", "domElement", "=", "$", "dom", "->", "importNode", "(", "$", "domElement", ",", "true", ")", ";", "$", "dom", "->", "appendChild", "(", "$", "domElement", ")", ";", "$", "dom", "->", "schemaValidate", "(", "$", "this", "->", "schemaPath", ")", ";", "$", "error", "=", "libxml_get_last_error", "(", ")", ";", "if", "(", "$", "error", "!==", "false", ")", "{", "throw", "new", "InvalidArgumentException", "(", "trim", "(", "$", "error", "->", "message", ")", ")", ";", "}", "libxml_use_internal_errors", "(", "$", "priorSetting", ")", ";", "}" ]

[ "Validates", "the", "configuration", "xml", "structure", "against", "the", "schema", "defined", "in", "the", "schemaPath", "." ]

[ "public", "function", "get", "(", "$", "index", ",", "$", "valueIfEmpty", "=", "null", ")", "{", "if", "(", "!", "$", "this", "->", "offsetExists", "(", "$", "index", ")", "&&", "$", "valueIfEmpty", "!==", "null", ")", "{", "$", "this", "->", "offsetSet", "(", "$", "index", ",", "$", "valueIfEmpty", ")", ";", "}", "return", "$", "this", "->", "offsetGet", "(", "$", "index", ")", ";", "}" ]

[ "Retrieves", "a", "specific", "item", "from", "the", "Collection", "with", "its", "index", "." ]

[ "public", "function", "offsetSet", "(", "$", "offset", ",", "$", "value", ")", "{", "if", "(", "$", "offset", "===", "''", "||", "$", "offset", "===", "null", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'The key of a collection must always be set'", ")", ";", "}", "$", "this", "->", "items", "[", "$", "offset", "]", "=", "$", "value", ";", "}" ]

[ "Sets", "an", "item", "at", "the", "given", "index", "." ]

[ "public", "function", "generate", "(", "$", "node", ")", "{", "$", "callable", "=", "$", "this", "->", "generator", ";", "$", "generatedPathAsUtf8", "=", "$", "callable", "(", "$", "node", ")", ";", "return", "$", "generatedPathAsUtf8", "?", "$", "this", "->", "translateToUrlEncodedPath", "(", "$", "generatedPathAsUtf8", ")", ":", "false", ";", "}" ]

[ "Generates", "an", "URL", "for", "the", "given", "node", "." ]

[ "public", "function", "copyTo", "(", "$", "destination", ")", "{", "foreach", "(", "$", "this", "as", "$", "source_path", "=>", "$", "asset_path", ")", "{", "if", "(", "!", "is_readable", "(", "$", "source_path", ")", ")", "{", "if", "(", "$", "this", "->", "logger", ")", "{", "$", "this", "->", "logger", "->", "error", "(", "'Asset \"'", ".", "$", "source_path", ".", "'\" could not be found or is not readable'", ")", ";", "}", "continue", ";", "}", "$", "destination_path", "=", "$", "destination", ".", "'/'", ".", "$", "asset_path", ";", "if", "(", "!", "file_exists", "(", "dirname", "(", "$", "destination_path", ")", ")", ")", "{", "mkdir", "(", "dirname", "(", "$", "destination_path", ")", ",", "0777", ",", "true", ")", ";", "}", "copy", "(", "$", "source_path", ",", "$", "destination_path", ")", ";", "}", "}" ]

[ "Copies", "all", "assets", "in", "this", "collection", "to", "their", "given", "destination", "location", "." ]

[ "public", "function", "findAlias", "(", "string", "$", "fqsen", ",", "$", "container", "=", "null", ")", "{", "$", "fqsen", "=", "$", "this", "->", "replacePseudoTypes", "(", "$", "fqsen", ",", "$", "container", ")", ";", "if", "(", "$", "this", "->", "isContextMarkerInFqsen", "(", "$", "fqsen", ")", "&&", "$", "container", "instanceof", "DescriptorAbstract", ")", "{", "// first exchange `@context::element` for `\\My\\Class::element` and if it exists, return that", "$", "classMember", "=", "$", "this", "->", "fetchElementByFqsen", "(", "$", "this", "->", "getTypeWithClassAsContext", "(", "$", "fqsen", ",", "$", "container", ")", ")", ";", "if", "(", "$", "classMember", ")", "{", "return", "$", "classMember", ";", "}", "// otherwise exchange `@context::element` for `\\My\\element` and if it exists, return that", "$", "namespaceContext", "=", "$", "this", "->", "getTypeWithNamespaceAsContext", "(", "$", "fqsen", ",", "$", "container", ")", ";", "$", "namespaceMember", "=", "$", "this", "->", "fetchElementByFqsen", "(", "$", "namespaceContext", ")", ";", "if", "(", "$", "namespaceMember", ")", "{", "return", "$", "namespaceMember", ";", "}", "// otherwise check if the element exists in the global namespace and if it exists, return that", "$", "globalNamespaceContext", "=", "$", "this", "->", "getTypeWithGlobalNamespaceAsContext", "(", "$", "fqsen", ")", ";", "$", "globalNamespaceMember", "=", "$", "this", "->", "fetchElementByFqsen", "(", "$", "globalNamespaceContext", ")", ";", "if", "(", "$", "globalNamespaceMember", ")", "{", "return", "$", "globalNamespaceMember", ";", "}", "// Otherwise we assume it is an undocumented class/interface/trait and return `\\My\\element` so", "// that the name containing the marker may be replaced by the class reference as string", "return", "$", "namespaceContext", ";", "}", "return", "$", "this", "->", "fetchElementByFqsen", "(", "$", "fqsen", ")", ";", "}" ]

[ "Attempts", "to", "find", "a", "Descriptor", "object", "alias", "with", "the", "FQSEN", "of", "the", "element", "it", "represents", "." ]