Added back abstract class change and fixed test

pkg/docgen/lib/docgen.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * **docgen** is a tool for creating machine readable representations of Dart
  * code metadata, including: classes, members, comments and annotations.
  *
  * docgen is run on a `.dart` file or a directory containing `.dart` files.
  *
@@ skipping 384 matching lines @@
 Class _class(ClassMirror mirror) {
   var clazz = entityMap[mirror.qualifiedName];
   if (clazz == null) {
     var superclass = mirror.superclass != null ?
         _class(mirror.superclass) : null;
     var interfaces =
         mirror.superinterfaces.map((interface) => _class(interface));
     clazz = new Class(mirror.simpleName, superclass, _commentToHtml(mirror),
         interfaces.toList(), _variables(mirror.variables),
         _methods(mirror.methods), _annotations(mirror), _generics(mirror),
-        mirror.qualifiedName, _isHidden(mirror), mirror.owner.qualifiedName);
+        mirror.qualifiedName, _isHidden(mirror), mirror.owner.qualifiedName,
+        mirror.isAbstract);
     if (superclass != null)
       clazz.addInherited(superclass);
     interfaces.forEach((interface) {
       clazz.addInherited(interface);
     });
     entityMap[mirror.qualifiedName] = clazz;
   }
   return clazz;
 }
 
@@ skipping 77 matching lines @@
   inputMap.forEach((key, value) {
     if (value is Map) {
       outputMap[key] = recurseMap(value);
     } else {
       outputMap[key] = value.toMap();
     }
   });
   return outputMap;
 }
 
-bool isError(String qualifiedName) {
-  return qualifiedName.toLowerCase().contains('error') ||
-      qualifiedName.toLowerCase().contains('exception');
-}
-
 /**
  * A class representing all programming constructs, like library or class.
  */
 class Indexable {
   String name;
   String qualifiedName;
   bool isPrivate;
 
   /// Documentation comment with converted markdown.
   String comment;
@@ skipping 55 matching lines @@
   /// Methods in the class.
   MethodGroup methods;
 
   /// Inherited methods in the class.
   MethodGroup inheritedMethods = new MethodGroup();
 
   /// Generic infomation about the class.
   Map<String, Generic> generics;
 
   Class superclass;
+  bool isAbstract;
 
   /// List of the meta annotations on the class.
   List<String> annotations;
 
   Class(String name, this.superclass, String comment, this.interfaces,
       this.variables, this.methods, this.annotations, this.generics,
-      String qualifiedName, bool isPrivate, String owner) : super(name, comment,
-          qualifiedName, isPrivate, owner) {}
+      String qualifiedName, bool isPrivate, String owner, this.isAbstract) 
+      : super(name, comment, qualifiedName, isPrivate, owner);
 
   /**
    * Returns a list of all the parent classes.
    */
   List<Class> parent() {
     var parent = superclass == null ? [] : [superclass];
     parent.addAll(interfaces);
     return parent;
   }
 
@@ skipping 19 matching lines @@
   void addSubclass(Class subclass) {
     if (!_includePrivate && isPrivate) {
       if (superclass != null) superclass.addSubclass(subclass);
       interfaces.forEach((interface) {
         interface.addSubclass(subclass);
       });
     } else {
       subclasses.add(subclass.qualifiedName);
     }
   }
+  
+  /**
+   * Check if this [Class] is an error or exception.
+   */
+  bool isError() {
+    if (qualifiedName == 'dart.core.Error' || 
+        qualifiedName == 'dart.core.Exception')
+      return true;
+    for (var interface in interfaces) {
+      if (interface.isError()) return true;
+    }
+    if (superclass == null) return false;
+    return superclass.isError();
+  }
 
   /**
    * Check that the class exists in the owner library.
    *
    * If it does not exist in the owner library, it is a mixin applciation and
    * should be removed.
    */
   void makeValid() {
     var library = entityMap[owner];
     if (library != null && !library.classes.containsKey(name)) {
@@ skipping 25 matching lines @@
     if (superclass == null) return 'dart.core.Object';
     if (_isVisible(superclass)) return superclass.qualifiedName;
     return superclass.validSuperclass();
   }
 
   /// Generates a map describing the [Class] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
+    'isAbstract' : isAbstract,
     'superclass': validSuperclass(),
     'implements': interfaces.where(_isVisible)
         .map((e) => e.qualifiedName).toList(),
     'subclass': subclasses.toList(),
     'variables': recurseMap(variables),
     'inheritedVariables': recurseMap(inheritedVariables),
     'methods': methods.toMap(),
     'inheritedMethods': inheritedMethods.toMap(),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
 }
 
 /**
  * A container to categorize classes into the following groups: abstract
  * classes, regular classes, typedefs, and errors.
  */
 class ClassGroup {
-  Map<String, Class> abstractClasses = {};
-  Map<String, Class> regularClasses = {};
+  Map<String, Class> classes = {};
   Map<String, Typedef> typedefs = {};
   Map<String, Class> errors = {};
 
   void addClass(ClassMirror mirror) {
     _currentClass = mirror;
     var clazz = _class(mirror);
 
     // Adding inherited parent variables and methods.
     clazz.parent().forEach((parent) {
       if (_isVisible(clazz)) {
         parent.addSubclass(clazz);
       }
     });
 
     clazz.ensureComments();
 
-    if (isError(mirror.qualifiedName)) {
+    if (clazz.isError()) {
       errors[mirror.simpleName] = clazz;
     } else if (mirror.isTypedef) {
       if (_includePrivate || !mirror.isPrivate) {
         entityMap[mirror.qualifiedName] = new Typedef(mirror.simpleName,
             mirror.value.returnType.qualifiedName, _commentToHtml(mirror),
             _generics(mirror), _parameters(mirror.value.parameters),
             _annotations(mirror), mirror.qualifiedName,  _isHidden(mirror),
             mirror.owner.qualifiedName);
         typedefs[mirror.simpleName] = entityMap[mirror.qualifiedName];
       }
-    } else if (mirror.isAbstract) {
-      abstractClasses[mirror.simpleName] = clazz;
     } else if (mirror.isClass) {
-      regularClasses[mirror.simpleName] = clazz;
+      classes[mirror.simpleName] = clazz;
     } else {
       throw new ArgumentError('${mirror.simpleName} - no class type match. ');
     }
   }
 
   /**
    * Checks if the given name is a key for any of the Class Maps.
    */
   bool containsKey(String name) {
-    return abstractClasses.containsKey(name) ||
-        regularClasses.containsKey(name) ||
-        errors.containsKey(name);
+    return classes.containsKey(name) || errors.containsKey(name);
   }
 
+  /**
+   * Creates a [Map] with [Class] names and a preview comment.
+   */
+  Map classMap(Class clazz) {
+    var finalMap = { 'name' : clazz.qualifiedName };
+    if (clazz.comment != '') {
+      var index = clazz.comment.indexOf('</p>');
+      finalMap['preview'] = '${clazz.comment.substring(0, index)}</p>';
+    }
+    return finalMap;
+  }
+  
   Map toMap() => {
-    'abstract': abstractClasses.values.where(_isVisible)
-      .map((e) => e.qualifiedName).toList(),
-    'class': regularClasses.values.where(_isVisible)
-      .map((e) => e.qualifiedName).toList(),
+    'class': classes.values.where(_isVisible)
+      .map((e) => classMap(e)).toList(),
     'typedef': recurseMap(typedefs),
     'error': errors.values.where(_isVisible)
-      .map((e) => e.qualifiedName).toList()
+      .map((e) => classMap(e)).toList()
   };
 }
 
 class Typedef extends Indexable {
   String returnType;
 
   Map<String, Parameter> parameters;
 
   /// Generic information about the typedef.
   Map<String, Generic> generics;
 
   /// List of the meta annotations on the typedef.
   List<String> annotations;
 
   Typedef(String name, this.returnType, String comment, this.generics,
       this.parameters, this.annotations,
-      String qualifiedName, bool isPrivate, String owner) : super(name, comment,
-          qualifiedName, isPrivate, owner) {}
+      String qualifiedName, bool isPrivate, String owner) 
+        : super(name, comment, qualifiedName, isPrivate, owner);
 
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'return': returnType,
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
@@ skipping 246 matching lines @@
   String qualifiedName;
   List<String> parameters;
 
   Annotation(this.qualifiedName, this.parameters);
 
   Map toMap() => {
     'name': qualifiedName,
     'parameters': parameters
   };
 }