asda2432es

✏️ Editing: flatdoc.js

/*!
 * Flatdoc - (c) 2013, 2014 Rico Sta. Cruz
 * http://ricostacruz.com/flatdoc
 * @license MIT
 */

(function($) {
  var exports = this;

var marked;

/**
   * Basic Flatdoc module.
   *
   * The main entry point is `Flatdoc.run()`, which invokes the [Runner].
   *
   *     Flatdoc.run({
   *       fetcher: Flatdoc.github('rstacruz/backbone-patterns');
   *     });
   */

var Flatdoc = exports.Flatdoc = {};

/**
   * Creates a runner.
   * See [Flatdoc].
   */

Flatdoc.run = function(options) {
    $(function() { (new Flatdoc.runner(options)).run(); });
  };

/**
   * File fetcher function.
   *
   * Fetches a given `url` via AJAX.
   * See [Runner#run()] for a description of fetcher functions.
   */

Flatdoc.file = function(url) {
    return function(callback) {
      $.get(url)
        .fail(function(e) { callback(e, null); })
        .done(function(data) {  callback(null, data); });
    };
  };

/**
   * Github fetcher.
   * Fetches from repo `repo` (in format 'user/repo').
   *
   * If the parameter `filepath` is supplied, it fetches the contents of that
   * given file in the repo.
   *
   * See [Runner#run()] for a description of fetcher functions.
   *
   * See: http://developer.github.com/v3/repos/contents/
   */
  Flatdoc.github = function(repo, filepath) {
    var url;
    if (filepath) {
      url = 'https://api.github.com/repos/'+repo+'/contents/'+filepath;
    } else {
      url = 'https://api.github.com/repos/'+repo+'/readme';
    }
    return function(callback) {
      $.get(url)
        .fail(function(e) { callback(e, null); })
        .done(function(data) {
          var markdown = exports.Base64.decode(data.content);
          callback(null, markdown);
        });
    };
  };

/**
   * Bitbucket fetcher.
   * Fetches from repo `repo` (in format 'user/repo').
   *
   * If the parameter `filepath` is supplied, it fetches the contents of that
   * given file in the repo.
   *
   * See [Runner#run()] for a description of fetcher functions.
   *
   * See: https://confluence.atlassian.com/display/BITBUCKET/src+Resources#srcResources-GETrawcontentofanindividualfile
   * See: http://ben.onfabrik.com/posts/embed-bitbucket-source-code-on-your-website
   * Bitbucket appears to have stricter restrictions on
   * Access-Control-Allow-Origin, and so the method here is a bit
   * more complicated than for Github
   *
   * If you don't pass a branch name, then 'default' for Hg repos is assumed
   * For git, you should pass 'master'. In both cases, you should also be able
   * to pass in a revision number here -- in Mercurial, this also includes
   * things like 'tip' or the repo-local integer revision number
   * Default to Mercurial because Git users historically tend to use GitHub
   */
  Flatdoc.bitbucket = function(repo, filepath, branch) {
    if (!filepath) filepath = 'readme.md';
    if (!branch) branch = 'default';

var url = 'https://bitbucket.org/api/1.0/repositories/'+repo+'/src/'+branch+'/'+filepath;

return function(callback) {
     $.ajax({
      url: url,
      dataType: 'jsonp',
      error: function(xhr, status, error) {
        alert(error);
      },
      success: function(response) {
        var markdown = response.data;
        callback(null, markdown);
      }
  });
};
};

/**
 * Parser module.
 * Parses a given Markdown document and returns a JSON object with data
 * on the Markdown document.
 *
 * var data = Flatdoc.parser.parse('markdown source here');
 * console.log(data);
 *
 * data == {
 * title: 'My Project',
 * content: 'This project is a...',
 * menu: {...}
 * }
 */

var Parser = Flatdoc.parser = {};

/**
   * Parses a given Markdown document.
   * See `Parser` for more info.
   */
  Parser.parse = function(source, highlight) {
    marked = exports.marked;

Parser.setMarkedOptions(highlight);

var html = $("<div>" + marked(source));
 var h1 = html.find('h1').eq(0);
 var title = h1.text();

// Mangle content
    Transformer.mangle(html);
    var menu = Transformer.getMenu(html);

return { title: title, content: html, menu: menu };
  };

Parser.setMarkedOptions = function(highlight) {
    marked.setOptions({
      highlight: function(code, lang) {
        if (lang) {
          return highlight(code, lang);
        }
        return code;
      }
    });
  };

/**
 * Transformer module.
 * This takes care of any HTML mangling needed. The main entry point is
 * `.mangle()` which applies all transformations needed.
 *
 * var $content = $("Hello there, this is a docu...");
 * Flatdoc.transformer.mangle($content);
 *
 * If you would like to change any of the transformations, decorate any of
 * the functions in `Flatdoc.transformer`.
 */

var Transformer = Flatdoc.transformer = {};

/**
   * Takes a given HTML `$content` and improves the markup of it by executing
   * the transformations.
   *
   * > See: [Transformer](#transformer)
   */
  Transformer.mangle = function($content) {
    this.addIDs($content);
    this.buttonize($content);
    this.smartquotes($content);
  };

/**
   * Adds IDs to headings.
   */

Transformer.addIDs = function($content) {
    var slugs = ['', '', ''];
    $content.find('h1, h2, h3').each(function() {
      var $el = $(this);
      var num = parseInt(this.nodeName[1]);
      var text = $el.text();
      var slug = slugify(text);
      if (num > 1) slug = slugs[num - 2] + '-' + slug;
      slugs.length = num - 1;
      slugs = slugs.concat([slug, slug]);
      $el.attr('id', slug);
    });
  };

/**
   * Returns menu data for a given HTML.
   *
   *     menu = Flatdoc.transformer.getMenu($content);
   *     menu == {
   *       level: 0,
   *       items: [{
   *         section: "Getting started",
   *         level: 1,
   *         items: [...]}, ...]}
   */

Transformer.getMenu = function($content) {
    var root = {items: [], id: '', level: 0};
    var cache = [root];

$content.find('h1, h2, h3').each(function() {
      var $el = $(this);
      var level = +(this.nodeName.substr(1));

var parent = mkdir_p(level-1);

var obj = { section: $el.text(), items: [], level: level, id: $el.attr('id') };
      parent.items.push(obj);
      cache[level] = obj;
    });

return root;
  };

/**
   * Changes "button >" text to buttons.
   */

Transformer.buttonize = function($content) {
    $content.find('a').each(function() {
      var $a = $(this);

var m = $a.text().match(/^(.*) >$/);
      if (m) $a.text(m[1]).addClass('button');
    });
  };

/**
   * Applies smart quotes to a given element.
   * It leaves `code` and `pre` blocks alone.
   */

Transformer.smartquotes = function ($content) {
 var nodes = getTextNodesIn($content), len = nodes.length;
 for (var i=0; i<len; i++) {
 var node = nodes[i];
 node.nodeValue = quotify(node.nodeValue);
 }
 };

/**
   * Syntax highlighters.
   *
   * You may add or change more highlighters via the `Flatdoc.highlighters`
   * object.
   *
   *     Flatdoc.highlighters.js = function(code) {
   *     };
   *
   * Each of these functions
   */

var Highlighters = Flatdoc.highlighters = {};

/**
   * JavaScript syntax highlighter.
   *
   * Thanks @visionmedia!
   */

Highlighters.js = Highlighters.javascript = function(code) {
 return code
 .replace(/</g, '&lt;')
 .replace(/>/g, '&gt;')
 .replace(/("[^\"]*?")/g, '$1')
 .replace(/('[^\']*?')/g, '$1')
 .replace(/\/\/(.*)/gm, '//$1')
 .replace(/\/\*(.*)\*\//gm, '/*$1*/')
 .replace(/(\d+\.\d+)/gm, '$1')
 .replace(/(\d+)/gm, '$1')
 .replace(/\bnew *(\w+)/gm, 'new $1')
 .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '$1');
 };

Highlighters.html = function(code) {
 return code
 .replace(/</g, '&lt;')
 .replace(/>/g, '&gt;')
 .replace(/("[^\"]*?")/g, '$1')
 .replace(/('[^\']*?')/g, '$1')
 .replace(/&lt;!--(.*)--&gt;/g, '&lt;!--$1--&gt;')
 .replace(/&lt;([^!][^\s&]*)/g, '&lt;$1');
 };

Highlighters.generic = function(code) {
 return code
 .replace(/</g, '&lt;')
 .replace(/>/g, '&gt;')
 .replace(/("[^\"]*?")/g, '$1')
 .replace(/('[^\']*?')/g, '$1')
 .replace(/(\/\/|#)(.*)/gm, '$1$2')
 .replace(/(\d+\.\d+)/gm, '$1')
 .replace(/(\d+)/gm, '$1');
 };

/**
   * Menu view. Renders menus
   */

var MenuView = Flatdoc.menuView = function(menu) {
 var $el = $("<ul>");

function process(node, $parent) {
      var id = node.id || 'root';

var $li = $('<li>')
 .attr('id', id + '-item')
 .addClass('level-' + node.level)
 .appendTo($parent);

if (node.section) {
 var $a = $('<a>')
 .html(node.section)
 .attr('id', id + '-link')
 .attr('href', '#' + node.id)
 .addClass('level-' + node.level)
 .appendTo($li);
 }

if (node.items.length > 0) {
 var $ul = $('<ul>')
 .addClass('level-' + (node.level+1))
 .attr('id', id + '-list')
 .appendTo($li);

node.items.forEach(function(item) {
          process(item, $ul);
        });
      }
    }

process(menu, $el);
    return $el;
  };

/**
   * A runner module that fetches via a `fetcher` function.
   *
   *     var runner = new Flatdoc.runner({
   *       fetcher: Flatdoc.url('readme.txt')
   *     });
   *     runner.run();
   *
   * The following options are available:
   *
   *  - `fetcher` - a function that takes a callback as an argument and
   *    executes that callback when data is returned.
   *
   * See: [Flatdoc.run()]
   */

var Runner = Flatdoc.runner = function(options) {
    this.initialize(options);
  };

Runner.prototype.root    = '[role~="flatdoc"]';
  Runner.prototype.menu    = '[role~="flatdoc-menu"]';
  Runner.prototype.title   = '[role~="flatdoc-title"]';
  Runner.prototype.content = '[role~="flatdoc-content"]';

Runner.prototype.initialize = function(options) {
    $.extend(this, options);
  };

/**
   * Syntax highlighting.
   *
   * You may define a custom highlight function such as `highlight` from
   * the highlight.js library.
   *
   *     Flatdoc.run({
   *       highlight: function (code, value) {
   *         return hljs.highlight(lang, code).value;
   *       },
   *       ...
   *     });
   *
   */

Runner.prototype.highlight = function(code, lang) {
    var fn = Flatdoc.highlighters[lang] || Flatdoc.highlighters.generic;
    return fn(code);
  };

/**
   * Loads the Markdown document (via the fetcher), parses it, and applies it
   * to the elements.
   */

Runner.prototype.run = function() {
    var doc = this;
    $(doc.root).trigger('flatdoc:loading');
    doc.fetcher(function(err, markdown) {
      if (err) {
        console.error('[Flatdoc] fetching Markdown data failed.', err);
        return;
      }
      var data = Flatdoc.parser.parse(markdown, doc.highlight);
      doc.applyData(data, doc);
      var id = location.hash.substr(1);
      if (id) {
        var el = document.getElementById(id);
        if (el) el.scrollIntoView(true);
      };
      $(doc.root).trigger('flatdoc:ready');
    });
  };

/**
   * Applies given doc data `data` to elements in object `elements`.
   */

Runner.prototype.applyData = function(data) {
    var elements = this;

elements.el('title').html(data.title);
    elements.el('content').html(data.content.find('>*'));
    elements.el('menu').html(MenuView(data.menu));
  };

/**
   * Fetches a given element from the DOM.
   *
   * Returns a jQuery object.
   * @api private
   */

Runner.prototype.el = function(aspect) {
    return $(this[aspect], this.root);
  };

/*
   * Helpers
   */

// http://stackoverflow.com/questions/298750/how-do-i-select-text-nodes-with-jquery
  function getTextNodesIn(el) {
    var exclude = 'iframe,pre,code';
    return $(el).find(':not('+exclude+')').andSelf().contents().filter(function() {
      return this.nodeType == 3 && $(this).closest(exclude).length === 0;
    });
  }

// http://www.leancrew.com/all-this/2010/11/smart-quotes-in-javascript/
  function quotify(a) {
    a = a.replace(/(^|[\-\u2014\s(\["])'/g, "$1\u2018");        // opening singles
    a = a.replace(/'/g, "\u2019");                              // closing singles & apostrophes
    a = a.replace(/(^|[\-\u2014\/\[(\u2018\s])"/g, "$1\u201c"); // opening doubles
    a = a.replace(/"/g, "\u201d");                              // closing doubles
    a = a.replace(/\.\.\./g, "\u2026");                         // ellipses
    a = a.replace(/--/g, "\u2014");                             // em-dashes
    return a;
  }

function slugify(text) {
    if (typeof text !== 'string') return "";
    return text.toLowerCase().match(/[a-z0-9]+/g).join('-');
  }
})(jQuery);

/* jshint ignore:start */

/*!
 * marked - a markdown parser
 * Copyright (c) 2011-2013, Christopher Jeffrey. (MIT Licensed)
 * https://github.com/chjj/marked
 */

/*!
 * base64.js
 * http://github.com/dankogai/js-base64
 */

/* jshint ignore:end */

Ubuntu

Sid Gifari From Gifari Industries - BD Cyber Security Team