def handleConstantDefinition(item, classNode):
if (item.type == "assignment"):
# This is a "normal" constant definition
leftItem = item.getFirstListChild("left")
name = leftItem.children[len(leftItem.children) - 1].get("name")
valueNode = item.getChild("right")
elif (item.type == "keyvalue"):
# This is a constant definition of a map-style class (like qx.Const)
name = item.get("key")
valueNode = item.getChild("value")
if not name.isupper():
return
node = tree.Node("constant")
node.set("name", name)
value = None
if valueNode.hasChild("constant"):
node.set("value", valueNode.getChild("constant").get("value"))
node.set("type", valueNode.getChild("constant").get("constantType").capitalize())
commentAttributes = comment.parseNode(item)
description = comment.getAttrib(commentAttributes, "description")
addTypeInfo(node, description, item)
classNode.addListChild("constants", node)
def handleConstantDefinition(item, classNode):
if (item.type == "assignment"):
# This is a "normal" constant definition
leftItem = item.getFirstListChild("left")
name = leftItem.children[len(leftItem.children) - 1].get("name")
valueNode = item.getChild("right")
elif (item.type == "keyvalue"):
# This is a constant definition of a map-style class (like qx.Const)
name = item.get("key")
valueNode = item.getChild("value")
if not name.isupper():
return
node = tree.Node("constant")
node.set("name", name)
value = None
if valueNode.hasChild("constant"):
node.set("value", valueNode.getChild("constant").get("value"))
node.set(
"type",
valueNode.getChild("constant").get("constantType").capitalize())
commentAttributes = comment.parseNode(item)
description = comment.getAttrib(commentAttributes, "description")
addTypeInfo(node, description, item)
classNode.addListChild("constants", node)
def handlePropertyDefinitionOldCommon(item, classNode, propertyName, paramsMap):
node = tree.Node("property")
node.set("name", propertyName)
propType = paramsMap.getChildByAttribute("key", "type", False)
if propType:
node.set("type", getType(propType.getChild("value").getFirstChild()))
allowNull = paramsMap.getChildByAttribute("key", "allowNull", False)
if allowNull:
node.set("allowNull", allowNull.getChild("value").getChild("constant").get("value"))
defaultValue = paramsMap.getChildByAttribute("key", "defaultValue", False)
if defaultValue:
node.set("defaultValue", getValue(defaultValue.getFirstListChild("value")))
getAlias = paramsMap.getChildByAttribute("key", "getAlias", False)
if getAlias:
node.set("getAlias", getAlias.getChild("value").getChild("constant").get("value"))
setAlias = paramsMap.getChildByAttribute("key", "setAlias", False)
if setAlias:
node.set("setAlias", setAlias.getChild("value").getChild("constant").get("value"))
unitDetection = paramsMap.getChildByAttribute("key", "unitDetection", False)
if unitDetection:
node.set("unitDetection", unitDetection.getChild("value").getChild("constant").get("value"))
instance = paramsMap.getChildByAttribute("key", "instance", False)
if instance:
node.set("instance", instance.getChild("value").getChild("constant").get("value"))
classname = paramsMap.getChildByAttribute("key", "classname", False)
if classname:
node.set("classname", classname.getChild("value").getChild("constant").get("value"))
possibleValues = paramsMap.getChildByAttribute("key", "possibleValues", False)
if possibleValues:
array = possibleValues.getChild("value").getChild("array")
values = ""
for arrayItem in array.children:
if len(values) != 0:
values += ", "
values += getValue(arrayItem)
node.set("possibleValues", values)
# If the description has a type specified then take this type
# (and not the one extracted from the paramsMap)
commentAttributes = comment.parseNode(item)
addTypeInfo(node, comment.getAttrib(commentAttributes, "description"), item)
classNode.addListChild("properties", node)
def handleMembers(item, classNode):
if item.hasChildren():
for keyvalue in item.children:
key = keyvalue.get("key")
value = keyvalue.getFirstChild(True, True).getFirstChild(True, True)
commentAttributes = comment.parseNode(keyvalue)
# print " - Found Member: %s = %s" % (key, value.type)
# Function
if value.type == "function":
node = handleFunction(value, commentAttributes, classNode)
node.set("name", key)
classNode.addListChild("methods", node)
def handleMembers(item, classNode):
if item.hasChildren():
for keyvalue in item.children:
key = keyvalue.get("key")
value = keyvalue.getFirstChild(True,
True).getFirstChild(True, True)
commentAttributes = comment.parseNode(keyvalue)
# print " - Found Member: %s = %s" % (key, value.type)
# Function
if value.type == "function":
node = handleFunction(value, commentAttributes, classNode)
node.set("name", key)
classNode.addListChild("methods", node)
def handleStatics(item, classNode):
if item.hasChildren():
for keyvalue in item.children:
key = keyvalue.get("key")
value = keyvalue.getFirstChild(True, True).getFirstChild(True, True)
commentAttributes = comment.parseNode(keyvalue)
# print " - Found Static: %s = %s" % (key, value.type)
# Function
if value.type == "function":
node = handleFunction(value, commentAttributes, classNode)
node.set("name", key)
node.set("isStatic", True)
classNode.addListChild("methods-static", node)
# Constant
elif key.isupper():
handleConstantDefinition(keyvalue, classNode)
def handleStatics(item, classNode):
if item.hasChildren():
for keyvalue in item.children:
key = keyvalue.get("key")
value = keyvalue.getFirstChild(True,
True).getFirstChild(True, True)
commentAttributes = comment.parseNode(keyvalue)
# print " - Found Static: %s = %s" % (key, value.type)
# Function
if value.type == "function":
node = handleFunction(value, commentAttributes, classNode)
node.set("name", key)
node.set("isStatic", True)
classNode.addListChild("methods-static", node)
# Constant
elif key.isupper():
handleConstantDefinition(keyvalue, classNode)
def handleMethodDefinitionOld(item, isStatic, classNode):
if item.type == "assignment":
# This is a "normal" method definition
leftItem = item.getFirstListChild("left")
name = leftItem.children[len(leftItem.children) - 1].get("name")
functionItem = item.getFirstListChild("right")
elif item.type == "keyvalue":
# This is a method definition of a map-style class (like qx.Const)
name = item.get("key")
functionItem = item.getFirstListChild("value")
commentAttributes = comment.parseNode(item)
node = handleFunction(functionItem, commentAttributes, classNode)
node.set("name", name)
isPublic = name[0] != "_"
listName = "methods"
if isStatic:
node.set("isStatic", True)
listName += "-static"
classNode.addListChild(listName, node)
def handleMethodDefinitionOld(item, isStatic, classNode):
if item.type == "assignment":
# This is a "normal" method definition
leftItem = item.getFirstListChild("left")
name = leftItem.children[len(leftItem.children) - 1].get("name")
functionItem = item.getFirstListChild("right")
elif item.type == "keyvalue":
# This is a method definition of a map-style class (like qx.Const)
name = item.get("key")
functionItem = item.getFirstListChild("value")
commentAttributes = comment.parseNode(item)
node = handleFunction(functionItem, commentAttributes, classNode)
node.set("name", name)
isPublic = name[0] != "_"
listName = "methods"
if isStatic:
node.set("isStatic", True)
listName += "-static"
classNode.addListChild(listName, node)
def handleClassDefinitionOld(docTree, item):
params = item.getChild("params")
paramsLen = len(params.children);
if paramsLen == 1:
superClassName = "Object"
ctorItem = None
elif paramsLen == 2:
superClassName = "Object"
ctorItem = params.children[1]
elif paramsLen == 3:
superClassName = assembleVariable(params.children[1])
ctorItem = params.children[2]
else:
raise DocException("defineClass call has more than three parameters: " + str(len(params.children)), item)
className = params.children[0].get("value")
classNode = getClassNode(docTree, className)
if superClassName != "Object":
superClassNode = getClassNode(docTree, superClassName)
childClasses = superClassNode.get("childClasses", False)
if childClasses:
childClasses += "," + className
else:
childClasses = className
superClassNode.set("childClasses", childClasses)
classNode.set("superClass", superClassName)
commentAttributes = comment.parseNode(item)
for attrib in commentAttributes:
if attrib["category"] == "event":
# Add the event
if comment.attribHas(attrib, "name") and comment.attribHas(attrib, "type"):
addEventNode(classNode, item, attrib);
else:
addError(classNode, "Documentation contains malformed event attribute.", item)
elif attrib["category"] == "description":
if attrib.has_key("text"):
descNode = tree.Node("desc").set("text", attrib["text"])
classNode.addChild(descNode)
# Add the constructor
if ctorItem and ctorItem.type == "function":
ctor = handleFunction(ctorItem, commentAttributes, classNode)
ctor.set("isCtor", True)
classNode.addListChild("constructor", ctor)
# Check for methods defined in the constructor
# (for method definition style that supports real private methods)
ctorBlock = ctorItem.getChild("body").getChild("block")
if ctorBlock.hasChildren():
for item in ctorBlock.children:
if item.type == "assignment":
leftItem = item.getFirstListChild("left")
rightItem = item.getFirstListChild("right")
# It's a method definition
if leftItem.type == "variable" and len(leftItem.children) == 2 and (leftItem.children[0].get("name") == "this" or leftItem.children[0].get("name") == "self") and rightItem.type == "function":
handleMethodDefinitionOld(item, False, classNode)
elif ctorItem and ctorItem.type == "map":
for keyvalueItem in ctorItem.children:
if keyvalueItem.type == "keyvalue":
valueItem = keyvalueItem.getChild("value").getFirstChild()
if (valueItem.type == "function"):
handleMethodDefinitionOld(keyvalueItem, True, classNode)
else:
handleConstantDefinition(keyvalueItem, classNode)
return classNode
def handlePropertyDefinitionOldCommon(item, classNode, propertyName,
paramsMap):
node = tree.Node("property")
node.set("name", propertyName)
propType = paramsMap.getChildByAttribute("key", "type", False)
if propType:
node.set("type", getType(propType.getChild("value").getFirstChild()))
allowNull = paramsMap.getChildByAttribute("key", "allowNull", False)
if allowNull:
node.set("allowNull",
allowNull.getChild("value").getChild("constant").get("value"))
defaultValue = paramsMap.getChildByAttribute("key", "defaultValue", False)
if defaultValue:
node.set("defaultValue",
getValue(defaultValue.getFirstListChild("value")))
getAlias = paramsMap.getChildByAttribute("key", "getAlias", False)
if getAlias:
node.set("getAlias",
getAlias.getChild("value").getChild("constant").get("value"))
setAlias = paramsMap.getChildByAttribute("key", "setAlias", False)
if setAlias:
node.set("setAlias",
setAlias.getChild("value").getChild("constant").get("value"))
unitDetection = paramsMap.getChildByAttribute("key", "unitDetection",
False)
if unitDetection:
node.set(
"unitDetection",
unitDetection.getChild("value").getChild("constant").get("value"))
instance = paramsMap.getChildByAttribute("key", "instance", False)
if instance:
node.set("instance",
instance.getChild("value").getChild("constant").get("value"))
classname = paramsMap.getChildByAttribute("key", "classname", False)
if classname:
node.set("classname",
classname.getChild("value").getChild("constant").get("value"))
possibleValues = paramsMap.getChildByAttribute("key", "possibleValues",
False)
if possibleValues:
array = possibleValues.getChild("value").getChild("array")
values = ""
for arrayItem in array.children:
if len(values) != 0:
values += ", "
values += getValue(arrayItem)
node.set("possibleValues", values)
# If the description has a type specified then take this type
# (and not the one extracted from the paramsMap)
commentAttributes = comment.parseNode(item)
addTypeInfo(node, comment.getAttrib(commentAttributes, "description"),
item)
classNode.addListChild("properties", node)
def handleClassDefinitionOld(docTree, item):
params = item.getChild("params")
paramsLen = len(params.children)
if paramsLen == 1:
superClassName = "Object"
ctorItem = None
elif paramsLen == 2:
superClassName = "Object"
ctorItem = params.children[1]
elif paramsLen == 3:
superClassName = assembleVariable(params.children[1])
ctorItem = params.children[2]
else:
raise DocException(
"defineClass call has more than three parameters: " +
str(len(params.children)), item)
className = params.children[0].get("value")
classNode = getClassNode(docTree, className)
if superClassName != "Object":
superClassNode = getClassNode(docTree, superClassName)
childClasses = superClassNode.get("childClasses", False)
if childClasses:
childClasses += "," + className
else:
childClasses = className
superClassNode.set("childClasses", childClasses)
classNode.set("superClass", superClassName)
commentAttributes = comment.parseNode(item)
for attrib in commentAttributes:
if attrib["category"] == "event":
# Add the event
if comment.attribHas(attrib, "name") and comment.attribHas(
attrib, "type"):
addEventNode(classNode, item, attrib)
else:
addError(classNode,
"Documentation contains malformed event attribute.",
item)
elif attrib["category"] == "description":
if attrib.has_key("text"):
descNode = tree.Node("desc").set("text", attrib["text"])
classNode.addChild(descNode)
# Add the constructor
if ctorItem and ctorItem.type == "function":
ctor = handleFunction(ctorItem, commentAttributes, classNode)
ctor.set("isCtor", True)
classNode.addListChild("constructor", ctor)
# Check for methods defined in the constructor
# (for method definition style that supports real private methods)
ctorBlock = ctorItem.getChild("body").getChild("block")
if ctorBlock.hasChildren():
for item in ctorBlock.children:
if item.type == "assignment":
leftItem = item.getFirstListChild("left")
rightItem = item.getFirstListChild("right")
# It's a method definition
if leftItem.type == "variable" and len(
leftItem.children) == 2 and (
leftItem.children[0].get("name") == "this"
or leftItem.children[0].get("name")
== "self") and rightItem.type == "function":
handleMethodDefinitionOld(item, False, classNode)
elif ctorItem and ctorItem.type == "map":
for keyvalueItem in ctorItem.children:
if keyvalueItem.type == "keyvalue":
valueItem = keyvalueItem.getChild("value").getFirstChild()
if (valueItem.type == "function"):
handleMethodDefinitionOld(keyvalueItem, True, classNode)
else:
handleConstantDefinition(keyvalueItem, classNode)
return classNode