breakout_parser 0.0.23 → 0.0.31

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTU3NTk2NGQ1ZTEyMjFlOTFiYmI4NDY0ZDIzOWFkNzRiMTFiNTdiYQ==
+  data.tar.gz: !binary |-
+    OGMwYTA0YjBiOTI2MDZmODc2M2NkYjk2OTQzN2QzMWI0NTg4OTlmMQ==
+SHA512:
+  metadata.gz: !binary |-
+    MjIzYjUyMzE3ZTE3MWIxMDIxMzgzMmJhYWI1ZTk0ZmQyZGQ1YmU5NDFhMzdm
+    NWUxODM5MzhmZTg0YjEzODg5MGFkMWFiODE0ZDgzN2EyYTY5ZTk5MTBhMTA3
+    Zjk2NzJhYzM4YzI4NmM0ZGY3NzcwN2ZkZDczMTY1YjgyMzM0MmE=
+  data.tar.gz: !binary |-
+    Nzk1MGE5YTVlYzY4NDJjZTI4YTE0NjYxYmE4ZWRkYmRjNDJmOWExNzA5MzQ5
+    YjkwMDRkNTQxMWJlZDc1NGQ1ODJmYTc0ZjViZjRjZGYyYWM4NGMxYTQwZWNj
+    NzA5MzY0NDlmYzQ5MmY5ZjY2MjU0ZGIyMzk3ZjIwNDA2MDBmZTk=

data/ChangeLog

@@ -1,3 +1,22 @@
+    * Rollback code that leaks RAM for LI processing
+    * Fixed RAM leaks in process_snippet_link()
+
+[ 0.0.30 ]
+    * added ability to chain unordered lists inside ordered lists and vice-versa
+    * added ability to insert ordered lists that use letters instead numbers (with '%' instead '#')
+
+[ 0.0.29 ]
+    * fixed unescaped characters in URL links
+
+[ 0.0.28 ]
+    * fixed bold or italic texts at the beginning or (un)ordered lists
+
+[ 0.0.26 ]
+    * fixed list parser for multilevel lists
+
+[ 0.0.24 ]
+    * Ruby 1.9.3 compatibility
+
 [ 0.0.21 ]
     * emit correct urls for external svn links
         (https://www.assembla.com/spaces/breakout/tickets/8472)

data/README

@@ -1,5 +1,5 @@
-Breakout Parser 
-=============== 
+Breakout Parser
+===============
 
  - simplified Textile parser with some Assembla-specific features
  - converts Textile into HTML
@@ -7,27 +7,39 @@ Breakout Parser
 Build dependencies
 ==================
 
-You will need Flex, Bison, GCC, and GNU Make to build this gem.
+  - You will need Flex, Bison, GCC, and GNU Make to build this gem.
+
+Development
+================
+
+  Compiling and testing
+    - just run 'rake' in the repos root dir
 
+  Just compiling
+    - just run 'rake build_ext'
+
+  Testing
+    - just run 'rspec' or 'rspec spec/'
 
 Usage
 ===============
 
   require 'breakout_parser'
-  puts BreakoutParser.parse("h1. xxx", "my_space") 
+  puts BreakoutParser.parse("h1. xxx", "my_space")
   # prints: <h1 id="h-xxx">xxx</h1>
 
-  puts BreakoutParser.parse_links_only("h1. http://xxx", "my_space") 
+  puts BreakoutParser.parse_links_only("h1. http://xxx", "my_space")
   # prints: h1. <a rel="nofollow" href="http://xxx">http://xxx</a>
 
-  
-
 Arguments
 ===============
 
   BreakoutParser.parse(
-  	data,			# data to parse
-	space_name,		# space name - for links parsing
-	site_url,		# [optional] global site url
-	vcs_url			# [optional] custom VCS url - f.ex. for github-hosted repos
+    data,			# data to parse
+    space_name,		# space name - for links parsing
+    site_url,		# [optional] global site url
+    vcs_url,			# [optional] custom VCS url - f.ex. for github-hosted repos
+    absolute_urls, # [optional] boolean value that denotes if URLs have to be absolute
+    large_files_url, # [optional] URL used for large files (i.e. when using ADN/CDN)
+    data_attributes, # [optional] hash of data attributes that would be added to links
   )

data/ext/breakout_parser/extconf.rb

@@ -12,12 +12,17 @@ dir_config(extension_name)
 if RUBY_PLATFORM['mswin32']
   $defs << "-MT" # link statically - avoid usage of MSVCR90.dll
 end
+
+# Add RUBY_19 constant if it's Ruby 1.9
+if RUBY_VERSION =~ /1.9/ then
+    $CPPFLAGS += " -DRUBY_19"
+end
 create_makefile(([extension_name]*2).join('/'))
 
 def check_version name, need_ver
   exe = find_executable name
   return false unless exe
-  exe_ver = `#{exe} -V`[/\d+\.\d+\.\d+/]
+  exe_ver = `#{exe} -V`[/\d+\.\d+(\.\d+)?/]
   unless exe_ver
     puts "[?] cannot determine #{name} version"
     return false
@@ -27,20 +32,20 @@ def check_version name, need_ver
   r = (exe_ver[0] > need_ver[0]) || (
     (exe_ver[0] == need_ver[0]) && (
        (exe_ver[1] > need_ver[1]) ||
-       (exe_ver[1] == need_ver[1] && exe_ver[2] >= need_ver[2])
+       (exe_ver[1] == need_ver[1] && (exe_ver[2] || 0) >= need_ver[2])
     )
   )
   puts "[-] wanted #{name} >= #{need_ver.join('.')}, but got only #{exe_ver.join('.')}" unless r
   r
 end
 
-if !windows && File.exist?('Makefile') && check_version('bison','2.4.0') && check_version('lex','2.5.30')
+if !windows && File.exist?('Makefile') && check_version('bison','2.3.0') && check_version('lex','2.5.30')
   File.open('Makefile','a') do |f|
     f.puts
     f.puts "parser.tab.c parser.tab.h: parser.y"
-    f.puts "\tbison -d parser.y"
+    f.puts "\tbison -d $(srcdir)/parser.y"
     f.puts
     f.puts "lex.yy.c: parser.l"
-    f.puts "\tlex parser.l"
+    f.puts "\tflex $(srcdir)/parser.l"
   end
 end

data/ext/breakout_parser/parser.h

@@ -0,0 +1,27 @@
+void process_url(const char *url);
+void process_email(const char *url);
+void process_inline_code(const char *p);
+void revert_bold();
+void revert_italic();
+void process_ticket_link(const char *ticket_id);
+void process_svn_link(const char *target, int numbered_repo);
+void process_git_link(const char *target, int numbered_repo);
+void process_url_link(const char *target,const char *proto);
+void process_wiki_link(const char *target);
+void process_anchor_link(const char *target);
+void process_file_link(const char *target);
+void process_image_link(const char *target);
+void process_snippet_link(const char *space_id_and_snippet_id);
+void concat_escaped_char(int c);
+void process_header(const char *title);
+int closing_list_stack_push(const char * term);
+const char * closing_list_stack_pop();
+void close_opened_lists();
+void process_list_item(int level, int type);
+const char *unconcat(const char *term);
+int is_ending_with(const char *term);
+void concat_raw_char(int c);
+int concat_custom_vcs_url(const char *rev);
+void set_numeric_ticket_id(const char *ticket_id, char *numeric_ticket_id);
+void process_data_attributes(char *ticket_id);
+void add_data_attribute(char *name, char *value);

data/ext/breakout_parser/parser.l

@@ -113,7 +113,7 @@ extern size_t in_buf_len;
 [ \t]+@[^\r\n\xff@]+@/[ \t\r\n,.\xff] { yylval.svalue = yytext; return INLINE_CODE; }
 
 ^h[1-5]\.[ \t]+[^ \t\r\n][^\r\n]*/[\r\n\xff] {
-    yylval.svalue = yytext+4; 
+    yylval.svalue = yytext+4;
     switch(yytext[1]){
         case '1': return H1;
         case '2': return H2;
@@ -121,17 +121,31 @@ extern size_t in_buf_len;
         case '4': return H4;
         case '5': return H5;
     }
-    return H1; 
+    return H1;
 }
 
-^[ \t]*\*\*\*[ ]+          { yylval.ivalue=3; return ULI; }
-^[ \t]*\*\*[ ]+            { yylval.ivalue=2; return ULI; }
+           /* PS1: being nice to bold and italic markup in the beginning of LI items */
+^[ \t]*\*{3}/[ ]+(?:\*|_) { yylval.ivalue=3; return ULI; /* PS1 */ }
+^[ \t]*\*{3}[ ]+          { yylval.ivalue=3; return ULI; }
+^[ \t]*\*{2}/[ ]+(?:\*|_)   { yylval.ivalue=2; return ULI; /* PS1 */ }
+^[ \t]*\*{2}[ ]+            { yylval.ivalue=2; return ULI; }
+^[ \t]*\*/[ ]+(?:\*|_)     { yylval.ivalue=1; return ULI; /* PS1 */ }
 ^[ \t]*\*[ ]+              { yylval.ivalue=1; return ULI; }
 
-^[ \t]*###[ ]+             { yylval.ivalue=3; return OLI; }
-^[ \t]*##[ ]+              { yylval.ivalue=2; return OLI; }
+^[ \t]*#{3}/[ ]+(?:\*|_)    { yylval.ivalue=3; return OLI; /* PS1 */ }
+^[ \t]*#{3}[ ]+             { yylval.ivalue=3; return OLI; }
+^[ \t]*#{2}/[ ]+(?:\*|_)     { yylval.ivalue=2; return OLI; /* PS1 */ }
+^[ \t]*#{2}[ ]+              { yylval.ivalue=2; return OLI; }
+^[ \t]*#/[ ]+(?:\*|_)      { yylval.ivalue=1; return OLI; /* PS1 */ }
 ^[ \t]*#[ ]+               { yylval.ivalue=1; return OLI; }
 
+^[ \t]*%{3}/[ ]+(?:\*|_)    { yylval.ivalue=3; return OLI2; /* PS1 */ }
+^[ \t]*%{3}[ ]+             { yylval.ivalue=3; return OLI2; }
+^[ \t]*%{2}/[ ]+(?:\*|_)     { yylval.ivalue=2; return OLI2; /* PS1 */ }
+^[ \t]*%{2}[ ]+              { yylval.ivalue=2; return OLI2; }
+^[ \t]*%/[ ]+(?:\*|_)      { yylval.ivalue=1; return OLI2; /* PS1 */ }
+^[ \t]*%[ ]+               { yylval.ivalue=1; return OLI2; }
+
 
 <INITIAL,_LINKS_ONLY,_BOLD,_ITALIC>{
     (https?:\/\/|www\.)[^ \r\n<>"(){}*]+[^ \r\n<>"(){}*,.\[\]]  { yylval.svalue = yytext; return URL; }
@@ -164,6 +178,8 @@ extern size_t in_buf_len;
     \[\[file:[a-zA-Z0-9_.-]+(\|[^\[\]]+)?\]\]  { yylval.svalue = yytext+7; return FILE_LINK; }
     \[\[image:[a-zA-Z0-9_.-]+(\|[^\[\]]+)?\]\] { yylval.svalue = yytext+8; return IMAGE_LINK; }
 
+    \[\[snippet:[a-zA-Z0-9_.-]+:[0-9]+\]\] { yylval.svalue = yytext+10; return SNIPPET_LINK; }
+
     ^[ \t]+                 ; /* skip spaces at line start */
     [ \t]+                  { yylval.ivalue = ' '; return T_CHAR; }
 

data/ext/breakout_parser/parser.y

@@ -1,13 +1,16 @@
 // vim:ts=4:sw=4:expandtab
-%{ 
+%{
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
-#ifdef RUBY_VERSION
+#include <time.h>
+#include "parser.h"
 #include "ruby.h"
+
+#ifdef RUBY_19
+  #include "ruby/st.h"
 #else
-#define REALLOC_N(ptr,type,n) ptr=realloc(ptr,sizeof(type)*n)
+  #include "st.h"
 #endif
 
 extern int yylex();
@@ -24,13 +27,20 @@ size_t space_name_len = 0;
 const char *site_url = NULL;
 size_t site_url_len = 0;
 
+const char *large_files_url = NULL;
+size_t large_files_url_len = 0;
+
+VALUE meta_attributes;
+
 extern VALUE vcs_url;
 
+const char ** closing_list_stack = NULL;
+int closing_list_stack_size = 0;
 int list_level = 1;
 int absolute_urls = 0;
 
 #define CHECK_BUF_SIZE(len) \
-    if( (bufptr - buf + len + 1) >= bufsize ){ \
+    if( (size_t)(bufptr - buf + len + 1) >= bufsize ){ \
         /*printf("[.] REALLOC oldsz=%d, newsz=%d\n",bufsize, (bufsize+((len > 0x1000) ? (len+0x1000) : 0x1000)));*/ \
         char *oldbuf = buf; \
         bufsize += (len > 0x1000) ? (len+0x1000) : 0x1000; \
@@ -38,18 +48,16 @@ int absolute_urls = 0;
         bufptr = buf + (bufptr-oldbuf); \
     }
 
-concat(const char*what, size_t len){
-//    printf("[.] concat: w=\"%s\", l=%d\n",what,len);
+void concat(const char*what, size_t len){
     CHECK_BUF_SIZE(len);
     memcpy(bufptr, what, len);
     bufptr += len;
-//    printf("[.] concat OK\n");
 }
 
 // it's better to use concat(), especially if "what"'s length is always predefined
-concat2(const char*what){
+void concat2(const char * what) {
     size_t len = strlen(what);
-    concat(what,len);
+    concat(what, len);
 }
 
 // better error reporting
@@ -70,13 +78,13 @@ void yyerror(const char *msg)
 %union {
         double dvalue;
         int ivalue;
-        char const* svalue;
+        const char* svalue;
 }
 
 
 %token <ivalue> T_CHAR BOLD_START ITALIC_START
 %token <ivalue> BOLD_ITALIC_START ITALIC_BOLD_START
-%token <ivalue> ULI OLI
+%token <ivalue> ULI OLI OLI2
 %token <svalue> T_WORD TICKET_LINK LINK SVN_REVISION_LINK GIT_REVISION_LINK WIKI_LINK ANCHOR_LINK
 %token <svalue> SVN_N_REVISION_LINK GIT_N_REVISION_LINK
 %token <svalue> URL_WITH_PROTO_LINK URL_WITHOUT_PROTO_LINK
@@ -85,146 +93,197 @@ void yyerror(const char *msg)
 %token <svalue> UL
 %token <svalue> H1 H2 H3 H4 H5
 %token <svalue> INLINE_CODE
-%token SPACE BR /*BRBR*/
+%token SPACE BR
 %token PRE_CODE_START PRE_CODE_END PRE_START PRE_END CODE_START CODE_END
 %token NOTEXTILE_START NOTEXTILE_END
 %token BOLD_END ITALIC_END
 %token REVERT_BOLD REVERT_ITALIC
+%token <svalue> SNIPPET_LINK
 
 //%type <dvalue> expression
 //%type <dvalue> term
 //%type <dvalue> varornum
 %%
-text : 
+text :
      | textitem text
 
 
 textitem: br
      | words
-     | h1 {concat("</h1>",5)}
-     | h2 {concat("</h2>",5)}
-     | h3 {concat("</h3>",5)}
-     | h4 {concat("</h4>",5)}
-     | h5 {concat("</h5>",5)}
-     | {
-            list_level=1; 
-            concat("<ul>",4)
-       } ulist { 
-            concat("</ul>",5); 
-            for(; list_level>1 && list_level<4; list_level--) concat("</li></ul>",10);
-       } textitem
-     | {
-            list_level=1; 
-            concat("<ol>",4)
-       } olist { 
-            concat("</ol>",5); 
-            for(; list_level>1 && list_level<4; list_level--) concat("</li></ol>",10);
-       } textitem
+     | h1 {concat("</h1>",5);}
+     | h2 {concat("</h2>",5);}
+     | h3 {concat("</h3>",5);}
+     | h4 {concat("</h4>",5);}
+     | h5 {concat("</h5>",5);}
+     | listitem { concat("</li>", 5); close_opened_lists(); }
      | code
 
-ulist: ulitem        {concat("</li>",5)}
-     | ulist ulitem  {concat("</li>",5)}
+listitem: ulitem
+        | olitem
+        | olitem2
 
 ulitem: uli words
       | uli words BR
 
-olist: olitem        {concat("</li>",5)}
-     | olist olitem  {concat("</li>",5)}
-
 olitem: oli words
       | oli words BR
 
+olitem2: oli2 words
+       | oli2 words BR
+
 words: word
      | word words
 
 word : chars
       | link
-      | T_WORD         {concat2($1)} // TODO: somehow pass T_WORD's length here
-      | URL            {process_url($1)}
-      | EMAIL          {process_email($1)}
-      | BOLD_START     {$1 ? concat(" <strong>",9) : concat("<strong>",8)}
-      | BOLD_END       {concat("</strong>",9)}
-      | ITALIC_START   {$1 ? concat(" <em>",5) : concat("<em>",4)}
-      | ITALIC_END     {concat("</em>",5)}
-      | BOLD_ITALIC_START {$1 ? concat(" <strong><em>",13) : concat("<strong><em>",12)}
-      | ITALIC_BOLD_START {$1 ? concat(" <em><strong>",13) : concat("<em><strong>",12)}
-      | INLINE_CODE    {process_inline_code($1)}
-      | REVERT_BOLD    {revert_bold()}
-      | REVERT_ITALIC  {revert_italic()}
-
-link: TICKET_LINK            {process_ticket_link($1)}
-    | SVN_REVISION_LINK      {process_svn_link($1,0)}
-    | GIT_REVISION_LINK      {process_git_link($1,0)}
-    | SVN_N_REVISION_LINK    {process_svn_link($1,1)}
-    | GIT_N_REVISION_LINK    {process_git_link($1,1)}
-    | URL_WITH_PROTO_LINK    {process_url_link($1,NULL)}
-    | URL_WITHOUT_PROTO_LINK {process_url_link($1,"http://")}
-    | WIKI_LINK              {process_wiki_link($1)}
-    | ANCHOR_LINK            {process_anchor_link($1)}
-    | FILE_LINK              {process_file_link($1)}
-    | IMAGE_LINK             {process_image_link($1)}
+      | T_WORD         {concat2($1);} // TODO: somehow pass T_WORD's length here
+      | URL            {process_url($1);}
+      | EMAIL          {process_email($1);}
+      | BOLD_START     {$1 ? concat(" <strong>",9) : concat("<strong>",8);}
+      | BOLD_END       {concat("</strong>",9);}
+      | ITALIC_START   {$1 ? concat(" <em>",5) : concat("<em>",4);}
+      | ITALIC_END     {concat("</em>",5);}
+      | BOLD_ITALIC_START {$1 ? concat(" <strong><em>",13) : concat("<strong><em>",12);}
+      | ITALIC_BOLD_START {$1 ? concat(" <em><strong>",13) : concat("<em><strong>",12);}
+      | INLINE_CODE    {process_inline_code($1);}
+      | REVERT_BOLD    {revert_bold();}
+      | REVERT_ITALIC  {revert_italic();}
+
+link: TICKET_LINK            {process_ticket_link($1);}
+    | SVN_REVISION_LINK      {process_svn_link($1,0);}
+    | GIT_REVISION_LINK      {process_git_link($1,0);}
+    | SVN_N_REVISION_LINK    {process_svn_link($1,1);}
+    | GIT_N_REVISION_LINK    {process_git_link($1,1);}
+    | URL_WITH_PROTO_LINK    {process_url_link($1,NULL);}
+    | URL_WITHOUT_PROTO_LINK {process_url_link($1,"http://");}
+    | WIKI_LINK              {process_wiki_link($1);}
+    | ANCHOR_LINK            {process_anchor_link($1);}
+    | FILE_LINK              {process_file_link($1);}
+    | IMAGE_LINK             {process_image_link($1);}
+    | SNIPPET_LINK           {process_snippet_link($1);}
 
 chars:
      | char chars
 
-char : T_CHAR {concat_escaped_char($1)}
+char : T_CHAR {concat_escaped_char($1);}
 
 //raw_chars:
 //     | raw_char raw_chars
 
 //raw_char : T_CHAR {concat_raw_char($1)}
 
-h1   : H1          {concat("<h1 id=\"h-",10); process_header($1)}
-h2   : H2          {concat("<h2 id=\"h-",10); process_header($1)}
-h3   : H3          {concat("<h3 id=\"h-",10); process_header($1)}
-h4   : H4          {concat("<h4 id=\"h-",10); process_header($1)}
-h5   : H5          {concat("<h5 id=\"h-",10); process_header($1)}
-//ul   : UL          {concat("<ul>",4)}
-oli  : OLI         {process_oli($1)}
-uli  : ULI         {process_uli($1)}
-br   : BR          {concat("<br />",6)}
-//     | BRBR        {concat("<br /><br />",12)}
-
-code : PRE_CODE_START {concat("<pre><code>",11)} chars PRE_CODE_END {concat("</code></pre>",13)}
+h1   : H1   {concat("<h1 id=\"h-",10); process_header($1);}
+h2   : H2   {concat("<h2 id=\"h-",10); process_header($1);}
+h3   : H3   {concat("<h3 id=\"h-",10); process_header($1);}
+h4   : H4   {concat("<h4 id=\"h-",10); process_header($1);}
+h5   : H5   {concat("<h5 id=\"h-",10); process_header($1);}
+uli  : ULI  {process_list_item($1, 1);}
+oli  : OLI  {process_list_item($1, 2);}
+oli2 : OLI2 {process_list_item($1, 3);}
+br   : BR   {concat("<br />",6);}
+
+code : PRE_CODE_START {concat("<pre><code>",11);} chars PRE_CODE_END {concat("</code></pre>",13);}
      | NOTEXTILE_START chars NOTEXTILE_END
-     | PRE_START      {concat("<pre>",5)}        chars PRE_END      {concat("</pre>",6)}
-     | CODE_START     {concat("<code>",6)}       chars CODE_END     {concat("</code>",7)}
+     | PRE_START      {concat("<pre>",5);}        chars PRE_END      {concat("</pre>",6);}
+     | CODE_START     {concat("<code>",6);}       chars CODE_END     {concat("</code>",7);}
 
 //word : T_WORD        { process_word($1); }
 
 %%
 
-process_uli(int level){
-    if( level == list_level ){
-        concat("<li>",4);
-    } else if( level < list_level ){
-        list_level--;
-        //unconcat("</li>");
-        concat("</ul></li><li>",14);
+int closing_list_stack_push(const char * term) {
+    closing_list_stack_size++;
+    if( closing_list_stack != NULL ) {
+        closing_list_stack = REALLOC_N(closing_list_stack, const char *, closing_list_stack_size);
     } else {
-        // if(level > list_level)
-        list_level++;
-        unconcat("</li>");
-        concat("<ul><li>",8);
+        closing_list_stack = ALLOC(const char *);
     }
+    *(closing_list_stack + closing_list_stack_size - 1) = (const char *) strdup(term);
+    xfree((void *) term);
+    return closing_list_stack_size;
 }
 
-process_oli(int level){
-    if( level == list_level ){
-        concat("<li>",4);
-    } else if( level < list_level ){
-        list_level = level;
-        //unconcat("</li>");
-        concat("</ol></li><li>",14);
+const char * closing_list_stack_pop() {
+    const char *term = NULL;
+    if( !closing_list_stack_size ) return NULL;
+    term = *(closing_list_stack + --closing_list_stack_size);
+    REALLOC_N(closing_list_stack, const char *, closing_list_stack_size);
+    return term;
+}
+
+void close_opened_lists() {
+    const char *term = NULL;
+    while( ( term = closing_list_stack_pop() ) != NULL ) {
+      concat2(term);
+      xfree((void *) term);
+    }
+}
+
+void process_list_item(int level, int type) {
+    int insert_start_tag = 0, unconcat_steps, level_diff = list_level - level;
+    const char *removed_term = NULL;
+    char * start_tag = NULL, * closing_tag = NULL;
+
+    switch( type ) {
+        case 1:
+            start_tag   = strdup("<ul>");
+            closing_tag = strdup("</ul>");
+            break;
+        case 2:
+            start_tag   = strdup("<ol>");
+            closing_tag = strdup("</ol>");
+            break;
+        case 3:
+            start_tag   = strdup("<ol class='letters'>");
+            closing_tag = strdup("</ol>");
+            break;
+    }
+
+    if( !is_ending_with("</ul>") && !is_ending_with("</ol>") ) {
+        insert_start_tag = 1;
+        list_level = 1;
+        level_diff = list_level - level;
+        if( level_diff < 0 ) {
+            level_diff = 0;
+            level = 1;
+        }
+    }
+    if( level_diff < -1 ) level = list_level + 1;
+
+    if( level_diff >= 0 ) {
+        unconcat_steps = level;
+        for( ; unconcat_steps; --unconcat_steps ) {
+            if( unconcat_steps > 1 ) {
+                removed_term = unconcat("</li></ul>");
+                if( removed_term == NULL ) removed_term = unconcat("</li></ol>");
+            } else {
+                removed_term = unconcat("</ul>");
+                if( removed_term == NULL ) removed_term = unconcat("</ol>");
+                if( removed_term != NULL ) {
+                    xfree((void *) removed_term);
+                    removed_term = NULL; // we don't want to push this closing tag into the stack in this case
+                }
+            }
+            if( removed_term != NULL ) closing_list_stack_push(removed_term);
+        }
+        if( insert_start_tag ) concat2(start_tag);
+        concat2("<li>");
     } else {
-        // if(level > list_level)
-        list_level = level;
-        unconcat("</li>");
-        concat("<ol><li>",8);
+        unconcat_steps = level - 1;
+        for( ; unconcat_steps; --unconcat_steps ) {
+          if( ( removed_term = unconcat("</li></ul>") ) || ( removed_term = unconcat("</li></ol>") ) ) {
+              closing_list_stack_push(removed_term);
+          }
+        }
+        concat2(start_tag);
+        concat2("<li>");
     }
+    list_level = level;
+    closing_list_stack_push(closing_tag);
+    xfree(start_tag);
 }
 
-concat_hex_char(char c){
+void concat_hex_char(char c){
     unsigned char d;
     d = ((unsigned char)c)>>4;
     concat_raw_char(d>9 ? ('a'+d-10) : '0'+d);
@@ -232,12 +291,12 @@ concat_hex_char(char c){
     concat_raw_char(d>9 ? ('a'+d-10) : '0'+d);
 }
 
-need_hex_convert(const char*p, const char*pend){
+int need_hex_convert(const char*p, const char*pend){
     // scan for non alphanum chars first
     for(; *p && p<=pend; p++){
-        if( *p == ' ' || 
-            *p == '_' || 
-            *p == '-' || 
+        if( *p == ' ' ||
+            *p == '_' ||
+            *p == '-' ||
             *p == '.' ||
             (*p >= '0' && *p <= '9') ||
             (*p >= 'a' && *p <= 'z') ||
@@ -252,7 +311,7 @@ need_hex_convert(const char*p, const char*pend){
     return 0;
 }
 
-process_inline_code(const char*p){
+void process_inline_code(const char*p){
     if( *p == ' ' || *p == 9 ){
         concat_raw_char(' ');
         while( *p == ' ' || *p == 9 ) p++;
@@ -266,7 +325,7 @@ process_inline_code(const char*p){
     concat("</code>",7);
 }
 
-process_header(const char*title){
+void process_header(const char*title){
     const char*p,*pend;
 
     // skip heading spaces
@@ -287,7 +346,7 @@ process_header(const char*title){
     for(p = title; *p && p<=pend; p++) concat_escaped_char( *p );
 }
 
-process_link_tail(const char*text,const char*pend,const char*prepend){
+void process_link_tail(const char*text,const char*pend,const char*prepend){
     const char*p;
 
     concat("\">",2);
@@ -311,7 +370,7 @@ process_link_tail(const char*text,const char*pend,const char*prepend){
     concat("</a>",4);
 }
 
-process_anchor_link(const char*target){
+void process_anchor_link(const char*target){
     const char *p,*pend;
 
     // skip tail
@@ -333,7 +392,7 @@ process_anchor_link(const char*target){
     process_link_tail(target,NULL,"#");
 }
 
-process_url_link(const char*target,const char* proto){
+void process_url_link(const char*target,const char* proto){
     const char *c;
     concat("<a rel=\"nofollow\" href=\"",24);
     if(proto){
@@ -345,17 +404,23 @@ process_url_link(const char*target,const char* proto){
             if(*(bufptr-1) == '/') bufptr--; // skip redundant '/'
         }
     }
-    for(c=target; *c && *c != ']' && *c != '|'; c++) concat_raw_char(*c);
+    for(c=target; *c && *c != ']' && *c != '|'; c++) concat_escaped_char(*c);
     process_link_tail(target,NULL,proto);
 }
 
-concat_site_url(){
+void concat_site_url(){
     if( site_url && site_url_len > 0 ){
         concat(site_url, site_url_len);
     }
 }
 
-process_svn_link(const char*target, int numbered_repo){
+void concat_large_files_url(){
+    if( large_files_url && large_files_url_len > 0 ){
+        concat(large_files_url, large_files_url_len);
+    }
+}
+
+void process_svn_link(const char*target, int numbered_repo){
     const char *c;
     // can use sprintf here.. but I think it's a way slower than raw concat
     concat("<a href=\"",9);
@@ -397,7 +462,7 @@ int concat_custom_vcs_url(const char*rev){
     return 0;
 }
 
-process_git_link(const char*target, int numbered_repo){
+void process_git_link(const char*target, int numbered_repo){
     const char *c;
     // can use sprintf here.. but I think it's a way slower than raw concat
     concat("<a href=\"",9);
@@ -418,7 +483,7 @@ process_git_link(const char*target, int numbered_repo){
     process_link_tail(target,NULL,"revision:");
 }
 
-process_wiki_link(const char*target){
+void process_wiki_link(const char*target){
     const char *c;
     // can use sprintf here.. but I think it's a way slower than raw concat
     concat("<a class=\"wiki_link\" title=\"",28);
@@ -441,11 +506,12 @@ process_wiki_link(const char*target){
     process_link_tail(target,NULL,NULL);
 }
 
-process_file_link(const char*target){
+void process_file_link(const char*target){
     const char *c;
     // can use sprintf here.. but I think it's a way slower than raw concat
     concat("<a href=\"",9);
     concat_site_url();
+    concat_large_files_url();
     concat("/spaces/",8);
     concat(space_name,space_name_len);
     concat("/documents/download/",20);
@@ -453,11 +519,12 @@ process_file_link(const char*target){
     process_link_tail(target,NULL,"file:");
 }
 
-process_image_link(const char*target){
+void process_image_link(const char*target){
     const char *c, *p;
     // can use sprintf here.. but I think it's a way slower than raw concat
     concat("<img src=\"",10);
     concat_site_url();
+    concat_large_files_url();
     concat("/spaces/",8);
     concat(space_name,space_name_len);
     concat("/documents/download/",20);
@@ -471,7 +538,7 @@ process_image_link(const char*target){
     concat("\" />",4);
 }
 
-process_ticket_link(const char*ticket_id){
+void process_ticket_link(const char*ticket_id){
     const char *c;
     while(*ticket_id && (*ticket_id < '0' || *ticket_id > '9') ) ticket_id++;
     // can use sprintf here.. but I think it's a way slower than raw concat
@@ -481,10 +548,102 @@ process_ticket_link(const char*ticket_id){
     concat(space_name,space_name_len);
     concat("/tickets/",9);
     for(c=ticket_id; *c && *c>='0' && *c<='9'; c++) concat_raw_char(*c);
+
+    if (RHASH_SIZE(meta_attributes) > 0) {
+        char *numeric_ticket_id = ALLOC_N(char, strlen(ticket_id));
+        set_numeric_ticket_id(ticket_id, numeric_ticket_id);
+
+        process_data_attributes(numeric_ticket_id);
+        xfree(numeric_ticket_id);
+    }
+
     process_link_tail(ticket_id,NULL,"#");
 }
 
-concat_escaped_char(int c){
+void process_snippet_link(const char *space_id_with_snippet_id) {
+    size_t len = strlen(space_id_with_snippet_id);
+    char *space_id = ALLOC_N(char, len);
+    char *snippet_id = ALLOC_N(char, len);
+    char *pch;
+    char *timeval = ALLOC_N(char, 20);
+    int i = 0;
+    pch = strtok((char *)space_id_with_snippet_id, ":]");
+    // Extract only first two tokens: space_id and snippet_id
+    while (i < 2) {
+        i == 0 ? strcpy(space_id, pch) : strcpy(snippet_id, pch);
+        pch = strtok(NULL, ":]");
+        i += 1;
+    }
+
+    concat("<script async=\"true\" id=\"snippet-", 33);
+    concat(snippet_id, strlen(snippet_id));
+    concat("\" src=\"", 7);
+    concat_site_url();
+    concat_large_files_url();
+    concat("/spaces/", 8);
+    concat2(space_id);
+    concat("/snippets/", 10);
+    concat2(snippet_id);
+    concat(".js?_=", 6);
+    sprintf(timeval, "%ld", (long)time(NULL));
+    concat2(timeval);
+    concat("\"></script>", 11);
+    xfree(timeval);
+    xfree(space_id);
+    xfree(snippet_id);
+}
+
+int iterate_attributes_hash(VALUE key, VALUE record, st_data_t arg) {
+    add_data_attribute(RSTRING_PTR(key), RSTRING_PTR(record));
+    return ST_CONTINUE;
+}
+
+// NOTE: Data attributes work for tickets only right now
+// Nevertheless, it's really easy to extend this method to
+// add data attributes to any desired object
+void process_data_attributes(char *ticket_id) {
+    VALUE meta_attributes_hash;
+
+    if (st_lookup(RHASH_TBL(meta_attributes), rb_str_new2(ticket_id), &meta_attributes_hash) == 1) {
+        // We found something for that ticket id
+        if (TYPE(meta_attributes_hash) == T_HASH) {
+            int meta_attributes_len = RHASH_SIZE(meta_attributes_hash);
+            if (meta_attributes_len > 0) {
+                st_data_t result = 0;
+                concat("\"", 1); // Close href quotation mark
+                st_foreach(RHASH_TBL(meta_attributes_hash), iterate_attributes_hash, result);
+                unconcat("\""); // Remove final quotation mark as it will be added by process_link_tail
+            };
+        } else {
+            rb_raise(rb_eTypeError, "Expected instance of Hash, %0x given", TYPE(meta_attributes_hash));
+        }
+    }
+}
+
+// Add data attribute to link
+void add_data_attribute(char *attribute_name, char *attribute_value) {
+    concat(" data-", 6);
+    concat2(attribute_name);
+    concat("=\"", 2);
+    concat2(attribute_value);
+    concat("\"", 1);
+}
+
+void set_numeric_ticket_id(const char *ticket_id, char *numeric_ticket_id) {
+    char *c, *mutable_ticket_id;
+    int i = 0;
+
+    mutable_ticket_id = ALLOC_N(char, strlen(ticket_id));
+    memcpy(mutable_ticket_id, ticket_id, strlen(ticket_id));
+    for (c = mutable_ticket_id; *c && *c >= '0' && *c <= '9'; c++) {
+        *(numeric_ticket_id + i) = *c;
+        i++;
+    }
+    xfree(mutable_ticket_id);
+    *(numeric_ticket_id + i) = '\0';
+}
+
+void concat_escaped_char(int c){
     switch(c){
         case '<':
             concat("&lt;",4);
@@ -505,12 +664,12 @@ concat_escaped_char(int c){
 }
 
 
-concat_raw_char(int c){
+void concat_raw_char(int c){
     CHECK_BUF_SIZE(1);
     *bufptr++ = c;
 }
 
-process_url(const char*url){
+void process_url(const char*url){
     const char *p;
 
     concat("<a rel=\"nofollow\" href=\"",24);
@@ -524,7 +683,7 @@ process_url(const char*url){
     process_link_tail(url,NULL,NULL);
 }
 
-process_email(const char*url){
+void process_email(const char*url){
     const char *p;
 
     concat("<a href=\"mailto:",16);
@@ -532,12 +691,21 @@ process_email(const char*url){
     process_link_tail(url,NULL,NULL);
 }
 
-unconcat(const char*what){
-    int l = strlen(what);
-    if( bufptr-buf > l && strncmp(bufptr-l,what,l) == 0 ) bufptr -= l;
+const char *unconcat(const char *term){
+    int str_size = is_ending_with(term);
+    if( str_size ) {
+        bufptr -= str_size;
+        return (const char *) strndup(term, str_size + 1);
+    }
+    return (const char *) NULL;
+}
+int is_ending_with(const char *term) {
+    int str_size = (int) strlen(term);
+    if( bufptr - buf > str_size && strncmp(bufptr - str_size, term, str_size) == 0 ) return str_size;
+    return 0;
 }
 
-revert_bold(){
+void revert_bold(){
     char *p;
     for( p=bufptr-1; p >= (buf+7) ; p--){
         if( 0 == strncmp(p-7, "<strong>", 8) ){
@@ -547,7 +715,7 @@ revert_bold(){
     }
 }
 
-revert_italic(){
+void revert_italic(){
     char *p;
     for( p=bufptr-1; p >= (buf+3) ; p--){
         if( 0 == strncmp(p-3, "<em>", 4) ){