miniblog 1.0.0.beta

Sign up to get free protection for your applications and to get access to all the features.
Files changed (119) hide show
  1. checksums.yaml +7 -0
  2. data/.autotest +5 -0
  3. data/.gitignore +17 -0
  4. data/.rspec +2 -0
  5. data/.simplecov +13 -0
  6. data/.travis.yml +17 -0
  7. data/CHANGELOG.md +7 -0
  8. data/Gemfile +20 -0
  9. data/Gemfile.4.1 +19 -0
  10. data/MIT-LICENSE +20 -0
  11. data/README.md +86 -0
  12. data/Rakefile +29 -0
  13. data/app/assets/images/crowdblog/.gitkeep +0 -0
  14. data/app/assets/javascripts/miniblog.js +7 -0
  15. data/app/assets/javascripts/miniblog/alerts.js +5 -0
  16. data/app/assets/javascripts/miniblog/form-errors.js +3 -0
  17. data/app/assets/stylesheets/application.css +3 -0
  18. data/app/assets/stylesheets/miniblog.css +5 -0
  19. data/app/assets/stylesheets/miniblog/bootstrap_and_overrides.css.scss +1 -0
  20. data/app/assets/stylesheets/miniblog/posts.css.scss +34 -0
  21. data/app/controllers/miniblog/admin/assets_controller.rb +20 -0
  22. data/app/controllers/miniblog/admin/base_controller.rb +7 -0
  23. data/app/controllers/miniblog/admin/posts_controller.rb +63 -0
  24. data/app/controllers/miniblog/admin/preview_controller.rb +8 -0
  25. data/app/controllers/miniblog/admin/states_controller.rb +11 -0
  26. data/app/controllers/miniblog/admin/transitions_controller.rb +22 -0
  27. data/app/controllers/miniblog/application_controller.rb +14 -0
  28. data/app/controllers/miniblog/posts_controller.rb +7 -0
  29. data/app/helpers/miniblog/admin/posts_helper.rb +18 -0
  30. data/app/helpers/miniblog/application_helper.rb +4 -0
  31. data/app/models/miniblog/asset.rb +7 -0
  32. data/app/models/miniblog/post.rb +135 -0
  33. data/app/models/miniblog/status_change_record.rb +6 -0
  34. data/app/models/miniblog/user.rb +32 -0
  35. data/app/presenters/miniblog/post_presenter.rb +13 -0
  36. data/app/uploaders/attachment_uploader.rb +48 -0
  37. data/app/views/layouts/miniblog/admin/base.html.erb +26 -0
  38. data/app/views/miniblog/admin/posts/_form.html.erb +10 -0
  39. data/app/views/miniblog/admin/posts/_form.html.slim +27 -0
  40. data/app/views/miniblog/admin/posts/_post.html.erb +14 -0
  41. data/app/views/miniblog/admin/posts/_post.html.slim +20 -0
  42. data/app/views/miniblog/admin/posts/edit.html.erb +19 -0
  43. data/app/views/miniblog/admin/posts/edit.html.slim +14 -0
  44. data/app/views/miniblog/admin/posts/index.html.erb +5 -0
  45. data/app/views/miniblog/admin/posts/new.html.erb +17 -0
  46. data/app/views/miniblog/admin/posts/new.html.slim +12 -0
  47. data/app/views/miniblog/application/_navbar.html.erb +19 -0
  48. data/app/views/miniblog/application/_notices.html.slim +6 -0
  49. data/app/views/miniblog/posts/_post.html.slim +4 -0
  50. data/app/views/miniblog/posts/index.html.slim +1 -0
  51. data/config/cucumber.yml +9 -0
  52. data/config/initializers/date_formats.rb +1 -0
  53. data/config/initializers/state_machine.rb +4 -0
  54. data/config/locales/devise.en.yml +57 -0
  55. data/config/routes.rb +26 -0
  56. data/db/migrate/20120217213920_create_miniblog_posts.rb +17 -0
  57. data/db/migrate/20120219071614_create_miniblog_assets.rb +10 -0
  58. data/lib/generators/miniblog/views_generator.rb +11 -0
  59. data/lib/miniblog.rb +18 -0
  60. data/lib/miniblog/devise/failure_app.rb +9 -0
  61. data/lib/miniblog/engine.rb +9 -0
  62. data/lib/miniblog/rspec.rb +1 -0
  63. data/lib/miniblog/rspec/miniblog_shared_examples.rb +77 -0
  64. data/lib/miniblog/version.rb +3 -0
  65. data/miniblog.gemspec +40 -0
  66. data/script/cucumber +10 -0
  67. data/script/rails +8 -0
  68. data/spec/dummy/README.rdoc +261 -0
  69. data/spec/dummy/Rakefile +7 -0
  70. data/spec/dummy/app/assets/javascripts/application.js +16 -0
  71. data/spec/dummy/app/assets/stylesheets/application.css +13 -0
  72. data/spec/dummy/app/controllers/application_controller.rb +2 -0
  73. data/spec/dummy/app/helpers/application_helper.rb +2 -0
  74. data/spec/dummy/app/mailers/.gitkeep +0 -0
  75. data/spec/dummy/app/models/.gitkeep +0 -0
  76. data/spec/dummy/app/models/user.rb +3 -0
  77. data/spec/dummy/app/views/home/show.html.slim +4 -0
  78. data/spec/dummy/app/views/layouts/application.html.erb +14 -0
  79. data/spec/dummy/bin/bundle +3 -0
  80. data/spec/dummy/bin/rails +4 -0
  81. data/spec/dummy/bin/rake +4 -0
  82. data/spec/dummy/config.ru +4 -0
  83. data/spec/dummy/config/application.rb +28 -0
  84. data/spec/dummy/config/boot.rb +4 -0
  85. data/spec/dummy/config/database.yml +25 -0
  86. data/spec/dummy/config/environment.rb +5 -0
  87. data/spec/dummy/config/environments/development.rb +37 -0
  88. data/spec/dummy/config/environments/production.rb +82 -0
  89. data/spec/dummy/config/environments/test.rb +39 -0
  90. data/spec/dummy/config/initializers/assets.rb +8 -0
  91. data/spec/dummy/config/initializers/backtrace_silencers.rb +7 -0
  92. data/spec/dummy/config/initializers/carrierwave.rb +18 -0
  93. data/spec/dummy/config/initializers/cookies_serializer.rb +3 -0
  94. data/spec/dummy/config/initializers/filter_parameter_logging.rb +4 -0
  95. data/spec/dummy/config/initializers/inflections.rb +16 -0
  96. data/spec/dummy/config/initializers/mime_types.rb +4 -0
  97. data/spec/dummy/config/initializers/miniblog.rb +2 -0
  98. data/spec/dummy/config/initializers/secret_token.rb +7 -0
  99. data/spec/dummy/config/initializers/session_store.rb +3 -0
  100. data/spec/dummy/config/initializers/wrap_parameters.rb +14 -0
  101. data/spec/dummy/config/locales/en.yml +23 -0
  102. data/spec/dummy/config/routes.rb +3 -0
  103. data/spec/dummy/config/secrets.yml +22 -0
  104. data/spec/dummy/db/schema.rb +50 -0
  105. data/spec/dummy/db/seed.rb +6 -0
  106. data/spec/dummy/lib/assets/.gitkeep +0 -0
  107. data/spec/dummy/lib/tasks/cucumber.rake +65 -0
  108. data/spec/dummy/public/404.html +26 -0
  109. data/spec/dummy/public/422.html +26 -0
  110. data/spec/dummy/public/500.html +25 -0
  111. data/spec/dummy/public/favicon.ico +0 -0
  112. data/spec/dummy/script/rails +6 -0
  113. data/spec/features/miniblog_spec.rb +5 -0
  114. data/spec/generators/miniblog/views_generator_spec.rb +16 -0
  115. data/spec/models/post_spec.rb +163 -0
  116. data/spec/spec_helper.rb +58 -0
  117. data/vendor/assets/javascripts/markdown.js +1470 -0
  118. data/vendor/assets/javascripts/uploader/jquery.html5uploader.js +148 -0
  119. metadata +464 -0
@@ -0,0 +1,1470 @@
1
+ // Released under MIT license
2
+ // Copyright (c) 2009-2010 Dominic Baggott
3
+ // Copyright (c) 2009-2010 Ash Berlin
4
+ // Copyright (c) 2011 Christoph Dorn <christoph@christophdorn.com> (http://www.christophdorn.com)
5
+
6
+ (function( expose ) {
7
+
8
+ /**
9
+ * class Markdown
10
+ *
11
+ * Markdown processing in Javascript done right. We have very particular views
12
+ * on what constitutes 'right' which include:
13
+ *
14
+ * - produces well-formed HTML (this means that em and strong nesting is
15
+ * important)
16
+ *
17
+ * - has an intermediate representation to allow processing of parsed data (We
18
+ * in fact have two, both as [JsonML]: a markdown tree and an HTML tree).
19
+ *
20
+ * - is easily extensible to add new dialects without having to rewrite the
21
+ * entire parsing mechanics
22
+ *
23
+ * - has a good test suite
24
+ *
25
+ * This implementation fulfills all of these (except that the test suite could
26
+ * do with expanding to automatically run all the fixtures from other Markdown
27
+ * implementations.)
28
+ *
29
+ * ##### Intermediate Representation
30
+ *
31
+ * *TODO* Talk about this :) Its JsonML, but document the node names we use.
32
+ *
33
+ * [JsonML]: http://jsonml.org/ "JSON Markup Language"
34
+ **/
35
+ var Markdown = expose.Markdown = function Markdown(dialect) {
36
+ switch (typeof dialect) {
37
+ case "undefined":
38
+ this.dialect = Markdown.dialects.Gruber;
39
+ break;
40
+ case "object":
41
+ this.dialect = dialect;
42
+ break;
43
+ default:
44
+ if (dialect in Markdown.dialects) {
45
+ this.dialect = Markdown.dialects[dialect];
46
+ }
47
+ else {
48
+ throw new Error("Unknown Markdown dialect '" + String(dialect) + "'");
49
+ }
50
+ break;
51
+ }
52
+ this.em_state = [];
53
+ this.strong_state = [];
54
+ this.debug_indent = "";
55
+ }
56
+
57
+ /**
58
+ * parse( markdown, [dialect] ) -> JsonML
59
+ * - markdown (String): markdown string to parse
60
+ * - dialect (String | Dialect): the dialect to use, defaults to gruber
61
+ *
62
+ * Parse `markdown` and return a markdown document as a Markdown.JsonML tree.
63
+ **/
64
+ expose.parse = function( source, dialect ) {
65
+ // dialect will default if undefined
66
+ var md = new Markdown( dialect );
67
+ return md.toTree( source );
68
+ }
69
+
70
+ /**
71
+ * toHTML( markdown, [dialect] ) -> String
72
+ * toHTML( md_tree ) -> String
73
+ * - markdown (String): markdown string to parse
74
+ * - md_tree (Markdown.JsonML): parsed markdown tree
75
+ *
76
+ * Take markdown (either as a string or as a JsonML tree) and run it through
77
+ * [[toHTMLTree]] then turn it into a well-formated HTML fragment.
78
+ **/
79
+ expose.toHTML = function toHTML( source , dialect , options ) {
80
+ var input = expose.toHTMLTree( source , dialect , options );
81
+
82
+ return expose.renderJsonML( input );
83
+ }
84
+
85
+ /**
86
+ * toHTMLTree( markdown, [dialect] ) -> JsonML
87
+ * toHTMLTree( md_tree ) -> JsonML
88
+ * - markdown (String): markdown string to parse
89
+ * - dialect (String | Dialect): the dialect to use, defaults to gruber
90
+ * - md_tree (Markdown.JsonML): parsed markdown tree
91
+ *
92
+ * Turn markdown into HTML, represented as a JsonML tree. If a string is given
93
+ * to this function, it is first parsed into a markdown tree by calling
94
+ * [[parse]].
95
+ **/
96
+ expose.toHTMLTree = function toHTMLTree( input, dialect , options ) {
97
+ // convert string input to an MD tree
98
+ if ( typeof input ==="string" ) input = this.parse( input, dialect );
99
+
100
+ // Now convert the MD tree to an HTML tree
101
+
102
+ // remove references from the tree
103
+ var attrs = extract_attr( input ),
104
+ refs = {};
105
+
106
+ if ( attrs && attrs.references ) {
107
+ refs = attrs.references;
108
+ }
109
+
110
+ var html = convert_tree_to_html( input, refs , options );
111
+ merge_text_nodes( html );
112
+ return html;
113
+ }
114
+
115
+ var mk_block = Markdown.mk_block = function(block, trail, line) {
116
+ // Be helpful for default case in tests.
117
+ if ( arguments.length == 1 ) trail = "\n\n";
118
+
119
+ var s = new String(block);
120
+ s.trailing = trail;
121
+ // To make it clear its not just a string
122
+ s.toSource = function() {
123
+ return "Markdown.mk_block( " +
124
+ uneval(block) +
125
+ ", " +
126
+ uneval(trail) +
127
+ ", " +
128
+ uneval(line) +
129
+ " )"
130
+ }
131
+
132
+ if (line != undefined)
133
+ s.lineNumber = line;
134
+
135
+ return s;
136
+ }
137
+
138
+ function count_lines( str ) {
139
+ var n = 0, i = -1;;
140
+ while ( ( i = str.indexOf('\n', i+1) ) != -1) n++;
141
+ return n;
142
+ }
143
+
144
+ // Internal - split source into rough blocks
145
+ Markdown.prototype.split_blocks = function splitBlocks( input, startLine ) {
146
+ // [\s\S] matches _anything_ (newline or space)
147
+ var re = /([\s\S]+?)($|\n(?:\s*\n|$)+)/g,
148
+ blocks = [],
149
+ m;
150
+
151
+ var line_no = 1;
152
+
153
+ if ( ( m = /^(\s*\n)/.exec(input) ) != null ) {
154
+ // skip (but count) leading blank lines
155
+ line_no += count_lines( m[0] );
156
+ re.lastIndex = m[0].length;
157
+ }
158
+
159
+ while ( ( m = re.exec(input) ) != null ) {
160
+ blocks.push( mk_block( m[1], m[2], line_no ) );
161
+ line_no += count_lines( m[0] );
162
+ }
163
+
164
+ return blocks;
165
+ }
166
+
167
+ /**
168
+ * Markdown#processBlock( block, next ) -> undefined | [ JsonML, ... ]
169
+ * - block (String): the block to process
170
+ * - next (Array): the following blocks
171
+ *
172
+ * Process `block` and return an array of JsonML nodes representing `block`.
173
+ *
174
+ * It does this by asking each block level function in the dialect to process
175
+ * the block until one can. Succesful handling is indicated by returning an
176
+ * array (with zero or more JsonML nodes), failure by a false value.
177
+ *
178
+ * Blocks handlers are responsible for calling [[Markdown#processInline]]
179
+ * themselves as appropriate.
180
+ *
181
+ * If the blocks were split incorrectly or adjacent blocks need collapsing you
182
+ * can adjust `next` in place using shift/splice etc.
183
+ *
184
+ * If any of this default behaviour is not right for the dialect, you can
185
+ * define a `__call__` method on the dialect that will get invoked to handle
186
+ * the block processing.
187
+ */
188
+ Markdown.prototype.processBlock = function processBlock( block, next ) {
189
+ var cbs = this.dialect.block,
190
+ ord = cbs.__order__;
191
+
192
+ if ( "__call__" in cbs ) {
193
+ return cbs.__call__.call(this, block, next);
194
+ }
195
+
196
+ for ( var i = 0; i < ord.length; i++ ) {
197
+ //D:this.debug( "Testing", ord[i] );
198
+ var res = cbs[ ord[i] ].call( this, block, next );
199
+ if ( res ) {
200
+ //D:this.debug(" matched");
201
+ if ( !isArray(res) || ( res.length > 0 && !( isArray(res[0]) ) ) )
202
+ this.debug(ord[i], "didn't return a proper array");
203
+ //D:this.debug( "" );
204
+ return res;
205
+ }
206
+ }
207
+
208
+ // Uhoh! no match! Should we throw an error?
209
+ return [];
210
+ }
211
+
212
+ Markdown.prototype.processInline = function processInline( block ) {
213
+ return this.dialect.inline.__call__.call( this, String( block ) );
214
+ }
215
+
216
+ /**
217
+ * Markdown#toTree( source ) -> JsonML
218
+ * - source (String): markdown source to parse
219
+ *
220
+ * Parse `source` into a JsonML tree representing the markdown document.
221
+ **/
222
+ // custom_tree means set this.tree to `custom_tree` and restore old value on return
223
+ Markdown.prototype.toTree = function toTree( source, custom_root ) {
224
+ var blocks = source instanceof Array
225
+ ? source
226
+ : this.split_blocks( source );
227
+
228
+ // Make tree a member variable so its easier to mess with in extensions
229
+ var old_tree = this.tree;
230
+ try {
231
+ this.tree = custom_root || this.tree || [ "markdown" ];
232
+
233
+ blocks:
234
+ while ( blocks.length ) {
235
+ var b = this.processBlock( blocks.shift(), blocks );
236
+
237
+ // Reference blocks and the like won't return any content
238
+ if ( !b.length ) continue blocks;
239
+
240
+ this.tree.push.apply( this.tree, b );
241
+ }
242
+ return this.tree;
243
+ }
244
+ finally {
245
+ if ( custom_root )
246
+ this.tree = old_tree;
247
+ }
248
+
249
+ }
250
+
251
+ // Noop by default
252
+ Markdown.prototype.debug = function () {
253
+ var args = Array.prototype.slice.call( arguments);
254
+ args.unshift(this.debug_indent);
255
+ if (typeof print !== "undefined")
256
+ print.apply( print, args );
257
+ if (typeof console !== "undefined" && typeof console.log !== "undefined")
258
+ console.log.apply( null, args );
259
+ }
260
+
261
+ Markdown.prototype.loop_re_over_block = function( re, block, cb ) {
262
+ // Dont use /g regexps with this
263
+ var m,
264
+ b = block.valueOf();
265
+
266
+ while ( b.length && (m = re.exec(b) ) != null) {
267
+ b = b.substr( m[0].length );
268
+ cb.call(this, m);
269
+ }
270
+ return b;
271
+ }
272
+
273
+ /**
274
+ * Markdown.dialects
275
+ *
276
+ * Namespace of built-in dialects.
277
+ **/
278
+ Markdown.dialects = {};
279
+
280
+ /**
281
+ * Markdown.dialects.Gruber
282
+ *
283
+ * The default dialect that follows the rules set out by John Gruber's
284
+ * markdown.pl as closely as possible. Well actually we follow the behaviour of
285
+ * that script which in some places is not exactly what the syntax web page
286
+ * says.
287
+ **/
288
+ Markdown.dialects.Gruber = {
289
+ block: {
290
+ atxHeader: function atxHeader( block, next ) {
291
+ var m = block.match( /^(#{1,6})\s*(.*?)\s*#*\s*(?:\n|$)/ );
292
+
293
+ if ( !m ) return undefined;
294
+
295
+ var header = [ "header", { level: m[ 1 ].length } ];
296
+ Array.prototype.push.apply(header, this.processInline(m[ 2 ]));
297
+
298
+ if ( m[0].length < block.length )
299
+ next.unshift( mk_block( block.substr( m[0].length ), block.trailing, block.lineNumber + 2 ) );
300
+
301
+ return [ header ];
302
+ },
303
+
304
+ setextHeader: function setextHeader( block, next ) {
305
+ var m = block.match( /^(.*)\n([-=])\2\2+(?:\n|$)/ );
306
+
307
+ if ( !m ) return undefined;
308
+
309
+ var level = ( m[ 2 ] === "=" ) ? 1 : 2;
310
+ var header = [ "header", { level : level }, m[ 1 ] ];
311
+
312
+ if ( m[0].length < block.length )
313
+ next.unshift( mk_block( block.substr( m[0].length ), block.trailing, block.lineNumber + 2 ) );
314
+
315
+ return [ header ];
316
+ },
317
+
318
+ code: function code( block, next ) {
319
+ // | Foo
320
+ // |bar
321
+ // should be a code block followed by a paragraph. Fun
322
+ //
323
+ // There might also be adjacent code block to merge.
324
+
325
+ var ret = [],
326
+ re = /^(?: {0,3}\t| {4})(.*)\n?/,
327
+ lines;
328
+
329
+ // 4 spaces + content
330
+ var m = block.match( re );
331
+
332
+ if ( !m ) return undefined;
333
+
334
+ block_search:
335
+ do {
336
+ // Now pull out the rest of the lines
337
+ var b = this.loop_re_over_block(
338
+ re, block.valueOf(), function( m ) { ret.push( m[1] ) } );
339
+
340
+ if (b.length) {
341
+ // Case alluded to in first comment. push it back on as a new block
342
+ next.unshift( mk_block(b, block.trailing) );
343
+ break block_search;
344
+ }
345
+ else if (next.length) {
346
+ // Check the next block - it might be code too
347
+ var m = next[0].match( re );
348
+
349
+ if ( !m ) break block_search;
350
+
351
+ // Pull how how many blanks lines follow - minus two to account for .join
352
+ ret.push ( block.trailing.replace(/[^\n]/g, '').substring(2) );
353
+
354
+ block = next.shift();
355
+ }
356
+ else
357
+ break block_search;
358
+ } while (true);
359
+
360
+ return [ [ "code_block", ret.join("\n") ] ];
361
+ },
362
+
363
+ horizRule: function horizRule( block, next ) {
364
+ // this needs to find any hr in the block to handle abutting blocks
365
+ var m = block.match( /^(?:([\s\S]*?)\n)?[ \t]*([-_*])(?:[ \t]*\2){2,}[ \t]*(?:\n([\s\S]*))?$/ );
366
+
367
+ if ( !m ) {
368
+ return undefined;
369
+ }
370
+
371
+ var jsonml = [ [ "hr" ] ];
372
+
373
+ // if there's a leading abutting block, process it
374
+ if ( m[ 1 ] ) {
375
+ jsonml.unshift.apply( jsonml, this.processBlock( m[ 1 ], [] ) );
376
+ }
377
+
378
+ // if there's a trailing abutting block, stick it into next
379
+ if ( m[ 3 ] ) {
380
+ next.unshift( mk_block( m[ 3 ] ) );
381
+ }
382
+
383
+ return jsonml;
384
+ },
385
+
386
+ // There are two types of lists. Tight and loose. Tight lists have no whitespace
387
+ // between the items (and result in text just in the <li>) and loose lists,
388
+ // which have an empty line between list items, resulting in (one or more)
389
+ // paragraphs inside the <li>.
390
+ //
391
+ // There are all sorts weird edge cases about the original markdown.pl's
392
+ // handling of lists:
393
+ //
394
+ // * Nested lists are supposed to be indented by four chars per level. But
395
+ // if they aren't, you can get a nested list by indenting by less than
396
+ // four so long as the indent doesn't match an indent of an existing list
397
+ // item in the 'nest stack'.
398
+ //
399
+ // * The type of the list (bullet or number) is controlled just by the
400
+ // first item at the indent. Subsequent changes are ignored unless they
401
+ // are for nested lists
402
+ //
403
+ lists: (function( ) {
404
+ // Use a closure to hide a few variables.
405
+ var any_list = "[*+-]|\\d\\.",
406
+ bullet_list = /[*+-]/,
407
+ number_list = /\d+\./,
408
+ // Capture leading indent as it matters for determining nested lists.
409
+ is_list_re = new RegExp( "^( {0,3})(" + any_list + ")[ \t]+" ),
410
+ indent_re = "(?: {0,3}\\t| {4})";
411
+
412
+ // TODO: Cache this regexp for certain depths.
413
+ // Create a regexp suitable for matching an li for a given stack depth
414
+ function regex_for_depth( depth ) {
415
+
416
+ return new RegExp(
417
+ // m[1] = indent, m[2] = list_type
418
+ "(?:^(" + indent_re + "{0," + depth + "} {0,3})(" + any_list + ")\\s+)|" +
419
+ // m[3] = cont
420
+ "(^" + indent_re + "{0," + (depth-1) + "}[ ]{0,4})"
421
+ );
422
+ }
423
+ function expand_tab( input ) {
424
+ return input.replace( / {0,3}\t/g, " " );
425
+ }
426
+
427
+ // Add inline content `inline` to `li`. inline comes from processInline
428
+ // so is an array of content
429
+ function add(li, loose, inline, nl) {
430
+ if (loose) {
431
+ li.push( [ "para" ].concat(inline) );
432
+ return;
433
+ }
434
+ // Hmmm, should this be any block level element or just paras?
435
+ var add_to = li[li.length -1] instanceof Array && li[li.length - 1][0] == "para"
436
+ ? li[li.length -1]
437
+ : li;
438
+
439
+ // If there is already some content in this list, add the new line in
440
+ if (nl && li.length > 1) inline.unshift(nl);
441
+
442
+ for (var i=0; i < inline.length; i++) {
443
+ var what = inline[i],
444
+ is_str = typeof what == "string";
445
+ if (is_str && add_to.length > 1 && typeof add_to[add_to.length-1] == "string" )
446
+ {
447
+ add_to[ add_to.length-1 ] += what;
448
+ }
449
+ else {
450
+ add_to.push( what );
451
+ }
452
+ }
453
+ }
454
+
455
+ // contained means have an indent greater than the current one. On
456
+ // *every* line in the block
457
+ function get_contained_blocks( depth, blocks ) {
458
+
459
+ var re = new RegExp( "^(" + indent_re + "{" + depth + "}.*?\\n?)*$" ),
460
+ replace = new RegExp("^" + indent_re + "{" + depth + "}", "gm"),
461
+ ret = [];
462
+
463
+ while ( blocks.length > 0 ) {
464
+ if ( re.exec( blocks[0] ) ) {
465
+ var b = blocks.shift(),
466
+ // Now remove that indent
467
+ x = b.replace( replace, "");
468
+
469
+ ret.push( mk_block( x, b.trailing, b.lineNumber ) );
470
+ }
471
+ break;
472
+ }
473
+ return ret;
474
+ }
475
+
476
+ // passed to stack.forEach to turn list items up the stack into paras
477
+ function paragraphify(s, i, stack) {
478
+ var list = s.list;
479
+ var last_li = list[list.length-1];
480
+
481
+ if (last_li[1] instanceof Array && last_li[1][0] == "para") {
482
+ return;
483
+ }
484
+ if (i+1 == stack.length) {
485
+ // Last stack frame
486
+ // Keep the same array, but replace the contents
487
+ last_li.push( ["para"].concat( last_li.splice(1) ) );
488
+ }
489
+ else {
490
+ var sublist = last_li.pop();
491
+ last_li.push( ["para"].concat( last_li.splice(1) ), sublist );
492
+ }
493
+ }
494
+
495
+ // The matcher function
496
+ return function( block, next ) {
497
+ var m = block.match( is_list_re );
498
+ if ( !m ) return undefined;
499
+
500
+ function make_list( m ) {
501
+ var list = bullet_list.exec( m[2] )
502
+ ? ["bulletlist"]
503
+ : ["numberlist"];
504
+
505
+ stack.push( { list: list, indent: m[1] } );
506
+ return list;
507
+ }
508
+
509
+
510
+ var stack = [], // Stack of lists for nesting.
511
+ list = make_list( m ),
512
+ last_li,
513
+ loose = false,
514
+ ret = [ stack[0].list ];
515
+
516
+ // Loop to search over block looking for inner block elements and loose lists
517
+ loose_search:
518
+ while( true ) {
519
+ // Split into lines preserving new lines at end of line
520
+ var lines = block.split( /(?=\n)/ );
521
+
522
+ // We have to grab all lines for a li and call processInline on them
523
+ // once as there are some inline things that can span lines.
524
+ var li_accumulate = "";
525
+
526
+ // Loop over the lines in this block looking for tight lists.
527
+ tight_search:
528
+ for (var line_no=0; line_no < lines.length; line_no++) {
529
+ var nl = "",
530
+ l = lines[line_no].replace(/^\n/, function(n) { nl = n; return "" });
531
+
532
+ // TODO: really should cache this
533
+ var line_re = regex_for_depth( stack.length );
534
+
535
+ m = l.match( line_re );
536
+ //print( "line:", uneval(l), "\nline match:", uneval(m) );
537
+
538
+ // We have a list item
539
+ if ( m[1] !== undefined ) {
540
+ // Process the previous list item, if any
541
+ if ( li_accumulate.length ) {
542
+ add( last_li, loose, this.processInline( li_accumulate ), nl );
543
+ // Loose mode will have been dealt with. Reset it
544
+ loose = false;
545
+ li_accumulate = "";
546
+ }
547
+
548
+ m[1] = expand_tab( m[1] );
549
+ var wanted_depth = Math.floor(m[1].length/4)+1;
550
+ //print( "want:", wanted_depth, "stack:", stack.length);
551
+ if ( wanted_depth > stack.length ) {
552
+ // Deep enough for a nested list outright
553
+ //print ( "new nested list" );
554
+ list = make_list( m );
555
+ last_li.push( list );
556
+ last_li = list[1] = [ "listitem" ];
557
+ }
558
+ else {
559
+ // We aren't deep enough to be strictly a new level. This is
560
+ // where Md.pl goes nuts. If the indent matches a level in the
561
+ // stack, put it there, else put it one deeper then the
562
+ // wanted_depth deserves.
563
+ var found = stack.some(function(s, i) {
564
+ if ( s.indent != m[1] ) return false;
565
+ list = s.list; // Found the level we want
566
+ stack.splice(i+1); // Remove the others
567
+ //print("found");
568
+ return true; // And stop looping
569
+ });
570
+
571
+ if (!found) {
572
+ //print("not found. l:", uneval(l));
573
+ wanted_depth++;
574
+ if (wanted_depth <= stack.length) {
575
+ stack.splice(wanted_depth);
576
+ //print("Desired depth now", wanted_depth, "stack:", stack.length);
577
+ list = stack[wanted_depth-1].list;
578
+ //print("list:", uneval(list) );
579
+ }
580
+ else {
581
+ //print ("made new stack for messy indent");
582
+ list = make_list(m);
583
+ last_li.push(list);
584
+ }
585
+ }
586
+
587
+ //print( uneval(list), "last", list === stack[stack.length-1].list );
588
+ last_li = [ "listitem" ];
589
+ list.push(last_li);
590
+ } // end depth of shenegains
591
+ nl = "";
592
+ }
593
+
594
+ // Add content
595
+ if (l.length > m[0].length) {
596
+ li_accumulate += nl + l.substr( m[0].length );
597
+ }
598
+ } // tight_search
599
+
600
+ if ( li_accumulate.length ) {
601
+ add( last_li, loose, this.processInline( li_accumulate ), nl );
602
+ // Loose mode will have been dealt with. Reset it
603
+ loose = false;
604
+ li_accumulate = "";
605
+ }
606
+
607
+ // Look at the next block - we might have a loose list. Or an extra
608
+ // paragraph for the current li
609
+ var contained = get_contained_blocks( stack.length, next );
610
+
611
+ // Deal with code blocks or properly nested lists
612
+ if (contained.length > 0) {
613
+ // Make sure all listitems up the stack are paragraphs
614
+ stack.forEach( paragraphify, this );
615
+
616
+ last_li.push.apply( last_li, this.toTree( contained, [] ) );
617
+ }
618
+
619
+ var next_block = next[0] && next[0].valueOf() || "";
620
+
621
+ if ( next_block.match(is_list_re) || next_block.match( /^ / ) ) {
622
+ block = next.shift();
623
+
624
+ // Check for an HR following a list: features/lists/hr_abutting
625
+ var hr = this.dialect.block.horizRule( block, next );
626
+
627
+ if (hr) {
628
+ ret.push.apply(ret, hr);
629
+ break;
630
+ }
631
+
632
+ // Make sure all listitems up the stack are paragraphs
633
+ stack.forEach( paragraphify , this );
634
+
635
+ loose = true;
636
+ continue loose_search;
637
+ }
638
+ break;
639
+ } // loose_search
640
+
641
+ return ret;
642
+ }
643
+ })(),
644
+
645
+ blockquote: function blockquote( block, next ) {
646
+ if ( !block.match( /^>/m ) )
647
+ return undefined;
648
+
649
+ var jsonml = [];
650
+
651
+ // separate out the leading abutting block, if any
652
+ if ( block[ 0 ] != ">" ) {
653
+ var lines = block.split( /\n/ ),
654
+ prev = [];
655
+
656
+ // keep shifting lines until you find a crotchet
657
+ while ( lines.length && lines[ 0 ][ 0 ] != ">" ) {
658
+ prev.push( lines.shift() );
659
+ }
660
+
661
+ // reassemble!
662
+ block = lines.join( "\n" );
663
+ jsonml.push.apply( jsonml, this.processBlock( prev.join( "\n" ), [] ) );
664
+ }
665
+
666
+ // if the next block is also a blockquote merge it in
667
+ while ( next.length && next[ 0 ][ 0 ] == ">" ) {
668
+ var b = next.shift();
669
+ block += block.trailing + b;
670
+ block.trailing = b.trailing;
671
+ }
672
+
673
+ // Strip off the leading "> " and re-process as a block.
674
+ var input = block.replace( /^> ?/gm, '' ),
675
+ old_tree = this.tree;
676
+ jsonml.push( this.toTree( input, [ "blockquote" ] ) );
677
+
678
+ return jsonml;
679
+ },
680
+
681
+ referenceDefn: function referenceDefn( block, next) {
682
+ var re = /^\s*\[(.*?)\]:\s*(\S+)(?:\s+(?:(['"])(.*?)\3|\((.*?)\)))?\n?/;
683
+ // interesting matches are [ , ref_id, url, , title, title ]
684
+
685
+ if ( !block.match(re) )
686
+ return undefined;
687
+
688
+ // make an attribute node if it doesn't exist
689
+ if ( !extract_attr( this.tree ) ) {
690
+ this.tree.splice( 1, 0, {} );
691
+ }
692
+
693
+ var attrs = extract_attr( this.tree );
694
+
695
+ // make a references hash if it doesn't exist
696
+ if ( attrs.references === undefined ) {
697
+ attrs.references = {};
698
+ }
699
+
700
+ var b = this.loop_re_over_block(re, block, function( m ) {
701
+
702
+ if ( m[2] && m[2][0] == '<' && m[2][m[2].length-1] == '>' )
703
+ m[2] = m[2].substring( 1, m[2].length - 1 );
704
+
705
+ var ref = attrs.references[ m[1].toLowerCase() ] = {
706
+ href: m[2]
707
+ };
708
+
709
+ if (m[4] !== undefined)
710
+ ref.title = m[4];
711
+ else if (m[5] !== undefined)
712
+ ref.title = m[5];
713
+
714
+ } );
715
+
716
+ if (b.length)
717
+ next.unshift( mk_block( b, block.trailing ) );
718
+
719
+ return [];
720
+ },
721
+
722
+ para: function para( block, next ) {
723
+ // everything's a para!
724
+ return [ ["para"].concat( this.processInline( block ) ) ];
725
+ }
726
+ }
727
+ }
728
+
729
+ Markdown.dialects.Gruber.inline = {
730
+ __call__: function inline( text, patterns ) {
731
+ // Hmmm - should this function be directly in Md#processInline, or
732
+ // conversely, should Md#processBlock be moved into block.__call__ too
733
+ var out = [ ],
734
+ m,
735
+ // Look for the next occurange of a special character/pattern
736
+ re = new RegExp( "([\\s\\S]*?)(" + (patterns.source || patterns) + ")", "g" ),
737
+ lastIndex = 0;
738
+
739
+ //D:var self = this;
740
+ //D:self.debug("processInline:", uneval(text) );
741
+ function add(x) {
742
+ //D:self.debug(" adding output", uneval(x));
743
+ if (typeof x == "string" && typeof out[out.length-1] == "string")
744
+ out[ out.length-1 ] += x;
745
+ else
746
+ out.push(x);
747
+ }
748
+
749
+ while ( ( m = re.exec(text) ) != null) {
750
+ if ( m[1] ) add( m[1] ); // Some un-interesting text matched
751
+ else m[1] = { length: 0 }; // Or there was none, but make m[1].length == 0
752
+
753
+ var res;
754
+ if ( m[2] in this.dialect.inline ) {
755
+ res = this.dialect.inline[ m[2] ].call(
756
+ this,
757
+ text.substr( m.index + m[1].length ), m, out );
758
+ }
759
+ // Default for now to make dev easier. just slurp special and output it.
760
+ res = res || [ m[2].length, m[2] ];
761
+
762
+ var len = res.shift();
763
+ // Update how much input was consumed
764
+ re.lastIndex += ( len - m[2].length );
765
+
766
+ // Add children
767
+ res.forEach(add);
768
+
769
+ lastIndex = re.lastIndex;
770
+ }
771
+
772
+ // Add last 'boring' chunk
773
+ if ( text.length > lastIndex )
774
+ add( text.substr( lastIndex ) );
775
+
776
+ return out;
777
+ },
778
+
779
+ "\\": function escaped( text ) {
780
+ // [ length of input processed, node/children to add... ]
781
+ // Only esacape: \ ` * _ { } [ ] ( ) # * + - . !
782
+ if ( text.match( /^\\[\\`\*_{}\[\]()#\+.!\-]/ ) )
783
+ return [ 2, text[1] ];
784
+ else
785
+ // Not an esacpe
786
+ return [ 1, "\\" ];
787
+ },
788
+
789
+ "![": function image( text ) {
790
+ // ![Alt text](/path/to/img.jpg "Optional title")
791
+ // 1 2 3 4 <--- captures
792
+ var m = text.match( /^!\[(.*?)\][ \t]*\([ \t]*(\S*)(?:[ \t]+(["'])(.*?)\3)?[ \t]*\)/ );
793
+
794
+ if ( m ) {
795
+ if ( m[2] && m[2][0] == '<' && m[2][m[2].length-1] == '>' )
796
+ m[2] = m[2].substring( 1, m[2].length - 1 );
797
+
798
+ m[2] == this.dialect.inline.__call__.call( this, m[2], /\\/ )[0];
799
+
800
+ var attrs = { alt: m[1], href: m[2] || "" };
801
+ if ( m[4] !== undefined)
802
+ attrs.title = m[4];
803
+
804
+ return [ m[0].length, [ "img", attrs ] ];
805
+ }
806
+
807
+ // ![Alt text][id]
808
+ m = text.match( /^!\[(.*?)\][ \t]*\[(.*?)\]/ );
809
+
810
+ if ( m ) {
811
+ // We can't check if the reference is known here as it likely wont be
812
+ // found till after. Check it in md tree->hmtl tree conversion
813
+ return [ m[0].length, [ "img_ref", { alt: m[1], ref: m[2].toLowerCase(), text: m[0] } ] ];
814
+ }
815
+
816
+ // Just consume the '!['
817
+ return [ 2, "![" ];
818
+ },
819
+
820
+ "[": function link( text ) {
821
+ // [link text](/path/to/img.jpg "Optional title")
822
+ // 1 2 3 4 <--- captures
823
+ var m = text.match( /^\[([\s\S]*?)\][ \t]*\([ \t]*(\S+)(?:[ \t]+(["'])(.*?)\3)?[ \t]*\)/ );
824
+
825
+ if ( m ) {
826
+ if ( m[2] && m[2][0] == '<' && m[2][m[2].length-1] == '>' )
827
+ m[2] = m[2].substring( 1, m[2].length - 1 );
828
+
829
+ // Process escapes only
830
+ m[2] = this.dialect.inline.__call__.call( this, m[2], /\\/ )[0];
831
+
832
+ var attrs = { href: m[2] || "" };
833
+ if ( m[4] !== undefined)
834
+ attrs.title = m[4];
835
+
836
+ var link = [ "link", attrs ];
837
+ Array.prototype.push.apply( link, this.processInline( m[1] ) );
838
+ return [ m[0].length, link ];
839
+ }
840
+
841
+ // [Alt text][id]
842
+ // [Alt text] [id]
843
+ // [id]
844
+ m = text.match( /^\[([\s\S]*?)\](?: ?\[(.*?)\])?/ );
845
+
846
+ if ( m ) {
847
+ // [id] case, text == id
848
+ if ( m[2] === undefined || m[2] === "" ) m[2] = m[1];
849
+
850
+ attrs = { ref: m[ 2 ].toLowerCase(), original: m[ 0 ] };
851
+ link = [ "link_ref", attrs ];
852
+ Array.prototype.push.apply( link, this.processInline( m[1] ) );
853
+
854
+ // We can't check if the reference is known here as it likely wont be
855
+ // found till after. Check it in md tree->hmtl tree conversion.
856
+ // Store the original so that conversion can revert if the ref isn't found.
857
+ return [
858
+ m[ 0 ].length,
859
+ link
860
+ ];
861
+ }
862
+
863
+ // Just consume the '['
864
+ return [ 1, "[" ];
865
+ },
866
+
867
+
868
+ "<": function autoLink( text ) {
869
+ var m;
870
+
871
+ if ( ( m = text.match( /^<(?:((https?|ftp|mailto):[^>]+)|(.*?@.*?\.[a-zA-Z]+))>/ ) ) != null ) {
872
+ if ( m[3] ) {
873
+ return [ m[0].length, [ "link", { href: "mailto:" + m[3] }, m[3] ] ];
874
+
875
+ }
876
+ else if ( m[2] == "mailto" ) {
877
+ return [ m[0].length, [ "link", { href: m[1] }, m[1].substr("mailto:".length ) ] ];
878
+ }
879
+ else
880
+ return [ m[0].length, [ "link", { href: m[1] }, m[1] ] ];
881
+ }
882
+
883
+ return [ 1, "<" ];
884
+ },
885
+
886
+ "`": function inlineCode( text ) {
887
+ // Inline code block. as many backticks as you like to start it
888
+ // Always skip over the opening ticks.
889
+ var m = text.match( /(`+)(([\s\S]*?)\1)/ );
890
+
891
+ if ( m && m[2] )
892
+ return [ m[1].length + m[2].length, [ "inlinecode", m[3] ] ];
893
+ else {
894
+ // TODO: No matching end code found - warn!
895
+ return [ 1, "`" ];
896
+ }
897
+ },
898
+
899
+ " \n": function lineBreak( text ) {
900
+ return [ 3, [ "linebreak" ] ];
901
+ }
902
+
903
+ }
904
+
905
+ // Meta Helper/generator method for em and strong handling
906
+ function strong_em( tag, md ) {
907
+
908
+ var state_slot = tag + "_state",
909
+ other_slot = tag == "strong" ? "em_state" : "strong_state";
910
+
911
+ function CloseTag(len) {
912
+ this.len_after = len;
913
+ this.name = "close_" + md;
914
+ }
915
+
916
+ return function ( text, orig_match ) {
917
+
918
+ if (this[state_slot][0] == md) {
919
+ // Most recent em is of this type
920
+ //D:this.debug("closing", md);
921
+ this[state_slot].shift();
922
+
923
+ // "Consume" everything to go back to the recrusion in the else-block below
924
+ return[ text.length, new CloseTag(text.length-md.length) ];
925
+ }
926
+ else {
927
+ // Store a clone of the em/strong states
928
+ var other = this[other_slot].slice(),
929
+ state = this[state_slot].slice();
930
+
931
+ this[state_slot].unshift(md);
932
+
933
+ //D:this.debug_indent += " ";
934
+
935
+ // Recurse
936
+ var res = this.processInline( text.substr( md.length ) );
937
+ //D:this.debug_indent = this.debug_indent.substr(2);
938
+
939
+ var last = res[res.length - 1];
940
+
941
+ //D:this.debug("processInline from", tag + ": ", uneval( res ) );
942
+
943
+ var check = this[state_slot].shift();
944
+ if (last instanceof CloseTag) {
945
+ res.pop();
946
+ // We matched! Huzzah.
947
+ var consumed = text.length - last.len_after;
948
+ return [ consumed, [ tag ].concat(res) ];
949
+ }
950
+ else {
951
+ // Restore the state of the other kind. We might have mistakenly closed it.
952
+ this[other_slot] = other;
953
+ this[state_slot] = state;
954
+
955
+ // We can't reuse the processed result as it could have wrong parsing contexts in it.
956
+ return [ md.length, md ];
957
+ }
958
+ }
959
+ } // End returned function
960
+ }
961
+
962
+ Markdown.dialects.Gruber.inline["**"] = strong_em("strong", "**");
963
+ Markdown.dialects.Gruber.inline["__"] = strong_em("strong", "__");
964
+ Markdown.dialects.Gruber.inline["*"] = strong_em("em", "*");
965
+ Markdown.dialects.Gruber.inline["_"] = strong_em("em", "_");
966
+
967
+
968
+ // Build default order from insertion order.
969
+ Markdown.buildBlockOrder = function(d) {
970
+ var ord = [];
971
+ for ( var i in d ) {
972
+ if ( i == "__order__" || i == "__call__" ) continue;
973
+ ord.push( i );
974
+ }
975
+ d.__order__ = ord;
976
+ }
977
+
978
+ // Build patterns for inline matcher
979
+ Markdown.buildInlinePatterns = function(d) {
980
+ var patterns = [];
981
+
982
+ for ( var i in d ) {
983
+ if (i == "__call__") continue;
984
+ var l = i.replace( /([\\.*+?|()\[\]{}])/g, "\\$1" )
985
+ .replace( /\n/, "\\n" );
986
+ patterns.push( i.length == 1 ? l : "(?:" + l + ")" );
987
+ }
988
+
989
+ patterns = patterns.join("|");
990
+ //print("patterns:", uneval( patterns ) );
991
+
992
+ var fn = d.__call__;
993
+ d.__call__ = function(text, pattern) {
994
+ if (pattern != undefined)
995
+ return fn.call(this, text, pattern);
996
+ else
997
+ return fn.call(this, text, patterns);
998
+ }
999
+ }
1000
+
1001
+ // Helper function to make sub-classing a dialect easier
1002
+ Markdown.subclassDialect = function( d ) {
1003
+ function Block() {};
1004
+ Block.prototype = d.block;
1005
+ function Inline() {};
1006
+ Inline.prototype = d.inline;
1007
+
1008
+ return { block: new Block(), inline: new Inline() };
1009
+ }
1010
+
1011
+ Markdown.buildBlockOrder ( Markdown.dialects.Gruber.block );
1012
+ Markdown.buildInlinePatterns( Markdown.dialects.Gruber.inline );
1013
+
1014
+ Markdown.dialects.Maruku = Markdown.subclassDialect( Markdown.dialects.Gruber );
1015
+
1016
+ Markdown.dialects.Maruku.block.document_meta = function document_meta( block, next ) {
1017
+ // we're only interested in the first block
1018
+ if ( block.lineNumber > 1 ) return undefined;
1019
+
1020
+ // document_meta blocks consist of one or more lines of `Key: Value\n`
1021
+ if ( ! block.match( /^(?:\w+:.*\n)*\w+:.*$/ ) ) return undefined;
1022
+
1023
+ // make an attribute node if it doesn't exist
1024
+ if ( !extract_attr( this.tree ) ) {
1025
+ this.tree.splice( 1, 0, {} );
1026
+ }
1027
+
1028
+ var pairs = block.split( /\n/ );
1029
+ for ( p in pairs ) {
1030
+ var m = pairs[ p ].match( /(\w+):\s*(.*)$/ ),
1031
+ key = m[ 1 ].toLowerCase(),
1032
+ value = m[ 2 ];
1033
+
1034
+ this.tree[ 1 ][ key ] = value;
1035
+ }
1036
+
1037
+ // document_meta produces no content!
1038
+ return [];
1039
+ }
1040
+
1041
+ Markdown.dialects.Maruku.block.block_meta = function block_meta( block, next ) {
1042
+ // check if the last line of the block is an meta hash
1043
+ var m = block.match( /(^|\n) {0,3}\{:\s*((?:\\\}|[^\}])*)\s*\}$/ );
1044
+ if ( !m ) return undefined;
1045
+
1046
+ // process the meta hash
1047
+ var attr = process_meta_hash( m[ 2 ] );
1048
+
1049
+ // if we matched ^ then we need to apply meta to the previous block
1050
+ if ( m[ 1 ] === "" ) {
1051
+ var node = this.tree[ this.tree.length - 1 ],
1052
+ hash = extract_attr( node );
1053
+
1054
+ // if the node is a string (rather than JsonML), bail
1055
+ if ( typeof node === "string" ) return undefined;
1056
+
1057
+ // create the attribute hash if it doesn't exist
1058
+ if ( !hash ) {
1059
+ hash = {};
1060
+ node.splice( 1, 0, hash );
1061
+ }
1062
+
1063
+ // add the attributes in
1064
+ for ( a in attr ) {
1065
+ hash[ a ] = attr[ a ];
1066
+ }
1067
+
1068
+ // return nothing so the meta hash is removed
1069
+ return [];
1070
+ }
1071
+
1072
+ // pull the meta hash off the block and process what's left
1073
+ var b = block.replace( /\n.*$/, "" ),
1074
+ result = this.processBlock( b, [] );
1075
+
1076
+ // get or make the attributes hash
1077
+ var hash = extract_attr( result[ 0 ] );
1078
+ if ( !hash ) {
1079
+ hash = {};
1080
+ result[ 0 ].splice( 1, 0, hash );
1081
+ }
1082
+
1083
+ // attach the attributes to the block
1084
+ for ( a in attr ) {
1085
+ hash[ a ] = attr[ a ];
1086
+ }
1087
+
1088
+ return result;
1089
+ }
1090
+
1091
+ Markdown.dialects.Maruku.block.definition_list = function definition_list( block, next ) {
1092
+ // one or more terms followed by one or more definitions, in a single block
1093
+ var tight = /^((?:[^\s:].*\n)+):\s+([^]+)$/,
1094
+ list = [ "dl" ];
1095
+
1096
+ // see if we're dealing with a tight or loose block
1097
+ if ( ( m = block.match( tight ) ) ) {
1098
+ // pull subsequent tight DL blocks out of `next`
1099
+ var blocks = [ block ];
1100
+ while ( next.length && tight.exec( next[ 0 ] ) ) {
1101
+ blocks.push( next.shift() );
1102
+ }
1103
+
1104
+ for ( var b = 0; b < blocks.length; ++b ) {
1105
+ var m = blocks[ b ].match( tight ),
1106
+ terms = m[ 1 ].replace( /\n$/, "" ).split( /\n/ ),
1107
+ defns = m[ 2 ].split( /\n:\s+/ );
1108
+
1109
+ // print( uneval( m ) );
1110
+
1111
+ for ( var i = 0; i < terms.length; ++i ) {
1112
+ list.push( [ "dt", terms[ i ] ] );
1113
+ }
1114
+
1115
+ for ( var i = 0; i < defns.length; ++i ) {
1116
+ // run inline processing over the definition
1117
+ list.push( [ "dd" ].concat( this.processInline( defns[ i ].replace( /(\n)\s+/, "$1" ) ) ) );
1118
+ }
1119
+ }
1120
+ }
1121
+ else {
1122
+ return undefined;
1123
+ }
1124
+
1125
+ return [ list ];
1126
+ }
1127
+
1128
+ Markdown.dialects.Maruku.inline[ "{:" ] = function inline_meta( text, matches, out ) {
1129
+ if ( !out.length ) {
1130
+ return [ 2, "{:" ];
1131
+ }
1132
+
1133
+ // get the preceeding element
1134
+ var before = out[ out.length - 1 ];
1135
+
1136
+ if ( typeof before === "string" ) {
1137
+ return [ 2, "{:" ];
1138
+ }
1139
+
1140
+ // match a meta hash
1141
+ var m = text.match( /^\{:\s*((?:\\\}|[^\}])*)\s*\}/ );
1142
+
1143
+ // no match, false alarm
1144
+ if ( !m ) {
1145
+ return [ 2, "{:" ];
1146
+ }
1147
+
1148
+ // attach the attributes to the preceeding element
1149
+ var meta = process_meta_hash( m[ 1 ] ),
1150
+ attr = extract_attr( before );
1151
+
1152
+ if ( !attr ) {
1153
+ attr = {};
1154
+ before.splice( 1, 0, attr );
1155
+ }
1156
+
1157
+ for ( var k in meta ) {
1158
+ attr[ k ] = meta[ k ];
1159
+ }
1160
+
1161
+ // cut out the string and replace it with nothing
1162
+ return [ m[ 0 ].length, "" ];
1163
+ }
1164
+
1165
+ Markdown.buildBlockOrder ( Markdown.dialects.Maruku.block );
1166
+ Markdown.buildInlinePatterns( Markdown.dialects.Maruku.inline );
1167
+
1168
+ var isArray = expose.isArray = function(obj) {
1169
+ return (obj instanceof Array || typeof obj === "array" || Array.isArray(obj));
1170
+ }
1171
+
1172
+ function extract_attr( jsonml ) {
1173
+ return isArray(jsonml)
1174
+ && jsonml.length > 1
1175
+ && typeof jsonml[ 1 ] === "object"
1176
+ && !( isArray(jsonml[ 1 ]) )
1177
+ ? jsonml[ 1 ]
1178
+ : undefined;
1179
+ }
1180
+
1181
+ function process_meta_hash( meta_string ) {
1182
+ var meta = split_meta_hash( meta_string ),
1183
+ attr = {};
1184
+
1185
+ for ( var i = 0; i < meta.length; ++i ) {
1186
+ // id: #foo
1187
+ if ( /^#/.test( meta[ i ] ) ) {
1188
+ attr.id = meta[ i ].substring( 1 );
1189
+ }
1190
+ // class: .foo
1191
+ else if ( /^\./.test( meta[ i ] ) ) {
1192
+ // if class already exists, append the new one
1193
+ if ( attr['class'] ) {
1194
+ attr['class'] = attr['class'] + meta[ i ].replace( /./, " " );
1195
+ }
1196
+ else {
1197
+ attr['class'] = meta[ i ].substring( 1 );
1198
+ }
1199
+ }
1200
+ // attribute: foo=bar
1201
+ else if ( /\=/.test( meta[ i ] ) ) {
1202
+ var s = meta[ i ].split( /\=/ );
1203
+ attr[ s[ 0 ] ] = s[ 1 ];
1204
+ }
1205
+ }
1206
+
1207
+ return attr;
1208
+ }
1209
+
1210
+ function split_meta_hash( meta_string ) {
1211
+ var meta = meta_string.split( "" ),
1212
+ parts = [ "" ],
1213
+ in_quotes = false;
1214
+
1215
+ while ( meta.length ) {
1216
+ var letter = meta.shift();
1217
+ switch ( letter ) {
1218
+ case " " :
1219
+ // if we're in a quoted section, keep it
1220
+ if ( in_quotes ) {
1221
+ parts[ parts.length - 1 ] += letter;
1222
+ }
1223
+ // otherwise make a new part
1224
+ else {
1225
+ parts.push( "" );
1226
+ }
1227
+ break;
1228
+ case "'" :
1229
+ case '"' :
1230
+ // reverse the quotes and move straight on
1231
+ in_quotes = !in_quotes;
1232
+ break;
1233
+ case "\\" :
1234
+ // shift off the next letter to be used straight away.
1235
+ // it was escaped so we'll keep it whatever it is
1236
+ letter = meta.shift();
1237
+ default :
1238
+ parts[ parts.length - 1 ] += letter;
1239
+ break;
1240
+ }
1241
+ }
1242
+
1243
+ return parts;
1244
+ }
1245
+
1246
+ /**
1247
+ * renderJsonML( jsonml[, options] ) -> String
1248
+ * - jsonml (Array): JsonML array to render to XML
1249
+ * - options (Object): options
1250
+ *
1251
+ * Converts the given JsonML into well-formed XML.
1252
+ *
1253
+ * The options currently understood are:
1254
+ *
1255
+ * - root (Boolean): wether or not the root node should be included in the
1256
+ * output, or just its children. The default `false` is to not include the
1257
+ * root itself.
1258
+ */
1259
+ expose.renderJsonML = function( jsonml, options ) {
1260
+ options = options || {};
1261
+ // include the root element in the rendered output?
1262
+ options.root = options.root || false;
1263
+
1264
+ var content = [];
1265
+
1266
+ if ( options.root ) {
1267
+ content.push( render_tree( jsonml ) );
1268
+ }
1269
+ else {
1270
+ jsonml.shift(); // get rid of the tag
1271
+ if ( jsonml.length && typeof jsonml[ 0 ] === "object" && !( jsonml[ 0 ] instanceof Array ) ) {
1272
+ jsonml.shift(); // get rid of the attributes
1273
+ }
1274
+
1275
+ while ( jsonml.length ) {
1276
+ content.push( render_tree( jsonml.shift() ) );
1277
+ }
1278
+ }
1279
+
1280
+ return content.join( "\n\n" );
1281
+ }
1282
+
1283
+ function escapeHTML( text ) {
1284
+ return text.replace( /&/g, "&amp;" )
1285
+ .replace( /</g, "&lt;" )
1286
+ .replace( />/g, "&gt;" )
1287
+ .replace( /"/g, "&quot;" )
1288
+ .replace( /'/g, "&#39;" );
1289
+ }
1290
+
1291
+ function render_tree( jsonml ) {
1292
+ // basic case
1293
+ if ( typeof jsonml === "string" ) {
1294
+ return escapeHTML( jsonml );
1295
+ }
1296
+
1297
+ var tag = jsonml.shift(),
1298
+ attributes = {},
1299
+ content = [];
1300
+
1301
+ if ( jsonml.length && typeof jsonml[ 0 ] === "object" && !( jsonml[ 0 ] instanceof Array ) ) {
1302
+ attributes = jsonml.shift();
1303
+ }
1304
+
1305
+ while ( jsonml.length ) {
1306
+ content.push( arguments.callee( jsonml.shift() ) );
1307
+ }
1308
+
1309
+ var tag_attrs = "";
1310
+ for ( var a in attributes ) {
1311
+ tag_attrs += " " + a + '="' + escapeHTML( attributes[ a ] ) + '"';
1312
+ }
1313
+
1314
+ // be careful about adding whitespace here for inline elements
1315
+ if ( tag == "img" || tag == "br" || tag == "hr" ) {
1316
+ return "<"+ tag + tag_attrs + "/>"
1317
+ } else {
1318
+ return "<"+ tag + tag_attrs + ">" + content.join( "" ) + "</" + tag + ">";
1319
+ }
1320
+ }
1321
+
1322
+ function convert_tree_to_html( tree, references, options ) {
1323
+ options = options || {};
1324
+
1325
+ // shallow clone
1326
+ var jsonml = tree.slice( 0 );
1327
+
1328
+ if (typeof options.preprocessTreeNode === "function") {
1329
+ jsonml = options.preprocessTreeNode(jsonml, references);
1330
+ }
1331
+
1332
+ // Clone attributes if they exist
1333
+ var attrs = extract_attr( jsonml );
1334
+ if ( attrs ) {
1335
+ jsonml[ 1 ] = {};
1336
+ for ( var i in attrs ) {
1337
+ jsonml[ 1 ][ i ] = attrs[ i ];
1338
+ }
1339
+ attrs = jsonml[ 1 ];
1340
+ }
1341
+
1342
+ // basic case
1343
+ if ( typeof jsonml === "string" ) {
1344
+ return jsonml;
1345
+ }
1346
+
1347
+ // convert this node
1348
+ switch ( jsonml[ 0 ] ) {
1349
+ case "header":
1350
+ jsonml[ 0 ] = "h" + jsonml[ 1 ].level;
1351
+ delete jsonml[ 1 ].level;
1352
+ break;
1353
+ case "bulletlist":
1354
+ jsonml[ 0 ] = "ul";
1355
+ break;
1356
+ case "numberlist":
1357
+ jsonml[ 0 ] = "ol";
1358
+ break;
1359
+ case "listitem":
1360
+ jsonml[ 0 ] = "li";
1361
+ break;
1362
+ case "para":
1363
+ jsonml[ 0 ] = "p";
1364
+ break;
1365
+ case "markdown":
1366
+ jsonml[ 0 ] = "html";
1367
+ if ( attrs ) delete attrs.references;
1368
+ break;
1369
+ case "code_block":
1370
+ jsonml[ 0 ] = "pre";
1371
+ var i = attrs ? 2 : 1;
1372
+ var code = [ "code" ];
1373
+ code.push.apply( code, jsonml.splice( i ) );
1374
+ jsonml[ i ] = code;
1375
+ break;
1376
+ case "inlinecode":
1377
+ jsonml[ 0 ] = "code";
1378
+ break;
1379
+ case "img":
1380
+ jsonml[ 1 ].src = jsonml[ 1 ].href;
1381
+ delete jsonml[ 1 ].href;
1382
+ break;
1383
+ case "linebreak":
1384
+ jsonml[0] = "br";
1385
+ break;
1386
+ case "link":
1387
+ jsonml[ 0 ] = "a";
1388
+ break;
1389
+ case "link_ref":
1390
+ jsonml[ 0 ] = "a";
1391
+
1392
+ // grab this ref and clean up the attribute node
1393
+ var ref = references[ attrs.ref ];
1394
+
1395
+ // if the reference exists, make the link
1396
+ if ( ref ) {
1397
+ delete attrs.ref;
1398
+
1399
+ // add in the href and title, if present
1400
+ attrs.href = ref.href;
1401
+ if ( ref.title ) {
1402
+ attrs.title = ref.title;
1403
+ }
1404
+
1405
+ // get rid of the unneeded original text
1406
+ delete attrs.original;
1407
+ }
1408
+ // the reference doesn't exist, so revert to plain text
1409
+ else {
1410
+ return attrs.original;
1411
+ }
1412
+ break;
1413
+ }
1414
+
1415
+ // convert all the children
1416
+ var i = 1;
1417
+
1418
+ // deal with the attribute node, if it exists
1419
+ if ( attrs ) {
1420
+ // if there are keys, skip over it
1421
+ for ( var key in jsonml[ 1 ] ) {
1422
+ i = 2;
1423
+ }
1424
+ // if there aren't, remove it
1425
+ if ( i === 1 ) {
1426
+ jsonml.splice( i, 1 );
1427
+ }
1428
+ }
1429
+
1430
+ for ( ; i < jsonml.length; ++i ) {
1431
+ jsonml[ i ] = arguments.callee( jsonml[ i ], references, options );
1432
+ }
1433
+
1434
+ return jsonml;
1435
+ }
1436
+
1437
+
1438
+ // merges adjacent text nodes into a single node
1439
+ function merge_text_nodes( jsonml ) {
1440
+ // skip the tag name and attribute hash
1441
+ var i = extract_attr( jsonml ) ? 2 : 1;
1442
+
1443
+ while ( i < jsonml.length ) {
1444
+ // if it's a string check the next item too
1445
+ if ( typeof jsonml[ i ] === "string" ) {
1446
+ if ( i + 1 < jsonml.length && typeof jsonml[ i + 1 ] === "string" ) {
1447
+ // merge the second string into the first and remove it
1448
+ jsonml[ i ] += jsonml.splice( i + 1, 1 )[ 0 ];
1449
+ }
1450
+ else {
1451
+ ++i;
1452
+ }
1453
+ }
1454
+ // if it's not a string recurse
1455
+ else {
1456
+ arguments.callee( jsonml[ i ] );
1457
+ ++i;
1458
+ }
1459
+ }
1460
+ }
1461
+
1462
+ } )( (function() {
1463
+ if ( typeof exports === "undefined" ) {
1464
+ window.markdown = {};
1465
+ return window.markdown;
1466
+ }
1467
+ else {
1468
+ return exports;
1469
+ }
1470
+ } )() );