Add resolution to spec identifiers using docfx references

This uses the docfx output references to resolve the spec identifier to a human
friendly name. The linking still requires full reference resolution however.

Refs #58

autoapi/mappers/dotnet.py

@@ -112,8 +112,10 @@ class DotNetSphinxMapper(SphinxMapperBase):
     def map(self, options=None, **kwargs):
         '''Trigger find of serialized sources and build objects'''
         for path, data in self.paths.items():
+            references = data['references']
             for item in data['items']:
-                for obj in self.create_class(item, options):
+                for obj in self.create_class(item, options,
+                                             references=references):
                     self.add_object(obj)
 
         self.organize_objects()
@@ -144,7 +146,7 @@ class DotNetSphinxMapper(SphinxMapperBase):
             self.app.warn('Unknown type: %s' % data)
         else:
             obj = cls(data, jinja_env=self.jinja_env, options=options,
-                      url_root=self.url_root)
+                      url_root=self.url_root, **kwargs)
 
             # Append child objects
             # TODO this should recurse in the case we're getting back more
@@ -235,11 +237,18 @@ class DotNetSphinxMapper(SphinxMapperBase):
 
 class DotNetPythonMapper(PythonMapperBase):
 
-    '''Base .NET object representation'''
+    """Base .NET object representation
+
+    :param references: object reference list from docfx
+    :type references: list of dict objects
+    """
 
     language = 'dotnet'
 
     def __init__(self, obj, **kwargs):
+        self.references = dict((obj.get('uid'), obj)
+                               for obj in kwargs.pop('references', [])
+                               if 'uid' in obj)
         super(DotNetPythonMapper, self).__init__(obj, **kwargs)
 
         # Always exist
@@ -271,13 +280,15 @@ class DotNetPythonMapper(PythonMapperBase):
                 if 'id' in param:
                     self.parameters.append({
                         'name': param.get('id'),
-                        'type': param.get('type'),
+                        'type': self.resolve_spec_identifier(param.get('type')),
                         'desc': self.transform_doc_comments(
                             param.get('description', ''))
                     })
 
             self.returns = {}
-            self.returns['type'] = syntax.get('return', {}).get('type')
+            self.returns['type'] = self.resolve_spec_identifier(
+                syntax.get('return', {}).get('type')
+            )
             self.returns['description'] = self.transform_doc_comments(
                 syntax.get('return', {}).get('description'))
 
@@ -419,6 +430,15 @@ class DotNetPythonMapper(PythonMapperBase):
             pass
         return text
 
+    def resolve_spec_identifier(self, obj_name):
+        """Find reference name based on spec identifier
+
+        Spec identifiers are used in parameter and return type definitions, but
+        should be a user-friendly version instead. Use docfx ``references``
+        lookup mapping for resolution.
+        """
+        return self.references.get(obj_name, {}).get('fullName', obj_name)
+
 
 class DotNetNamespace(DotNetPythonMapper):
     type = 'namespace'