Atomineer Pro Documentation Development History
January 2021
10.18 |
- Added C# 9 support, including records and positional records, and property init accessors
|
December 2020
10.17 |
- Some minor tweaks and improvements.
|
October 2020
10.16 |
- Added support for C++ defaulted and deleted constructors, destructors and operators.
- Fixed issues with skipping attributes when commenting at the very top of a Visual Basic file, and within enums.
- Doc this Project/Solution now detect and skip additional forms of designer-generated files.
- Doc this Project/Solution will not document partial classes unless they match the filename.
|
August 2020
10.15 |
- The batch-processing commands are now able to process methods and members implemented in the @code section within Blazor '.razor'
files, as well as inserting HTML header comments for these files if required.
- #pragma directives immediately prior to code elements are now treated like attributes.
- Upgraded a portion of the argument parser to improve handling of optional parameter defaults for strings, which
could occasionally cause the parser to produce partial results.
- Fixed an uncommon issue in emitted doxygen function declarations
- Fixed a batch processing issue in Doc all in File when intellisense is unavailable, which could lead to processing being
skipped rather than the built in parser fallback being used.
- Where updating a partial documentation comment, if the 'returns' entry is missing this will now be duplicated from
base class information when possible (as is already the case for param/tparam entries)
|
June 2020
10.14 |
- Unnamed parameters in C++ methods are documented by Atomineer as (e.g.) 'parameter1'. When prototypes for these
methods are inserted they are now corrected to use the generated parameter name so that the prototype reflects
the parameters as documented.
- Fixed a rare bug in 'Delete all Doc Comments' which could cause the command to abort with an error.
- Corrected a small problem in live typing aid indentation handling when splitting a line immediately after an XML tag.
- Improved handling for regular multiline comments, including a fix for converting them into doc comments (a case where
a new comment could be inserted inside the existing one rather than replacing it)
- Improved the processing of attributes to handle additional nested code cases, such as C# object initialisers
- Small update for Atomineer Spelling
|
May 2020
10.12 |
- If file header comments are configured using XML templates (rather than verbatim text), Atomineer will now treat them as doc
comments, and will update them in the same way as for normal doc comments.
- When formatted as doc comments, file header comments can now be edited in the Documentation Editor view.
- Breaking change: XML Docs 'cref' entries no longer use the type prefix letter (T:, M:, P: etc) by default. Although this
is the documented standard, the .net compiler adds these to the output automatically, and the recently introduced
CA1200 code analysis rule complains if the type prefix is specified in the source comment. In the 'Doc General' preferences there
is now an option to control whether XML cref references include the type prefix letter, should you need to turn this back on.
- When duplicating SeeAlso entries, Atomineer will now strip off type prefixes if the 'use type prefix' preference is disabled.
- In C# if the namespace for a cref is defined in a 'using' or 'namespace' statement it will no longer be included in the cref.
Note that to avoid having to scan the entire file, Atomineer will only look for usings/namespaces near the top of the file.
- Atomineer now recognises .razor files as containing C# so the code in them can be documented.
|
April 2020
10.11 |
- Improvements to the Live Typing Aid when pasting into comments.
- (C++) Doc all in Chosen Files can now optionally include/exclude namespace comments. The default is not to document namespaces, to align C++
processing with all other languages, and avoid documenting namespaces more than once.
- (C++) the 'specialType' variable is now set to 'final' when appropriate for the current method.
- copydoc, copydetails and copybrief Doxygen entries are now treated in the same way as inheritdoc (they are preserved, and
no documentation will be generated for code elements carrying these documentation commands)
- Added a preference for controlling the indentation prefix for lists of items (e.g. param entries) in NaturalDocs comments.
- Several small updates to the preferences dialog.
- Reviewed and updated the User Manual and Website.
|
March 2020
10.10 |
- Fixed an issue in inheritdoc support that was inadvertently caused by the new documentation duplication algorithm.
- Further improvements to documentation duplication (improvements to Property and Interface support, and gathering docs from additional sources).
- Added word-wrap support for doxygen/natural tables where '|' characters are used to delimit cells.
- Improved handling of an indentation case to ensure that indentation is correctly preserved.
|
February 2020
10.09 |
- Rewrote the documentation duplication algorithm to improve matching of related documentation entries. In particular this enables
discovery of documentation from more complex inheritance trees and chains of derived interfaces.
- Performance optimisations
- Resolved an issue with auto-punctuation being incorrectly applied to some prototypes in Doxygen docs
- Added :UnixDir command for expanding %variables%, which converts windows directory separators into unix style separators, e.g. %filePath:UnixDir%
- Added :Match(regex) command which returns the part of the variable text that is matched by the regex between the brackets.
:MatchIC(regex) does the same but is case insensitive. See Page 77 of the user manual for full details and examples.
- Added :Strip(regex) command which removes all matches for the regex between the brackets from the variable text.
:StripIC(regex) does the same but is case insensitive. See Page 77 of the user manual for full details and examples.
|
January 2020
November 2019
10.07 |
- Added 'Build New Doc Comment' command (ctrl+shift+A, ctrl+shift+N), which generates a completely new doc comment to
replace an existing one. This can be very useful when changing interfaces, overrides and overloads, to copy updated
documentation from the base interface/implementation to the derived ones.
- Similarly, 'Doc all in Chosen Files' now has a 'build new' option that allows you to forcibly overwrite all
processed doc comments with newly generated descriptions.
- Documentation Editor: Improved the bullet list support and added editing of numbered lists. The existing bullet character markup
has been extended to allow numbered list items, with each line prefixed in the style '1)', '2)' etc. In addition, support
has been added for three more markup formats: XML doc
'<list>', simple XML '<list>', and HTML '<ul>'/'<ol>' markup support.
(Both XML formats support the type='bullet' and type='number' styles, and XML-doc supports term & definition which are then
separated in the editor by ' - '). Choose your preferred list markup style on the Live Aids
tab of the preferences ... See pages 91-96 of the user manual for full details.
- Doc All... commands: Improved parsing and comment insertion logic. Fixed some edge cases where comments were
not generated and inserted as expected.
- Doc All in File now handles missing intellisense better, falling back to Doc All in Scope more reliably when
Intellisense information for the project is unavailable.
- Align into Columns now supports more operator symbols.
- Closing tags for XML elements are now word wrapped by default. There's a new preference on the Doc Formatting tab
of the options that can be used to restore the previous (non-wrapping) behaviour if you prefer not to use those extra
lines of source code.
- Fixed an issue in the preferences dialog that could sometimes lead to custom per-language settings not being shown.
- Updated and improved the custom preprocessing extension example for VS2019. This is now able to produce XMLDoc, JavaDoc or QDoc
formatted comments for Atomineer to ingest, making legacy conversion even easier.
- Resolved an issue in Doxygen format where one combination of the 'InOutFollowsName ' and 'AlignInOut' options caused in/out
generation to become disabled.
- Improved blank line enforcement following #pragma directives.
- Fixed a small bug in the documentation editor where the character after an embedded XML element was sometimes lost.
- Corrected English (US) spellings for 'specialize', 'normalize'.
- Fixed a handling issue for multi-line attributes in VB code.
|
October 2019
10.06 |
- Added a formatting preference ('Doc Style' tab) that allows the first entry in the comment to start on the leading
line of the comment block, i.e. 'on the end' of the top separator line. This allows multiline /** comments to
be more compact by removing the need for the opening /** to be on its own line.
- Improvements to VB declaration parsing for methods, properties and enumerated types.
- NaturalDocs: Improved generation of NaturalDocs comments and fixed a regression ("Function" being emitted as "fn")
- Added a preference option (in prefs.xml only - <DocViewer><DefaultToReadOnly>) to allow the default
read-only state of the documentation editor to be pushed to PCs along with other preferences.
- Resolved a small issue in new generic typeparam parsing code that could cause typeparams to be lost from comments
under some circumstances.
|
September 2019
10.05 |
- Resolved a small regression and made further improvements in Visual Basic attribute handling.
|
10.04 |
- Added _createOnly attribute for template entries. This marks an entry as one that should only be added when
creating new comments, and not when updating existing comments - this can be used to insert 'to do' reminders
into comments, which are preserved if present but can be permanently deleted when the work is done.
- Improved support for Unreal 'attribute' macros (UFUNCTION and UPROPERTY), and added support for UCLASS.
- Added support for per-language preprocessing rules.
- Extended the reach of preprocessing rules to more code element types.
- Reviewed and updated the preprocessing sections of the user manual, and added more example preprocessing
code links.
- Reworked a key part of the parsing engine to unlock improvements in parsing around enum members, complex
generic/template parameters, embedded expressions, and remove some edge cases involving code with multiple
concatenated statements on a single line.
- Added namespace comment support for Visual Basic.
- Improved handling of attributes in C++
- Added handling for C++ 'noexcept' specifiers.
- Fixed an issue in parsing of C++ operator templates.
|
August 2019
July 2019
10.03 |
- Word Wrap Comment now removes trailing space from the last line of the comment.
- Added support for C++ trailing return types using ->.
- Added support for C++ "type const" parameter-type syntax.
- Added C++20 support for three way comparison operators.
- 'Create C# Property' now has an additional conversion stage, which converts an expression-bodied auto-property
into a WPF/Prism BindableBase implementation using SetProperty().
- Adding a file header comment now creates one rather then two undo steps.
|
May 2019
10.02 |
- Added word-wrap support for multiline comments - /*...*/ in C-style languages and <!--...--> in XML and XAML.
- Added support for Unreal 'attribute' macros (UFUNCTION and UPROPERTY)
- Attribute matches using defined="..." now set the %match% variable so the matched attribute name can be
used in the generated description.
- Added the variable %newline%, which allows a newline to be more easily inserted into the description text
that's output.
- Doc All in Scope now handles C# usings inside namespace scopes correctly.
- Small fixes to the trial version.
|
April 2019
10.01 (+9.50) |
- Tested Atomineer Pro Doc and Atomineer Spelling in the final Visual Studio 2019 release.
- Special update to v9.50 for visual studio addin for VS 2005-2013 - Fixes issues with the trial version.
(No change to the VS Extension for VS 2015-2019)
|
March 2019
10.01 |
- Tested Atomineer Pro Doc and Atomineer Spelling in Visual Studio 2019 preview 3.0 and RC.
- Improved the documentation editor, adding handling for <para> and <p> markup. Paragraph options have
been added to the preferences 'Live Aids' tab to control whether edited text paragraphs are written back to source code
using double newlines, or enclosed in para/p markup. Paragraph markup is not added within 'example' entries.
- Improved parsing and round-tripping of description text between source code and the documentation editor, producing
more consistent formatting results
- Fixed an issue where edited documentation was not always written back to the source code after editing if the doc editor
view was floating rather than docked.
- Resolved a parsing problem that could sometimes cause fragments of xml markup to be shown in the editor.
- Resolved an issue with reinserting edited comments with some /* ...*/ block styles that resulted in a spurious
extra column of indentation.
|
January 2019
10.00 |
- Major update: Atomineer Pro Documentation and Atomineer Spelling both now support Visual Studio 2019 Preview
(tested with preview versions 1 and 2). Please let us know if you find any issues with Atomineer in this new version
of Visual Studio.
- The old installer for Atomineer for Visual Studio verisons 2005-2013 has now been frozen at version 9.49.
In future we only expect to update these old versions if required to resolve serious bugs.
- Added a <templatemethod> template, to independently control the documentation output for C++ templates.
- Fixed an issue that could cause markup < characters to be displayed in the document viewer.
|
December 2018
9.49 |
- Improved the documentation generated for C# Func<...,TResult> types.
- Variable replacement in separators now supports all variables available for the code element being processed,
rather than just the specialised separator variables previously available.
- Added a new processing command that can be used when expanding variables. Adding a ':default(TEXT)' command
will replace any variable that has become an empty string with a given default value ('TEXT' in this example).
The default text can include any character except : or %.
- Corrected generic casting operators being documented with a spurious typeparam entry.
- Fixed an incorrect default value in the exception preferences that could cause unexpected behaviour
when processing exception entries.
- Extended the handling of OS environment variables in the rules search path.
- Improvements in parsing of member variable assignments.
- Fixed a bug in the handling of aliases in doxygen templates which sometimes caused duplicate entries to be generated
- Fixed a bug in the handling of 'returns' entries in doxygen templates which could cause it to emit an incorrect alias tag.
- Corrected _blankEntry handling, which was not always picking up _blankEntry values from the <EntrySettings> section.
- Fixed a regression that caused #define macros to be incorrectly documented.
|
November 2018
9.48 |
- Fixed a processing issue for some operator rules due to a change in the parser output.
- Update for Atomineer Spelling. Visual Studio 2017 was sometimes causing new and unnecessary instances of the
spelling engine to be created and never cleaned up. Under some circumstances after editing many
documents this could cause sporadic messages from VS about slowdowns. The fix works around this
behaviour of Visual Studio 2017 to ensure that only one spelling engine is ever active at any time.
- Fixed a bug in Doc All in Scope when processing C++ templates, which caused the code scanner to
identify incorrect starting lines for some code elements, causing comments to be generated within the
templated declaration rather than above.
- Added a preference in the Misc section of prefs.xml, EditXmlWithVerb. The default operating system 'verb' is
value="edit" which typically runs Notepad for editing XML files, or you can set it to
value="open" to use the double-click file association instead.
- Fixed a conversion issue where typeparam/tparam conversions failed, causing Atomineer to generate
spurious new '@tparam' entries in Doxygen comments.
- Fixed an issue in Suffix removal where merged preference sets were ignored, resulting in configured
suffixes not being removed.
|
October 2018
9.47 |
- The documentation editor now supports 'see' markup - the references are highlighted in the viewer, and the reference text can be edited.
Committing blank text to the reference will remove the 'see' markup from the doc comment when it is updated, and new 'see' references
can be inserted into the text from the right-click context menu.
- The documentation viewer/editor (VS2015/2017) now has a 'lock' mode that switches it between editable and view-only modes, so
it can be used without any risk of changing the comments it views. It also has improved icons, supporting high DPI monitors.
- 'Create C# Property' now supports a 'this.varName' form of property get/set, which can be combined with 'varName' or
'VarName' member format. (Enabled in the 'Other Features' tab in the options)
- 'Create C# Property' now supports emitting of expression-bodied (lambda) property get/set syntax. (Enabled in the 'Other Features' tab in the options)
- 'Add C++ Accessors' now supports a 'this->varName' form of property get/set, which can be combined with 'varName' or
'VarName' member format. (Enabled in the 'Other Features' tab in the options)
- Fixed a parsing issue in 'Add C++ Accessors' where access modifier prefixes are on the same line as a member declaration.
- Added protection around an API call which was found to (rarely) fail unexpectedly.
- Added context menu items for the Add Property/Accessor commands.
|
September 2018
9.46 |
- More work on extension initialisation to best support changes in Visual Studio startup.
- Improved C++ parsing to address an issue with access modifier prefixes on the same line as a member declaration.
- Fixed an issue with code element identification and indentation when parsing member
variables preceded by attributes on the same line.
|
July 2018
9.45 |
- Under-the-bonnet changes and testing to ensure Atomineer Pro Documentation is compatible with some changes that are
coming in Visual Studio 2017 (15.8) and future versions, and testing of these changes in older versions.
- Updates to Atomineer Spelling for similar forwards compatibility issues.
- Improvements in Atomineer Spelling's word detection, and a fix for a regression that caused symbols with
underscores to be handled as if they were separate words.
- Fixed an issue in Delete Documentation which could cause single-line comments to not be deleted
for some comment block configurations.
- Fixed a parser categorisation issue that caused incorrect documentation to be generated for some enum entries.
|
May 2018
9.44 |
- Updated Atomineer for Atmel Studio 7.0
- Improvements to the Align Code Into Columns behaviour for C# 7.0 syntax
- Tested against Visual Studio 15.7 release and 15.8 prerelease builds
|
April 2018
9.43 |
- Improvements to text formatting within the Doc Editor view, with better handling of tall narrow aspect
layouts and ne template settings for controlling maximum column widths.
- Improved handling of embedded XML/HTML elements within the Doc Editor
- Fixed a parsing error that could cause multi-line C++/C# declarations to be incorrectly classified
as enum entries
- Added support for documenting within .cshtml files
- Addressed a report of unknown failures in Extensions. We could not confirm an actual problem in Atomineer,
but have added more exception checks to minimise the risk that Atomineer might cause such reports from Visual Studio.
- Some changes to our website for renewals, and our company policy information has been updated in light of the
introduction of GDPR across Europe.
|
March 2018
9.42 |
- Improvements to Typescript/Javascript support. As there is a loit of variation in the syntax of these languages,
if you spot anything that Atomineer doesn't handle well, please let us know so we can ensure it's fully supported.
- More work on Atomineer Spelling, as recent updates (presumably .net/roslyn) have also
retroactively affected older Visual Studio installs, causing the 2015 Spelling to cease working.
We have now back-ported the fixes that were required for VS2017 into the previous version
and tested in VS 2013 and 2015. The new implementation no longer requires roslyn/intellisense
to operate, so also works on non-compiling code.
- Spelling 2017: Fixed an issue that caused spelling corrections to be suggested
occasionally on text outside of doc comments. The new implementation no longer requires
roslyn/intellisense to operate, so also works on non-compiling code.
- Spelling: Improvements to default custom dictionary.
- Fixed a small bug in the new declaration parser that caused problems for enum members using
UPPER_CASE naming style.
- Internal: improved reporting mechansim for errors and notifications.
|
February 2018
9.41 |
- Rewrote the Atomineer Spelling extension to resolve issues in Visual Studio 2017. Several recent
changes to the Roslyn engine and some other internals of Visual Studio caused problems with the
installer and then the spelling highlighting. In addition, switched the suggestions menu over to use
the new Visual Studio 'lightbulb' suggestion system.
- Improved handling of enum members in the new declaration parser implementation.
- Improvements to parsing relating to some old C style syntax cases.
- Fixed an edge case in handling of templated classes
- Adjusted 'asSee' generated crefs to use double rather than single quotes.
- Fixed an issue caused by a software update on our web host, which affected some non-essential featues on
the account management web page (such as the last downloaded version not being reported correctly).
|
January 2018
9.40 |
- Added handling for C-style structs, unions and enums (as in: struct S function() {}).
- Documentation Editor Improvements
- Added a new "Add Entry" button. This allows optional entries (e.g. remarks) to be inserted into the documnetation.
- You can now navigate to the Next/Previous code element using Alt+Down and Alt+Up. (The Alt key binding
is used to avoid clashes with Visual Studio's built in bindings)
- Next/Previous navigation now places the input focus in the first editable field so that you can
now fully document an entire file through the editor without needing to use the mouse.
- Some other small improvements.
- Fixed a regression in live typing aids that could extend a comment incorrectly if return was pressed
on the final line of a /* */ comment.
|
December 2017
9.39 |
- Tested with Visual Studio 2017 (15.5). We recommend users of Atomineer Spelling update to this
version of VS 2017 as it resolves issues with the underlining highlights for misspelled words.
- Added <paramref> support to the documentation editor. New paramrefs can be added from the context menu
on any editable field. Existing paramrefs are shown as the parameter name with a highlighted background colour
- just click the parameter name to change the reference.
- Improved parsing of typescript declarations, fixing a case that was handled incorrectly
- Fixed a rare edge case where Atomineer was not detecting doc comments in single-line /* ... */ comments,
causing duplicate comments to be added.
|
November 2017
9.38 |
- Added support for C# 7 expression-bodied members in the new method declaration parser, which was unfortunately
missed due to some unit tests not being applied to the new code.
|
October 2017
9.37 |
- Rewrote the method declaration parser to fully handle inline syntax in C++ and C# declarations,
as there were edge cases that the previous parser did not handle correctly.
- Documentation editor: Improved bullet-list support.
- Fixed a parsing glitch in Natural Docs exception entries.
- A large behind the scenes upgrade to our website.
|
September 2017
9.36 |
- Documentation editor now has next/previous buttons. These advance the cursor to the next/previous code element
and if necessry, executes Add Doc Comment to create a comment, which can then be adjusted in the editor.
This allows you to easily step through a file and document it directly in the editor.
- Documentation editor: Added simple bullet-list support.
- Documentation editor now automatically snaps its toolbar to the top or left side of the view
- Documentation editor: some general improvements and under-the-bonnet work to support planned future features.
- Fixed an issue that could sometimes stop the new template system's EntrySettings being correctly applied.
This could cause several symptoms (e.g. optional entries such as seealso being incorrectly deleted from comments while updating
them, punctuation being applied to entries that should have had the feature disabled).
- Added an option for Doxygen-style comments to place in/out specifiers before or after the parameter name.
- Improved C# 7.0 support for expression-bodied properties and added support for tuple parameters.
- Fixed a small bug in the preferences app relaing to the 'enforce blanks' settings which worked correctly, but were
not being displayed properly when reopening the preferences.
- Fixed: Word wrapping engine could sometimes break URLs containing minus characters.
- Improved parsing of C# generics
- Added support for C++11 brace-initialisation syntax.
- 'Reformat Doc Comment' will no longer duplicate documentation for parameters.
- Some more support for ASP.net projects
- Small tweaks to the installer to support VS2017 better.
|
July 2017
9.35 |
- For Visual Studio 2017/2015, the Documentation Viewer has been upgraded to a Documentation Editor. Edits made in this view will be
written back to your source code automatically when the input focus moves out of any entry (i.e. if you switch to editing
a different entry, or move the input focus back to your source code, or to another application). The editor supports some
basic markup (<b> <i> <code> ) and has been tested primarily with XML documentation; it is being relessed now as a
beta feature so that more users can feed back to us if they find any issues with the many variations of documentation
styles and formats in the wild, to allow us to develop the feature forwards more quickly. Please note that the editor does
not currently support a full set of markup features - markup such as inheritdoc, see, paramref, bullet lists and tables, as well as
special doxygen markup (@ commands) will be supported in upcoming releases.
- Resolved a regression in reformatting of indentation (a poor interaction with specific formatting options), which was
introduced by an attempted fix for code block indentation in the 9.34 release. The fix was rolled back and a new fix
implemented which does not introduce any side effects.
- Added a new 'Reformat Doc Comment' command. This reformats a doc comment exactly as Add/Update Doc Comment does,
but without adding any new entries to it.
- The 'convert to entities' option has been expanded, so that < > & can be converted to XML entities
< > & or now into more human readable { } + characters.
- Further small improvements to the C# 7.0 parser.
- Fixed an edge-case which could adversely affect parsing of attributes embedded within method parameter lists.
- Fixed a minor parsing issue that was caused by unrecognised macros with 1-character names applied after parameter declarations.
- Fixed an issue in Doc All in File where some code constructs were not correctly located when
intellisense was unavailable, resulting in failure to document some code elements.
- Fixed a small bug in the preferences that meant generation of 'inheritdoc' rather than 'seealso' was not
persisted and had to be set manually.
- Fixed an issue in the new template system that caused DocXml settings to be applied to Doxygen entries
when they used a custom tag name.
|
May 2017
9.34 |
- Improvements to the C# 7.0 parser, including a bug fix for misidentified constructors.
- Fixed cases where exceptions outside the scope of C# 7.0 expression-bodied members were being inadvertently documented.
- Several improvements to the typescript/javascript parser.
- Fixed an issue in chained constructors.
- Fixed a very rare case where documentation background colouring would be missed out for a comment.
- Improved reformatting of indented example code in a few cases.
|
April 2017
9.33 |
- Out-of-band release to fix a small but significant parsing bug introduced in the last release
which interfered with processing of member variables.
- Found and fixed a generic method declaration syntax that was not being correctly handled
|
9.32 |
- Added support for C# 7.0 features:
- Tuple return types
- Tuple deconstructor member-methods and extension-methods
- 'ref' method return values
- Expression bodied members, and exceptions thrown from within them.
- Auto-properties with default values
- Improved C# lambda support
- Improved C# Async support
- Fixed an indentation issue on duplicated documentation.
- Optimisations to improve speed of some parsing cases.
- Added preference for JSDoc (Java, JavaScript, Typescript) documentation format.
Although the options are the same as those for Doxygen, this mode now enables the
output of JSDoc {type} markup in parameter entries.
|
February 2017
9.31 |
- Don't forget to join in with the Visual Studio 2017 launch on March 7!
- Added support for NaturalDocs format doc comments. Due to the large number of formatting options available,
please consider this a public beta at this stage, and let us know if you spot any formatting issues.
- Updated the core templating system with a new global entry style system so it is no longer necessary to repeat the
same settings on each templated entry. This significantly simplifies the templates and ensures consistent
formatting across all code element types. The change rationalises the alias mechanism to better support
conversion from legacy comment content, and significantly improves the handling of custom entry 'tag'
names for built-in entry types. While this is a largely internal change it allows Atomineer to be much more
flexible while improving a number of edge cases.
- Fixed a small but elusive bug in comment updating that occasionally caused entries that should have been
deleted to be preserved.
- Improved extraction of author names from a wider variety of login name styles.
- Fixed an abbreviation expansion issue when using embedded variables.
- Fixed a formatting issue when updating a comment containing an <inheritdoc> and overridden doc entries.
- Live typing aids: Comment auto completion now allows multi-line comments to be missing the closing */
- Added a new <Suffixes> section in the rules to improve the handling of parameters and members that include
custom suffixes like _u32
|
January 2017
9.30 |
- New build with additional improvements in the support for Visual Studio 2017 and its new Extension format.
- Updated copyright dates.
|
December 2016
9.29 |
- Added BETA support for Visual Studio 2017 RC. Please let us know if you notice any problems with Atomineer in 2017 RC.
- Tested with Visual Studio 2017 RC.
- Improvements to Doc All in Scope, and Doc All progress reporting.
- Internal improvements to file header comment handling.
- Fixed 'check for updates', which had been broken by our https website conversion.
|
October 2016
9.28 |
- You can now choose to place comments after the code element declaration rather than before it. This is primarily intended
for languages like Python where this is the standard documentation approach, but can be applied to any language.
(Be aware that most external documentation tools don't support docs in these locations, or may require specific markup
to relate comment to the code element). In C-style languages Atomineer allows the comment to be inserted between the
declaration and the { scope brace, or after the opening { scope brace.
- The Atomineer website now uses secure https connections throughout.
- Fixed a bug in the documentation merge process where summary entries using a 'details' custom tag were not correctly
merged with the generated summary, causing the original details to be marked as a deleted entry rather than being
properly preserved.
- Added a new attribute for template entries, _minTagLength="12", which allows doxygen users to control the extra
padding added to the @commands to line them up into tidy columns. This attribute overrides the global MinTagLength
preference on a per-entry basis for finer control.
- The suppressInOut now works properly if set to 'true' rather than 'y'.
- Testing with Visual Studio '15' preview 5.
|
September 2016
9.27 |
- Document All... and Process All... commands will all now process C++ header files. (This feature was previously
disabled due to difficulties in the way Visual Studio intellisense system works in headers. Atomineer now uses
its built-in parser to handle headers, automatically working around the Intellisense issues)
- Document All in this Scope now descends into child scopes of 'containers' such as classes and interfaces so
it will now document entire files.
- Fixed a small issue with the names for re-thrown exceptions in C++.
- Improved handling of duplicated documentation containing embedded markup.
- Resolved an issue that occasionally caused the first character of a description to be generated in lowercase.
- Improvements to 'Delete Documentation from this File'.
- Some important under-the-bonnet upgrades to our website.
|
August 2016
9.26 |
- Improved alignment of [in,out] attributes on Doxygen entries. (The previous alignment behaviour can be reinstated
by adding a preference to the <Doxygen> section, <AlignInOut value="false">)
- Preference option <Doxygen><MinTagLength value="12"> can now be used to set a minimum width
in characters for doxygen command tags. This can be used to achieve a columnar layout of doxygen comment blocks.
- Added an option to remove seeAlsos from existing comments when updating them.
- Improvements to Doc All in Scope.
- Fixed a small regression in live typing aids when applied to the first line of /** ... */ comments.
- Fixed a problem with removing entries marked as 'deleted' (###) from some comment block formats.
- Addition/Removal of '(Optional)' prefixing now ensures correct casing of the following character.
- Small improvement to parameter parsing logic for C++.
- Doxygen: Atomineer no longer adds auto-punctuation to @copybrief entries.
- When configured with auto-insert #region/#endregion directives, 'Delete Docs from this File' now correctly
removes the corresponding #endregion.
- Tested on Windows 10 version 1607.
|
July 2016
9.25 |
- Tested against Visual Studio 2015 Update 3.
- (Visual Studio 2015 only) Added an option (see the new 'Live Aids' tab in the preferences, and the updated user
manual) to highlight /// documentation comments by filling the background of the comment with a subtle colour (the
defaults are beige for light colour themes and navy blue for dark themes). This can be used in addition to or
instead of top/bottom separator lines to visually distinguish code form comments.
- 'Doc All in this Scope' will now document any #define macros discovered in the processed source code.
- Fixed two regressions in parsing of #define macro declarations which would cause incorrect output to
be generated if a rare combination of preference options were configured.
- Added an option to change the behaviour of typedef to better match C and C++ variations of usage, and improved
handling of C-style unnamed types.
- Fixed a bug in live typing aids that could leave spurious characters behind when generating a DocComment
using a 3-character prefix which was not configured as the primary comment style's prefix.
- Added the ability to emit a type attribute on return values. Added the preference option
<DocComment><EmitParamType value="true"/> to force parameter/return types to be emitted in
XMLDoc/JavaDoc/QDoc comments if desired (previously this feature was only available for JavaDoc/JSDoc/JSDuck commenting).
Added <DocComment><EmitParamTypeWithBrace value="true"/> preference to control whether these types
are written as MyType or {MyType}
- A small improvement to bullet-list continuation.
- Added the ability for templates to be applied only to specific filetypes.
- Improvements to handling of one-line and two-line doxygen/JavaDoc/QDoc comments.
- Improvements to pre-processing replacements when applied to #define macro definitions.
- In cases where a VS Project is not being used (e.g. when using makefiles), project-relative roots can now be set
by adding a <DocComment><RootPaths value="..."/> preference entry. This contains a semicolon-separated
list of folder path names that you wish to treat as project root(s) to be stripped off any project-relative
pathnames that you use.
|
June 2016
9.24 |
- Parameter attributes can now be used in rules to generate documentation for parameters.
- Added support for more attributes (most notably, the NotNull/CanBeNull resharper annotations for methods and parameters,
and nUnit Fixture and Test attributes)
- Added 'suffix=...' syntax to rules to allow additional comments to be appended to the generated description.
- Improvements to Align into Columns. If a block is processed which contains a mixture of comment lines and code lines,
only the lines matching the type of the line containing the cursor (code/comment) will be processed, so that
comment lines can be skipped during the processing.
- (Xml Documentation) Base class documentation references for overrides can now generate 'inheritdoc' rather than
'seealso' references. This new option can be set on the 'Doc General' preferences tab.
- The Documentation Viewer will now view inherited documentation for methods/properties with valid <inheritdoc> references.
- Exception documentation auto-deletion behaviour can now be enabled/supressed (on the 'Doc General' preferences tab).
- Exception documentation will no longer be auto-deleted from comments in C++ header files.
- Fixed cases where the (optional) prefix would be not be added as expected to parameter documentation.
- Fixed a rare 'index out of range' bug in non-splittable-word handling.
- Live typing aids now support creation of comments by typing '/**'
|
April 2016
9.23 |
- Improvements to 'Delete Documentation' commands - Whitespace is now compacted after deletion, and end-of-line
documentation comments (in standard // and /*...*/ formats) are now also removed. Also fixed a problem that
could occur when processing single-line /**...*/ comments.
- C++: Added support for 'final' and 'override' keywords.
- Improved handling of rarely-used integral types (such as 'long long int')
- Improved handling of <content> entries.
- 'Document All in Chosen Files' has been renamed to 'Process All in Chosen Files' to better reflect
its operation (it can be used to delete docs as well as create/update them).
- 'Process All in Chosen Files' now has filtering options to allow you to control which types of code elements
will be processed, so for example you can process all methods and/or skip all properties.
- A small improvement to handling of some forms of end-of-line comments.
- Tested against Visual Studio 2015 Update 2.
|
March 2016
9.22 |
- Updated the installers to work around code signing issues. As of 1 January 2016 code signing must use SHA256 rather
than SHA1 encryption. This means Visual Studio 2015 and Windows 10 may refuse to install extensions/applications unless
they are SHA256 signed, yet earlier versions of Windows and Visual Studio may fail to regocnise the new signing. After
considerable research we have been unable to find a solution that works in all cases, so we have had to take the
unfortunate choice of providing multiple installers that target different versions of Visual Studio and Atmel Studio.
We hope that eventually a solution can be found and the installers can be re-integrated.
- Added more supported filetypes for Python code.
- Fixed Indentation settings in VS2015 - After 2015 Update 1 Atomineer would always use spaces due to a
change in the way the text editor option needed to be read. It will now use tabs if they are configured.
- The spelling of "Initialise" (UK) or "Initialize" (US) now uses the %initialise% variable, which can be set
for US or UK English using a new check box in the preferences. The default is now the US spelling. (Note that
this does not affect the spelling used in Style-cop compatible comments, which must always use the US English
variation).
- The Documentation Viewer is now able to process XML <include> directives (as long as they are well formed and
redirect to a valid XML element in a valid external documentation file - as described
here). Includes can be placed as root-level
items (providing a full or partial documentation comment) or be embedded within entries (providing a fragment of
documentation text).
- Improved parser to allow plain-text documentation comments prefixed with /// to be converted into fully formed
doc comments.
- Fixed a parsing problem on nested templates/generics which could cause declarations to become truncated.
- C++: Fixed an issue on namespaced function-pointer parameters. (Name cleanup sometimes left additional
text appended to the name).
- Resolved a regression that caused types like 'const int' to be reported as 'int' in method returns %type% variable.
- Resolved rare issues that could occur where end-of-line text after a #region directive was not being ignored by
the parser, causing it to become confused.
- Resolved an issue when generating a new end-of-line comment by typing /// would leave the /// in place.
- Ported 'Hide Doc Comments using Outlining' command to VS2015 and re-enabled it.
|
January 2016
9.21 |
- Atomineer now supports Atmel Studio 7.0 (Just run the .vsix installer to install into it)
|
December 2015
9.20 |
- Improved Python support. In particular, classes and their member functions are now supported, documentation is
generated for all known 'magic' functions, and the Doc All... commands all now support Python projects/solutions.
- Implemented a workaround for the Visual Studio 2015 bug that caused Atomineer Spelling to become non-functional
in the 2015 RTM.
- Added %lang% variable, which can be used to apply rules only to certain coding languages.
- Fixed a preferences bug that could cause custom PrefSets.xml files to grow each time the prferences were edited.
(The fix will also correct any existing files when writing back preferences to ensure they are no larger than they should be)
|
November 2015
9.19 |
- First public release of Python language support. Atomineer can now create and update documentation comments
for Python function 'def's. Doc All in Scope/File can be used to automate documentation of a python source file
(The other Doc All... commands are not yet supported, but are coming soon). Live typing Aids work within Python
comment blocks much as for other languages (although there are some features yet to be implemented). The preferences
also support language-specific preference sets for Python. (We'll continue to roll out additional features for
Python next month. Please let us know if there is anything you'd particularly like to see in Atomineer's Python
support)
- Improved live typing aids. After going to a new line in a doc comment, Atomineer will usually add auto-indentation,
but this is now removed automatically if you start typing a new documentaiton entry command, so that new doc entries
are pulled back to the left of the comment block automatically.
- Fixed separator clipping when used on multiline comments, which could sometimes clip away the closing
*/ of the comment block..
- Improved handling of multi-word prefix removals.
- Improved auto-punctuation control on exception entries.
- Fixed a glitch with exception entries which rarely caused the exception entries to move to the bottom of the
comment block rather than obeying the layout template.
- Added a preference <DocComment><PunctuateBlankDescs value="false"/> which can be set
to disable the auto-punctuation feature in cases where the description part of a doc entry is blank. (Atomineer
usually adds punctuation in these cases to higlight the missing field of the doc entry and ensure that it's valid)
- Improvements and clarifications for the user manual.
|
9.18 |
- (Limited release beta build)
|
October 2015
9.17 |
- Finished porting 'Add Property' and 'Add Access Method' into the Visual Studio 2015 extension.
- Updated the user manual for Windows 10.
- Added support for C# Code Contracts.Requires() statements - these now generate/update exception entries
in a similar way to throw statements.
- Improved parsing of C++ exception 'throw' statements to cover a previously unsupported syntax.
- Fixed a rare glitch in parsing doxygen multiline comments.
- Significantly improved the entry aliasing system. This previously allowed you to easily convert legacy formats
to the Atomineer format (by adding an _aliases='name1,name2,...' attribute on template entries) so that legacy entry
names (e.g. 'throws') could be converted to the Atomineer form ('exception'). However, you can now set a custom tag
name so that Atomineer will work natively with the legacy format. For example, add _tagName='throws' to an
<exception> template to make Atomineer generate 'throws' rather than 'exception' entries, while retaining
all the built-in support for auto-generating and updating these entries.
- Improved handling of Doxygen entries with optional descriptions.
- Please note: This month we have discovered two serious bugs in Visual Studio 2015
(both introduced in the final release version and not present in the preview versions) which unfortunately affect
Atomineer. (1) under some circumstances intellisense information is unavailable (this primarily affects generics
and classes defined in external assemblies, but can affect other cases), so duplication of base class
documentation (and sometimes document all in... commands) do not always work as expected. (2) causes Atomineer
Spelling to cease highlighting of spelling mistakes. We hope that these bugs will both be resolved by Visual
Studio 2015 Update 1 (expected to be available soon). However, in case this does not happen we are investigating
a revised implementation of the spelling checker to work around the bug. In the meantime we apologise for any
inconvenience this may cause.
|
September 2015
9.16 |
- A quick release to resolve an issue in VS2013 and earlier where some users were unable to open the
preferences. This was due to a small installation change required to support VS2015. Many apologies to
those who were affected by this issue.
- Fixed an issue with parsing of C++ variadic function arguments.
|
9.15 |
- Resolved problems with VS2015 installation due to the way the Microsoft VSIX installation/upgrade
system and version numbering work.
We have unfortunately had to make a breaking change to the extension GUID to fully resolve the install problems.
If you have already installed Atomineer into VS 2015, please uninstall it from the Tools >
Extensions and Updates menu, and then double-click the new AtomineerProDocumentation.vsix file
to install the new version. It will not be necessary to do this for future releases. This need to
fully re-install does not apply to Atomineer installed into Visual 2013 or earlier.
Please accept our apologies for this inconvenience.
- The Atomineer version number has been incremented from 9.04 to 9.15 to resolve issues with some websites
which do not handle our old version numbering system well.
- Resolved 'Rules file not found' errors in Visual Studio 2015 after uninstalling and reinstalling Atomineer.
- Improvements to parser robustness when presented with malformed XML comments.
- Added preference to describe a class in either the form 'Class' or 'Namespace.Class'
- Added prefix-removal support for prefixes that include numerical values, e.g. 'u32'
- Added %solution% variable, which expands to the name of the Solution containing the file being documented.
|
August 2015
9.04 |
- Upgraded our development systems to TFS 2015 & VS 2015 on Windows 10.
- Tested and updated all Atomineer apps for Windows 10 compatibility.
- Fixed a DPI scaling issue in the setup Wizard.
- Improved the vsix installer for Visual Studio 2015.
- Fixed a signing problem that caused the 2015 trial to expire immediately on some PCs.
|
July 2015
9.03 |
- Updated Atomineer release for Visual Studio 2015 (now out of beta).
- Released trial version of Atomineer for Visual Studio 2015.
- Updated Atomineer Spelling to support Visual Studio 2015.
- Significant improvements to the 'Word Wrap Comment' implementation to support more languages and also
to allow it to process Documentation Comments. While Add Doc Comment includes word-wrapping in its
processing, it also adds/removes entries and specialised line formatting for different entry types.
Sometimes you may just want to simply word-wrap the text in a doc comment, and this is now possible
by executing 'word wrap comment' on the doc comment instead of 'add doc comment'. The word-wrapping
behaviour of Add Doc Comment itslef is unchanged (i.e. if you execute it on a regular comment, it
drops down to executing 'word wrap comment' on it for convenience)
- Fixed a parsing glitch when processing Typescript member variables.
- Fixed a problem with Implement/Declare Method when applied to operator declarations.
|
June 2015
9.02 |
- Performance improvements when commenting methods.
- Added new template attribute: _tagName="name" allows you to specify a custom tag to represent an
existing entry (for example, <exception _tagName="throws"/> will cause Atomineer to use the name
'throws' instead of 'exception' for its entries.
- Added new template attribute: _aliases="name,name,name..." which allows you to specify additional tags
that Atomineer will read as being the same (e.g. <exception _aliases="exceptions,throw,throws"/> will
allow Atomineer to convert any of those entry names to 'exception').
- For foreign language documentation, added new user variable, %except-passprefix%. Set this to the text you normally
use as a prefix on exception descriptions when they are passed through a method from a subroutine, so that Atomineer
can detect these 'passed' exceptions and preserve the desriptions even when it can't see the exception being thrown
in the method body. The default value is 'pass' to handle cases like 'passed if' and 'passed when'. e.g. for German,
you might use 'Wird weitergeleitet'.
- Added new commands for variable expansion. %variable:SafeGen% converts template/generic <> characters in the variable
into {} characters so they can be safely embedded in XML comments. %variable:AsSee% wraps the variable value in a
<see cref='xxx'/> block.
- C++ #define macros are no longer commented if they merely define a symbol without assigning a value to it.
This stops Atomineer documenting macros used to provide 'include only once' functionality in headers.
- More improvements to TypeScript/JavaScript parsing, in particular for more complex forms of parameter
declarations.
|
May 2015
9.01 |
- Improvements to the support for Typescript & JavaScript
- Rewrote the user manual into a PDF format, integrating the tutorials and other information to form a
single document
|
March 2015
9.00 |
- Apologies for skipping the February release. This was due to the work we had to put in to support new tax laws
in January, and the considerable work and testing needed to bring Atomineer to Visual Studio 2015.
- Major Upgrade: This is the first release of the Atomineer Beta for Visual Studio 2015 (compatible with
CTP 5 and 6). In order to support 2015 the Atomineer Add-in has been rewritten as an Extension, which also
affects the installation process. The existing installer is used as normal for versions of Visual Studio up to
and including VS 2013, but for VS 2015 (onwards) there is now a separate installer which uses Microsoft's
standard 'VSIX' Extension installer system.
To install this into VS 2015 please double-click the 'Atomineer Pro Documentation.vsix' file in
your downloaded .zip file. An updated User Guide covering this new version in more detail will appear
on our website soon.
- Performance and accuracy improvements in the parser's code-type recognition system.
- Improvements to the Visual Basic sub/function/property declaration parsers.
- Small improvements to prefix stripping algorithm.
- Fixed a problem in live typing aids where tabs were sometimes interpreted as newline characters.
- Improved C++ handling of 'extern' scopes, which were interfering with the operation of comment creation
when typing '///'
|
January 2015
8.37 |
- Improvements to parsing and handling of C++ templates.
- Fixed a small regression that affected the parsing of C++ function-call operators.
- Improvements in the operation of Align Into Columns when used at the start of lines.
- Single-line doc comments are now word-wrapped if you update them.
- The 'Convert Entities' preference is now saved in language-specific pref sets.
- Our conversion from an Addin to an Extension (to support Visual Studio 2015) has been completed,
and is now undergoing testing.
- Some changes to our website and pricing necessitated by changes to European tax law.
|
December 2014
8.36 |
- Tested with Visual Studio 2013 Community. No compatibility problems were found.
- Live typing aids are now available in Typescript, JavaScript and JScript files.
- New live typing aid: Atomineer can now optionally override tab and shift-tab to navigate the cursor quickly to
the next/previous documentation entry within a doc comment. See the 'Other Features' tab of the preferences
(Live Typing Aids section) if you wish to try this new option.
- Improved updating of end-of-line doc comments
- Improved conversion from end-of-line comments to regular doc comments
- Improved handling of type="" attributes for optional parameters.
- Added support for the optional (header reference) elements in doxygen '\class' entries. There is a new
preference (on the 'Doc General' tab) to enable this additional information.
- Added rules for WPF dependency properties.
- Many small improvements to the Atomineer website, including support for high DPI displays.
|
November 2014
8.35 |
- Improved the generation of operator descriptions for explicit operators.
- Improved handling of [in,out] tags on parameter descriptions, and added processing variables to
allow the output to be controlled more easily.
- Fixed a small issue in the preferences which stopped settings from the Quick-Set wizard being picked up
when returning to the prefs dialog.
- A small tweak to improve the handling of global-scoped parameter types in C++.
- Improved switching between different preference sets for diffferent projects and solutions.
- Description attributes are now picked up from interfaces.
- Fixed a case where class comments could be auto-punctuated with a double full-stop.
- VB: Improved comment updating when a doc comment joins directly onto a single-line comment.
- We've also tested against VS 2013.4 and have been working on support for Visual Studio 2015, which necessitates
conversion of Atomineer from an Addin to an Extension.
|
October 2014
8.34 |
- Improved the generated descriptions for enums and bitfields, and added an <Enums> rules section. As for other types,
the preferences 'Doc Advanced' section now also includes a button to allow you to easily edit the enum rules.
- When documenting within an enum, the %containingClass% variable will now contain the enum name, if it is available
from intellisense. (In this context 'containingClass' is not a terribly accurate name any more, but has been retained
for backwards compatibility)
- Added the %namespace% variable.
- Attributes applied to Classes and Structs are now available for use in rules, in the same way as they already were for Methods.
- Classes and Structs tagged with [Description] attributes will now use the description text as the summary for generated comments.
- Methods, Properties, Classes and Structs tagged with [GeneratedCode] attributes are no longer documented by Atomineer.
- Typing '///' within an enum scope now adds doc comments to enum-members.
- Improved handling of covariant/contravariant generic type parameters.
- Fixed a parsing issue on enum entries which could result in the wrong style of comment being inserted.
- Fixed a minor problem in end-of-line comment insertion which could occasionally cause it to incorrectly truncate the line of code.
- Fixed location of the inserted namespace comment when cursor was immediately inside the namespace's opening brace.
- Improved documentation of casting operators.
- Logic for DocXml <remarks> was interfering with Doxygen processing of @remarks. This has been corrected.
- Improved documentation output for PHP methods.
- Auto-conversion of < and > into XML entities (<, >) now supports embedded XML comments and CDATA sections.
- Atomineer Spelling: Improved performance on extremely long words. Fixed an error reported when deleting all text
from a file. Additions to the coding jargon dictionary.
|
September 2014
8.33 |
- Preferences now uses friendly dedicated editors for user variable, non-splittable word and replacement word lists.
- Added support for Visual Basic 'properties with parameters'. Additional params are now added as <param> entries.
(if a parameter is named 'value', it is ignored as this special parameter is already documented by the
<value> entry)
- Improvements to parsing of VB code (special cases added to handle more syntax variations).
- Updated the installer and preferences windows, which could appear blurry on high DPI monitors in Windows 8.1.
- Added support for using /*...*/ delimiters on single-line doc-comments.
- Fixed an issue in the preferences where switching between Language preference sets could lose
some Doxygen (JavaDoc) settings.
- Improved handling of method access levels (public members of an internal class are now considered internal)
- A number of improvements to exception parsing and class rules.
- NotImplementedExceptions are no longer documented.
- Added a preference to force Atomineer to always preserve all exception documentation. This is not currently
supported in the Options dialog, but can be added to the Prefs.xml manually if needed.
- Param 'type' attribute now support generic/template types.
- Improvements to duplication of base-class or overload documentation.
|
August 2014
8.32 |
- Added 'Non-Splittable terms' to the rules. This informs Atomineer of special terms like 'IPv4' and 'PowerPoint',
which Atomineer's generalised heuristics would normally break into several words, so that the correct formatting
and capitalisation is retained for these special terms. A new button has been added to the Atomineer Options
('Doc Advanced' Tab) to allow custom terms to be added. Please let us know if you discover any common terms that
ought to be added to the default dictionary, and we'll add them to the master Rules.
- Upgraded 'Doc all in Chosen Files' to be capable of deleting doc comments from processed files,
allowing entire solutions to be processed in batch mode.
- Improved reporting of skipped source files in 'Doc all in Chosen Files' in cases where intellisense is unavailable
for a file (this is usually because the file has not been successfully compiled).
- Fixed a special-case failure in the Delete Doc Comments command when using an embedded 'end of comment'
sequence */ in the separator of a doc comment, e.g. a top separator of the form /****//**. Atomineer
would see this as the end of the comment, and incorrectly leave the second 'part' of the doc comment undeleted.
- Fixed a refactoring glitch that caused 'tparam' and 'typeparam' entry tags to be emitted incorrectly
(tparam incorrectly appearing in DocXml, and typeparam in doxygen)
- Fixed an issue that caused 'type' attributes to be added to param entries for languages other than
TypeScript/JavaScript under some circumstances. Although this is now disabled by default, if you wish to
have type attributes for your param entries, there is now a preference to enable this behaviour.
|
July 2014
8.31 |
- Improvements to the TypeScript and JavaScript language syntax support.
- TypeScript, JavaScript, and JScript code: Added initial support for JSDoc and JSDuck
documentation syntax, in particular for parameter and returns markup. Atomineer now supports
{types}, [optional] and [optional=default] syntaxes in these entries. In addition, if types
are specified in Typescript code, Atomineer now incorporates them into generated documentation.
- Added a 'parent class type' variable that indicates if a parent structure is a class, struct
or interface during rules processing.
- Small improvements to stylecop support and rules.
|
June 2014
8.30 |
- Added initial support for TypeScript, JavaScript, JScript and PHP.
We've tried to test against a wide range of scripts, but please let us know if you find any syntax
variations that our parser struggles with. We'll be working on additional documentation entries/attributes
to further support documenting these languages in upcoming releases.
- Atomineer Spelling: Performance improvements for check-as-you-type functionality (particularly when
undoing/redoing typing), and some dictionary improvements.
- Added support for Atmel .ino files (which are now treated as C++).
- Improved <Set> Rules commands. These used to only be able to set 'desc', but now can set any
variable (other than continue or abortComment) to a new value. Usually this is combined with
'continue', e.g. <Set isOptional="y" continue="y"/> to alter the flow
of or output from following rules.
- Parameter In/Out and Optional description generation can now be disabled in the default rules by
setting the variable suppressInOut="y" in your custom parameter rules.
- Fixed a regression (caching bug) that meant new custom entries added to the rules were not fully
picked up until the next restart.
- Improved handling when a group of several custom elements of the same type are used in a comment.
- Improved support for end-of-line comments in VB.
- Fixed an errant event handler in the preferences that stopped the Doc Formatting tab updating
correctly when switching between different language preference-sets.
- Small improvement to parsing of attribute content.
|
May 2014
8.18 |
- Added support for C# generic covariance and contravariance. The <TypeParameters> rules can now
use the variables %isIn% and %isOut% to produce more meaningful documentation if desired.
- Rules for Classes can now use the variables %isStatic%, %isPartial%, %isSealed%, %isAbstract%,
%isGeneric%, and %isTemplate%, which are set to 'y' or 'n' as appropriate)
- Rewrote a portion of the Visual Basic parser to fix some parsing glitches and add support for a few
additional keywords. Improved documentation generation for VB event handlers.
- Some small improvements to C/C++/C#/Java parsing
- 'Doc All in Project/Solution' commands will now process C++ files with .cc and .cxx filename
extensions.
- The Preferences dialog will now warn if it is unable to expand environment variables on the
Prefs Storage Search Path.
|
April 2014
8.17 |
- Atomineer now includes the new Atomineer Spelling
extension (Beta) for Visual Studio 2010, 2012, and 2013. This provides spell checking as you type in
comments. Follow the link above for more information on installation and usage.
- Auto-punctuation now detects and cleans up accidental double periods ('..') at the end of a comment.
- Improvements to conversion of legacy JavaDoc comments.
- Improvements to StyleCop compatibility mode (Atomineer now ensures a blank line prior to
single-line and enum-entry comments; A <content> entry is now used on partial class declarations
that don't match their filename - this ensures that all partial class parts except for the main one
have an XML doc comment to satisfy StyleCop, but do not contribute chaff to the generated
documentation. The main part of the partial class is documented as normal).
- Improved the undo experience after insertion of comments when typing /// or '''.
- Fixed a regression that stopped Interface documentation being correctly duplicated.
- Fixed a glitch in generation of seealso entries for methods with optional parameters.
- Added 'see' as an accepted alias for 'sa' in Doxygen comments.
- Fixed duplicated interface name in seealso when generated from an explicitly implemented interface member.
- Fixed a few rules that used an incorrect matching pattern and thus produced unexpected descriptions.
- Stopped '\commands' being split across two lines in doxygen comments if the \ happened to occur
on the last usable character column in the first line during word wrapping.
- Fixed a poorly reported error when attempting to update a file header comment during debugging.
|
March 2014
8.16 |
- Inheritdoc support. Updating doc comments containing 'inheritdoc' entries now disables
duplication of documentation from base classes and auto-generation of new doc entries, so that the
inheritance is correctly preserved.
- Added an option to the 'restrict documentation by access level' feature. Previously, comments
that were not allowed under this restriction were automatically deleted. This option can now be
disabled (via the check-box at the bottom of the Doc General tab of the Options), in which
case Atomineer will simply ignore any existing comment on restricted code elements.
- Fixed an issue in 'Document All in This Solution' where sub-projects were sometimes
skipped during processing. Some improvements to Output window reporting during processing.
- Fixed a broken help link in the preferences dialog.
- Fixed a case where %containingclass% could lose generic suffixes from the classname.
- Fixed a parsing glitch in seealso generation for generics, which could add junk entries
for the 'where' clauses in cases where intellisense data was unavailable.
- The documentation rules no longer generate '[in,out]' or '(optional)' in StyleCop
compatibility mode.
- Tested and updated for compatibility with Atmel Studio 6.2.
|
February 2014
8.15 |
- The Atomineer rules now support user-configurable text for 'true', 'false', 'null' and 'nullptr'. To
configure different text from the default (true, false, null, nullptr), go to the Atomineer
options, Doc Advanced tab, and click the 'User %variables%' button. Edit the variables for
true/false/null/nullptr - e.g. to output 'true' as "<c>true</c>" use
"<c"gt;true"lt;/c"gt;"
- Exceptions thrown within properties are now documented.
- Resolved a rare installation situation where VS would not pick up the addin after installation.
- Fixed a tiny bug in conversion of // comments into summary documentation, which
could cause parts of URLs to be 'lost' during the conversion.
- Fixed a failure caused by a regression in parsing a C# code element when preceded by an attribute
on a single line
- Fixed incorrect use of tabs rather than spaces (when configured in Visual Studio editor settings)
in C++ accessor generation and end-of-line comments.
- Fixed a case with single-line enum value comments in DocXml format when using a multiline C++ comment
style, where the documentation entry was emitted without comment /* ... */ delimiters.
- Fixed a glitch that could occur in handling of parameters after some forms of regex pre-processing.
- We suffered a catastrophic hardware failue this month and it took a lot of time to resurrect our systems from
our backups and then test our new builds to be sure that everything still works. We were hoping to deliver
a major new feature for this release, but this has unfortunately had to be deferred for a bit...
watch this space!
|
January 2014
8.14 |
- Happy New Year! We wish you all the best for a great 2014!
- Added Attribute auto-doc support. For each attribute applied to the code element being documented,
Atomineer now creates an 'attr-???' variable for use in the Rules, containing the parameter-list for
the attribute (e.g. [Conditional("DEBUG")] will generate a variable 'attr-conditional' with the
value 'DEBUG'). To support this in Rules, you can now use tests of the form
<If defined="attr-name"...> to test if a variable is defined. This is
used by new rules to extract data from attributes and include it in the generated documentation text.
For example, if the conditional attribute above is assigned, Atomineer will now prefix the
summary documentation with '(Only available in DEBUG builds)'
- General improvements to conversion of double-slash comments into doc summaries. In addition,
double-slash comments are no longer converted into summaries if they appear to be
commented-out code.
- Popup reports will no longer be split across screens on mulit-monitor systems.
|
December 2013
8.12 |
- Added new 'Doc All in Chosen Files' command. This offers a front-end user-interface for the other Doc All
commands which allows you to set a number of additional options before the documentation process
begins, including file filtering and greater control over what documentation is generated. It also
provides a new documentation mode, to document all open files.
- Updated preferences now allow you to customise Atomineer Menus. This allows you to remove unwanted
items from the Tools > Atomineer menu and also to show extra commands on the Text Editor's context
menu if you wish. These new options are in the 'General Settings' tab of the preferences.
- Doc All... and Delete Documentation commands now report information on the projects, files and
code elements they have processed. This is shown in the Visual Studio 'Output' window (choose
'Atomineer Pro Documentation' entry in the 'Show output from' combo box to see this output)
- Doc All... commands now report completion using a temporary "tooltip" style window, which disappears
automatically after a few seconds or if it is dismissed with a click.
- Changed the way Atomineer inserts text into the document in some cases to work around a problem
in VS 2013 where certain other addins were occasionally found to interfere with the insertion process.
- Added 'ClassDecl' regular-expression preprocessing, which works exaclty like the existing 'MethodDecl'
preprocessing, but for class/struct/interface members.
- Fixed a glitch in derived documentation duplication that sometimes caused a param entry to be
added twice.
|
November 2013
8.11 |
- Fixed a bug introduced in v8.10 when handling C++ projects. A small additional check added in the
menu-item state code in 8.10 was requesting Intellisense information from Visual Studio, sometimes causing
an Intellisense loading-progress dialog to be shown momentarily, which in turn closed the menu, making
it impossible to open the Atomineer menu. This check has been removed and the menu now operates
correctly once more.
|
October 2013
8.10 |
- Added 'Doc all in Project' and 'Doc all in Solution' commands.
These allow you to update documentation for thousands of code elements in a single pass,
which is particularly useful when converting legacy documentation to a new style. Note that
this processing can take a considerable amount of time on a large project/solution, and is
not undoable.
- New algorithm for 'Doc All In Scope/File/Project/Solution' processing: Under some circumstances
the Visual Studio Intellisense information used by these commands could become slightly out of step
with the source code during processing, causing Atomineer to miss occasional code elements out. The
core processing algorithm has been completely rewritten to resolve this issue.
- Significant speed-ups to all 'Doc All in...' commands.
- 'Doc All in Scope/File' commands all now create a single undo step for their processing rather than
an undo step for each code element documented.
- Improved 'Doc All in...' handling of enum entries.
- Improved 'Doc All in...' status line progress handling.
- Added 'Delete Documentation from this File' command. To be used with care, this command deletes
all documentation comments from a source code file. This can be useful for stripping away legacy
documentation or forcing a complete regeneration of documentation (when used with Doc all in File)
- Added support for __declspec() on classes in C++
- The Documentation Viewer window now reopens on startup if it was open when Visual Studio last quit.
|
September 2013
8.06 |
- Added a tutorial to the website, Making the Most of Atomineer.pdf
which offers a number of hints and tips about how to get the best results out of Atomineer.
- Upgraded the 'word wrap comment' feature to detect most forms of 'separator' line at the top and
bottom of comments and exclude them from the word wrapping pass.
- A small improvement to the auto-punctuation feature to suppress spurious punctuation in one rare case
- A small improvement to generation of file header comments in 'Doc All in this File'
- Began adding support for MVC code. If you use MVC and find examples of MVC-specific classes or methods
that Atomineer does not document well, please let us know so we can improve our coverage of
these cases.
- Many improvements to the rules, especially in cases where generic/template types are used.
- Improved the a/an autocorrection algorithm.
- Added two 'inverted' (white on black) colour schemes for the documentation viewer.
- Added a preference (not exposed in user interface) that allows Atomineer to correct the behaviour
of other addins that incorrectly add their menu items into the Atomineer menu. If you experience
this problem, please contact us for details of how to enable the workaround.
|
August 2013
8.05 |
- Atomineer has now been verified compatible with Visual Studio 2013 Preview. (But please let us
know if you find any unexpected behaviour in VS2013). To get Atomineer working in 2013, just
run the 8.05 installer to update as normal - there is no need to uninstall first.
- The installer now displays the version number (and '(Trial)' for trial versions) in its
title bar so you can easily see which version you are about to install.
- The installer will now warn you if you attempt to install over a full version with a trial version.
- Fixed a loophole in the installer that allowed users to inadvertently install two or more copies
of Atomineer (when changing the install location without uninstalling first). This could lead
to Visual Studio running the old version, and the installer no longer appearing to update anything.
- Some refactoring of the installer code.
|
8.04 |
|
July 2013
8.03 |
- Atomineer is now fully code-signed to provide proper company information in UAC prompts during
installation, and confidence that the addin has not been tampered with since leaving Atomineer.
- Updated the 'configuring Atomineer' tutorial to describe the new preferences user interfaces.
- Shuffled a couple of preference items to more logical places in the preferences dialog.
- Fixed a small glitch in backwards compatibility for VB preferences
- Added a 'clip column' preference for the separator lines, allowing them to be clipped at an absolute
column so that indentation of the comment block does not cause the right hand side of the block
to extend any further to the right. By default clipping is disabled, but if enabled it is usually set
to the same column as the word wrap column to give a consistent block layout and ensure that none
of the comment flows out of the desired display/print boundaries - but some users may prefer to
extend the separators a couple of characters beyond the word wrapping column.
- Fixed a rare bug in the word wrapping (on the first line of flowed entries, when the previous entry text
started with a blank line, too much text to be added to the first line, causing it to flow past the wrap
column)
- Fixed a minor parsing glitch when commenting operator<= and operator<<, which caused them to
be incorrectly treated as a generic in one processing pathway.
|
June 2013
8.02 |
- Significantly redesigned the Atomineer preferences window layout, exposing a couple of new preferences,
adding a welcome page and embedded help links to the Atomineer website.
- Documentation system, formatting and layout preferences can now be configured separately for each
code language directly within the preferences dialog. (This was possible in the past using per-solution/project
Rules Paths, but is now considerably faster and easier to set up, and applies on a per-source-file basis
so you can work in mixed codebases much more easily).
- Reskinned the preferences and wizard forms to the new Atomineer graphical design.
- Fixed a generic parameter parsing glitch in Visual Basic.
- Improvements to the parsing of properties and exceptions in Visual Basic
- Added optional support for converting Doxygen ///< or /*!< ... */ end-of-line comments on enum entries
and variables into regular XML documentation comments. (If you would like to use this conversion, please
email us for details of how to enable the feature)
|
May 2013
8.01 |
- Oops! Removed a debugging behaviour that slipped into the last release, which was causing the
documentation viewer to reopen whenever Add Doc Comment was executed, if you had previously closed the view.
- Added handling for '@' prefixed strings in parameter attributes.
|
8.00 |
- Added the Documentation Viewer.
This displays documentation comments in a human readable style (similar to the sort of output you can generate
with tools like Sandcastle, Doxygen, and JavaDoc) so that documentation can be easily browsed as cursor moves
through source code.
|
April 2013
7.68 |
- Added support for inline ReSharper code-inspection suppression comments. Atomineer will no longer convert
comments of the form '// ReSharper disable RedundantThisQualifier' into DocComments. Instead, the code
element will be considered undocumented and a new comment will be inserted without consuming the ReSharper
command.
- Added support for per-parameter attribute decorations as used by ExcelDNA. Atomineer will now
correctly handle these attributes embedded within the method declaration. In addition, if a
'Description="..."' attribute value is present it is assumed to be a description of
the parameter, and used as the default text for the parameter description that Atomineer generates.
- Fixed the missing menu separators in VS 2010 and 2012.
- Fixed a problem with parsing one very special case: single-line auto-brief Doxygen/Javadoc/QDoc comments.
Atomineer would classify this particular case as a 'separator line' rather than a documentation comment
due to the lack of any documentation entry syntax in the line. It now recognises this particular case
and updates it as expected.
- Declare/Implement method: updated to correctly process method declarations occurring on the same line
as the access specifier, and removed a problem with C++/CLI handles (^) in return values.
- Added support for constructor-style member variable initialisation syntax.
|
March 2013
7.67 |
- Improved conversion of /** ... */ comments when they are not configured as the primary Atomineer
format. This increases the number of common documentation styles that Atomineer can convert
automatically (without needing any explicit tweaking of conversion settings).
- A few small improvements to the setup Wizard application.
- Fixed a small issue in the uninstaller that caused it to silently fail in rare circumstances.
- Tested Atomineer for compatibility with the Atmel Studio 6.1 Beta, added installation support
for this new version of Atmel Studio, and launched Atomineer on the
Atmel Gallery.
- Implemented a small but important missing feature - updating parameter descriptions
to include or exclude auto-generated (Optional) tags as appropriate when default values
are added or removed, or when documentaiton is copied from other same-named parameters.
- Fixed an update problem with [in, out] parameter tagging.
- Removed a minor caching issue that meant documentation updates did not work properly until after
a restart of Visual Studio when changing between JavaDoc and QDoc style comments
|
7.66 |
- Added conversion support for end of line comments (on parameters and member variables).
If a parameter or member variable is followed by an end-of-line comment (a // comment, or
a documentation comment prefixed with ///< or //!<), Atomineer will now merge the text
of the comment into the documentation block. The original comment will be removed (This is
added as a separate undo step so you can undo through the history of changes after converting
a code element's comment). This can be used to convert EOL comments into entries within doc
comment blocks, or (if Atomineer is configured to generate EOL comments for single-line entries)
to convert EOL comments into the configured Atomineer format. This feature also promotes
consistent behaviour when reapplying Atomineer to code elements that are already documented.
- Added conversion support for single line /** ... */ documentation comments that occur prior to
a code element. (Previously Atomineer would only pick up this style of comment if the closing */
occurred on a different line to the opening /**).
- Implemented support for editing custom preference files in solution-relative and project-relative
rules paths. Creating new custom rules files now reports the filename of the generated file to
make troubleshooting easier.
- Adjusted Atomineer to work around a minor compatibility issue introduced in the latest version of
Atmel Studio 6, which was causing blank doc comments to be generated.
- Improved handling in the case where Add Doc Comment was executed on the last line of a scope
preceeding the code element to be commented. This would incorrectly insert the new comment just
inside the previous scope, but now handles this case correctly.
|
February 2013
7.65 |
- Member variables and enum members are now commented properly if decorated with attributes.
- Fixed a failure that could occur when trying to document during debugging under conditions that
made the source file read-only (e.g. edit and continue unavailable).
- Fixed a small parsing error in C++ exception specifiers that could cause an invalid exception
entry to be added under rare circumstances.
- Improvements to the 'stylecop compatibility' mode, which now provides MSDN-like descriptions
for more common .Net cases, even though these are not actually checked by StyleCop.
- Improvements to the generated documentation for operators, including handling of explicit
and implicit operators.
|
January 2013
7.64
|
-
Improved documentation for enumerated type members. When processing the <Variables> rules, the
%type% variable is now set to 'enum' for members of enumerated types, and 'bitfield' for members of
enums marked with FlagsAttribute. These special types are now used to generate improved documentation
specific to enumerated values (enum) and binary constants (bitfield).
-
Added 'camel' and 'pascal' commands for use when expanding variables (e.g. %name:Camel%). This outputs the
name in the form 'camelCasedName' or 'PascalCasedName' respectively. This will of course only be useful for
names in a multi-word format (multi_words or MultiWords)
-
Fixed a small glitch in the C++ parser that could stop Atomineer from generating a comment when the
user typed ///. (This problem did not occur with ctrl+shift+D)
- Existing documentation is no longer duplicated for event handler 'EventArgs' parameters
|
December 2012
7.63
|
-
Optimised and improved the code that searches for base class documentation that can be re-used.
This can significantly improve performance in cases where complex class hierarchies are encountered
(in both user code, and underlying/system libraries).
- Tested Atomineer with Visual Studio 2012 Update 1.
- A few small improvements to generic and template parsing.
-
Fixed a problem in 'Doc all in File' caused by C++ macros that inject methods into a class.
These 'non existent' methods could be returned by the Visual Studio intellisense system,
causing Atomineer to try to document members that didn't exist in the source code. They
are now ignored.
- For convenience the preferences dialog can now be minimised to the TaskBar.
- Small improvements to the installer/uninstaller.
|
November 2012
7.62
|
- A slightly new look for our website.
-
Fixed an unexpected bug introduced in 7.61 - this caused problems when attempting to document code
in C++ header files. If you have 7.61 and wish to document C++ headers, please update to the latest
version (for those with a single-download copy of version 7.61, please
contact us and we'll send
you a free upgrade to 7.62)
-
Added a mechanism for conditonally marking documentation entries as 'optional'. This allows entries
to be added to a documentation block for some cases (e.g. overrides) but not others. The conditions use
the same expressions as available in <If> commands. See the description of _optional in the
Rules Guide for details.
|
7.61+
|
-
Moved our web hosting to new servers to provide improvements to our online service, and freshened
up the website look and feel.
-
Atomineer now has a Facebook page and
a Twitter account, so please look us up, Like us,
and Follow us for announcements about new releases etc.
|
October 2012
7.61
|
-
If 'Add Doc Comment' is executed within the body of a method or property, Atomineer will now
move the cursor out of the top of the method/property and document it. Note that this relies on the
Intellisense information provided by Visual Studio, so it may not work if the code is in a
non-compiling state or a language for which Visual Studio doesn't provide this information.
-
Improvements to the Live Typing Aids when typing and pasting into comment blocks. (Atomineer will no longer break
a comment if you type a double-newline in the middle of it. This was intended to be useful behaviour but
has been found to work poorly in practice. Typing /// in illegal places such as within method bodies will
no longer attempt to insert doc comments. Pasting within multiline comments now pastes verbatim)
-
Improved 'Implement/Declare C++ method' command - as well as reading the text from single-line (//) comments
from declarations and using them as summary text for the implemented method, it can now read fully blown
doc comments and duplicate them onto the implemented method. It now also handles existing comments in
the target source file.
-
Fixed a localisation issue (only affecting Visual Studio 2012 in a few non-English language locales)
where the Atomineer main-menu items were not appearing.
- Improved handling of seealso entries for Generics/Templates when updating existing comments.
- Fixed a small problem that sometimes interfered with correct handling of [in,out] parameter entries.
- Fixed a breakage in the handling of namespaced MyClass::operator= in C++
- Corrected handling of Doxygen AutoBrief comments when using /// comments without top/bottom separators.
|
7.60
|
- Fixed a bug from 7.59 that caused Atomineer to fail sometimes when documenting member variables
- Improved handling of XML entities within cref attributes
- Improved handling of C# generic typeparams using 'where T : ...' clauses
|
September 2012
7.59 |
- By default, Atomineer will now assume that // comments that contain plain text are to be converted
into a fully-blown doc comment (it assumes that the comment body represents the summary/brief description
to be used in the new doc comment). If this conversion is unwanted, it can be disabled in prefs.xml -
contact us for details of how to do this.
- Improved compatibility with different Atmel Studio versions
- The Installer now registers Atomineer in the Programs And Features control panel,
so it can now be uninstalled directly from Programs and Features as well as by running the
original installer and choosing the Uninstall option.
- Anywhere a %variable% can be used in Atomineer and the Atomineer preferences (e.g. Rules Search paths),
it is now possible to use OS environment variables (An Atomineer variable will take precedence over any
environment variable of the same name)
- Xml Documentation: By adding a <prototype _punctuate='false'/> element to your templates you can
now cause the method signature to be added to the comment, just as for Doxygen comments. This element will be
named 'signature' (currently a fixed name, but contact us if you would like this name to be configurable).
- Improved handling of generic classes in the new class parser.
- Fixed a some minor parsing glitches in C++ (relating to array parameters, namespaced parent class
names, and array-member initialisation lists).
|
August 2012
7.58 |
- Added support for UnrealScript (.uc) code syntax.
- When updating interface and abstract methods, exception descriptions are no longer removed.
- Added a preference (on the Doc Comment Style tab, Automatic Tidying section) that controls
removal of 'invalid' entries. By default, if Atomineer finds an unknown doc entry during a
comment update (such as a description for a parameter or exception that is no longer present
in the method), it prepends the entry with '###'. This allows you to see what Atomineer intends
to remove, so you can choose to re-use the description text, or you can execute Add Doc Comment
a second time to clean up the comment and remove all the invalid entries. The new preference
allows you to turn off this safety measure, so Atomineer will silently remove all invalid
entries.
- (Related to the previous change) The 'Doc All' commands now force immediate deletion of invalid
doc comment entries, rather than leaving them with a prefix of '###'. This avoids having to
update a large batch of comments twice to clear away invalid entries.
- Added support for optional 'inheritdoc' entries.
- A couple of small improvements to C++/CLI code handling.
- Added handling for __declspec() on methods in C/C++.
- Fixed a case in C++ where seealso entries were being duplicated.
|
July 2012
7.57 |
- Extensive testing with Visual Studio 2012 RC. Found and fixed an occasional problem where
incorrect documentation was being generated. (This was due to a breaking change in
Visual Studio's internal 'find' operations, which now interpret regular expressions using
.NET regex syntax)
- Fixed a side effect of improved 'optional' template entry handling, which had inadvertently supressed seealso output.
- Fixed a problem with adding seealso entries in C++.
|
7.56 |
- Improved handling of 'optional' template entries, which had not been extended to all entry types.
- Now supports Atmel Studio 6.0.
- Some small performance optimisations.
|
June 2012
7.55 |
- Significant performance improvement when updating existing comments.
- Rewrote the code-element detection parser. (This is used to determine what kind of code element
is being processed before a more-specific parser is used to actually document that element). This
has provided the following improvements:
- More efficient processing of code elements.
- Better handling of complex multi-line declarations
- Less likely to be 'confused' by different coding styles, especially
when handling class/module/struct/union/interface code elements.
- TypeParams for Generic/Template classes are now supported.
- When adding <seealso> entries to a comment or if <see> entries are being added
to description text (%docBasesWithSee% is true), Atomineer will now add seealso/see entries for
all base classes/interfaces rather than only the primary base.
- When restricting generation of documentation to certain access levels, the default behaviour
is now to only apply the restriction to the commands that generate multiple comments
(i.e. Doc All In Scope/File)- if you deliberately try to document a code element with
'Add Doc Comment' it will allow the comment to be added. There is a new preference (on the
General preferences tab) that extends the restriction to the Add Doc Comment command as well.
The reason for this change to the default behaviour is that it can be very confusing
(e.g. if you type /// and that text is simply deleted without any obvious explanation).
- Fixed an issue with updating single-line comments when using certain comment-block styles.
|
7.54 |
- Improved the support for duplicating documentation for parameters from elsewhere in a class.
Previously this feature copied appropriate documentation from other parameters in the class,
but it now also considers documentation from Properties and Member Variables as well. In the
case of properties, the <value> documentation will be used if available, or the
<summary> if not (any 'gets or sets' text is stripped in this case to make the generated
parameter description coherent).
- Duplication of parameter documentation is now applied when updating a comment as well as when
creating a new one. This allows the documentation to be duplicated onto parameters that are
subsequently added to methods.
- Hotkeys are no longer assigned to Atomineer commands if they have been bound to other commands in
the 'Global' key context. (Hotkeys used to be assigned only in the 'Text Editor' context, but this
meant they could override global hotkeys)
- Added handling for foreign characters (É, Ø, ß etc.) in code-element names.
|
May 2012
7.53 |
- Added support for user-defined acronym and general text replacements. As a variable (such as a parameter
name) is expanded, separate words within it can be selectively replaced. The primary use is for
converting words like 'html' or 'Html' to uppercase 'HTML', but it can be used to apply any replacement
required (e.g. 'atomineer' with 'At*mineer'). This replacement system is enabled by default but can be
disabled in the Doc Comment General tab of the preferences. The list of acronyms and replacements can
be customised by clicking the 'Acronyms & Replacements' button on the Advanced Customisation tab.
- 'Create C# or C++/CLI property' can now generate auto-properties in a single-line or multi-line format.
The default is a single-line implementation, but this can be changed to multi-line in the Misc tab of
the Atomineer Options.
- 'Create C# or C++/CLI property' can now convert the multi-line auto-properties into a
property-with-backing-field.
- Improved handling of custom preferences files in the Options dialog.
- Improved 'Doc All in This File' with a preference (on the 'Misc' tab) that controls whether or not
file header comments are added (if not already present).
- Fixed an oversight in 'Doc All in This File' that could sometimes lead to unexpected code elements being
documented (such as 'using' directives and some parameters) depending on the version of Visual Studio
in use.
- Fixed a problem with <seealso> entries referencing base classes, where Atomineer could
incorrectly remove the seealso when updating an existing comment, and very rarely enter an
infinite loop. As a result part of the XML comment parser was rewritten and is now more efficient
and robust.
- Fixed a scoping issue with C++ that was interfering with handling of copy constructors and operators.
- Added support for C++ iostream << and >> operators
- A number of other small tweaks to the code and rules
|
April 2012
7.52 |
- Added 'Document All in this File' command.
Unlike 'Doc all in this Scope', this command relies on the Intellisense
CodeModel information in Visual Studio, so is not available in some languages. However,
it can be used in .net languauges where a file contains multiple classes/enums, to process
everything in a single pass, whereas each class would have to be processed individually
with Doc All In Scope.
- Added an unattended command-line mode to the installer. See the
Installation section of the user guide for details.
- Fixed a small bug in the processing of exceptions that could cause junk text to be reported
in place of the exception name under some circumstances.
- Improved handling for read-only files (code logic dating back to VS2005/2008 has been updated to take
advantage of improvements in 2010/11). Visual Studio now correctly prompts, allows editing,
or checks-out read-only files from source control as it is configured to do.
- Added a new attribute for template-entry xml elements, '_style="multiline"'. This can be used to force
individual entry types to use a multiline format even when they could fit on a single line.
(This can be used to make entries like 'summary' always use a multiline format, while still
allowing short entries like 'returns' to use the more compact single-line format. Details
can be found here.
- Added a new set-up tutorial to the User Guide.
- Fixed an interaction with the Visual Assist X addin that caused incorrect indentation of
the cursor in a few specific circumstances when VAX was injecting code snippets.
- C#: Added handling for '@' to allow reserved words to be used as names for class, parameters, etc.
- Improved StyleCop handling for properties where users want to allow private members to be documented,
but still don't want private property accessors to be documented (i.e. 'gets' rather than
'gets or sets').
|
March 2012
7.51 |
- Changed the name of the addin from "AtomineerUtils" to "Atomineer"
(it had 'utils' in the name purely for historical reasons). Please also note that
'Subscription' has been renamed to 'Support and Update Plan' - it works exactly as before,
and has simply been renamed for clarity.
- A lot of work went into improving the website, with easier to read typography, reduced
text descriptions, improved section separation, etc.
- Reworked the installer and preferences app to use the new Atomineer graphics.
- Removed most of the documentation that was embedded in Rules.xml, replacing it with links to
the online documentation. This has reduced the download size and helped to improve startup times.
- Atomineer now considers 'value' and 'returns' to be aliases. This allows a method to be converted
to a property (or vice versa) and updating the documentation will automatically migrate the description
of the return value across to the appropriate entry in the new comment.
- Improved C# indexer support. Indexer parameters are now fully documented, and the return value is
now documented as a 'returns' rather than 'value' entry, for StyleCop compatibility.
- Added access-level detection for enum entries, which were inadvertently being removed if
Atomineer was configured not to comment private members.
- Added a new rules attribute that can be used to stop Atomineer from generating a documentation
comment for any given code element. This works much as the access-level system already did, but
with much finer-grained control over exactly which code element(s) you apply the restrictions
to (for example, to all member variables, or to all methods that start with the word 'On', etc).
- Doc all in scope now reports a more helpful error message when CodeModel information isn't
available (usually when the project requires a rebuild).
|
7.50 |
- Now supports the Visual Studio 11 Beta.
- Visual Basic: Fixed a regression that caused some methods and properties to be commented as constructors.
- Visual Basic: Fixed a small issue that meant that single-line doc comments would not be updated in
some circumstances.
|
February 2012
7.49 |
- AtomineerUtils now detects and ignores single-line 'separator' comments that happen to start with
/// or ''' (VB).
- Made improvements to live typing aids (better handling of bullet-lists, better behaviour when pressing
return at the end of a doc comment block if separators are disabled, improved the handling of pasting
text into comment blocks).
- Typing /// to insert a comment with the 'ensure blank lines above comment' preference disabled
now retains the line spacing correctly (previously it 'inserted' a surplus blank line)
- Small improvements to constructor handling.
- Fixed a problem in the Align into Columns command that could occur if it was the first AtomineerUtils
command executed after starting up Visual Studio.
- Fixed a word wrap infinite loop that could occur if a line with excessive (more than a
full line of) indentation whitespace was encountered.
- Fixed a glitch that left the cursor in the wrong location after inserting a few types of comments.
- Improvements in the installer's detection of old versions of Visual Studio.
- When suppressing auto-generation of author/date entries, AtomineerUtils now treats these entries
(or remarks in DocXml) as 'optional', so that any existing entries are not considered 'illegal'
and removed.
|
January 2012
7.48 |
- Live typing aids: When pressing Return/Enter in a comment block, AtominerUtils will
extend the comment onto the new line. The behaviour of this feature has been improved - Previously
a comment on only a single line was not extended (for convenience) but a comment spanning
several lines would be. Now, even single-line comments are automatically extended, locking you
into a 'comment editing mode' where AtomineerUtils assists easy commenting. To exit this mode is easy,
just press Return twice in a row - the first press will extend the comment onto the new line, but the
second will remove the comment header.
- Live typing aids: If you press delete (to delete forwards) at the end of a comment line, and the
following line is also in the comment block, the delete wil consume the newline all indentation
from the second line, and the comment prefix, so that the text of the comment body is concatenated
cleanly.
- Live typing aids: A few small improvements to the creation of comments when typing /// or '''.
- A lot of work on updates and additions to the commenting rules (a 5% increase overall), improving the
quality of the generated documentation for some existing cases, and adding support for a large number
of new cases.
- 'Align code into columns' now handles strings in a more intuitive manner.
- Significant improvements made to the installer, making it much easier to install/uninstall AtomineerUtils
to a custom location. It now only installs itself for versions of Visual Studio that are currently installed
on the PC (i.e. if you install a new version you will now need to re-run the AtomineerUtils installer).
- Improved handling of templated structs in C++.
|
December 2011
7.47 |
- A new preference has been added, 'Use simple format for single line entries'. Any doc comment
that occupies only one line (e.g. just a short summary/brief description) will now be output
without separators or enforcement of blank lines. This is primarily intended for use with
member variables, but if you set up templates for Properties, Enums etc to produce only one-line
comments, they too can use this briefer format. This preference is enabled by default (for
backwards compatibility) but can be disabled if you prefer to use full block formats for
every comment. (Note: This option is not applicable if multi-line comment formats are in use)
- Member (variable, field) comments are now supported much better: They can now be updated (to word-wrap
their description text), and will use the block format determined by the single-line preference
described above. In addition, the Templates now contain a '<Members>' element that allows
full control of the entries that should be included in Member comment blocks.
- A new preference allows you to set the text used to refer to 'this object' in generated documentation.
The options are to use 'object', 'instance', or the name of the containing class. Thus, you can now
generate documentation like 'Initialises this object' or 'Initialises this VehicleCollection'. The
default setting (for backwards compatibility) is 'object'.
- Align into columns now respects the Visual Studio tab/space preference.
- Improved handling for unnamed parameters.
- Fixed a small issue that could cause misidentification of operator !=
- Added handling for comma-separated variable declaration lists. Instead of becoming confused, AtomineerUtils
now simply comments the first variable in the list.
- Fixed a refactoring bug that sometimes caused parsing problems with 'internal' code elements
- Some small speed-ups have been made in the formatting engine
- Many small improvements to the auto-documentation rules
|
November 2011
7.46 |
- C#: 'gets or sets' descriptions for properties are now generated correctly if you have set
AtomineerUtils to not comment members of particular access levels, and one of the accessors is set
to a lower access than the property itself (e.g. If you've configured AtomineerUtils so that
'private' members won't be documented, a property 'public Prop { get; private set;}' will now be
commented as 'gets' rather than 'gets or sets', as the set accessor is configured to be invisible for
documentation purposes.
- Properties and Events that override base class members or implement interfaces can now be
documented with <see> entries.
- Improved parsing of default/optional parameters using nested bracketed expressions.
- XML entity conversions (e.g. '<' becomes '<') are now applied to generic typenames in
generated documentation text (as well as being converted when updating existing documentation).
- Some improvements to the Align Code into Columns command.
- Fixed a smal glitch that recently crept into the Implement Method command when used on parameters
with default values.
|
October 2011
7.45 |
- Added a new command: 'Align code into columns'. This uses a smart algorithm to align text
patterns into a column across a block of similar lines. It can be used to align code into columns
before/after assignments, commas, arithmetic/logical/bitwise/comparison operators, brackets, strings,
numbers, variables and keywords, which serves in some cases to clarify code and make it easier to
read and maintain. It not only aligns exact matches, but also 'similar' matches such as mathematical
operators, and is able to span non matching lines (e.g. blank lines) so that it can be used to tidy
up large tables of Text, CSV or XML data as well as small blocks of code.
See the user guide for full details.
- Improved handling of single-line comments
- Fixed a spurious space displayed in the Options comment preview with word-wrap disabled.
- Fixed a spurious space on Class and Interface summaries when all whitespace was being suppressed.
- Corrected Property processing, which was generating an incorrect default access level for undecorated
properties, suppressing documentaion incorrectly when limited to some access levels.
- Improvements and clarifications made to the User Manual.
|
September 2011
7.44 |
- Improvements in handling of prefixes on names embedded within C# event handlers.
- Improvements in generated exception documentation text.
- Added support for C++ exception specifiers on methods.
- Checked compatibility with and added support where necessary for C++11 features: constexpr,
=default, =delete, auto, override, final, explicit, trailing return type, constructor delegation,
enum class, enum struct, using (as typedef).
- Improved handling of C++/CLI constructs and modifiers.
- Attempts to document 'using' statements (apart from C++ aliases) are now ignored.
- Fixed a case where complex casting operators were misidentified and documented incorrectly
- Added a template block for unions to the rules.
- A lot of new rules and abbreviation expansions added.
- Added some extra exception handling code to 'Open Source Or Header' after discovering some
undocumented exceptions that can be thrown by the Visual Studio APIs.
|
August 2011
7.43 |
- Improved support for prefix removal. A new <Prefixes> section in the rules allows
substitutions to be made (just like WordExpansions) but only for the first word of a name.
The default rules use this feature to now auto-remove common prefixes (lpsz, afx, etc).
A new variable is available, %nameNP% (for 'no prefix') which provides the symbol name with
the prefix removed, to allow clean documentation to be generated from prefixed names.
- Further work on the optional see-also processing has improved the quality of the see-also reference
generation overall. In addition, 'see also' entries are now generated for interfaces, implemented
interface methods and properties.
- Quite a lot of behind the scenes work on improving the website, and a new
look for our web pages and customer notification emails.
- Made some improvements to the handling of override and overload documentation handling
- Improvements to the rules
- 'Open Source or Header' and 'Implement Method' now support .hxx as well as .hpp and .h files.
- Fixed an irritating issue in the last Trial version that caused it (when expired) to report trial expiry
every time VS was launched instead of only when an attempt was made to use AtomineerUtils commands.
|
July 2011
7.42 |
- Documenting only those members with specified access levels has now been extended to include
member variables.
- The default author and date entries can now be suppressed easily from within the AtomineerUtils
Options - previously this required customising the templates XML.
- Fixed a small glitch in 'Open Source File' in C projects
- The word abbreviations dictionary can now be used to delete unwanted words (such as library
method prefixes). Just add an abbreviation entry that returns desc="-" to delete any
matching word.
- Some small improvements to the pluralisation algorithm.
- Live typing aids were interfering with intellisense auto-completion (when pressing return within XML
doc comments - pressing TAB or ctrl+space to autocomplete was not affected). The live aids system now
allows the default VS or Resharper auto-completion behaviour to operate as normal.
- Live typing aids now auto-continue numbered and lettered lists starting with numbers in forms like
1 2 3 - 1. 2. 3. - 1) 2) 3) - a: b: c: - a) b) c) etc.
- Resolved an issue where Outline Doc Comments did no always work properly with comments if they had no
top/bottom separator lines.
- Improved handling of generic class declarations
- Fixed the 'see' entries generated (if configured) for overloads. (Note: In this version implemented
interface methods and properties are not commented with 'see' entries. This feature will be added soon).
|
June 2011
7.41 |
- Extended the support for StyleCop compatibility. On the General tab of the Options there is now
a checkbox that enables StyleCop compatibility. This sets the variable 'stylecop' to true, causing
StyleCop-compatible comments (file headers, constructors, finalisers, etc) to be generated instead
of the AtomineerUtils defaults.
- AtomineerUtils can now document derived classes and override methods/properties by adding
<see> or <seealso> entries.
- To add <seealso> entries, go to the Advanced Customisation tab of the preferences, and
tick the options for derived classes and/or override method/properties.
- Alternatively, to add a <see> reference within the <summary> entry itself,
edit the UserVariables and set <Variable name="docBasesWithSee" value="true"/> and/or
<Variable name="docBasesWithSee" value="true"/>.
In addition, there are two new checkboxes in the Advanced Customisation tab that can be ticked
to suppress the other documentation generated for overrides, so that they are simply documented
as references to their base class/method/property.
(Note that these options rely on the Visual Studio Intellisense (Code Model) information, the
availability of which varies with language and VS version).
- Added a new preference to the Advanced Customisation tab to optionally disable the
automatic duplication of existing documentation (from base classes, interfaces, overloads
and other parameters in a class). If disabled, the documentation text will be auto-generated
rather than being copied from existing 'best match' documentation.
- Added a new variable (in the User Variables in the Advanced Customisation tab), 'docOverridesWithSee'.
If set to true, this changes the documentation generated for overrides in C# and VB to use a
<see cref='BaseClass.Method'> reference instead of a textual description.
- UserVariables can now be set in the Prefs.xml. As long as the UserVariables in rules.xml are
conditional (using ifSet="false") they can be overridden in the Prefs.
- Added new variables for use in rules: %time% and (for C#/V/Java methods) %access%.
- Improved the word wrapping algorithm, which will no longer split XML elements or URLs across
lines.
- Added support for optional parameters, which are now documented with the text '(optional)'.
- C# Implement Property now handles virtual/override auto properties correctly.
- Fixed a couple of subtle bugs in the new (7.36) text formatter that caused paramrefs and root-level
seealso elements to be removed if they occurred at the very start of a line.
- Improved parsing of templated class constructors when the declaration has been split across multiple lines.
- Fixed a rare infinite loop that could occur when generating a class comment for a file containing fewer than
4 lines of code.
- Made some minor improvements to the installer.
- A lot of work also went into improving the website this month.
|
May 2011
7.40 |
- Improved 'Document all in this Scope' to handle C/C++ better - The most significant improvement is that
header files are now supported and class declarations can be documented.
- When adding a file header, any existing file header comment is now replaced by the new header comment,
making it much easier to update file headers to a new style. (Note that file headers are still treated as
plain text (i.e. not parsed and reformatted) - they are simply replaced)
- Improved formatting of [in], [out] and [in,out] param entries.
- Fixed a sneaky bug (it only occurred in the formatting of Javadoc comments in Auto-brief mode with
long top separators), where a portion of the separator text could be repeated in the start of the
brief description.
|
April 2011
7.39 |
- Fixed a tiny bug that caused Properties to be misidentified and documented incorrectly.
|
7.38 |
- Improved 'Document all in this Scope Block': It now supports Visual Basic, and documents
more code elements in C# (the most significant additional support being for members in interfaces).
- (In C#, Visual Basic & Java code) the access level of a code element (public, protected private,
internal etc) can now be used to control whether documentation comments are required. By limiting
Doc Comments in this way, it is now possible to use 'Doc all in scope' to automate documentation
conversion/generation across an entire class without any private members being documented. (The new
preference setting can be found on the General tab of the AtomineerUtils Options)
- Improved handling of [in], [out] and [in,out] param entry prefixes. [in] and [out] will no longer be
removed if the user explicitly set them.
- AtomineerUtils can now be used in
Atmel AVR Studio 5.0, a custom
IDE based on Visual Studio 2010.
- Fixed an issue that interfered with method classification, resulting in event handlers sometimes not being
correctly documented.
|
March 2011
7.37 |
- The search paths used for AtomineerUtils Rules can now include %solutionPath%, %solutionName%,
%projectPath% or %projectName% variables. These are expanded to the full path of the
active solution/project folder or their leafname as appropriate. This allows every Visual Studio
project to optionally contain AtomineerUtils rules/prefs xml files that are project-specific,
and as you comment your code the appropriate settings will be used for the active document.
This makes it much easier to use different comment formats or rules for different languages (for
example, a common use of this is to use Doxygen commenting for C++ and DocXml for C# code).
Please see here for full details.
- Added support for executing user-defined macros to preprocess the active document before AtomineerUtils
tries to parse the code. For example, when AtomineerUtils has found an existing comment format in the
'alternate' style, and is ready to convert it to the new AtomineerUtils format, it can call a user macro
with the coment selected so that user-defined transformations can be applied to convert the comment
into an AtomineerUtils-compatible (XmlDoc or Doxygen) form. For more information, see
the preprocessing manual page.
- When parsing method declarations, AtomineerUtils can now apply optional regular-expression replacements
to the text before it is parsed. This does not change the code in the document being processed, but
just the view AtomineerUtils has of it. This allows users to convert in-house types, typedefs and
macros into a form that AtomineerUtils can handle better. For more information, see
the preprocessing manual page.
- Added the ability to wrap commented code elements in regions. Comment styles can now be set up with
'#region' or '#pragma region' top separators but no matching #endregion in the bottom separator. In this
special case, AtomineerUtils will automatically add the #endregion or #pragma endregion (as appropriate)
after the scope of the code element, thus wrapping the entire element in its own region. Parsing of
existing comments with #region/#endregion separators has also been slightly improved.
- Added support for C++ TR1 Move Constructors and Move Assignment Operators
- Added the Rules Guide to the distribution zip file to make this information
easier to find. Clicking the 'user guide' button in the preferences dialog now also shows the rules guide
rather than the general user manual page if the Advanced Customisation tab is active.
- A small improvement to the insert-blanks-before logic.
- Fixed a small issue that caused Doxygen tparams to be emitted with the wrong tag ('typeparam')
- Improved the efficiency of the abbreviation expansion rules
|
February 2011
7.36 |
- Reworked the DocComment entry formatting approach. This simplifies the options and in conjunction with
the Quick-setup Wiozard, makes it much easier to configure AtomineerUtils to achieve the style you
want, while at the same time making it possible to format entries in ways that were not previously
possible. The quick-setup wizard and preferences have been significantly updated to support the new
options and provide better previews.
- The preferences now have a lot of help built in as tool-tips. Hover over items to get a lot
more information on what the options control and how to get the best out of them.
- 'Document All In Scope' now understands what you want if you place the cursor on the open brace
of a scope rather than the declaration for the scope.
- File and File-footer comments can now be targetted to specific file extensions, to allow different
headers to be added to (for example) .cpp and .h files, and adding a file header can optionally
add a file footer at the same time. The default templates now contain an example that can be
used to add a #ifndef ... #endif 'include once' mechanism to header files using these features.
- Fixed a small glitch in the uninstaller when removing files from a custom installation folder,
which could unintentionally leave some of the folder structure behind.
|
January 2011
7.35 |
- Added the ability to insert file footer comments. Just place the cursor in whitespace at the end of the
document and execute 'Add Doc Comment' to insert a footer. The format of this footer is set in the
<filefooter> Rules Template, and supports all the features of the <file> template.
- File headers and footers as well as basic 'catch all' doc comments can now be inserted into
files of any type. The comment block formats used are configured in prefs.xml (a number of common
programming file formats are pre-configured - variants of html, xml, resources, sql, lua, python,
perl, ruby, powershell and batch files - but you can add any more you require). For file types
that are not explicitly mentioned in this list, the default AtomineerUtils C-style comment format
will be used (which covers a great number of additional code formats). Note that <file>
comments ideally need to be defined using an xml template rather than free text template to ensure
that a legal comment is output in all such cases. The auto-generated documentation for these comments
can be customised by using a <CatchAll> block in your custom rules xml and a <catchall>
custom template used to control the layout of the general comments inserted in this way. Examples
of both are now included in the default Rules.xml file.
- Auto-punctuation can now be disabled on doxygen brief entries.
- Added '_tagName' property to the templates, allowing entries such as 'exception' to be generated
with a custom name such as 'throws'.
- Many small improvements to the rules and abbreviations.
|
December 2010
7.34 |
- Updated the installer to provide an Uninstall option. (This approach was taken rather than registering with
the 'Add/Remove Programs' control panel to avoid the need for UAC elevation on Vista/Win7, making the
install/uninstall process easier and faster).
- Added the Quick-Setup Wizard to help new users chose a basic commenting format and style quickly
and easily.
- Added support for generic typeparams in class and interface documentation.
- Improved handling of scopes (methods) with unmatched braces. In large files, an 'unterminated method'
could lead AtomineerUtils to process a lot of text, which would succeed, but could take a long time.
This was only a problem with broken code in massive source files, so a very rare occurrence.
|
November 2010
7.33 |
- Added a minimum comment column preference for end-of-line comments on single-line code elements.
This ensures that eol comments are always placed at least at that column, which can help to
line a block of these comments into a single column to the right of a ragged list of items.
- Made some improvements to the comment-typing/indentation helper.
- Extended support for the _separators='false' attribute to all templates, to allow seprators to
now be suppressed individually for any comment-block type if you so wish.
- The code element name variables (%name%, %sName%, %sNameRaw%) can now be used within template blocks.
- Improved the Options dialog, and added explicit support for JavaDoc (instead of it being treated as
a subset of Doxygen format).
- Updated template handling of <_/> elements to allow newlines to be added at the start or end of a
template body (previously leading/trailing blanks were formatted away)
- Fixed a small bug that caused a failure when documenting a parameterless method called Append().
- Fixed a small bug that stopped the 'no bottom line separator' functioning correctly.
|
October 2010
7.32 |
- Renamed parameters and typeparams are now detected and updated automatically where possible. (Previously
these were marked as 'deleted' entries and a new entry created, as it is impossible to always determine
the difference between simple refactorings and certain patterns of adding/deleting parameters. However,
simple refactorings, additions and removals are the most common forms of update, so these are now supported
by the new behaviour to make AtomineerUtils more convenient in typical situations). Renaming is detected
primarily based on the location of a parameter relative to others - therefore if you wish to replace a
parameter with a new one, the best approach is to delete it, update the documetation, and add the new
parameter as a separate 'step'. If AtomineerUtils is unable to make the correct choice, you could end up
with old documentation applied to a new parameter, so (as always) check that the results are correct and
complete after updating a comment.
- Improved commenting on Constructors. Where avaialble, documentation is duplicated from method overrides,
which in most cases works very well. However, in the case of constructors this could cause a description
like 'Default constructor' to be duplicated onto a normal or copy constructor. AtomineerUtils now detects
these "short" constructor descriptions and does not duplicate them, allowing the regular auto-doc rules
to supply the correct description instead.
- 'Create C# or C++/CLI Property' now retains internal/protected access permissions from auto-properties
when converting to a property with backing field.
- Several improvements to 'Add C++ accessors' - it now handles namespaces better, and some glitches with
const and pointer member variables were ironed out.
|
7.31 |
- When updating documentation, AtomineerUtils can now optionally convert <, > and & characters into
the XML/HTML entities < > and & so that XML/HTML remains valid when code snippets
containing less than, greater than, AND operations, generic types or Visual Basic attributes are used. This
conversion is enabled by default, but can be disabled in the general DocComment Options.
- Eliminated a small but unnecessary delay when processing header declarations.
- Fixed capitalisation of a/an/the when corrected in the first word of a description
- Added rules for handling C#/VB enumerators, C++/CLI finalisers, and quite a few small improvements to
the rules
|
September 2010
7.30 |
- Added support for Java source code. Please let me know if you find any Java constructs that
AtomineerUtils has problems documenting properly.
- Added a Windows 7 compatibility manifest to the installer to stop Win7 occasionally asking if
AtomineerUtils installed correctly.
- Options: Improved handling of the Advanced Customisation preferences. If you hold down Shift
while clicking a custom-rules button, it now opens the folder containing that custom xml
file, making it much easier to locate the files.
- Options: under some circumstances, custom prefs would fail to overwrite the default preferences
when opening the Options window, so it could 'revert' the options to old settings. This has been fixed.
- Fixed an indentation glitch that occured with some JavaDoc auto-brief style comments.
- Improved parsing of nested XML elements. The parser included code to improve resilience when
presented with poorly formed XML, but this produced incorrect results in the case of <paramrefs>
nested within <params>. The code has been rewritten to eliminate this flaw.
- Made some small improvements to the live editing handling within comment blocks.
- 'Document all in Scope' now shows a progress bar in the Visual Studio status line. In VS2005 and
VS2008 the progress is obvious as you can see the comments as they are generated, but in VS2010
the IDE doesn't display anything while it is processing, so appears to 'lock up' for large
code files. The progress bar makes it much easier to see what is going on. (Also remember that you can
press Esc to abort processing at any time)
- A small improvement to property get/set parsing
- More rules improvements.
|
August 2010
7.24 |
- AtomineerUtils can now optionally track changes within comments and doc comments, and offers the
following enhancements to the basic Visual Studio support:
- Type /// or ''' above a code element, and AtomineerUtils will automatically add documentation
for it. Although Visual Studio does this (for VB and C#), it only creates an empty skeleton
comment, while AtomineerUtils fills everything in for you as usual. In addition, the generated
comment block will be in the configured AtomineerUtils style. This feature also applies to all
supported languages - i.e. it also works for C++ and C.
- When your cursor is inside a block comment made of single line comments (// in C# and C++ or
' in Visual Basic), or inside a doc comment block (whatever you have configured as the AtomineerUtils
style, for example /// or ''') and you press Enter to insert a new line, AtomineerUtils will
create the blank line for you, automatically adding your configured line header and then
indenting the cursor within the comment so that it lines up directly under the comment text
on the preceeding line. In addition, if the current line of your comment seems to start with
a bullet-point (-, *, +), AtomineerUtils will duplicate it to automatically continue the bulleted
list. To use the default Visual Studio behaviour when pressing Enter, hold down Shift (add a newline)
or Ctrl (add a newline before the current line) at the same time.
See this page for full documentation on these new features.
Note that there are new preference options to disable these extensions if they are not desired.
- It appears that the code-model information for C functions (which worked well in VS2005, VS2008)
sometimes returns incorrect information within VS2010. This tricked AtomineerUtils into using the wrong
template for the resulting documentation. AtomineerUtils now detects and corrects this issue to produce the
correct documentation block.
- Added support for C/C++ unions.
- Fixed a small glitch in generic-method name handling that caused incorrect commenting to be generated for
operators like < and <=.
- Fixed a small problem that could sometimes cause word expansions to be repeated. This only showed up with
the few 'recursive' expansions such as 'y' => 'y coordinate'
- Entry lines that end with the text <br/> (note: with no spaces in the element) are no longer word-wrapped.
|
7.23 |
- A lot of work on the website; primarily a lot of new documentation on
customising the rules.
- Improved parsing of generic function names to handle nested generics.
- Fixed a glitch in the new conversion code that sometimes interfered with the
removal of deleted parameters.
- Hid the menu items for SuppressUI/AllowUI in Visaul Studio 2010 RTM, which is ignoring the
command's options.
|
July 2010
7.22 |
- Added more support for conversions between comment formats. The new <Conversions> section
of the rules allows simple transforms to be applied to entry tags as they are read so that
they may be read from one format (e.g Doxygen) and converted to a new format (e.g. DocXML).
Currently the support is mainly for conversions to DocXML, although the system works
bidirectionally, and specific support for conversion to Doxygen could be added should anyone
request it.
- Fixed a small bug in the new existing-comment parsing algorithm that could be confused by a multiline
comment occurring immediately inside a method, causing the wrong line of code to be documented.
- 'Doc all in Scope' now reports read-only files once, rather than once per code element.
- Significantly improved parsing of operators, and added support for the less-used operators.
- Improved handling of indentation in some cases when using base class documentation.
- Improved parsing of attributes containing comments.
- Doxygen comment auto-brief entries may now be preceeded by an /ingroup entry.
- A few improvements to the documentation Rules.
|
7.21 |
- Added an 'Add Doc Comment' command at the top of the context menu. This can be disabled in the AtomineerUtils
options if you don't want it.
- Doxygen/Javadoc auto-brief mode now picks up the brief text properly if the brief is on the same line as the /**
- Fixed handling of uppercased acronyms in property names (e.g. URL), which were being output as 'Gets uRL...'.
- Improved the technique used by Declare/Implement C++ method for handling nested namespace/class names.
- Fixed an errant chunk of C++ scoping code that was applied to VB parsing, causing occasional addition of the
class name into generated summary text.
- Copy constructors are now detected and documented as such.
- In DocXml, Properties and Indexers now have an optional <remarks> section, allowing you to add remarks
without AtomineerUtils stripping them away as 'illegal' entries.
- Fixed a Doxygen comment updating glitch that occurred if the <returns> element was forced into comments
for void methods by using _blankentry.
- Made some minor code tweaks and rules additions to improve the commenting operation in a few special cases.
|
June 2010
7.20 |
Apologies for the unusually long gap between releases. I've been hard at work with some major
under-the-bonnet improvements and a big change to the website, and there have been a number of interruptions
by life-with-kids in the last month. I expect to now resume the normal rate of 1-2 releases per month.
- Re-wrote the existing-comment detection/parsing algorithm. The previous algorithm evolved from handling a fixed
format to handling highly customisable formats for mulitple languages, and had recently reached its
scalability limits. I've redesigned the algorithm to encompasses all the features required in a
leaner, faster, and much more robust manner. Improvements: it is now possible to use exactly the same text
for the separator lines and line headers; it handles non-doc comments immediately prior to a code element much
better; it copes robustly with comments that contain code snippets; it can now more reliably parse and convert
user-defined comment block formats as well as /// and /** ... */ comment styles to the configured style;
the DocComment command now runs approximately 30% faster on typical cases.
- 'Document all in this scope' can now be interrupted by pressing escape, and runs about 30% faster.
- When generating documentation for overloads and overrides, the formatting would sometimes be
incorrect for the first line. This issue has now been corrected so that derived documentation formats
much more cleanly.
- AtomineerUtils now detects the newline format of documents, so it works properly on Macintosh or
UNIX source files.
- Fixed a small oversight in some method processing code that could very occasionally lead to a delay when
generating documentation comments in large code files.
- Fixed a parsing error that caused new comments to be inserted in incorrect locations if a non-documentation
comment was discovered above a code element, or if no separator lines were used and no blank lines were
placed between a doc-comment and the code element.
- Fixed a problem with the output from Implement/Declare C++ method when there was whitespace between the
function name and open bracket.
- Added new global variables: %projectpathname% and %projectfolder%. If you have a file in a sub-folder of your
project, these return the project-relative file/folder pathname. The default file comment now uses
%projectpathname% by default instead of just the folder and leafname.
- AddDocComment now adds the class scope to the doxygen prototype for methods in header files.
- AddDocComment now uses the 'space after #region' preference to control the space inserted after C++
public/private/protected statements.
- When writing preferences out to custom files, it now exports 'user-guide' comments into each
custom file so that the docs you need to edit the rules are readily available in every prefs section
that you customise.
- Improved handling of explicit/implicit constructors.
- Improved handling of enum entries.
- Added two new commands, SuppressUI and AllowUI. These cannot be executed from the AtomineerUtils menu, but
may be invoked from a macro with DTE.ExecuteCommand("Atomineer.Utils.Commands.SuppressUI"). SuppressUI
suppresses (almost) all MessageBox reports from AtomineerUtils so that its commands can be safely executed
within a macro. AllowUI simply reverts to the regular behaviour.
- Fixed a bug in the preferences that saved the 'single line comment suffix' incorrectly when (none) was
chosen, causing this text to be added to the comments.
- A large update to the website, causing the gap between releases to be somewhat longer than usual. I hope
to return to a more regular release schedule soon.
|
April 2010
7.12 |
- Added new preferences that allow an old comment format to be converted into your new AtomineerUtils style.
The preference options describe the top/bottom block separator lines and the prefix used on the remaining
lines of the comment. The content within the block must use the Doxygen or DocXml syntax. If AtomineerUtils
is able to parse the old format it will then regenerate the comment in your primary format. It is able to
convert between Doxygen and DocXml formats (the core entry tags that AtomineerUtils knows will be converted
properly (e.g. summary/brief, returns/return, seealso/sa, etc). Any additional tags must be entered into
your template so that AtomineerUtils knows what to look for. If you use this feature and find situations
that AtomineerUtils fails to convert well, please send me some examples and I'll see if I can improve
the conversion.
- 'Document All In This Scope' now allows you to document all elements in the global scope by executing the
command with the cursor in the first line of the file. (Mainly useful for C code, but sometimes handy in
other languages too)
- Added preferences for single-line comments allowing the user to set the prefix (and optional suffix) used for
the comments so that any of the doxygen single-line comment styles can now be generated -
e.g ///! or //!< or /*!< ... */ etc
- Added an additional preference allowing the number of blank lines enforced above a DocComment to be
independently configured for comments that follow an #if/#else/#region directive.
- Fixed a problem with empty embedded XML elements in XmlDoc entries.
- <file> templates may now use <, > and " encoding to embed literal characters into
the file comment. This allows a StyleCop-compatible form of file comment (which is a hybrid of Xml in a
normal (non-doc-comment) comment block) to be used. An example of this is now in the DocXmlTemplates
section of the Rules.xml file.
- Fixed a failure in 'Open Header/Source file' if the target file was blank.
- Added support for doxygen 'throw', 'throws', 'exceptions' aliases for 'exception'
|
March 2010
7.11 |
- Improved the algorithms for extracting overload, override and implemented-interface documentation from the
intellisense system. The new system provides a higher quality best-match result, resulting in
even better final documentation. Under some circumstances an error from the Intellisense system could
cause AtomineerUtils to revert to the default auto-doc text - this has now been fixed.
- AtomineerUtils Pro now has a much improved mechanism for specifying its rules. The default rules
remain in Rules.xml, the format of which is unchanged. However, user customisations and comment format
preferences can now be saved into separate files (one for each major element in Rules.xml) which
are executed in preference to the defaults in Rules.xml. This allows users to customise most aspects
of AtomineerUtils without having to merge their changes every time they update to a newer version.
- In addition, a new preference allows the custom rules files to be fetched from a 'search path', so
that they can be stored in any user defined location - This allows the rules customisations and
comment format preferences to be held under Source Control or in a network folder for easy deployment
throughout an organisation and/or safe backup.
- Corrected the handling of explicitly implemented interface method names.
- Updated and improved the User Guide.
|
7.10 |
- Added support for Visual Basic in the 'Add DocComment' and 'Word wrap comment' commands.
The parser is primarily based on the VB 9.0 spec, so please let me know if you find any legacy VB code that
it doesn't comment well. Note that only the above commands currently support VB - support will be
extended to other commands in future.
- Added 'isOptional' variable for use in parameter rules (Currently only supported for Visual Basic).
- Fixed a bug in AUTOBRIEF mode which truncated the brief text if a block format with no
line prefixes (only top/bottom separators) was configured.
- The block format options now work for Doxygen comments. The first line of an entry is always
added directly after the doxygen command, but the indent level of any subsequent lines can now be
set with this preference to be the left edge of the block, one tab of indent from the left of the
block, or to line up the left side of the block of text with the start of the first line
(the old style).
- 'Implement C++ Accessors' now has an additional option controlling the naming of the Set method's
parameter. As with the member and method name templates, use 'varName' or 'VarName' to use the
name of the variable (and control the case of the leading character), you can add any prefix/suffix
you require, or alternatively you may use a fixed name (e.g. 'value').
- Fixed a case-insensitivity bug that caused the capitalisation for some 'Implement Property/Accessor'
options to be lost (e.g. 'varName' would change to 'VarName') when re-opening the Options window.
- Fixed handling of namespaced exception names in C++
- Fixed handling of namespaced parameter names and return types in C#. Only the leafname is now passed
into the rules, so (e.g.) 'System.EventArgs' is commented using the rules for 'EventArgs'.
- Improved exception rules - Now handles both 'SomeNameException' and 'ESomeName' naming styles.
- Fixed a small bug in the documentation generated for casting operators.
- Improved layout of controls in the preferences slightly.
|
January 2010
7.03 |
- Word wrap can now be suppressed by ending a line with exactly two spaces. This suffix causes a newline to be
retained at that location - very useful for achieving correct formatting of numbered lists.
- Fixed a bug in code...endcode processing (only in Doxygen comments using the \code command form, word wrap was not suppressed).
- 'Add access methods' has been split into two commands - 'Create C++ accessors' and 'Create C# or C++/CLI property'.
These commands both do the same thing except when applied to C++, one produces a pair of get/set C++ methods and
the other produces a C++/CLI property.
- For the new 'Create C++ accessors' command, you can now specify a pair of naming templates in the options. These
contain the text 'VarName' as a placeholder for the value name, and may include any prefix and/or suffix
you wish to build the get/set methods in the form you desire. Use 'varName' rather than 'VarName' to control
the capitalisation. This allows you to have method names such as 'GetSpeed,SetSpeed', 'Speed,SetSpeed', 'set_speed,get_speed' etc.
- Add Doc Comment now works for C++/CLI properties.
- The 'Create C++ accessors' and 'Create C# or C++/CLI property' member variable style preference now gives you more control.
It must contain the text 'VarName', but can have any prefix and/or suffix (e.g. 'm_VarName_'). These custom
prefixes/suffixes are stripped off variables to generate the accessor name correctly. In C# it is also used to
generate the name of the backing field. Use 'varName' or 'VarName' to control the capitalisation. In addition,
this command still strips off common prefixes (such as _ or m_), and now handles underscores used as suffixes.
- Fixed a bug in class/struct handling for C++ namespaces.
- Insertion positions are now correctly located when commenting in C++ header files where an access specifier
(e.g. public:) immediately preceeds the code element being documented.
|
7.02 |
- Added Document all in this scope command. This scans a namespace/class/struct/interface/enum
scope, applying the 'Add Doc Comment' command to all the primary child code elements (class, method,
property, enum etc) within it in a single pass. This is invaluable for:
- Quickly and easily building the documentation structure for all the entries in an enum definition,
- Converting existing comments (e.g. in the Visual Studio default XmlDoc /// format) into
the configured AtomineerUtils format,
- Automating updates to documentation after changing the AtomineerUtils block format or preferences,
- For automating an initial documentation pass - but it is most important in this case to
then read and manually update the resulting documentation to be sure that it is accurate and complete.
AtomineerUtils gives a great starting point for documentation, but it doesn't (can't) add all
the most critical bits of information about special cases etc that make documentation truly
effective and informative.
- Fixed doxygen commenting of template class, file and namespace comments which were affected by
a recent parsing upgrade.
- Improved handling of fatal errors to ensure that the VS undo system is not affected by an AtomineerUtils failure.
- Create Property no longer creates an auto-property for a variable with a default value, but
converts it directly to a property with a backing field so that the default is retained.
|
December 2009
7.01 |
- Now parses and provides auto-documentation for member variable declarations (sharing most of the
rules with Parameters and Typedefs via the <Execute> command).
- Now parses and provides auto-documentation for structs (sharing the rules for classes).
- Now supports <pre>, <code>, @code...@endcode, and @verbatim...@endverbatim tags.
These blocks are now left untouched (word wrap is suppressed within them). Note that the start/end tags
must be the first nonblank text in the line.
- Improved handling of optional entries - you can now add entries like <customtag _optional="true">
to templates to specify that this entry is legal but should not be automatically added by AtomineerUtils.
This improves the handling for these entries and allows you to specify precisely where such elements will be
positioned in your doc comments. Templates now include optional seealso, sa, and example entries.
- Improved parsing of attributes - special characters and extra indentation within attribute parameters,
and multi-line attribute declarations, could cause method documentation to be incorrectly generated or
positioned.
- No longer attempts to add doc comments if executed on common undocumentable statements (for loops etc)
or preprocessor directives.
- If you enter a specific username in the options, it is now used verbatim (if you used initials like JCW
they would be 'tidied' to Jcw. It now uses JCW as it should).
- Removed [in,out] specifier for const pointers.
- Removed a legacy line of code that generated 'Thrown when .' for undocumented exceptions.
|
7.00 |
- Major new release. AtomineerUtils was split into two products, a free trial (AtomineerUtils) and
a charged (but very inexpensive) version (AtomineerUtils Pro).
|
|
- Ability to fully customise the comment style (separator & line prefix style, and control of blank lines between entries)
- Enhanced auto-doc engine. AtomineerUtils Pro will derive new documentation from related code elements,
re-using appropriate portions of existing documentation to build excellent documentation for the following
code elements:
- Implemented interface members
- Overridden virtual methods
- Overloaded methods
- Parameters. AtomineerUtils Pro will duplicate documentation for parameters of the same name/type
wherever they are repeated in the class, keeping the documentation consistent throughout.
- Now supports Doxygen JAVADOC_AUTOBRIEF style, where the 'brief' entry does not have a tag introducing it.
Note that this disables inclusion of the prototype tag, and will only work if the brief entry is the
first entry within the comment.
|
November 2009
6.12 |
- Added the <Execute> command for Rules.xml. This allows you to 'include' a block of rules from
elsewhere in the rules.xml at the position of the Execute command. The included block can be a standard
rules block (e.g. 'Parameters' or 'Classes') or it can be a user-defined block (e.g. 'JasonsExtras')
- Added support for comments on simple typedefs. This includes a new 'Typedefs' section in Rules.xml
to control the documentation output. Note that this currently only applies to type aliases (not function
aliases)
- Added support for C++/CLI System::Void
- Added support for C++ templates
- Fixed a recent breakage in enum entry parsing that caused entries with an assignment to be mishandled.
- Fixed C# Property commenting in interfaces, which was not picking up the get/set declarations correctly.
- Fixed parsing of operators containing whitespace in the name ('operator ==' rather than 'operator==')
- Fixed a bug in handling of blank custom documentation entries with auto-punctuation disabled, which
caused the custom entry to be skipped in the output documentation.
- Fixed a potential failure in handling of blank entries.
- Fixed Word Wrap Comment command to wrap at the configured column - it was wrapping 2 chars too late.
- Added two Implement/Declare method preferences (in the Misc section):
- Switch to the newly implemented code after implementing: If enabled, the command will
leave you in the file where the new code has been added (to allow you to immediately edit the result).
If disabled, you will remain in the file where the command was executed (to allow many methods to
be conveniently implemented/declared in a row)
- When implementing a method, you can now choose not to automatically add a DocComment to it.
- Added a few improvements to the rules.xml.
- Improved the installer icon.
|
October 2009
6.11 |
- Added %name% and %type% variables for use in top-separator lines. This makes it possible to add a
header with information like "Method: WriteAllFiles" embedded in it. Combined
with '\n' to generate a multiline separator, this allows a lot more flexiblity of block style.
Note that multiline separators usually needs to be in a /** ... */ format block (with blank line headers)
in order to be parsed and updated correctly by AtomineerUtils. An example 3-line header format
is now available in the AtomineerUtils Options drop-down list.
- Exception documentation parser now handles managed C++ better.
- Added support for C++/CLI tracking references (% and ^%)
|
6.10 |
- Create Property/Accessors for C++ now uses an improved indentation/column alignment algorithm.
- Fixed a silly bug in the parsing of C++ constructors that could enter an incomplete prototype into
doxygen comments.
|
September 2009
6.09 |
- Fixed a small bug in parsing constructors with default parameters and static initialisers.
- Create Property/Accessors for C# has been upgraded in VS008 and VS2010 to support auto properties:
- Executing the command on a variable declaration converts it into a C# 3 automatic property.
- Executing the command on an automatic property declaration converts it into an explicit property
implementation and a backing field. (You can execute it twice in succession to get from a variable
to an explicit property as used to happen). The backing field for 'SomeProperty' will be given the
name 'someProperty' by default - a prefix can be added in the preferences to generate fields
with names such as 'mSomeProperty', 'm_SomeProperty', '_SomeProperty', etc.
- In addition, it no longer adds debugger attributes to generated properties in Visual Studio 2008 or
later versions (as the IDE provides much improved debugger stepping controls).
- A small bug was fixed that caused it to fail in some circumstances when executed on a variable
with a static initialiser.
- Combined the two lesser preference tabs into a 'Misc' tab to reduce the number of tab pages.
|
6.08 |
- Added 'General' tab to the Preferences. This allows you to hide sets of menu commands (Outlining,
Clipboard, and C++) that you don't wish to use, to remove 'junk' from the user interface.
- Word Wrap Comment now supports doxygen //! comments.
- Fixed a minor parsing glitch that caused the wrong type of comment to be generated when commenting a
declaration of an operator= in a header file.
- 'Check for Updates' now pings Atomineer.com to determine if your copy of the addin is up to date.
- Added 'Help...' command to launch the AtomineerUtils hopme page in your web browser.
|
6.07 |
- Major bugfix - An obfuscation glitch stopped the block formatting options working properly,
leaving users stuck in 'FramedFlush' mode.
|
August 2009
6.06 |
- Added templates for controlling documentation of interface and abstract-class methods. The new default
templates produce simpler comments (no author/date or exception entries). This is on the basis that
you seldom need to know the author of an interface declaration; this information is usually only important
in the concrete implementations. It also allows you to remove blank lines to make interface definitions
more compact and easier to scan through.
- Now properly handles attempts to edit read only documents (read-only files, documents auto-generated from
metadata, attempts to edit files while the applcation is being debugged, etc).
- Now handles single-line properties regardless of where the cursor is in the line.
- Attempting to add a line comment now does nothing if a line comment is already present on the previous line
|
6.05 |
- Fixed a stupid bug in 6.04 - I left the default for Doxygen comments with prototypes/declarations disabled.
- Doxygen prototype no longer picks up member initialisers from constructors.
|
6.04 |
- Added handling of several more 'simple' types to the C++ 'Add Accessor' command.
- Added %specialType% for methods, allowing the rules to access whether a method is normal, static,
inline, abstract, virtual, or override.
- Quite a few rules improvement (e.g. now documents static constructors, interface files)
- Added an option to suppress or include the declaration/prototype entry in doxygen comments.
- Now supports documentation of macros (#define).
The rules.xml templates contain a new <def> template to control these comments.
- Added support for use of \ for continuation of lines in methods and macros
- Word wrap no longer splits parameter names in doxygen declaration/prototype entries.
- Improved handling of [in,out] to preserve user-edited [in] or [out] tagging. Fixed a small [in,out]
formatting glitch in doxygen.
- The block-format for groups of similar entries now also applies to single entries of types that are
normally in a group (params, exceptions, etc).
- Fixed a bug in Create Accessor for C++ that caused it to insert the accessor in every public/protected/private
block (how the heck did that get broken?!)
- Parser is no longer confused by a < character if it occurs in an operator method
- Cleaned up the options window, breaking the DocComment options into three separate tabs.
This allowed me to make the options cleaner & more descriptive, and make it easier to use with
restricted screen resolutions (600px height).
|
6.03 |
- Added new command for C/C++: Open Source or Header. This simply finds the source/header file that
matches the header/source file you are working in.
- More work on "Implement/Declare C++ method". Now handles extra prototype entries such
as DLLEXPORT. Handles namespaces properly, and now inserts the generated code in the correct scope.
- %ContainingClass% is now available even when intellisense is unavailable.
- Improved the block-formatting options. By default, all contiguous entries with the same tag (a block
of entries) are formatted so that the text for all entries is indented to start at the same column - This makes
param lists more readable. Added a preference to disable this so that every entry is treated standalone -
This is less readable, but minimises the space used.
- When updating a comment, the autodoc entry will now override any existing entry that is essentially blank.
- Several improvements to parsing of class names.
- Fixed a bug in detecting const methods under very rare conditions.
- Fixed a block grouping bug when updating blocks of user-defined elements, that caused blank lines to be
inserted between all the entries in the block.
- Fixed a parsing bug that caused one form of static class declaration to be commented as a property
|
July 2009
6.02 |
- "Implement C++ method from header" has been upgraded, and is now called "Implement/Declare C++ method".
- When used in a header, now locates the paired .cpp file and appends the generated method to it.
- When used in a source file, now locates the paired .h file and inserts the generated declaration into the relevant class.
- Now detects the parent class name correctly (previously relied on the classname and filename matching).
|
6.01 |
- Significantly improved exception (throw) parsing. AtomineerUtils can now detect and handle most throws
including exceptions thrown via variables and rethrown exceptions.
- Added a preference: When padding is enabled (default), each entry can now be started with a tab character
(default) or a space. Using a space reduces the whitespace in comments at the cost of the start column of each
entry not being guaranteed to line up on a tab column.
- Block top/bottom separator lines can now be made up of multiple lines of text by including \n within
the text to represent newlines. Note that the block matching algorithm only uses the first line of the
top separator and last line of the bottom separator to match any existing comment block in the code, so
these must be unique (and different from each other) for AtomineerUtils to correctly detect and replace
existing comment blocks.
- Bugfix: Doxygen property comments were not being correctly updated to contain the appropriate "gets
or sets" text for the type of property being updated.
- Fixed a tiny bug. File/namespace headers that included templated text containing embedded XML
elements would not expand %fileDescription% or %namespaceDescription% variables.
|
6.00 |
- Sorry, no major features for 6.00 - I simply ran out of version numbers in 5.xx!
- Bugfix. AtomineerUtils was not reading the Text Editor options in Visual Studio correctly, so under some
circumstances tabs were used instead of spaces regardless of the user preferences.
- Bugfix: If the first code element immediately followed a file header, and that header was using the
same format as the doc comments, it would be replaced. File headers are now correctly preserved.
|
5.99 |
- Refactored OutlineDocComments command to work with the new block formats - it previously only supported
triple-slash style comments.
- Added a new preference that controls whether single-line comments (on variables, enum entries, etc) are
placed on the previous line (DocXml/Doxygen style) or added to the right of the code element being documented
(Doxygen style). Note that although you can use this mode with DocXml, comments must be placed before the
code element that they refer to in order to correctly associate the documentation with the element.
- Now works better if you attempt to document a selected block of text (instead of placing the cursor
in the first line of the element to document).
- Bugfix: %monthOfYear% variable was not returning the correct text.
- Bugfix: Fixed occasional problem with Add Accessor/Property on generic types.
- Bugfix: Word-wrap would occasionally break embedded XML commands.
- Web pages now display correctly under the Chrome browser.
|
June 2009
5.98 |
- Added DateCulture preference, allowing the date format to be forced to a particular culture rather than using
the current OS culture. This is useful for companies that have to document code in English, but have their
PCs set up for a non-English culture.
- Added Template '_blankEntry' attribute. This overrides the standard behaviour of deleting entries such as
<param> when there are no parameters, allowing you instead to substitute a plain text comment, to
generate an entry like <param>None.</param> for parameterless methods. (Note that this is a
custom documentation format that will not be compatible with the DocXml/Doxygen standards, so should only
be used with bespoke documentation publishing tools).
|
5.97 |
- Improvements in parsing of C++ class & function headers.
- Small improvements to the Pluralise heuristics.
- Bugfix: (Doxygen) 'return' tags are now removed if you change the return type of a method to void.
- Bugfix: (Doxygen) Under some circumstances enum/class/interface names were not parsed correctly,
causing spurious text to be included in the auto-generated documentation.
- Bugfix: Commenting the final entry in an enumerated type now works correctly.
- More rules added
|
5.96 |
- Significantly updated and improved the rules for auto-documentation of properties.
- Section prefix/suffix strings now have any contained %variables% expanded.
- New global variable %containingclass% now provides the name of the class that contains the current
code element. If no containing class is found, the file leafname is used instead. (Currently this relies
on intellisense information)
- Bugfix: Exception documentation was not being generated for C++ code.
|
5.95 |
- File and Namespace comments are now properly supported. The old file header preferences have been removed,
and the whole process is entirely controlled from the rules.xml templates. You can either use plain text
or an XML template, and new variables and AutoDoc rule sections have been introduced to give you full
control of the formatting and auto-doc text that is output into file/namespace headers. Full details can be
found in rules.xml
- Added more comments to rules.xml to make it easier to understand and edit the rules.
|
5.94 |
- Improved FramedXxxFlowSingle block formatting when an entry is too long to be formatted in 'flow' mode due to
the length of its tag. This occasionally caused parameters with long names in single-parameter methods to be
formatted poorly (resulting in a line of excessive length).
- Bugfix: When XML tags were embedded within template elements, newlines were being stripped.
These newlines are now preserved.
- Small improvements were made to the word wrap logic.
- Fixed the file header preferences - in moving the controls to a new tab, VS created two
imposters and hid the original controls in an alternate universe.
|
5.93 |
- Added a preference to globally enable/disable insertion of blank lines between entries. (The templates
in rules.xml still gives finer control of the locations of the blank lines)
- Added a live preview to the preferences so you can easily see the effect your choices will have
- Fixed a small bug that stopped Properties picking up base class documentation.
- Fixed some minor word-wrap artifacts (e.g. joining 'and/or' back together as 'and/ or')
- Fixed an error that could cause several comments to be gathered into one comment if a rare 'confusing'
character sequence was found in the file being documented.
|
5.92 |
- Tested with Visual Studio 2010 beta - found to work fine.
- Added a preference for the overall style of each entry, giving 5 new options regarding the way the block is formatted.
See block format examples for a pictorial explanation of how the
different formats look. Note that the default format has now been changed. To retain the old AtomineerUtils
formatting behaviour, set the 'Put tags on the same lines as the entry text' (Flow) mode.
- An additional option allows you to apply a single formatting options across all entries in a group of similar
entries (e.g. params) where it looks messy to use different format styles on each entry
- Added a global preference allowing the automatic insertion of whitespace between the entry tags
and the body text to be suppressed if preferred.
- Discovered that Express Editions don't support add-ins, so added a note to the download page.
|
May 2009
5.90 |
- Refactored the word wrap and indentation systems to work much more effectively. AtomineerUtils now
handles indentation made up of a mixture of spaces and tabs correctly, and correctly preserves blocks of
text at different indent levels, so it handles lists and example code much better. The new engine is also
able to correctly parse blocks with no line headers (C style /* ... */ comment blocks), allowing almost
any conceivable block comment style to be used with AtomineerUtils
- Added _punctuate, _wordwrap, and _verbatim attributes to the Rules.xml templates. These can be
used to control the behaviour of AtomineerUtils on a per-entry level. Documentation on these is
included in rules.xml.
- Fixed a bug in Doxygen handling of interface elements.
- Changed Doxygen default tag (in rules.xml) for returns from "retval" to "return" as
I discovered I'd mistakenly been using the wrong tag for years! Also removed the dash in doxygen param
entries to follw the doxygen standard more correctly.
- Property/Indexer "gets or sets" text strings are now set in user variables to support
foreign language translations of rules.xml
- Added parser support for C++ function type declarations and template classes.
- Added support for BOOLEAN type in Rules.xml.
- Fixed occasional infinite loop bug when parsing base class doc-comments.
- Exposed DateFormat preference in the options window. This can be set to any standard DateTime
format string such as "d" or "dddd dd mmmm yyyy"
- Doxygen comment update now properly updates the prototype (class, fn, etc) entry and
[in,out] parameter descriptions if the function prototype changes
- AddAccessMethods handling improved to handle generic types and volatile variables.
- Installer now allows the addin install location to be set by the user. This is needed as
a workaround for companies that place 'My Documents' on a mapped (server) drive.
|
April 2009
5.86 |
- Comment-wrap feature now works fully for comments that have no whitespace between the // and the comment text.
- Small bugfix for enum entry line comments
- Fixed small bugs in the handling of leading and trailing blank lines for word-wrap and auto-punctuation.
- Improved updating of comments containing user-defined tags (from Rules.xml templates).
|
5.85 |
- Improved override documentation harvesting.
- Added "Check for updates..." menu item.
|
5.84 |
- Prefs application now supports enforcing of 0 lines above/below DocComments.
|
5.83 |
- Bugfixes in handling of multiple C# attributes, and for one case of wildcard rule matching.
- Added %typeBase% variable and <IfNot> rules.xml command.
- Improved handling of 'a', 'an' and 'the'.
- Made a significant number of improvements to the default rules.xml
|
5.82 |
- Added template support for file and namespace comments. In DocXml, this is disabled by default,
but can be turned on in Rules.xml to use the Xml format for file and namespace comments.
- Added more date variables for use in Rules.xml
- Added project/assembly variables (e.g. %AssemblyName%) for use in Rules.xml
|
5.81 | - Upgraded Doxygen code to use the (relatively) new Templating system already in use for DocXml.
|
March 2009
5.80 | - Fixed a bug in doxygen indentation processing.
|
5.79 | - First widespread public release.
|
|