super-pro-rb 0.0.1

data/gollum-6.1.0/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' highlighter.
+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/gollum-6.1.0/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/gollum-6.1.0/lib/gollum/public/gollum/javascript/editor.js

@@ -0,0 +1,30 @@
+//= require ace-builds/src-noconflict/ace
+//= require ace-builds/src-noconflict/mode-markdown
+//= require ace-builds/src-noconflict/mode-asciidoc
+//= require ace-builds/src-noconflict/mode-text
+//= require ace-builds/src-noconflict/mode-rdoc
+//= require ace-builds/src-noconflict/mode-textile
+//= require ace-builds/src-noconflict/mode-rst
+//= require ace-builds/src-noconflict/mode-latex
+//= require ace-builds/src-noconflict/theme-tomorrow
+//= require ace-builds/src-noconflict/keybinding-vim
+//= require ace-builds/src-noconflict/keybinding-emacs
+//= require ace-builds/src-noconflict/ext-elastic_tabstops_lite
+//= require ace-builds/src-noconflict/ext-error_marker
+//= require ace-builds/src-noconflict/ext-keybinding_menu
+//= require ace-builds/src-noconflict/ext-language_tools
+//= require ace-builds/src-noconflict/ext-linking
+//= require ace-builds/src-noconflict/ext-rtl.js
+//= require ace-builds/src-noconflict/ext-searchbox
+//= require ace-builds/src-noconflict/ext-settings_menu
+//= require ace-builds/src-noconflict/ext-spellcheck
+//= require ace-builds/src-noconflict/ext-split
+//= require ace-builds/src-noconflict/ext-static_highlight
+//= require ace-builds/src-noconflict/ext-statusbar
+//= require ace-builds/src-noconflict/ext-textarea
+//= require ace-builds/src-noconflict/ext-themelist
+//= require ace-builds/src-noconflict/ext-whitespace
+//= require editor/modes
+//= require editor/gollum.editor
+//= require editor/langs/default
+//= require_tree ./editor/langs

data/gollum-6.1.0/lib/gollum/public/gollum/javascript/gollum.behaviors.js

@@ -0,0 +1,40 @@
+function basicSelectSetSelection(select, value) {
+   select.find('.SelectMenu-item').each(function () {
+     $(this).attr('aria-checked', false);
+     if($(this).attr('value') === value ) {
+       $(this).attr('aria-checked', true);
+       $(this).closest('details').find('summary span').text($(this).attr('value'));
+     }
+   });
+}
+
+function basicSelectGetSelection(select) {
+  return select.find('.SelectMenu-item[aria-checked="true"]');
+}
+
+$(document).ready(function() {
+  
+  // Implement basic select behavior
+  // Only one item can be selected at the same time
+  // Close the select modal after selection
+  $('.BasicSelect .SelectMenu-item').on('click', function(e) {
+    e.preventDefault();
+    selected = $(this);
+    // find select menu context and uncheck all items for that context
+    selected.parent('.SelectMenu-list').children('.SelectMenu-item').each(function () {
+      $(this).attr('aria-checked', false);
+    });
+    // select clicked item
+    selected.attr('aria-checked', true);
+    // Change button text
+    details = selected.closest('details');
+    details.find('summary span').text(selected.text());
+    // Close menu
+    details.removeAttr('open');
+    // Trigger change callback with selected value
+    selected.trigger('change', selected.attr('value'));
+    
+    
+  });
+
+});

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

@@ -0,0 +1,263 @@
+/**
+  *  gollum.dialog.js
+  *
+  *  Used for dialogs. Duh.
+  *
+  */
+
+(function($) {
+
+  var Dialog = {
+
+    debugOn: false,
+    markupCreated: false,
+    markup: '',
+
+    currentAspect: function(){
+      if (window.innerWidth < 480) return "small-mobile";
+      if ($('#gollum-dialog-dialog').css('position') == 'fixed') return "large-mobile";
+      return "desktop";
+    },
+
+    attachEvents: function( evtOK ) {
+      $('#gollum-dialog-action-ok').click(function( e ) {
+        Dialog.eventOK( e, evtOK );
+      });
+      $('#gollum-dialog-action-cancel').click( Dialog.eventCancel );
+      $('#gollum-dialog-dialog input[type="text"]').keydown(function( e ) {
+        if ( e.keyCode == 13 ) {
+          Dialog.eventOK( e, evtOK );
+        }
+      });
+    },
+
+    detachEvents: function() {
+      $('#gollum-dialog-action-ok').unbind('click');
+      $('#gollum-dialog-action-cancel').unbind('click');
+    },
+
+    createFieldMarkup: function( fieldArray ) {
+      var fieldMarkup = '<fieldset>';
+      for ( var i=0; i < fieldArray.length; i++ ) {
+        if ( typeof fieldArray[i] == 'object' ) {
+          fieldMarkup += '<div class="field">';
+          switch ( fieldArray[i].type ) {
+
+          case 'text':
+            fieldMarkup += Dialog.createFieldText( fieldArray[i] );
+            break;
+
+          case 'file':
+            fieldMarkup += Dialog.createFieldFile( fieldArray[i] );
+            break;
+
+          default:
+            break;
+
+          }
+          fieldMarkup += '</div>';
+        }
+
+      }
+      fieldMarkup += '</fieldset>';
+      return fieldMarkup;
+    },
+
+    createFieldText: function( fieldAttributes ) {
+      var html = '';
+
+      if ( fieldAttributes.name ) {
+        html += '<label';
+        if ( fieldAttributes.id ) {
+          html += ' for="gollum-dialog-dialog-generated-field-' + fieldAttributes.id + '"';
+        }
+        html += '>' + fieldAttributes.name + '</label>';
+      }
+
+      html += '<input type="text" class="form-control input-sm width-full"';
+
+      if ( fieldAttributes.id ) {
+        html += ' name="' + fieldAttributes.id + '"'
+        if ( fieldAttributes.type == 'code' ) {
+          html+= ' class="code"';
+        }
+        if ( fieldAttributes.defaultValue ) {
+          html+= ' value="' + fieldAttributes.defaultValue.split('"').join('&quot;') + '"';
+        }
+        html += ' id="gollum-dialog-dialog-generated-field-' +
+          fieldAttributes.id + '">';
+      }
+
+      if( fieldAttributes.context ){
+        html += '<span class="context">' + fieldAttributes.context + '</span>';
+      }
+
+      return html;
+    },
+
+    createFieldFile: function( fieldAttributes ) {
+      // Not actually a field, but an embedded form.
+      var html = '';
+
+      var id = fieldAttributes.id || 'upload';
+      var name = fieldAttributes.name || 'file';
+      var action = fieldAttributes.action || routePath('upload_file');
+
+      html += '<form method=post enctype="multipart/form-data" ' +
+        'action="' + action + '" ' + 'id="' + id + '">';
+      html += '<input type=file name="' + name + '" class="form-control width-full">';
+      html += '</form>';
+
+      if( fieldAttributes.context ){
+        html += '<span class="context">' + fieldAttributes.context + '</span>';
+      }
+
+      return html;
+    },
+
+    createMarkup: function( title, body ) {
+      Dialog.markupCreated = true;
+      return '<div id="gollum-dialog-dialog">' +
+             '<div id="gollum-dialog-dialog-inner" class="border rounded-1">' +
+             '<div id="gollum-dialog-dialog-title"><h4 class="f2 border-bottom mb-3">' +
+             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 ) {
+      e.preventDefault();
+      debug('Cancelled dialog.');
+      Dialog.hide();
+    },
+
+    eventOK: function( e, evtOK ) {
+      e.preventDefault();
+
+      var results = [];
+      // get the results from each field and build them into the object
+      $('#gollum-dialog-dialog-body input').each(function() {
+        results[$(this).attr('name')] = $(this).val();
+      });
+
+      // pass them to evtOK if it exists (which it should)
+      if ( evtOK &&
+           typeof evtOK == 'function' ) {
+        evtOK( results );
+      }
+      Dialog.hide();
+    },
+
+    hide: function() {
+      $('#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);
+    },
+
+    init: function( argObject ) {
+      var title = '';
+      var body = '';
+
+      // bail out if necessary
+      if ( !argObject ||
+           typeof argObject != 'object' ) {
+        debug('Editor Dialog: Cannot init; invalid init object');
+        return;
+      }
+
+      if ( argObject.body && typeof argObject.body == 'string' ) {
+        body = '<p>' + argObject.body + '</p>';
+      }
+
+      // alright, build out fields
+      if ( argObject.fields && typeof argObject.fields == 'object' ) {
+        body += Dialog.createFieldMarkup( argObject.fields );
+      }
+
+      if ( argObject.title && typeof argObject.title == 'string' ) {
+        title = argObject.title;
+      }
+
+      if ( Dialog.markupCreated ) {
+        $('#gollum-dialog-dialog').remove();
+      }
+
+      Dialog.markup = Dialog.createMarkup( title, body );
+
+      $('body').append( Dialog.markup );
+      if ( argObject.OK &&
+           typeof argObject.OK == 'function' ) {
+        Dialog.attachEvents( argObject.OK );
+      }
+
+      Dialog.show();
+    },
+
+    show: function() {
+      if ( !Dialog.markupCreated ) {
+        debug('Dialog: No markup to show. Please use init first.');
+      } else {
+        debug('Showing dialog');
+
+        $('#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);
+      }
+    },
+
+    resize: function(){
+      Dialog.position();
+    },
+
+    position: function() {
+      if (Dialog.currentAspect() == "small-mobile") {
+        $('#gollum-dialog-dialog-inner').css('height', '100%').css('margin-top', 'auto');
+      }
+      else if (Dialog.currentAspect() == "large-mobile") {
+        $('#gollum-dialog-dialog-inner').css('height', 'auto').css('margin-top', 'auto');
+      }
+      else if (Dialog.currentAspect() == "desktop") {
+        var dialogHeight = $('#gollum-dialog-dialog-inner').height();
+        $('#gollum-dialog-dialog-inner')
+          .css('height', dialogHeight + 'px')
+          .css('margin-top', -1 * parseInt( dialogHeight / 2 ));
+      }
+    }
+  };
+
+
+  var debug = function(m) {
+    if ( Dialog.debugOn
+         && typeof console != 'undefined' ) {
+      console.log( m );
+    }
+  };
+
+  $.GollumDialog = Dialog;
+
+})(jQuery);