initial commit
added a license (Apache v2)
first working version of the AnnDocuGen tool
added a simple build script
added field initializer reading and more examples
moved field initializer reading from custom ANTLR parser to Compiler Tree API

This sounds like it ties the implementation to the Sun Java Compiler,
but this tie was already in place with the previous implementation. In fact,
this implementation only relies on public APIs, even if they are
vendor-specific, while the old one relied on a private implementation detail
of a vendor-specific class.
handle Optional types properly

Proper handling of Optionals means:

1. Deciding if something is Optional is not based on comparing strings
   but actual types.
2. If a field is Optional and has no initializer, it is implied to be
   initialized to Optional.absent
handle primitive types properly

Fields of primitive types are always initialized even if the field declaration
has no initializer expression. In that case, the field is initialized to
the default value (false, 0, 0.0, '\u0000'). This means that properties
of primitive types are never mandatory.
don't claim the annotations

Previously, the AnnDocuGen annotation processor returned true, because I didn't
really understand what the return value means. Returning true means that
the processor "claimed" the annotations and they won't be passed to other
processors to process. This is not what I want.
separate @Inject from @Property

Turns out that in the real project, injecting properties via @Inject @Property
is not going to work. Instead, @Inject will be used for dependencies and
properties, marked with @Property, will be handled manually. This changes
the annotation processor to handle the new situation, and even issue a warning
when the combination of @Inject @Property is encountered.
document qualifier and scope annotations

Dependencies injected via @Inject can have qualifier annotations and scope
annotations that affect the injection process. Qualifier annotation is
an annotation that is itself annotated with @Qualifier. Scope annotation is
an annotation that is itself annotated with @Scope. These annotations are now
visible in the generated documentation, together with parameter values.
use short type names in the documentation

Currently, the documentation prints fully qualified names of all the types.
That's not very user-friendly; instead of "java.lang.String", the documentation
should only have "String". Other cases are even worse, such as
"java.util.Map<java.lang.String,java.lang.String>".
generate an index and distinguish units from services

The documentation should have an index of all classes that were processed.
For that, it's good to distinguish units (classes that implement the Unit
interface, directly or indirectly) from services (other classes).
move build to Maven and add com.google.guice and javax.inject

The move to Maven was long overdue. With that, the classes from "framework"
that simulate the javax.inject and Guava classes were removed and the actual
classes are used instead.

The "annotation-processor" Maven module has to have annotation processing
turned off, otherwise the build fails. Fortunately, this is not a problem
in this case.
refactoring

The project is now sufficiently big to introduce a few refactorings. A lot
of concepts are now modeled by special classes instead of Strings. Nullability
is no longer ignored, but expressed using Guava Optionals.
better index of units and services

The index of units and services now contains, for each class, a first line
of the Javadoc, stripped of all HTML tags. This requires an actual HTML parser,
doing things like this with a regexp is a direct road to hell. Hence
the dependency on jsoup, a nice HTML5 parser with sanitizing capabilities.
HTML output

This finally provides an almost-production-quality HTML output. The Markdown
output is gone because Markdown (at least the core Markdown) can't express
all the HTML tags that are needed (e.g. tables). Instead, HTML output
is generated directly from Mustache templates, using the excellent
Mustache.java library.

Bootstrap is used for styling, but a few very minor corrections had to be
applied (see style.css). It looks boring, but way better than unstyled HTML
and it's pretty usable. The static assets (currently only stylesheets, but
that may expand) are all copied to the generated output. They are small,
so it's not a big problem.