- Johannes created a new basic infrastructure for Crunchy where we can introduce new capabilities via plugins, without needing to change a single line of the core in most instances.
- Based on the new architecture, I came up with a new way to process pages so that no additional markup was needed for Crunchy to do its magic. This is what makes it possible, for example, to interact with the official Python tutorial on the python.org site.
In any event, after reading some comments on this post by Georg Brandl, I started thinking about adding a new option to test code embedded in documentation. To quote from the comments on that post:
One thing that is seriously needed is the ability to run and test code snippets in some fashion. It's just too easy for documentation to get out of date relative to the code, and if you can effectively "unit test" your docs, you're in much better shape.Alternatively, from another reader:
And I don't mean like doctests, because not everything lends it self well to that style of testing. If it's possible to mark up some code as being for test fixture and some code as being what belongs in the doc, that would be good.
For me a key is being able to test code in the docs, and think the key is being able to "annotate" a code snipit with information about the context in which it should run, and the output it should give.
I think that Crunchy is a very good platform to implement this. There are currently three complementary options I am considering, one of which I have started to implement.
The first option is to have something like the following [note that while I use html notation, Crunchy is now capable of handling reStructuredText, including having the possibility of dealing with additional directives]:
Some normally hidden code, used for setup:
<pre title="setup_code name=first">
Followed by the code sample to be tested:
<pre title="check_code name=first">
And the expected output:
<pre title="code_output name=first">
This type of approach could, in theory, be used for other languages than Python; code could be executed by passing information to a separate process launched in a terminal window, with the result fed back into Crunchy as described above.
A second approach is to use the same method used by doctest to combine code sample and expected output; the setup code could still be used as described above.
A third approach, this one completely different, could be used for more general situation than simply for documentation code testing.
Currently, the Python code needs to be embedded inside an html (or rst) document. However, one could create links to code that lives inside separate Python files. For example, one could have the following:
<span title="python_file_name"> file_path </span>
<span title="python_file_linenumbers"> some_range </span>
When viewing the above using a normal browser, one would see something like (using a fictitious example)
However, when viewing the same page with Crunchy, the appropriate lines would be extracted from the file and displayed in the browser. Alternatively, instead of specifying the line numbers, one could have a directive to extract a specific function/method/class as in
[1-3, 5, 7, 10-15]
<span title="python_file_function"> function_name </span>
which would instruct Crunchy to extract all the code for the function definition, and inserting it in the document. By using such links, the code in the documentation would always (by definition) be kept in sync with the real code. I realize that this is not exactly a novel idea but one whose potential could be extended by using Crunchy in ways never seen before. However, this last approach will have to wait until after Crunchy version 1.0 has been released.
What do you think of these ideas?