github-markdown-server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f1f3e1b6c0b783128c49522e43ed9a0adad443c
+  data.tar.gz: 9b81373d11efa51e007e87e495ad1a65fecc640a
+SHA512:
+  metadata.gz: 6c6de876abe5323c3fcb788827e2a76c9c244da3afa336ea5fdb649c5aeaee12bb28dec649a43563ed95df8724f3c733c27a7228631ca016eb63b3c01e884b95
+  data.tar.gz: a998e171e149d42f06941a553335791c7faeb70f20570616e61f87f18c7863678d12f3c36d3d1dd977ce3d8df18b968814e8d73f6e46a8e24ac143c51fb1b0f9

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 ark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,24 @@
+# Github Markdown Server
+
+Use your favorite editor to edit a markdown file, Run the server and open the file.
+Saving in your editor updates instantly in the browser.
+
+github-markdown-server is built on top of [github-markdown-preview](https://github.com/dmarcotte/github-markdown-preview).
+
+## Usage
+
+```shell
+github-markdown-server README.md
+```
+
+This will start a server serving in the current directory and all child directories and open a browser (on a mac) showing README.md converted to html. If you navigate to a directory name only child directories and .md files are shown in a directory listing. If there is a README.md file in that directory it will be appended to the directory listing.
+
+## Contrib
+
+There is a [contrib](contrib/) directory with an emacs lisp file which will start a server and open a file for you. It'll keep track of which servers it has started and reuse an existing server if a file you want to preview is under that server's serving directory.
+
+There is also a small python script (called `p`) which will work with files and produce paths and urls.
+
+## Contributing
+
+Please feel free to send me pull requests! This is my first Ruby project and it always feels like my first time when I write Emacs Lisp.

data/bin/github-markdown-server

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift("#{File.dirname(File.dirname(__FILE__))}/lib")
+
+require 'github-markdown-server'
+require 'optparse'
+
+comment_mode = false
+server_port = 8000
+browser = true
+directory = nil
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: github-markdown-server DIRECTORY"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-b", "--[no-]browser", "don't open initial file in browser when you start a server") do |b|
+    browser = b
+  end
+
+  opt.on("-c", "--comment-mode", "renders a preview for Github comments/issues") do
+    comment_mode = true
+  end
+
+  opt.on("-d=", "--directory=", "start webserver listening on this port") do |dir|
+    directory = dir
+  end
+
+  opt.on("-p=", "--port=", "start webserver listening on this port") do |port|
+    server_port = port unless port.nil?
+  end
+
+  opt.on("-v", "--version", "print the version") do
+    $stdout.puts 'github-markdown-server version ' + GithubMarkdownServer::VERSION
+    Kernel.exit
+  end
+end
+
+opt_parser.parse!
+
+file_name = ARGV.at(0) || '.'
+directory = directory || file_name
+options = {
+  :comment_mode => comment_mode,
+  :server_port => server_port,
+  :browser => browser,
+  :directory => directory,
+  :file_name => file_name,
+}
+p "go on #{server_port}"
+GithubMarkdownServer::Server.new(options)

data/contrib/github-markdown-server.el

@@ -0,0 +1,73 @@
+;;; github-markdown-server -- start a server and open a markdown file in it
+;;; Created by: Alex K (wtwf.com) Thu Nov 27 02:48:00 2014
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'cl-lib)
+
+(defvar github-markdown-servers '() "The servers we have running.")
+(defvar github-markdown-server-port 7494 "The next available server port.")
+
+(defun git-base (&optional file-name)
+  "Get the base of a git repository for FILE-NAME (or the current buffer)."
+  (interactive (buffer-file-name))
+  (shell-command-to-string (concat "p -t -g " (shell-quote-argument buffer-file-name))))
+
+(defun github-markdown-serve  (&optional file-name)
+  "Get the base of a git repository for FILE-NAME (or the current buffer)."
+  (interactive (list (buffer-file-name)))
+  (let ((base (git-base file-name)) (server nil) (server-running nil))
+    ;;;
+    (progn
+      (if (< (length base) 1) (setq base (directory-file-name file-name)))
+      ;; find a server that might still be running
+      (setq server (cl-reduce (lambda (a b)
+                             (if (and (string= (car b) (substring base 0 (length (car b))))
+                                   (or (not (car a)) (< (length (car b)) (length (car a)))))
+                               b a)) (cons nil github-markdown-servers)))
+      (if (and server
+            (progn
+              (message (concat "Checking if server running at" (prin1-to-string server)))
+              (setq server-running
+                (shell-command-to-string
+                  (concat "lsof -n -i4TCP:" (number-to-string (cdr server)) " | grep LISTEN")))
+              (> (length server-running) 0)))
+        (progn
+          (message "reusing server")
+          (call-process-shell-command
+            (concat "open "
+              (shell-quote-argument
+                (concat "http://localhost:"
+                  (number-to-string (cdr server))
+                  (substring file-name (length (car server))))))))
+        (progn
+          (if server
+            (progn (message (concat "re-starting server on port " (number-to-string (cdr server)))))
+            (progn
+              (message "starting server"))
+              (setq server (cons base github-markdown-server-port))
+              ))
+          (call-process-shell-command (concat "github-markdown-server"
+                                        " --directory=" (shell-quote-argument (car server))
+                                        " --port=" (number-to-string (cdr server))
+                                        " " (shell-quote-argument file-name)) nil 0)
+          (if (not server)
+            (progn (add-to-list 'github-markdown-servers server)
+              (setq github-markdown-server-port (+ github-markdown-server-port 1))))))))
+
+(defun view-file-in-browser (&optional file-name)
+  "Open up file on github or via a local markdown server.
+FILE-NAME will be current buffer if not specified.
+Prefix arg \[universal-argument] to not run local server."
+  (interactive (list (buffer-file-name)))
+  (if (and (not current-prefix-arg) (string-match "\.md$" file-name))
+    (github-markdown-serve file-name)
+    (call-process-shell-command
+      (concat "open "
+        (shell-quote-argument
+          (shell-command-to-string (concat "p -u -t " (shell-quote-argument file-name))))) nil 0)))
+
+(provide 'github-markdown-server)
+;;; github-markdown-server ends here

data/contrib/p

@@ -0,0 +1,116 @@
+#!/usr/bin/python
+# Created by: Alex K (wtwf.com)Tue Dec  7 16:50:41 2004
+# Last Modified: Time-stamp: <Thu Nov 27 03:08:53 PST 2014>
+
+"""
+Turn a path into an absolute path or url.
+
+-g, --git print out the root directory of this git repository
+-h, --help print out this message
+-p, --path show a full absolute path to the file
+-t, --trim do not append a newline to the file
+-u, --url show a url to the file (https://github.com/... or file:///)
+-s, --server show a utl to a local github-markdown-server
+--port use this port for github-markdown-server url (default 7474)
+--host use this host for github-markdown-server url (default localhost)
+"""
+
+__author__ = 'wtwf.com (Alex K)'
+
+import getopt
+import logging
+import os
+import re
+import sys
+
+def Usage(code, msg=''):
+  """Show a usage message."""
+  if code:
+    fd = sys.stderr
+  else:
+    fd = sys.stdout
+  PROGRAM = os.path.basename(sys.argv[0]) # pylint: disable=invalid-name,unused-variable
+  print >> fd, __doc__ % locals()
+  if msg:
+    print >> fd, msg
+  sys.exit(code)
+
+def Main():
+  """Run."""
+  logging.basicConfig()
+  logging.getLogger().setLevel(logging.DEBUG)
+  try:
+    opts, args = getopt.getopt(sys.argv[1:], 'ghpstu',
+                               'git,help,host=,path,port=,server,trim,url'.split(','))
+  except getopt.error, msg:
+    Usage(1, msg)
+
+  if not args:
+    Usage(1)
+
+  output = 'path'
+  trim = False
+  port = 7474
+  host = 'localhost'
+  for opt, arg in opts:
+    if opt in ('-g', '--git'):
+      output = 'git'
+    if opt in ('-h', '--help'):
+      Usage(0)
+    if opt in ('--host',):
+      host = arg
+    if opt in ('-p', '--path'):
+      output = 'path'
+    if opt in ('--port',):
+      port = int(arg)
+    if opt in ('-s', '--server'):
+      output = 'github-markdown-server'
+    if opt in ('-t', '--trim'):
+      trim = True
+    if opt in ('-u', '--url'):
+      output = 'url'
+
+  for arg in args:
+    arg = os.path.abspath(arg)
+    if output != 'path':
+      arg = ConvertToUrl(arg, output, port, host)
+    if trim:
+      sys.stdout.write(arg)  # for python 3 we could do print(arg, end='',flush=True)
+    else:
+      print arg
+
+def ConvertToUrl(arg, output, port, host):
+  """Try to turn this into a url."""
+  directory = arg
+  base_url = None
+  while directory != '/' and not base_url:
+    directory = os.path.dirname(directory)
+    config_filename = os.path.join(directory, '.git', 'config')
+    if os.path.exists(config_filename):
+      if output == 'git':
+        return directory
+      for line in open(config_filename):
+        match = re.search(r'url = git@github.com:(.*)\.git', line)
+        if match:
+          base_url = 'https://github.com/%s/blob/master/' % match.group(1)
+          break
+
+  if output == 'git':
+    return ''
+  if output == 'github-markdown-server':
+    if base_url:
+      basename = arg[len(directory) + 1:]
+      arg = 'http://%s:%d/%s' % (host, port, basename)
+    else:
+      basename = os.path.basename(arg)
+      arg = 'http://%s:%d/%s' % (host, port, basename)
+  else:
+    if base_url:
+      arg = base_url + arg[len(directory) + 1:]
+    else:
+      arg = 'file://' + arg
+
+  return arg
+
+if __name__ == '__main__':
+  Main()

data/data/js/live.js

@@ -0,0 +1,233 @@
+ /*
+  Live.js - One script closer to Designing in the Browser
+  Written for Handcraft.com by Martin Kool (@mrtnkl).
+
+  Version 4.
+  Recent change: Made stylesheet and mimetype checks case insensitive.
+
+  http://livejs.com
+  http://livejs.com/license (MIT)
+  @livejs
+
+  Include live.js#css to monitor css changes only.
+  Include live.js#js to monitor js changes only.
+  Include live.js#html to monitor html changes only.
+  Mix and match to monitor a preferred combination such as live.js#html,css
+
+  By default, just include live.js to monitor all css, js and html changes.
+
+  Live.js can also be loaded as a bookmarklet. It is best to only use it for CSS then,
+  as a page reload due to a change in html or css would not re-include the bookmarklet.
+  To monitor CSS and be notified that it has loaded, include it as: live.js#css,notify
+*/
+(function () {
+
+  var headers = { "Etag": 1, "Last-Modified": 1, "Content-Length": 1, "Content-Type": 1 },
+      resources = {},
+      pendingRequests = {},
+      currentLinkElements = {},
+      oldLinkElements = {},
+      interval = 1000,
+      loaded = false,
+      active = { "html": 1, "css": 1, "js": 1 };
+
+  var Live = {
+
+    // performs a cycle per interval
+    heartbeat: function () {
+      if (document.body) {
+        // make sure all resources are loaded on first activation
+        if (!loaded) Live.loadresources();
+        Live.checkForChanges();
+      }
+      setTimeout(Live.heartbeat, interval);
+    },
+
+    // loads all local css and js resources upon first activation
+    loadresources: function () {
+
+      // helper method to assert if a given url is local
+      function isLocal(url) {
+        var loc = document.location,
+            reg = new RegExp("^\\.|^\/(?!\/)|^[\\w]((?!://).)*$|" + loc.protocol + "//" + loc.host);
+        return url.match(reg);
+      }
+
+      // gather all resources
+      var scripts = document.getElementsByTagName("script"),
+          links = document.getElementsByTagName("link"),
+          uris = [];
+
+      // track local js urls
+      for (var i = 0; i < scripts.length; i++) {
+        var script = scripts[i], src = script.getAttribute("src");
+        if (src && isLocal(src))
+          uris.push(src);
+        if (src && src.match(/\blive.js#/)) {
+          for (var type in active)
+            active[type] = src.match("[#,|]" + type) != null
+          if (src.match("notify"))
+            alert("Live.js is loaded.");
+        }
+      }
+      if (!active.js) uris = [];
+      if (active.html) uris.push(document.location.href);
+
+      // track local css urls
+      for (var i = 0; i < links.length && active.css; i++) {
+        var link = links[i], rel = link.getAttribute("rel"), href = link.getAttribute("href", 2);
+        if (href && rel && rel.match(new RegExp("stylesheet", "i")) && isLocal(href)) {
+          uris.push(href);
+          currentLinkElements[href] = link;
+        }
+      }
+
+      // initialize the resources info
+      for (var i = 0; i < uris.length; i++) {
+        var url = uris[i];
+        Live.getHead(url, function (url, info) {
+          resources[url] = info;
+        });
+      }
+
+      // add rule for morphing between old and new css files
+      var head = document.getElementsByTagName("head")[0],
+          style = document.createElement("style"),
+          rule = "transition: all .3s ease-out;"
+      css = [".livejs-loading * { ", rule, " -webkit-", rule, "-moz-", rule, "-o-", rule, "}"].join('');
+      style.setAttribute("type", "text/css");
+      head.appendChild(style);
+      style.styleSheet ? style.styleSheet.cssText = css : style.appendChild(document.createTextNode(css));
+
+      // yep
+      loaded = true;
+    },
+
+    // check all tracking resources for changes
+    checkForChanges: function () {
+      for (var url in resources) {
+        if (pendingRequests[url])
+          continue;
+
+        Live.getHead(url, function (url, newInfo) {
+          var oldInfo = resources[url],
+              hasChanged = false;
+          resources[url] = newInfo;
+          for (var header in oldInfo) {
+            // do verification based on the header type
+            var oldValue = oldInfo[header],
+                newValue = newInfo[header],
+                contentType = newInfo["Content-Type"];
+            switch (header.toLowerCase()) {
+              case "etag":
+                if (!newValue) break;
+                // fall through to default
+              default:
+                hasChanged = oldValue != newValue;
+                break;
+            }
+            // if changed, act
+            if (hasChanged) {
+              Live.refreshResource(url, contentType);
+              break;
+            }
+          }
+        });
+      }
+    },
+
+    // act upon a changed url of certain content type
+    refreshResource: function (url, type) {
+      switch (type.toLowerCase()) {
+        // css files can be reloaded dynamically by replacing the link element
+        case "text/css":
+          var link = currentLinkElements[url],
+              html = document.body.parentNode,
+              head = link.parentNode,
+              next = link.nextSibling,
+              newLink = document.createElement("link");
+
+          html.className = html.className.replace(/\s*livejs\-loading/gi, '') + ' livejs-loading';
+          newLink.setAttribute("type", "text/css");
+          newLink.setAttribute("rel", "stylesheet");
+          newLink.setAttribute("href", url + "?now=" + new Date() * 1);
+          next ? head.insertBefore(newLink, next) : head.appendChild(newLink);
+          currentLinkElements[url] = newLink;
+          oldLinkElements[url] = link;
+
+          // schedule removal of the old link
+          Live.removeoldLinkElements();
+          break;
+
+        // check if an html resource is our current url, then reload
+        case "text/html":
+          if (url != document.location.href)
+            return;
+
+          // local javascript changes cause a reload as well
+        case "text/javascript":
+        case "application/javascript":
+        case "application/x-javascript":
+          document.location.reload();
+      }
+    },
+
+    // removes the old stylesheet rules only once the new one has finished loading
+    removeoldLinkElements: function () {
+      var pending = 0;
+      for (var url in oldLinkElements) {
+        // if this sheet has any cssRules, delete the old link
+        try {
+          var link = currentLinkElements[url],
+              oldLink = oldLinkElements[url],
+              html = document.body.parentNode,
+              sheet = link.sheet || link.styleSheet,
+              rules = sheet.rules || sheet.cssRules;
+          if (rules.length >= 0) {
+            oldLink.parentNode.removeChild(oldLink);
+            delete oldLinkElements[url];
+            setTimeout(function () {
+              html.className = html.className.replace(/\s*livejs\-loading/gi, '');
+            }, 100);
+          }
+        } catch (e) {
+          pending++;
+        }
+        if (pending) setTimeout(Live.removeoldLinkElements, 50);
+      }
+    },
+
+    // performs a HEAD request and passes the header info to the given callback
+    getHead: function (url, callback) {
+      pendingRequests[url] = true;
+      var xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XmlHttp");
+      xhr.open("HEAD", url, true);
+      xhr.onreadystatechange = function () {
+        delete pendingRequests[url];
+        if (xhr.readyState == 4 && xhr.status != 304) {
+          xhr.getAllResponseHeaders();
+          var info = {};
+          for (var h in headers) {
+            var value = xhr.getResponseHeader(h);
+            // adjust the simple Etag variant to match on its significant part
+            if (h.toLowerCase() == "etag" && value) value = value.replace(/^W\//, '');
+            if (h.toLowerCase() == "content-type" && value) value = value.replace(/^(.*?);.*?$/i, "$1");
+            info[h] = value;
+          }
+          callback(url, info);
+        }
+      }
+      xhr.send();
+    }
+  };
+
+  // start listening
+  if (document.location.protocol != "file:") {
+    if (!window.liveJsLoaded)
+      Live.heartbeat();
+
+    window.liveJsLoaded = true;
+  }
+  else if (window.console)
+    console.log("Live.js doesn't support the file protocol. It needs http.");
+})();

data/github-markdown-server.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'github-markdown-server'
+
+Gem::Specification.new do |s|
+  s.name        = 'github-markdown-server'
+  s.version     = GithubMarkdownServer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Alex K (wtwf.com)']
+  s.email       = 'ruby@mail.wtwf.com'
+  s.homepage    = 'https://github.com/arkarkark/github-markdown-server'
+  s.summary     = %q{Use your favorite editor to edit a markdown file, Run the server and open the file. Saving in your editor updates instantly in the browser.}
+  s.description = %q{Runs a webserver to preview Github markdown with live.js updating.}
+  s.license     = 'MIT'
+
+  s.add_dependency 'github-markdown-preview', '~> 3.1', '>= 3.1.3'
+
+  s.add_development_dependency 'minitest', '~> 5.4'
+  s.add_development_dependency 'bundler', '~> 1.7'
+  s.add_development_dependency 'rake', '~> 10.3'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+end

data/lib/github-markdown-server.rb

@@ -0,0 +1,7 @@
+module GithubMarkdownServer
+  class FileNotFoundError < StandardError; end
+
+  require 'github-markdown-server/version'
+  require 'github-markdown-server/resources'
+  require 'github-markdown-server/server'
+end

data/lib/github-markdown-server/resources.rb

@@ -0,0 +1,9 @@
+module GithubMarkdownServer
+  class Resources
+    ##
+    # Transforms a resource_path in data/ into an absolute path
+    def self.expand_path(resource_path)
+      File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'data', resource_path)
+    end
+  end
+end

data/lib/github-markdown-server/server.rb

@@ -0,0 +1,136 @@
+require 'github-markdown-preview'
+require 'pathname'
+require 'tempfile'
+require 'webrick'
+
+
+module GithubMarkdownServer
+
+  ##
+  # Serves files and converts markdown to github like html (with live.js as well).
+  class Server
+    def initialize(options = {})
+      port = options[:server_port] || 8000
+      @directory = File.expand_path(options[:directory])
+      @file_name = File.expand_path(options[:file_name])
+      url = "http://localhost:#{port}/"
+
+      if !File.directory?(@directory)
+        @directory = File.dirname(@directory)
+      end
+
+      url += @file_name[@directory.length + 1..-1]
+
+      server_options = {
+        :Port => port,
+        :DocumentRoot => @directory,
+        Logger: WEBrick::Log.new("/dev/null"),
+        AccessLog: [],
+      }
+      if options[:browser]
+        server_options[:StartCallback] = Proc.new {
+          system('open', url)
+        }
+      end
+      server = WEBrick::HTTPServer.new(server_options)
+
+      trap 'INT' do server.shutdown end
+      server.mount_proc '/' do |req, res|
+        if req.path == '/favicon.ico'
+          source_file = Resources.expand_path(File.join('image','favicon.ico'))
+        else
+          source_file = File.join(@directory, req.path)
+        end
+        case req.request_method
+        when 'HEAD'
+          res['last-modified'] = File.mtime(source_file).to_s
+        else
+          livejs = "<script>\n#{IO.read(Resources.expand_path(File.join('js','live.js')))}\n</script>"
+
+          if source_file.end_with? '.md'
+            res.body = md2html(source_file)
+            res.body += livejs
+          elsif File.directory?(source_file)
+            directory = source_file
+            for index in ['index.md', 'index.html', 'index.htm']
+              source_file = File.join(directory, index)
+              if File.exists?(source_file)
+                res.body = IO.read(source_file)
+                res.body += livejs
+                break
+              end
+            end
+            if !File.exists?(source_file)
+              bonus = nil
+              readme = File.join(directory, '/README.md')
+              if File.exists?(readme)
+                bonus = md2html(readme)
+              else
+                bonus = emptystyles
+              end
+              res.body = directory_listing(directory, req.path == '/', bonus)
+            end
+          else
+            res.body = IO.read(source_file)
+          end
+        end
+        res['content-type'] = mime_type(File.extname(source_file))
+      end
+
+      puts "Starting server #{url}"
+      server.start
+    end
+
+
+    def md2html(file)
+      out = Tempfile.new(File.basename(file))
+      GithubMarkdownPreview::HtmlPreview.new(file, {:preview_file => out.path})
+      IO.read(out.path)
+    end
+
+    def emptystyles
+      file = Tempfile.new('')
+      out = Tempfile.new('')
+      GithubMarkdownPreview::HtmlPreview.new(file, {:preview_file => out.path}).wrap_preview('')
+    end
+
+    def directory_listing(dir, root, bonus)
+      body = '<ul>'
+      body += '<li><a href="../">..</a>' unless root
+      dirs = Pathname.glob(File.join(dir, '/*/')).map do |x|
+        d = x.basename.to_s
+        "<li><a href=\"#{d}/\">#{d}</a></li>"
+      end
+      mds = Pathname.glob(File.join(dir, '*.md')).map do |x|
+        md = x.basename.to_s
+        "<li><a href=\"#{md}\">#{md}</a></li>"
+      end
+
+      body += dirs.join('') unless dirs.empty?
+      body += mds.join('') unless mds.empty?
+
+      body += '</ul>'
+      if bonus
+        sep = '<div class="readme-content">'
+        body = bonus.sub!(sep, (body + sep))
+      end
+      body
+    end
+
+    def mime_type(ext)
+      ext = ext.downcase.sub(/^\./, '')
+      case ext
+      when 'gif', 'jpg', 'png'
+        "image/#{ext}"
+      when 'md', 'html', 'htm'
+        'text/html'
+      when 'js', 'css'
+        "text/#{ext}"
+      when 'ico'
+        'image/vnd.microsoft.icon'
+      else
+        'application/octet-stream'
+      end
+    end
+  end
+end

data/lib/github-markdown-server/version.rb

@@ -0,0 +1,3 @@
+module GithubMarkdownServer
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: github-markdown-server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex K (wtwf.com)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: github-markdown-preview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+description: Runs a webserver to preview Github markdown with live.js updating.
+email: ruby@mail.wtwf.com
+executables:
+- github-markdown-server
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- bin/github-markdown-server
+- contrib/github-markdown-server.el
+- contrib/p
+- data/image/favicon.ico
+- data/js/live.js
+- github-markdown-server.gemspec
+- lib/github-markdown-server.rb
+- lib/github-markdown-server/resources.rb
+- lib/github-markdown-server/server.rb
+- lib/github-markdown-server/version.rb
+homepage: https://github.com/arkarkark/github-markdown-server
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Use your favorite editor to edit a markdown file, Run the server and open
+  the file. Saving in your editor updates instantly in the browser.
+test_files: []