|   | 1 | = Wiki Processors = | 
          
          
            |   | 2 | Processors are WikiMacros designed to provide alternative markup formats for the Trac Wiki engine. Processors can be thought of as ''macro functions to process user-edited text''.  | 
          
          
            |   | 3 |  | 
          
          
            |   | 4 | The wiki engine uses processors to allow using [wiki:WikiRestructuredText Restructured Text] and [wiki:WikiHtml raw HTML] in any wiki text throughout Trac. | 
          
          
            |   | 5 |  | 
          
          
            |   | 6 | == Using Processors == | 
          
          
            |   | 7 | To use a processor on a block of text, use a wiki blockquote, selecting a processor by name using ''shebang notation'' (#!), familiar to most UNIX users from scripts. | 
          
          
            |   | 8 |  | 
          
          
            |   | 9 | '''Example 1''' (''inserting raw HTML in a wiki text''): | 
          
          
            |   | 10 |  | 
          
          
            |   | 11 | {{{ | 
          
          
            |   | 12 | #!html | 
          
          
            |   | 13 | <pre class="wiki">{{{ | 
          
          
            |   | 14 | #!html | 
          
          
            |   | 15 | <h1 style="color: orange">This is raw HTML</h1> | 
          
          
            |   | 16 | }}}</pre> | 
          
          
            |   | 17 | }}} | 
          
          
            |   | 18 |  | 
          
          
            |   | 19 | '''Results in:''' | 
          
          
            |   | 20 | {{{ | 
          
          
            |   | 21 | #!html | 
          
          
            |   | 22 | <h1 style="color: orange">This is raw HTML</h1> | 
          
          
            |   | 23 | }}} | 
          
          
            |   | 24 |  | 
          
          
            |   | 25 | ---- | 
          
          
            |   | 26 |  | 
          
          
            |   | 27 | '''Example 2''' (''inserting Restructured Text in wiki text''): | 
          
          
            |   | 28 |  | 
          
          
            |   | 29 | {{{ | 
          
          
            |   | 30 | #!html | 
          
          
            |   | 31 | <pre class="wiki">{{{ | 
          
          
            |   | 32 | #!rst | 
          
          
            |   | 33 | A header | 
          
          
            |   | 34 | -------- | 
          
          
            |   | 35 | This is some **text** with a footnote [*]_. | 
          
          
            |   | 36 |  | 
          
          
            |   | 37 | .. [*] This is the footnote. | 
          
          
            |   | 38 | }}}</pre> | 
          
          
            |   | 39 | }}} | 
          
          
            |   | 40 |  | 
          
          
            |   | 41 | '''Results in:''' | 
          
          
            |   | 42 | {{{ | 
          
          
            |   | 43 | #!rst | 
          
          
            |   | 44 | A header | 
          
          
            |   | 45 | -------- | 
          
          
            |   | 46 | This is some **text** with a footnote [*]_. | 
          
          
            |   | 47 |  | 
          
          
            |   | 48 | .. [*] This is the footnote. | 
          
          
            |   | 49 | }}} | 
          
          
            |   | 50 | ---- | 
          
          
            |   | 51 | '''Example 3''' (''inserting a block of C source code in wiki text''): | 
          
          
            |   | 52 |  | 
          
          
            |   | 53 | {{{ | 
          
          
            |   | 54 | #!html | 
          
          
            |   | 55 | <pre class="wiki">{{{ | 
          
          
            |   | 56 | #!c | 
          
          
            |   | 57 | int main(int argc, char *argv[]) | 
          
          
            |   | 58 | { | 
          
          
            |   | 59 |   printf("Hello World\n"); | 
          
          
            |   | 60 |   return 0; | 
          
          
            |   | 61 | } | 
          
          
            |   | 62 | }}}</pre> | 
          
          
            |   | 63 | }}} | 
          
          
            |   | 64 |  | 
          
          
            |   | 65 | '''Results in:''' | 
          
          
            |   | 66 | {{{ | 
          
          
            |   | 67 | #!c | 
          
          
            |   | 68 | int main(int argc, char *argv[]) | 
          
          
            |   | 69 | { | 
          
          
            |   | 70 |   printf("Hello World\n"); | 
          
          
            |   | 71 |   return 0; | 
          
          
            |   | 72 | } | 
          
          
            |   | 73 | }}} | 
          
          
            |   | 74 |  | 
          
          
            |   | 75 | ---- | 
          
          
            |   | 76 |  | 
          
          
            |   | 77 | == Available Processors == | 
          
          
            |   | 78 | The following processors are included in the Trac distribution: | 
          
          
            |   | 79 |  * '''html''' -- Insert custom HTML in a wiki page. See WikiHtml. | 
          
          
            |   | 80 |  * '''rst''' -- Trac support for Restructured Text. See WikiRestructuredText. | 
          
          
            |   | 81 |  * '''textile''' -- Supported if  [http://dealmeida.net/projects/textile/ Textile] is installed. | 
          
          
            |   | 82 |  | 
          
          
            |   | 83 | === Code Highlighting Support === | 
          
          
            |   | 84 | Trac includes processors to provide inline [wiki:TracSyntaxColoring syntax highlighting] for the following languages: | 
          
          
            |   | 85 |  * '''c''' -- C | 
          
          
            |   | 86 |  * '''cpp''' -- C++ | 
          
          
            |   | 87 |  * '''python''' -- Python | 
          
          
            |   | 88 |  * '''perl''' -- Perl | 
          
          
            |   | 89 |  * '''ruby''' -- Ruby | 
          
          
            |   | 90 |  * '''php''' -- PHP | 
          
          
            |   | 91 |  * '''asp''' --- ASP | 
          
          
            |   | 92 |  * '''sql''' -- SQL | 
          
          
            |   | 93 |  * '''xml''' -- XML | 
          
          
            |   | 94 | '''Note:''' ''Trac relies on external software packages for syntax coloring. See TracSyntaxColoring for more info.'' | 
          
          
            |   | 95 |  | 
          
          
            |   | 96 | By using the MIME type as processor, it is possible to syntax-highlight the same languages that are supported when browsing source code. For example, you can write: | 
          
          
            |   | 97 | {{{ | 
          
          
            |   | 98 | {{{ | 
          
          
            |   | 99 | #!text/html | 
          
          
            |   | 100 | <h1>text</h1> | 
          
          
            |   | 101 | }}} | 
          
          
            |   | 102 | }}} | 
          
          
            |   | 103 |  | 
          
          
            |   | 104 | The result will be syntax highlighted HTML code. The same is valid for all other mime types supported. | 
          
          
            |   | 105 |  | 
          
          
            |   | 106 |  | 
          
          
            |   | 107 | For more processor macros developed and/or contributed by users, visit:  | 
          
          
            |   | 108 |  * [http://projects.edgewall.com/trac/wiki/ProcessorBazaar ProcessorBazaar] | 
          
          
            |   | 109 |  * [http://projects.edgewall.com/trac/wiki/MacroBazaar MacroBazaar] | 
          
          
            |   | 110 |  | 
          
          
            |   | 111 |  | 
          
          
            |   | 112 | == Advanced Topics: Developing Processor Macros == | 
          
          
            |   | 113 | Developing processors is no different than WikiMacros. In fact they work the same way, only the usage syntax differs. See WikiMacros for more information. | 
          
          
            |   | 114 |  | 
          
          
            |   | 115 | '''Example:''' (''Restructured Text Processor''): | 
          
          
            |   | 116 | {{{ | 
          
          
            |   | 117 | from docutils.core import publish_string | 
          
          
            |   | 118 |  | 
          
          
            |   | 119 | def execute(hdf, text, env): | 
          
          
            |   | 120 |     html = publish_string(text, writer_name = 'html') | 
          
          
            |   | 121 |     return html[html.find('<body>')+6:html.find('</body>')].strip() | 
          
          
            |   | 122 | }}} | 
          
          
            |   | 123 |  | 
          
          
            |   | 124 | ---- | 
          
          
            |   | 125 | See also: WikiMacros, WikiHtml, WikiRestructuredText, TracSyntaxColoring, WikiFormatting, TracGuide |