Merge branch 'master' of https://github.com/ElunaLuaEngine/Eluna

docs/ElunaDoc/__main__.py

@@ -79,7 +79,7 @@ if __name__ == '__main__':
         """Returns a function that parses content for refs to other classes, methods, or enums,
         and automatically inserts the correct link.
         """
-        # Make a list of all class names and method names.
+        # Make lists of all class names and method names.
         class_names = []
         method_names = []
 
@@ -96,23 +96,36 @@ if __name__ == '__main__':
             content = ''
 
             for token in tokens:
-                if token in class_names:
-                    # Take the "&" off the front of the class's name.
-                    class_name = token[len('&'):]
-                    url = '{}{}/index.html'.format(('../' * level), class_name)
-                    token = '<a class="mod" href="{}">{}</a>'.format(url, class_name)
+                # Ignore tokens that don't start with "&amp;".
+                if not token.startswith('&amp;'):
+                    content += token + ' '
+                    continue
 
-                elif token in method_names:
-                    # Take the "amp;" off the front of the method's name.
-                    full_name = token[len('&amp;'):]
-                    # Split "Class:Method" into "Class" and "Method".
-                    class_name, method_name = full_name.split(':')
-                    url = '{}{}/{}.html'.format(('../' * level), class_name, method_name)
-                    token = '<a class="fn" href="{}">{}</a>'.format(url, full_name)
+                # Try to find a matching class.
+                for class_name in class_names:
+                    if token.startswith(class_name):
+                        # Take the "&amp;" off the front of the token and class's name.
+                        token = token[len('&amp;'):]
+                        class_name = class_name[len('&amp;'):]
+                        url = '{}{}/index.html'.format(('../' * level), class_name)
+                        token = '<a class="mod" href="{}">{}</a>'.format(url, token)
+                        break
+
+                # No matching class, try to find a method.
+                else:
+                    for method_name in method_names:
+                        if token.startswith(method_name):
+                            # Take the "amp;" off the front of the token.
+                            full_name = token[len('&amp;'):]
+                            # Split "Class:Method" into "Class" and "Method".
+                            class_name, method_name = method_name.split(':')
+                            url = '{}{}/{}.html'.format(('../' * level), class_name, method_name)
+                            token = '<a class="fn" href="{}">{}</a>'.format(url, full_name)
+                            break
 
                 content += token + ' '
 
-            return content
+            return content[:-1]  # Strip off the last space.
 
         # Links to the "Programming in Lua" documentation for each Lua type.
         lua_type_documentation = {

docs/ElunaDoc/parser.py

@@ -43,9 +43,11 @@ class ParameterDoc(object):
                 self.description += '<p><em>Valid numbers</em>: all decimal numbers.</p>'
 
             self.data_type = 'number'
+
         elif self.data_type == 'bool':
             self.data_type = 'boolean'
-        elif self.data_type == 'uint64':
+
+        elif self.data_type == 'uint64' or self.data_type == 'int64':
             self.data_type = 'string'
 
 
@@ -108,16 +110,16 @@ class ClassParser(object):
     body_regex = re.compile(r"\s*\s?\*\s*(.*)")  # The "body", i.e. a * and optionally some descriptive text.
     # An extra optional space (\s?) was thrown in to make it different from `class_body_regex`.
 
-    param_regex = re.compile(r"""\s*\*\s@param\s # The @param tag starts with opt. whitespace followed by "* @param ".
-                                 ([&\w]+)\s(\w+) # The data type, a space, and the name of the param.
-                                 (?:\s=\s(.-))?  # The default value: a = surrounded by spaces, followed by text.
-                                 (?:\s:\s(.+))?  # The description: a colon surrounded by spaces, followed by text.""",
-                             re.X)
-
+    param_regex = re.compile(r"""\s*\*\s@param\s  # The @param tag starts with opt. whitespace followed by "* @param ".
+                                 ([&\w]+)\s(\w+)  # The data type, a space, and the name of the param.
+                                 (?:\s=\s(\w+))?  # The default value: a = surrounded by spaces, followed by text.
+                                 (?:\s:\s(.+))?   # The description: a colon surrounded by spaces, followed by text.
+                                 """, re.X)
     # This is the same as the @param tag, minus the default value part.
     return_regex = re.compile(r"""\s*\*\s@return\s
                                   ([&\w]+)\s(\w+)
-                                  (?:\s:\s(.+))?""", re.X)
+                                  (?:\s:\s(.+))?
+                                  """, re.X)
 
     comment_end_regex = re.compile(r"\s*\*/")  # The end of the comment portion, i.e. */
     end_regex = re.compile(r"\s*int\s(\w+)\s*\(")  # The end of the documentation, i.e. int MethodName(

docs/ElunaDoc/templates/method.html

@@ -62,7 +62,7 @@
             {%- if current_method.parameters|length > 0 %}
             {%- for param in current_method.parameters %}
             <dl>
-                <dt><code>{{ param.data_type|escape|parse_data_type }} {{ param.name }} {{ param.default_value + ' ' if param.default_value }}</code></dt>
+                <dt><code>{{ param.data_type|escape|parse_data_type }} {{ param.name }} {{- ' (' + param.default_value + ')' if param.default_value }}</code></dt>
                 <dd class="docblock">{{ param.description|parse_links if param.description else '<em>See method description.</em>' }}</dd>
             </dl>
             {%- endfor %}