gollum 4.1.4 → 5.0.0

data/lib/gollum/public/gollum/javascript/editor/modes.js.erb

@@ -0,0 +1,252 @@
+/*  modes.js
+
+    Add highlighting rules for gollum-specific syntax to ACE.
+    We first have to extends the Highlighters for each supported syntax,
+    so that later, we can extend the relevant ACE Mode to use the custom Highlighter.
+    At the moment there are two gollum-wide block level syntaxes which need to be added:
+
+    * GitHub style code blocks: ``` ... ```
+    * UML blocks: @startuml ... @enduml
+
+    In addition, there are universal gollum tags:
+
+    [[link]]]
+
+    The regexes defined for these below should be equivalent to the regexes used by
+    gollum-lib to extract these blocks.
+
+    ACE Docs:
+      * Highlight Rules: https://cloud9-sdk.readme.io/docs/highlighting-rules
+      * Dynamically generating modes: https://stackoverflow.com/questions/22166784/dynamically-update-syntax-highlighting-mode-rules-for-the-ace-editor
+*/
+
+// For Gollum link tags
+var GollumTagStart = {
+  token: "support.function",
+  regex: "\\[\\[.*\\]\\]",
+  next: 'start'
+};
+
+<%
+uml_rule_name = 'UMLBlock'
+uml_rule_id = 'umlblock'
+%>
+
+// The rule defining the UML state for the ACE Tokenizer
+var <%= uml_rule_name %>  = [{
+  token: "support.function",
+  regex: "^\\@enduml$",
+  next:  "start"
+  },
+  {
+    defaultToken: "support.function"
+  }];
+
+// The rule defining how the ACE Tokenizer gets into the UML state
+var UMLStart = {
+  token: "support.function",
+  regex: "^(?:[ \\t]*)\\@startuml$",
+  next:  "<%= uml_rule_id %>"
+};
+
+<%
+codeblock_rule_name = 'GithubCodeBlock'
+codeblock_rule_id = 'githubblock';
+%>
+
+// Generic rule for github style fenced code blocks (both for three backticks, or tildes).
+// The generic approach was lifted from ACE's markdown_highlight_rules.js
+// Relies on startCodeBlockMatch to be called in the 'start' state to log the length and kind of the opening tag.
+var <%= codeblock_rule_name %> = [{
+  token: "support.function",
+  regex: ".*",
+  onMatch:  function(value, state, stack, line) {
+              var length     = stack[2][0];
+              var symbol     = stack[2][1];
+              // length and symbol are logged by startCodeBlockMatch
+              var match = /^( {0,3})(~~[~]+|```)\s*$/.exec(value);
+              // if there's a matching close tag, it's at least as long as the logged open tag, and it's the same character (backtick or tilde) as the opening tag.
+              if (match && match[2].length >= length && match[2].charAt(0) == symbol) {
+                stack.splice(0, 3);
+                this.next = stack.shift();
+                return this.token;
+              }
+              this.next = "";
+              return this.token;
+            }
+  },
+  {
+    defaultToken: "support.function"
+  }];
+
+// When we have a match for the start of a code block, log the information how long the opening tag was, and which character (backtick or tilde) it used.
+var startCodeBlockMatch = function(value, state, stack, line) {
+  var match = new RegExp(this.regex).exec(value);
+  stack.unshift("<%= codeblock_rule_id %>", [], [match[2].length, match[2].charAt(0)], state);
+  return this.token;
+}
+
+// Three backticks should work on all pages
+var GollumCodeStart = {
+  token: "support.function",
+  regex: "^( {0,3})(```)[^`]*$",
+  onMatch: startCodeBlockMatch,
+  next:  "<%= codeblock_rule_id %>"
+};
+
+// Markdown pages should also support fenced code blocks
+var MarkdownCodeStart = {
+  token: "support.function",
+  regex: "^( {0,3})(~~[~]+)[^`~]*$",
+  onMatch: startCodeBlockMatch,
+  next:  "<%= codeblock_rule_id %>"
+};
+
+<%
+default_rules = {
+  :path => '',
+  :rule_name => '',
+  :start_rules => ['GollumTagStart', 'UMLStart', 'GollumCodeStart'],
+  :block_rules => { codeblock_rule_id => codeblock_rule_name, 
+                    uml_rule_id => uml_rule_name,
+                  }
+}
+
+rst_rules = default_rules.dup
+rst_rules[:path] = 'ace/mode/rst_highlight_rules'
+rst_rules[:rule_name] = 'RSTHighlightRules'
+
+asciidoc_rules = default_rules.dup
+asciidoc_rules[:start_rules] = ['UMLStart', 'GollumCodeStart'] # Gollum tags are disabled for asciidoc
+asciidoc_rules[:path] = 'ace/mode/asciidoc_highlight_rules'
+asciidoc_rules[:rule_name] = 'AsciidocHighlightRules'
+
+textile_rules = default_rules.dup
+textile_rules[:path] = 'ace/mode/textile_highlight_rules'
+textile_rules[:rule_name] = 'TextileHighlightRules'
+
+rdoc_rules = default_rules.dup
+rdoc_rules[:path] = 'ace/mode/rdoc_highlight_rules'
+rdoc_rules[:rule_name] = 'RDocHighlightRules'
+
+# Create set of extended rules for markups that don't have their own Ace mode, based on the default 'text' highligter.
+text_rules = default_rules.dup
+text_rules[:path] = 'ace/mode/text_highlight_rules'
+text_rules[:rule_name] = 'TextHighlightRules'
+
+markdown_rules = default_rules.dup
+markdown_rules[:path] = 'ace/mode/markdown_highlight_rules'
+markdown_rules[:rule_name] = 'MarkdownHighlightRules'
+markdown_rules[:start_rules] = ['GollumTagStart', 'UMLStart', 'GollumCodeStart', 'MarkdownCodeStart'] # Markdown pages should also support fenced code blocks
+
+
+{
+  'GollumRstHighlightRules'      => rst_rules,
+  'GollumAsciidocHighlightRules' => asciidoc_rules,
+  'GollumTextileHighlightRules'  => textile_rules,
+  'GollumTextHighlightRules'     => text_rules,
+  'GollumRdocHighlightRules'     => rdoc_rules,
+  'GollumMarkdownHighlightRules' => markdown_rules 
+}.each do |name, highlighter|
+%>
+// Register gollum-specific HighlightRules with ACE
+ace.define("<%= name %>", [], function(require, exports, module) {
+  "use strict";
+
+  var oop = require("ace/lib/oop");
+  var BaseHighlightRules = require('<%= highlighter[:path] %>').<%= highlighter[:rule_name] %>;
+
+  var GollumHighlightRules = function() {
+    var mergeRules = new BaseHighlightRules();
+    this.$rules = mergeRules.getRules();
+    this.$rules.start = this.$rules.start.filter(function (item) {
+      return !(item.next == 'githubblock');
+    });
+    <% highlighter[:start_rules].each do |rule| %>
+    this.$rules.start.unshift(<%= rule %>);
+    <% end %>
+    <% highlighter[:block_rules].each do |id, rule| %>
+    this.addRules({
+      <%= id %> : <%= rule %>
+    });
+    if (this.$rules.listblock != null){
+      // Some markup languages, like markdown, have a separate starting block for list contents, which also need to parse Gollum Tags.
+      this.$rules.listblock.unshift(GollumTagStart);
+    }
+    <% end %>
+
+    this.normalizeRules();
+  };
+
+  oop.inherits(GollumHighlightRules, BaseHighlightRules);
+
+  exports.GollumHighlightRules = GollumHighlightRules;
+});
+<% end %>
+// Done defining the extended HighlightRule definitions
+
+(function($) {
+  var AceMode = {
+    asciidoc: {
+      mode: 'asciidoc',
+      highlighter: 'GollumAsciidocHighlightRules'
+    },
+    creole: {
+      mode: 'text',
+      highlighter: 'GollumTextHighlightRules'
+    },
+    markdown: {
+      mode: 'markdown',
+      highlighter: 'GollumMarkdownHighlightRules'
+    },
+    mediawiki: {
+      mode: 'text',
+      highlighter: 'GollumTextHighlightRules'
+    },
+    bib: {
+      mode: 'latex'
+    },
+    org: {
+      mode: 'text',
+      highlighter: 'GollumTextHighlightRules'
+    },
+    rst: {
+      mode: 'rst',
+      highlighter: 'GollumRstHighlightRules'
+    },
+    txt: {
+      mode: 'text'
+    },
+    pod: {
+      mode: 'text',
+      highlighter: 'GollumTextHighlightRules'
+    },
+    rdoc: {
+      mode: 'rdoc',
+      highlighter: 'GollumRdocHighlightRules'
+    },
+    textile: {
+      mode: 'textile',
+      highlighter: 'GollumTextileHighlightRules'
+    }
+  };
+
+  $.getEditorMode = function ( mode ) {
+    var lang = null;
+    if (lang = AceMode[mode]) {
+      var ace_mode = lang['mode'];
+      var gollum_rules = lang['highlighter'];
+      if (gollum_rules){ // We have extended highlighters
+        var baseMode = ace.require("ace/mode/" + ace_mode).Mode;
+        var dynamicMode = new baseMode();
+        dynamicMode.HighlightRules = ace.require(gollum_rules).GollumHighlightRules;
+        return dynamicMode;      
+      } else {
+        return "ace/mode/" + ace_mode;
+      }
+    } else {
+      return null;
+    }
+  }
+
+})(jQuery);

data/lib/gollum/public/gollum/javascript/editor/sections.js

@@ -0,0 +1,87 @@
+(function($) {
+
+  $.markupSupportsEditableSections = function ( markup ) {
+    var supportedFormats = ['markdown', 'textile', 'asciidoc', 'rst'];
+    return supportedFormats.includes(markup);
+  }
+
+  $.findSection = function ( anchor, languageHelpers ) {
+    var titles = {};
+
+    for (i = 0; i < window.ace_editor.getSession().getLength(); i++) {
+      var foundLine = null;
+
+      var results = getSectionTokens(i);
+      var section = results[0];
+      var header  = results[1];
+
+      if (!section) {
+        continue; // No section on this line, go to the next
+      }
+
+      if (header) {
+        header = header['value'];
+        foundLine = i; // Header text was found on this line
+      } else
+      {
+        // No header text found on this line. Perhaps the markup language puts section-defining syntax and the title of the section on different lines?
+        var header_and_line = getHeader(i, section['value'], languageHelpers);
+        if ( header_and_line.length ) {
+          header = header_and_line[0];
+          foundLine = header_and_line[1];        
+        } else {
+          continue; // No header text was found again. Skip this line.
+        }
+      }
+
+      // Now that we have the header text, compare it to the anchor we're looking for.
+      header = generateAnchor(header);
+
+      // If we've encountered this header before, add an index to it (e.g. 'bilbo-baggins-1'.
+      if (index = titles[header]) {
+        header = header + '-' + index.toString();
+        titles[header] = index+1;
+      } else {
+        titles[header] = 1;
+      }
+
+      // Compare the final header to the anchor we're looking for
+      if (header == anchor) {
+        return foundLine;
+      }
+    }
+    return null;  
+  }
+
+  function getSectionTokens ( line ) {
+    var session = window.ace_editor.getSession();
+    tokens = session.getTokens(line);
+
+    // Assume we can't have more than one section heading per line, so take the first section and the first header text
+    section = tokens.filter(function (token) {
+      return token.type.startsWith('markup.heading');
+    })[0];
+
+    header = tokens.filter(function (token) {
+      return /^(heading)|(text)$/.test(token.type); 
+    })[0];
+
+    return [section, header];
+  }
+
+  function getHeader ( section_line, section_token, languageHelpers ) {
+    if (!languageHelpers || !languageHelpers['find-header-line']) {
+      return [];
+    }
+    var results  = languageHelpers['find-header-line'](section_line, section_token);
+    if ( results == null ) {
+      return [];
+    } else {
+      return [results[0], results[1]];
+    }
+  }
+
+  function generateAnchor ( header ) {
+    return header.trim().replace(/[^a-z0-9_\s]/gi, ' ').replace(/\s\s+/g, ' ').split(/\s/).join('-').replace(/^-/,'').toLowerCase();
+  }
+})(jQuery);

data/lib/gollum/public/gollum/javascript/gollum.dialog.js

@@ -74,7 +74,7 @@
         html += '>' + fieldAttributes.name + '</label>';
       }
 
-      html += '<input type="text"';
+      html += '<input type="text" class="form-control input-sm width-full"';
 
       if ( fieldAttributes.id ) {
         html += ' name="' + fieldAttributes.id + '"'
@@ -101,13 +101,11 @@
 
       var id = fieldAttributes.id || 'upload';
       var name = fieldAttributes.name || 'file';
-      var action = fieldAttributes.action || '/uploadFile';
+      var action = fieldAttributes.action || routePath('upload_file');
 
       html += '<form method=post enctype="multipart/form-data" ' +
         'action="' + action + '" ' + 'id="' + id + '">';
-      html += '<input type="hidden" name="upload_dest" value="' +
-        uploadDest + '">';
-      html += '<input type=file name="' + name + '">';
+      html += '<input type=file name="' + name + '" class="form-control width-full">';
       html += '</form>';
 
       if( fieldAttributes.context ){
@@ -119,35 +117,20 @@
 
     createMarkup: function( title, body ) {
       Dialog.markupCreated = true;
-      if ($.facebox) {
-        return '<div id="gollum-dialog-dialog">' +
-               '<div id="gollum-dialog-dialog-title"><h4>' +
-               title +'</h4></div>' +
-               '<div id="gollum-dialog-dialog-body">' + body + '</div>' +
-               '<div id="gollum-dialog-dialog-buttons">' +
-               '<a href="#" title="Cancel" id="gollum-dialog-action-cancel" ' +
-               'class="gollum-minibutton">Cancel</a>' +
-               '<a href="#" title="OK" id="gollum-dialog-action-ok" '+
-               'class="gollum-minibutton">OK</a>' +
-               '</div>' +
-               '</div>';
-      } else {
-        return '<div id="gollum-dialog-dialog">' +
-               '<div id="gollum-dialog-dialog-inner">' +
-               '<div id="gollum-dialog-dialog-bg">' +
-               '<div id="gollum-dialog-dialog-title"><h4>' +
-               title +'</h4></div>' +
-               '<div id="gollum-dialog-dialog-body">' + body + '</div>' +
-               '<div id="gollum-dialog-dialog-buttons">' +
-               '<a href="#" title="Cancel" id="gollum-dialog-action-cancel" ' +
-               'class="minibutton">Cancel</a>' +
-               '<a href="#" title="OK" id="gollum-dialog-action-ok" '+
-               'class="minibutton">OK</a>' +
-               '</div>' +
-               '</div>' +
-               '</div>' +
-               '</div>';
-      }
+      return '<div id="gollum-dialog-dialog">' +
+             '<div id="gollum-dialog-dialog-inner" class="border rounded-1">' +
+             '<div id="gollum-dialog-dialog-title"><h4>' +
+             title +'</h4></div>' +
+             '<div id="gollum-dialog-dialog-body">' + body + '</div>' +
+             '<div id="gollum-dialog-dialog-buttons" class="pt-2 float-right">' +
+             '<button name="Cancel" id="gollum-dialog-action-cancel" ' +
+             'class="btn">Cancel</button>' +
+             '<span class="px-1"></span>' +
+             '<button name="OK" id="gollum-dialog-action-ok" '+
+             'class="btn btn-primary">OK</button>' +
+             '</div>' +
+             '</div>' +
+             '</div>';
     },
 
     eventCancel: function( e ) {
@@ -174,23 +157,17 @@
     },
 
     hide: function() {
-      if ( $.facebox ) {
-        Dialog.markupCreated = false;
-        $(document).trigger('close.facebox');
-        Dialog.detachEvents();
+      if ( $.browser.msie ) {
+        $('#gollum-dialog-dialog').hide().removeClass('active');
+        $('select').css('visibility', 'visible');
       } else {
-        if ( $.browser.msie ) {
-          $('#gollum-dialog-dialog').hide().removeClass('active');
-          $('select').css('visibility', 'visible');
-        } else {
-          $('#gollum-dialog-dialog').animate({ opacity: 0 }, {
-            duration: 200,
-            complete: function() {
-              $('#gollum-dialog-dialog').removeClass('active');
-              $('#gollum-dialog-dialog').css('display', 'none');
-            }
-          });
-        }
+        $('#gollum-dialog-dialog').animate({ opacity: 0 }, {
+          duration: 200,
+          complete: function() {
+            $('#gollum-dialog-dialog').removeClass('active');
+            $('#gollum-dialog-dialog').css('display', 'none');
+          }
+        });
 
         $(window).unbind('resize', Dialog.resize);
       }
@@ -221,29 +198,15 @@
       }
 
       if ( Dialog.markupCreated ) {
-        if ($.facebox) {
-          $(document).trigger('close.facebox');
-        } else {
-          $('#gollum-dialog-dialog').remove();
-        }
+        $('#gollum-dialog-dialog').remove();
       }
 
       Dialog.markup = Dialog.createMarkup( title, body );
 
-      if ($.facebox) {
-        $(document).bind('reveal.facebox', function() {
-          if ( argObject.OK &&
-               typeof argObject.OK == 'function' ) {
-            Dialog.attachEvents( argObject.OK );
-            $($('#facebox input[type="text"]').get(0)).focus();
-          }
-        });
-      } else {
-        $('body').append( Dialog.markup );
-        if ( argObject.OK &&
-             typeof argObject.OK == 'function' ) {
-          Dialog.attachEvents( argObject.OK );
-        }
+      $('body').append( Dialog.markup );
+      if ( argObject.OK &&
+           typeof argObject.OK == 'function' ) {
+        Dialog.attachEvents( argObject.OK );
       }
 
       Dialog.show();
@@ -254,27 +217,24 @@
         debug('Dialog: No markup to show. Please use init first.');
       } else {
         debug('Showing dialog');
-        if ($.facebox) {
-          $.facebox( Dialog.markup );
+
+        if ( $.browser.msie ) {
+          $('#gollum-dialog.dialog').addClass('active');
+          Dialog.position();
+          $('select').css('visibility', 'hidden');
         } else {
-          if ( $.browser.msie ) {
-            $('#gollum-dialog.dialog').addClass('active');
-            Dialog.position();
-            $('select').css('visibility', 'hidden');
-          } else {
-            $('#gollum-dialog.dialog').css('display', 'none');
-            $('#gollum-dialog-dialog').animate({ opacity: 0 }, {
-              duration: 0,
-              complete: function() {
-                $('#gollum-dialog-dialog').css('display', 'block');
-                Dialog.position(); // position this thing
-                $('#gollum-dialog-dialog').animate({ opacity: 1 }, {
-                duration: 500
-                });
-                $($('#gollum-dialog-dialog input[type="text"]').get(0)).focus();
-              }
-            });
-          }
+          $('#gollum-dialog.dialog').css('display', 'none');
+          $('#gollum-dialog-dialog').animate({ opacity: 0 }, {
+            duration: 0,
+            complete: function() {
+              $('#gollum-dialog-dialog').css('display', 'block');
+              Dialog.position(); // position this thing
+              $('#gollum-dialog-dialog').animate({ opacity: 1 }, {
+              duration: 500
+              });
+              $($('#gollum-dialog-dialog input[type="text"]').get(0)).focus();
+            }
+          });
         }
 
         $(window).bind('resize', Dialog.resize);
@@ -301,11 +261,6 @@
     }
   };
 
-  if ($.facebox) {
-    $(document).bind('reveal.facebox', function() {
-      $('#facebox img.close_image').remove();
-    });
-  }
 
   var debug = function(m) {
     if ( Dialog.debugOn