Yeah, I poked around and found there's a PHP one that does it, but I couldn't be arsed figuring out how to get a command line PHP thing setup.

I'm working with an Eclipse plugin - which is ok though relatively basic (This one - it seems to be the only Markdown plugin for Eclipse in existence! :/ )

Anyway, that came with the source attached, so I just hacked in a quick bit of replacement code, to work with a variant of the syntax I did above, and I've got it working now with this:

!table [ head | is | first | row ]
	[ any | number | of | rows ]
	[ with | bracket | for | tr ]
	[ and | pipe | for | td ]
/table

And that works well enough for now - relatively crude and fragile (e.g. doesn't attempt to handle nested/escaped brackets/pipes), but it means I can get on with doing more useful stuff.

At some point I might see about improving what I've done and releasing it, if there's actually anyone out there that wants it.

Is there a reason you're not just using HTML for tables? I know it's a faff, but still, Markdown does allow for HTML.

<table>
	<thead>
		<tr><th> because <th> it <th> is <th> way </tr>
	</thead>
	<tbody>
		<tr><td> more <td> bloated <td> and <td> harder </tr>
		<tr><td> to   <td> read <td> cells <td> quickly </tr>
		<tr><td> when <td> viewing <td> in <td> markup </tr>
	</tbody>
</table>

!table [ whilst | like | this | it ]
	[ is  | easier | to | ignore ]
	[ the | delimiters | and | focus ]
	[ on  | the | actual | contents ]
/table

More importantly though, you can't use markdown inside of HTML, which I've only just remembered I'll need to do, and fortunately my [s don't get in the way of regular markdown [s. Phew.

Well yeah, I know it's more verbose. Just sayin. If you manage to get this thing working well, I may steal it and make a JavaScript version.

Heh, the original is in Java, and can't be directly translated because JS doesn't have equivalents.

Although... it does have replace callbacks which Java doesn't, so could actually be an interesting comparison...

Here we go:

private String convertTables( String html )
{
   Pattern p = Pattern.compile("(?ms)^<p>!table(.*?)(?<=\\n\\s{0,99})/table</p>", 0);
   Matcher m = p.matcher(html);
   StringBuffer sb = new StringBuffer("");
 
   while (m.find())
   {
      String[] Rows = m.group(1).trim().split("(?:^|\\]?\\n)\\s*\\[");
 
      String Head = "<thead><tr><th>"
         + Rows[1]
              .replaceAll("\\|","<th>")
              .replaceAll("\\]\\s*+$","</th>")
         + "</thead>"
         ;
 
      String Body = "<tbody>";
 
      for ( int i = 2 ; i < Rows.length; i++ )
      {
         Body += "<tr><td>"
            + Rows[i]
            .replaceAll("\\|","<td>")
            .replaceAll("\\]\\s*+$","</td>")
            ;
      }
 
      m.appendReplacement(sb,"<table>" + Head + Body + "</tbody></table>");
   }
 
   m.appendTail(sb);
 
   return sb.toString();
}

function convertTables( html )
{
   return html.replace
      ( /^<p>!table([\w\W]*?)\/table<\/p>/gm
      , function()
         {
            var Rows = arguments[1].split(/(?:^|\]?\n)\s*\[/);
 
            var Head = '<thead><tr><th>'
               + Rows[1]
                    .replace(/\|/g,'<th>')
                    .replace(/\]\s*$/g,'</th>')
               + '</thead>'
               ;
 
            var Body = '<tbody>'
 
            for ( var i = 2 ; i < Rows.length; i++ )
            {
               Body += '<tr><td>'
                  + Rows[i]
                  .replace(/\|/g,'<td>')
                  .replace(/\]\s*$/g,'</td>')
                  ;
            }
 
            return '<table>' + Head + Body + '</tbody></table>'
 
         }
      )
}

Of course, the JS one is just as flaky as the original, but if you do feel like doing anything with it, go ahead. :)