mdless 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f01cf923665ca168bdbe40383e7182173c9b3427
+  data.tar.gz: 9d9e98c876836336fa9f789997db7c939b931948
+SHA512:
+  metadata.gz: 26539f402a4c058de79aa8539e8872fc12a8c564380f58231a5ec4f8df637740c3f48e336c71bdc88c1cb6f289424c7fc05cad5d33cea284896525d83082885c
+  data.tar.gz: 885ca66c4586a75d3aabef7a7cd50c6f692864e298f8041be6abf3270746e92916ddfb29012dc0cf2d2f180f206651a5e6252cea91758d2beb5cae876c19066b

data/README.md

@@ -0,0 +1,56 @@
+
+# mdless
+
+
+`mdless` is a utility that provides a formatted and highlighted view of Markdown files in Terminal.
+
+I often use iTerm2 in visor mode, so `qlmanage -p` is annoying. I still wanted a way to view Markdown files quickly and without cruft.
+
+## Features
+
+- Built in pager functionality with pipe capability, `less` replacement for Markdown files
+- Format tables
+- Colorize Markdown syntax for most elements
+- Normalize spacing and link formatting
+- Display footnotes after each paragraph
+- Inline image display (local, optionally remote) if using iTerm2 2.9+
+- Syntax highlighting when `pygmentize` is available
+- List headlines in document
+- Display section of the document via headline search
+
+## Installation
+
+    gem install mdless
+
+## Usage 
+
+`mdless [options] path` or `cat [path] | mdless`
+
+The pager used is determined by system configuration in this order of preference:
+
+* `$GIT_PAGER`
+* `$PAGER`
+* `git config --get-all core.pager`
+* `less`
+* `more`
+* `cat`
+* `pager`
+
+### Options
+
+    -s, --section=TITLE              Output only a headline-based section of 
+                                     the input
+    -w, --width=COLUMNS              Column width to format for (default 80)
+    -p, --[no-]pager                 Formatted output to pager (default on)
+    -P                               Disable pager (same as --no-pager)
+    -c, --[no-]color                 Colorize output (default on)
+    -l, --list                       List headers in document and exit
+    -i, --images=TYPE                Include [local|remote (both)] images in 
+                                     output (requires imgcat and iTerm2, 
+                                     default NONE)
+    -I, --all-images                 Include local and remote images in output 
+    -h, --help                       Display this screen
+    -v, --version                    Display version number
+
+
+

data/bin/mdless

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+require 'mdless'
+
+def class_exists?(class_name)
+  klass = Module.const_get(class_name)
+  return klass.is_a?(Class)
+rescue NameError
+  return false
+end
+
+if class_exists? 'Encoding'
+  Encoding.default_external = Encoding::UTF_8 if Encoding.respond_to?('default_external')
+  Encoding.default_internal = Encoding::UTF_8 if Encoding.respond_to?('default_internal')
+end
+
+CLIMarkdown::Converter.new(ARGV)

data/lib/helpers/formattables.py

@@ -0,0 +1,105 @@
+#!/usr/bin/python
+
+import sys
+import re
+
+def just(string, type, n):
+    "Justify a string to length n according to type."
+
+    if type == '::':
+        return string.center(n)
+    elif type == '-:':
+        return string.rjust(n)
+    elif type == ':-':
+        return string.ljust(n)
+    else:
+        return string
+
+
+def normtable(text):
+    "Aligns the vertical bars in a text table."
+
+    # Start by turning the text into a list of lines.
+    lines = text.splitlines()
+    rows = len(lines)
+
+    # Figure out the cell formatting.
+    # First, find the separator line.
+    for i in range(rows):
+        if set(lines[i]).issubset('|:.-'):
+            formatline = lines[i]
+            formatrow = i
+            break
+
+    # Delete the separator line from the content.
+    del lines[formatrow]
+
+    # Determine how each column is to be justified.
+    formatline = formatline.strip(' ')
+    if formatline[0] == '|': formatline = formatline[1:]
+    if formatline[-1] == '|': formatline = formatline[:-1]
+    fstrings = formatline.split('|')
+    justify = []
+    for cell in fstrings:
+        ends = cell[0] + cell[-1]
+        if ends == '::':
+            justify.append('::')
+        elif ends == '-:':
+            justify.append('-:')
+        else:
+            justify.append(':-')
+
+    # Assume the number of columns in the separator line is the number
+    # for the entire table.
+    columns = len(justify)
+
+    # Extract the content into a matrix.
+    content = []
+    for line in lines:
+        line = line.strip(' ')
+        if line[0] == '|': line = line[1:]
+        if line[-1] == '|': line = line[:-1]
+        cells = line.split('|')
+        # Put exactly one space at each end as "bumpers."
+        linecontent = [ ' ' + x.strip() + ' ' for x in cells ]
+        content.append(linecontent)
+
+    # Append cells to rows that don't have enough.
+    rows = len(content)
+    for i in range(rows):
+        while len(content[i]) < columns:
+            content[i].append('')
+
+    # Get the width of the content in each column. The minimum width will
+    # be 2, because that's the shortest length of a formatting string and
+    # because that matches an empty column with "bumper" spaces.
+    widths = [2] * columns
+    for row in content:
+        for i in range(columns):
+            widths[i] = max(len(row[i]), widths[i])
+
+    # Add whitespace to make all the columns the same width and
+    formatted = []
+    for row in content:
+        formatted.append('|' + '|'.join([ just(s, t, n) for (s, t, n) in zip(row, justify, widths) ]) + '|')
+
+    # Recreate the format line with the appropriate column widths.
+    formatline = '|' + '|'.join([ s[0] + '-'*(n-2) + s[-1] for (s, n) in zip(justify, widths) ]) + '|'
+
+    # Insert the formatline back into the table.
+    formatted.insert(formatrow, formatline)
+
+    # Return the formatted table.
+    return '\n'.join(formatted)
+
+space_cleaner = r'''(?s)[ \t]*(?P<value>[\|:])[ \t]*'''
+
+def whitespaceProcess(group_object):
+    return group_object.group('value')
+
+
+# Read the input, process, and print.
+unformatted = sys.stdin.read()
+unformatted = re.sub(space_cleaner, whitespaceProcess, unformatted, flags=re.DOTALL)
+
+print normtable(unformatted)

data/lib/mdless/colors.rb

@@ -0,0 +1,124 @@
+module CLIMarkdown
+  module Colors
+
+    def uncolor
+      self.gsub(/\e\[[\d;]+m/,'')
+    end
+
+    def uncolor!
+      self.replace self.uncolor
+    end
+
+    def size_clean
+      self.uncolor.size
+    end
+
+    def wrap(width=78)
+
+      if self.uncolor =~ /(^([%~] |\s*>)| +[=\-]{5,})/
+        return self
+      end
+
+      visible_width = 0
+      lines = []
+      line = ''
+      last_ansi = ''
+
+      line += self.match(/^\s*/)[0].gsub(/\t/,'    ')
+      input = self.dup # .gsub(/(\w-)(\w)/,'\1 \2')
+      input.split(/\s+/).each do |word|
+        last_ansi = line.scan(/\e\[[\d;]+m/)[-1] || ''
+        if visible_width + word.size_clean >= width
+          lines << line + xc
+          visible_width = word.size_clean
+          line = last_ansi + word
+        elsif line.empty?
+          visible_width = word.size_clean
+          line = last_ansi + word
+        else
+          visible_width += word.size_clean + 1
+          line << " " << last_ansi + word
+        end
+       end
+       lines << line + self.match(/\s*$/)[0] + xc if line
+      return lines.join("\n") # .gsub(/\- (\S)/,'-\1')
+    end
+
+    def xc(count=0)
+      c([:x,:white])
+    end
+
+    def c(args)
+
+      colors = {
+            :reset => 0,     # synonym for :clear
+            :x => 0,
+            :bold => 1,
+            :b => 1,
+            :dark => 2,
+            :d => 2,
+            :italic => 3,     # not widely implemented
+            :i => 3,
+            :underline => 4,
+            :underscore => 4,     # synonym for :underline
+            :u => 4,
+            :blink => 5,
+            :rapid_blink => 6,     # not widely implemented
+            :negative => 7,     # no reverse because of String#reverse
+            :r => 7,
+            :concealed => 8,
+            :strikethrough => 9,     # not widely implemented
+            :black => 30,
+            :red => 31,
+            :green => 32,
+            :yellow => 33,
+            :blue => 34,
+            :magenta => 35,
+            :cyan => 36,
+            :white => 37,
+            :on_black => 40,
+            :on_red => 41,
+            :on_green => 42,
+            :on_yellow => 43,
+            :on_blue => 44,
+            :on_magenta => 45,
+            :on_cyan => 46,
+            :on_white => 47,
+            :intense_black => 90,    # High intensity, aixterm (works in OS X)
+            :intense_red => 91,
+            :intense_green => 92,
+            :intense_yellow => 93,
+            :intense_blue => 94,
+            :intense_magenta => 95,
+            :intense_cyan => 96,
+            :intense_white => 97,
+            :on_intense_black => 100,    # High intensity background, aixterm (works in OS X)
+            :on_intense_red => 101,
+            :on_intense_green => 102,
+            :on_intense_yellow => 103,
+            :on_intense_blue => 104,
+            :on_intense_magenta => 105,
+            :on_intense_cyan => 106,
+            :on_intense_white => 107
+          }
+
+      out = []
+
+      args.each {|arg|
+        if colors.key? arg
+          out << colors[arg]
+        end
+      }
+
+      if out.size > 0
+        "\e[#{out.sort.join(';')}m"
+      else
+        ''
+      end
+    end
+  end
+end
+
+class String
+  include CLIMarkdown::Colors
+end

data/lib/mdless/converter.rb

@@ -0,0 +1,781 @@
+module CLIMarkdown
+  class Converter
+    include Colors
+
+    attr_reader :helpers, :log
+
+    def version
+      "#{CLIMarkdown::EXECUTABLE_NAME} #{CLIMarkdown::VERSION}"
+    end
+
+    def initialize(args)
+      @log = Logger.new(STDERR)
+      @log.level = Logger::FATAL
+
+      @options = {}
+      optparse = OptionParser.new do |opts|
+        opts.banner = "#{version} by Brett Terpstra\n\n> Usage: #{CLIMarkdown::EXECUTABLE_NAME} [options] path\n\n"
+
+        @options[:section] = nil
+        opts.on( '-s', '--section=TITLE', 'Output only a headline-based section of the input' ) do |section|
+          @options[:section] = section
+        end
+
+        @options[:width] = 80
+        opts.on( '-w', '--width=COLUMNS', 'Column width to format for (default 80)' ) do |columns|
+          @options[:width] = columns.to_i
+          if @options[:width] = 0
+            @options[:width] = %x{tput cols}.strip.to_i
+          end
+        end
+
+        @options[:pager] = true
+        opts.on( '-p', '--[no-]pager', 'Formatted output to pager (default on)' ) do |p|
+          @options[:pager] = p
+        end
+
+        opts.on( '-P', 'Disable pager (same as --no-pager)' ) do
+          @options[:pager] = false
+        end
+
+        @options[:color] = true
+        opts.on( '-c', '--[no-]color', 'Colorize output (default on)' ) do |c|
+          @options[:color] = c
+        end
+
+        @options[:links] = :inline
+        opts.on( '--links=FORMAT', 'Link style ([inline, reference], default inline)' ) do |format|
+          if format =~ /^r/i
+            @options[:links] = :reference
+          end
+        end
+
+        @options[:list] = false
+        opts.on( '-l', '--list', 'List headers in document and exit' ) do
+          @options[:list] = true
+        end
+
+        @options[:local_images] = false
+        @options[:remote_images] = false
+
+        if exec_available('imgcat') && ENV['TERM_PROGRAM'] == 'iTerm.app'
+          opts.on('-i', '--images=TYPE', 'Include [local|remote (both)] images in output (requires imgcat and iTerm2, default NONE)' ) do |type|
+            if type =~ /^(r|b|a)/i
+              @options[:local_images] = true
+              @options[:remote_images] = true
+            elsif type =~ /^l/i
+              @options[:local_images] = true
+            end
+          end
+          opts.on('-I', '--all-images', 'Include local and remote images in output (requires imgcat and iTerm2)' ) do
+            @options[:local_images] = true
+            @options[:remote_images] = true
+          end
+        end
+
+
+        opts.on( '-d', '--debug LEVEL', 'Level of debug messages to output' ) do |level|
+          if level.to_i > 0 && level.to_i < 5
+            @log.level = 5 - level.to_i
+          else
+            $stderr.puts "Log level out of range (1-4)"
+            Process.exit 1
+          end
+        end
+
+        opts.on( '-h', '--help', 'Display this screen' ) do
+          puts opts
+          exit
+        end
+
+        opts.on( '-v', '--version', 'Display version number' ) do
+          puts version
+          exit
+        end
+      end
+
+      optparse.parse!
+
+      @cols = @options[:width] || %x{tput cols}.strip.to_i * 0.9
+      @output = ''
+
+      input = ''
+      @ref_links = {}
+      @footnotes = {}
+
+      if args.length > 0
+        files = args.delete_if { |f| !File.exists?(f) }
+        files.each {|file|
+          @log.info(%Q{Processing "#{file}"})
+          @file = file
+          begin
+            input = IO.read(file).force_encoding('utf-8')
+          rescue
+            input = IO.read(file)
+          end
+          if @options[:list]
+            list_headers(input)
+          else
+            convert_markdown(input)
+          end
+        }
+        printout
+      elsif STDIN.stat.size > 0
+        @file = nil
+        begin
+          input = STDIN.read.force_encoding('utf-8')
+        rescue
+          input = STDIN.read
+        end
+        if @options[:list]
+          list_headers(input)
+        else
+          convert_markdown(input)
+        end
+        printout
+      else
+        $stderr.puts "No input"
+        Process.exit 1
+      end
+    end
+
+    def list_headers(input)
+      h_adjust = highest_header(input) - 1
+      input.gsub!(/^(#+)/) do |m|
+        match = Regexp.last_match
+        new_level = match[1].length - h_adjust
+        if new_level > 0
+          "#" * new_level
+        else
+          ''
+        end
+      end
+
+      headers = []
+      last_level = 0
+      input.split(/\n/).each do |line|
+        if line =~ /^(#+)\s*(.*?)( #+)?\s*$/
+          level = $1.size - 1
+          title = $2
+
+          if level - 1 > last_level
+            level = last_level + 1
+          end
+          last_level = level
+
+          subdoc = case level
+          when 0
+            '  '
+          when 1
+            '- '
+          when 2
+            '+ '
+          when 3
+            '* '
+          else
+            '  '
+          end
+          headers.push(("  "*level) + (c([:x, :yellow]) + subdoc + title.strip + xc))
+        end
+      end
+
+      @output += headers.join("\n")
+    end
+
+    def highest_header(input)
+      headers = input.scan(/^(#+)/)
+      top = 6
+      headers.each {|h|
+        top = h[0].length if h[0].length < top
+      }
+      top
+    end
+
+    def color_table(input)
+      first = true
+      input.split(/\n/).map{|line|
+        if first
+          first = false
+          line.gsub!(/\|/, "#{c([:d,:black])}|#{c([:x,:yellow])}")
+        elsif line.strip =~ /^[|:\- ]+$/
+          line.gsub!(/^(.*)$/, "#{c([:d,:black])}\\1#{c([:x,:white])}")
+          line.gsub!(/([:\-]+)/,"#{c([:b,:black])}\\1#{c([:d,:black])}")
+        else
+          line.gsub!(/\|/, "#{c([:d,:black])}|#{c([:x,:white])}")
+        end
+      }.join("\n")
+    end
+
+    def table_cleanup(input)
+      in_table = false
+      header_row = false
+      all_content = []
+      this_table = []
+      orig_table = []
+      input.split(/\n/).each {|line|
+        if line =~ /(\|.*?)+/ && line !~ /^\s*~/
+          in_table = true
+          table_line = line.to_s.uncolor.strip.sub(/^\|?\s*/,'|').gsub(/\s*([\|:])\s*/,'\1')
+
+          if table_line.strip.gsub(/[\|:\- ]/,'') == ''
+            header_row = true
+          end
+          this_table.push(table_line)
+          orig_table.push(line)
+        else
+          if in_table
+            if this_table.length > 3
+              # if there's no header row, add one, cleanup requires it
+              unless header_row
+                cells = this_table[0].sub(/^\|/,'').scan(/.*?\|/).length
+                cell_row = '|' + ':-----|'*cells
+                this_table.insert(1, cell_row)
+              end
+
+              table = this_table.join("\n")
+              begin
+                res = clean_table(table)
+                res = color_table(res)
+              rescue
+                res = orig_table.join("\n")
+              end
+              all_content.push("\n" + res)
+            else
+              all_content.push(orig_table.join("\n"))
+            end
+            this_table = []
+            orig_table = []
+          end
+          in_table = false
+          header_row = false
+          all_content.push(line)
+        end
+      }
+      all_content.join("\n")
+    end
+
+    def clean_table(input)
+      dir = File.dirname(__FILE__)
+      lib = File.expand_path(dir + '/../../lib')
+      script = File.join(lib, 'helpers/formattables.py')
+
+      if File.exists?(script) and File.executable?(script)
+        begin
+
+          res, s = Open3.capture2(script, :stdin_data=>input.strip)
+
+          if s.success?
+            res
+          else
+            input
+          end
+        rescue => e
+          @log.error(e)
+          input
+        end
+      else
+        input
+      end
+    end
+
+    def clean_markers(input)
+      input.gsub!(/^(\e\[[\d;]+m)?[%~] ?/,'\1')
+      input
+    end
+
+    def update_inline_links(input)
+      links = {}
+      counter = 1
+      input.gsub!(/(?<=\])\((.*?)\)/) do |m|
+        links[counter] = $1.uncolor
+        "[#{counter}]"
+      end
+    end
+
+    def find_color(line,nullable=false)
+      return line if line.nil?
+      colors = line.scan(/\e\[[\d;]+m/)
+      if colors && colors.size > 0
+        colors[-1]
+      else
+        nullable ? nil : xc
+      end
+    end
+
+    def color_link(line, text, url)
+      out = c([:b,:black])
+      out += "[#{c([:u,:blue])}#{text}"
+      out += c([:b,:black])
+      out += "]("
+      out += c([:x,:cyan])
+      out += url
+      out += c([:b,:black])
+      out += ")"
+      out += find_color(line)
+      out
+    end
+
+    def color_image(line, text, url)
+      text.gsub!(/\e\[0m/,c([:x,:cyan]))
+
+      "#{c([:x,:red])}!#{c([:b,:black])}[#{c([:x,:cyan])}#{text}#{c([:b,:black])}](#{c([:u,:yellow])}#{url}#{c([:b,:black])})" + find_color(line)
+    end
+
+    def convert_markdown(input)
+
+      # yaml/MMD headers
+      in_yaml = false
+      if input.split("\n")[0] =~ /(?i-m)^---[ \t]*?(\n|$)/
+        @log.info("Found YAML")
+        # YAML
+        in_yaml = true
+        input.sub!(/(?i-m)^---[ \t]*\n([\s\S]*?)\n[\-.]{3}[ \t]*\n/) do |yaml|
+          m = Regexp.last_match
+
+          @log.warn("Processing YAML Header")
+          m[0].split(/\n/).map {|line|
+            if line =~ /^[\-.]{3}\s*$/
+              line = c([:d,:black,:on_black]) + "% " + c([:d,:black,:on_black]) + line
+            else
+              line.sub!(/^(.*?:)[ \t]+(\S)/, '\1 \2')
+              line = c([:d,:black,:on_black]) + "% " + c([:d,:white]) + line
+            end
+            if @cols - line.uncolor.size > 0
+              line += " "*(@cols-line.uncolor.size)
+            end
+          }.join("\n") + "#{xc}\n"
+        end
+      end
+
+      if !in_yaml && input.gsub(/\n/,' ') =~ /(?i-m)^\w.+:\s+\S+ /
+        @log.info("Found MMD Headers")
+        input.sub!(/(?i-m)^([\S ]+:[\s\S]*?)+(?=\n\n)/) do |mmd|
+          puts mmd
+          mmd.split(/\n/).map {|line|
+            line.sub!(/^(.*?:)[ \t]+(\S)/, '\1 \2')
+            line = c([:d,:black,:on_black]) + "% " + c([:d,:white,:on_black]) + line
+            if @cols - line.uncolor.size > 0
+              line += " "*(@cols - line.uncolor.size)
+            end
+          }.join("\n") + " "*@cols + "#{xc}\n"
+        end
+
+      end
+
+
+      # Gather reference links
+      input.gsub!(/^\s{,3}(?<![\e*])\[\b(.+)\b\]: +(.+)/) do |m|
+        match = Regexp.last_match
+        @ref_links[match[1]] = match[2]
+        ''
+      end
+
+      # Gather footnotes (non-inline)
+      input.gsub!(/^ {,3}(?<!\*)(?:\e\[[\d;]+m)*\[(?:\e\[[\d;]+m)*\^(?:\e\[[\d;]+m)*\b(.+)\b(?:\e\[[\d;]+m)*\]: *(.*?)\n/) do |m|
+        match = Regexp.last_match
+        @footnotes[match[1].uncolor] = match[2].uncolor
+        ''
+      end
+
+      if @options[:section]
+        in_section = false
+        top_level = 1
+        new_content = []
+
+        input.split(/\n/).each {|graf|
+          if graf =~ /^(#+) *(.*?)( *#+)?$/
+            level = $1.length
+            title = $2
+
+            if in_section
+              if level > top_level
+                new_content.push(graf)
+              else
+                break
+              end
+            elsif title.downcase =~ /#{@options[:section]}/i
+              in_section = true
+              top_level = level
+              new_content.push(graf)
+            else
+              next
+            end
+          elsif in_section
+            new_content.push(graf)
+          end
+        }
+
+        input = new_content.join("\n")
+      end
+
+      h_adjust = highest_header(input) - 1
+      input.gsub!(/^(#+)/) do |m|
+        match = Regexp.last_match
+        "#" * (match[1].length - h_adjust)
+      end
+
+      # TODO: Probably easiest to just collect these with line indexes, remove until other highlighting is finished
+      input.gsub!(/(?i-m)([`~]{3,})([\s\S]*?)\n([\s\S]*?)\1/ ) do |cb|
+        m = Regexp.last_match
+        leader = m[2] ? m[2].upcase + ":" : 'CODE:'
+        leader += xc
+
+        if exec_available('pygmentize')
+          lexer = m[2].nil? ? '-g' : "-l #{m[2]}"
+          begin
+            hilite, s = Open3.capture2(%Q{pygmentize #{lexer} 2> /dev/null}, :stdin_data=>m[3])
+
+            if s.success?
+              hilite = hilite.split(/\n/).map{|l| "#{c([:x,:black])}~ #{xc}" + l}.join("\n")
+            end
+          rescue => e
+            @log.error(e)
+            hilite = m[0]
+          end
+
+        else
+
+          hilite = m[3].split(/\n/).map{|l|
+            new_code_line = l.gsub(/\t/,'    ')
+            orig_length = new_code_line.size + 3
+            new_code_line.gsub!(/ /,"#{c([:x,:white,:on_black])} ")
+            "#{c([:x,:black])}~ #{c([:x,:white,:on_black])} " + new_code_line + c([:x,:white,:on_black]) + " "*(@cols - orig_length) + xc
+          }.join("\n")
+        end
+        "#{c([:x,:magenta])}#{leader}\n#{hilite}#{xc}"
+      end
+
+      # remove empty links
+      input.gsub!(/\[(.*?)\]\(\s*?\)/, '\1')
+      input.gsub!(/\[(.*?)\]\[\]/, '[\1][\1]')
+
+      lines = input.split(/\n/)
+
+      # previous_indent = 0
+
+      lines.map!.with_index do |aLine, i|
+        line = aLine.dup
+        clean_line = line.dup.uncolor
+
+
+        if clean_line.uncolor =~ /(^[%~])/ # || clean_line.uncolor =~ /^( {4,}|\t+)/
+          ## TODO: find indented code blocks and prevent highlighting
+          ## Needs to miss block indented 1 level in lists
+          ## Needs to catch lists in code
+          ## Needs to avoid within fenced code blocks
+          # if line =~ /^([ \t]+)([^*-+]+)/
+          #   indent = $1.gsub(/\t/, "    ").size
+          #   if indent >= previous_indent
+          #     line = "~" + line
+          #   end
+          #   p [indent, previous_indent]
+          #   previous_indent = indent
+          # end
+        else
+          # Headlines
+          line.gsub!(/^(#+) *(.*?)(\s*#+)?\s*$/) do |match|
+            m = Regexp.last_match
+            pad = ""
+            ansi = ''
+            case m[1].length
+            when 1
+              ansi = c([:b, :black, :on_intense_white])
+              pad = c([:b,:white])
+              pad += m[2].length + 2 > @cols ? "*"*m[2].length : "*"*(@cols - (m[2].length + 2))
+            when 2
+              ansi = c([:b, :green, :on_black])
+              pad = c([:b,:black])
+              pad += m[2].length + 2 > @cols ? "-"*m[2].length : "-"*(@cols - (m[2].length + 2))
+            when 3
+              ansi = c([:u, :b, :yellow])
+            when 4
+              ansi = c([:x, :u, :yellow])
+            else
+              ansi = c([:b, :white])
+            end
+
+            "\n#{xc}#{ansi}#{m[2]} #{pad}#{xc}\n"
+          end
+
+          # place footnotes under paragraphs that reference them
+          if line =~ /\[(?:\e\[[\d;]+m)*\^(?:\e\[[\d;]+m)*(\S+)(?:\e\[[\d;]+m)*\]/
+            key = $1.uncolor
+            if @footnotes.key? key
+              line += "\n\n#{c([:b,:black,:on_black])}[#{c([:b,:cyan,:on_black])}^#{c([:x,:yellow,:on_black])}#{key}#{c([:b,:black,:on_black])}]: #{c([:u,:white,:on_black])}#{@footnotes[key]}#{xc}"
+              @footnotes.delete(key)
+            end
+          end
+
+          # color footnote references
+          line.gsub!(/\[\^(\S+)\]/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match, true)
+            counter = i
+            while last.nil? && counter > 0
+              counter -= 1
+              find_color(lines[counter])
+            end
+            "#{c([:b,:black])}[#{c([:b,:yellow])}^#{c([:x,:yellow])}#{match[1]}#{c([:b,:black])}]" + (last ? last : xc)
+          end
+
+          # blockquotes
+          line.gsub!(/^(\s*>)+( .*?)?$/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match, true)
+            counter = i
+            while last.nil? && counter > 0
+              counter -= 1
+              find_color(lines[counter])
+            end
+            "#{c([:b,:black])}#{match[1]}#{c([:x,:magenta])} #{match[2]}" + (last ? last : xc)
+          end
+
+          # make reference links inline
+          line.gsub!(/(?<![\e*])\[(\b.*?\b)?\]\[(\b.+?\b)?\]/) do |m|
+            match = Regexp.last_match
+            title = match[2] || ''
+            text = match[1] || ''
+            if match[2] && @ref_links.key?(title.downcase)
+              "[#{text}](#{@ref_links[title]})"
+            elsif match[1] && @ref_links.key?(text.downcase)
+              "[#{text}](#{@ref_links[text]})"
+            else
+              if input.match(/^#+\s*#{Regexp.escape(text)}/i)
+                "[#{text}](##{text})"
+              else
+                match[1]
+              end
+            end
+          end
+
+          # color inline links
+          line.gsub!(/(?<![\e*!])\[(\S.*?\S)\]\((\S.+?\S)\)/) do |m|
+            match = Regexp.last_match
+            color_link(match.pre_match, match[1], match[2])
+          end
+
+
+
+          # inline code
+          line.gsub!(/`(.*?)`/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match, true)
+            "#{c([:b,:black])}`#{c([:b,:white])}#{match[1]}#{c([:b,:black])}`" + (last ? last : xc)
+          end
+
+          # horizontal rules
+          line.gsub!(/^ {,3}([\-*] ?){3,}$/) do |m|
+            c([:x,:black]) + '_'*@cols + xc
+          end
+
+          # bold, bold/italic
+          line.gsub!(/(^|\s)[\*_]{2,3}([^\*_\s][^\*_]+?[^\*_\s])[\*_]{2,3}/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match, true)
+            counter = i
+            while last.nil? && counter > 0
+              counter -= 1
+              find_color(lines[counter])
+            end
+            "#{match[1]}#{c([:b])}#{match[2]}" + (last ? last : xc)
+          end
+
+          # italic
+          line.gsub!(/(^|\s)[\*_]([^\*_\s][^\*_]+?[^\*_\s])[\*_]/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match, true)
+            counter = i
+            while last.nil? && counter > 0
+              counter -= 1
+              find_color(lines[counter])
+            end
+            "#{match[1]}#{c([:u])}#{match[2]}" + (last ? last : xc)
+          end
+
+          # equations
+          line.gsub!(/((\\\\\[)(.*?)(\\\\\])|(\\\\\()(.*?)(\\\\\)))/) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match)
+            if match[2]
+              brackets = [match[2], match[4]]
+              equat = match[3]
+            else
+              brackets = [match[5], match[7]]
+              equat = match[6]
+            end
+            "#{c([:b, :black])}#{brackets[0]}#{xc}#{c([:b,:blue])}#{equat}#{c([:b, :black])}#{brackets[1]}" + (last ? last : xc)
+          end
+
+          # list items
+          line.gsub!(/^(\s*)([*\-+]|\d\.) /) do |m|
+            match = Regexp.last_match
+            last = find_color(match.pre_match)
+            indent = match[1] || ''
+            "#{indent}#{c([:d, :red])}#{match[2]} " + (last ? last : xc)
+          end
+
+          # definition lists
+          line.gsub!(/^(:\s*)(.*?)/) do |m|
+            match = Regexp.last_match
+            "#{c([:d, :red])}#{match[1]} #{c([:b, :white])}#{match[2]}#{xc}"
+          end
+
+          # misc html
+          line.gsub!(/<br\/?>/, "\n")
+          line.gsub!(/(?i-m)((<\/?)(\w+[\s\S]*?)(>))/) do |tag|
+            match = Regexp.last_match
+            last = find_color(match.pre_match)
+            "#{c([:d,:black])}#{match[2]}#{c([:b,:black])}#{match[3]}#{c([:d,:black])}#{match[4]}" + (last ? last : xc)
+          end
+        end
+
+        line
+      end
+
+      input = lines.join("\n")
+
+      # images
+      input.gsub!(/^(.*?)!\[(.*)?\]\((.*?\.(?:png|gif|jpg))( +.*)?\)/) do |m|
+        match = Regexp.last_match
+        if match[1].uncolor =~ /^( {4,}|\t)+/
+          match[0]
+        else
+          tail = match[4].nil? ? '' : " "+match[4].strip
+          result = nil
+          if exec_available('imgcat') && @options[:local_images]
+            if match[3]
+              img_path = match[3]
+              if img_path =~ /^http/ && @options[:remote_images]
+                begin
+                  res, s = Open3.capture2(%Q{curl -sS "#{img_path}" 2> /dev/null | imgcat})
+
+                  if s.success?
+                    pre = match[2].size > 0 ? "    #{c([:d,:blue])}[#{match[2].strip}]\n" : ''
+                    post = tail.size > 0 ? "\n    #{c([:b,:blue])}-- #{tail} --" : ''
+                    result = pre + res + post
+                  end
+                rescue => e
+                  @log.error(e)
+                end
+              else
+                if img_path =~ /^[~\/]/
+                  img_path = File.expand_path(img_path)
+                elsif @file
+                  base = File.expand_path(File.dirname(@file))
+                  img_path = File.join(base,img_path)
+                end
+                if File.exists?(img_path)
+                  pre = match[2].size > 0 ? "    #{c([:d,:blue])}[#{match[2].strip}]\n" : ''
+                  post = tail.size > 0 ? "\n    #{c([:b,:blue])}-- #{tail} --" : ''
+                  img = %x{imgcat "#{img_path}"}
+                  result = pre + img + post
+                end
+              end
+            end
+          end
+          if result.nil?
+            match[1] + color_image(match.pre_match, match[2], match[3] + tail) + xc
+          else
+            match[1] + result + xc
+          end
+        end
+      end
+
+      @footnotes.each {|t, v|
+        input += "\n\n#{c([:b,:black,:on_black])}[#{c([:b,:yellow,:on_black])}^#{c([:x,:yellow,:on_black])}#{t}#{c([:b,:black,:on_black])}]: #{c([:u,:white,:on_black])}#{v}#{xc}"
+      }
+
+      @output += input
+
+    end
+
+    def exec_available(cli)
+      if File.exists?(File.expand_path(cli))
+        File.executable?(File.expand_path(cli))
+      else
+        system "which #{cli} &> /dev/null"
+      end
+    end
+
+    def page(text, &callback)
+      read_io, write_io = IO.pipe
+
+      input = $stdin
+
+      pid = Kernel.fork do
+        write_io.close
+        input.reopen(read_io)
+        read_io.close
+
+        # Wait until we have input before we start the pager
+        IO.select [input]
+
+        pager = which_pager
+        begin
+          exec(pager.join(' '))
+        rescue SystemCallError => e
+          @log.error(e)
+          exit 1
+        end
+      end
+
+      read_io.close
+      write_io.write(text)
+      write_io.close
+
+      _, status = Process.waitpid2(pid)
+      status.success?
+    end
+
+    def printout
+      out = @output.strip.split(/\n/).map {|p|
+        p.wrap(@cols)
+      }.join("\n")
+
+
+      unless out && out.size > 0
+        $stderr.puts "No results"
+        Process.exit
+      end
+
+      out = table_cleanup(out)
+      out = clean_markers(out)
+      out = out.gsub(/\n+{2,}/m,"\n\n") + "\n#{xc}\n\n"
+
+      unless @options[:color]
+        out.uncolor!
+      end
+
+      if @options[:pager]
+        page("\n\n" + out)
+      else
+        $stdout.puts ("\n\n" + out)
+      end
+    end
+
+    def which_pager
+      pagers = [ENV['GIT_PAGER'], ENV['PAGER'],
+                `git config --get-all core.pager`.split.first,
+                'less', 'more', 'cat', 'pager']
+      pagers.select! do |f|
+        if f
+          system "which #{f} &> /dev/null"
+        else
+          false
+        end
+      end
+
+      pg = pagers.first
+      args = case pg
+      when 'more'
+        ' -r'
+      when 'less'
+        ' -r'
+      else
+        ''
+      end
+
+      [pg, args]
+    end
+  end
+end

data/lib/mdless/version.rb

@@ -0,0 +1,3 @@
+module CLIMarkdown
+  VERSION = '0.0.5'
+end

data/lib/mdless.rb

@@ -0,0 +1,12 @@
+require 'optparse'
+require 'shellwords'
+require 'open3'
+require 'fileutils'
+require 'logger'
+require 'mdless/version.rb'
+require 'mdless/colors'
+require 'mdless/converter'
+
+module CLIMarkdown
+  EXECUTABLE_NAME = 'mdless'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: mdless
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Brett Terpstra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A CLI that provides a formatted and highlighted view of Markdown files
+  in a terminal
+email: me@brettterpstra.com
+executables:
+- mdless
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- bin/mdless
+- lib/helpers/formattables.py
+- lib/mdless.rb
+- lib/mdless/colors.rb
+- lib/mdless/converter.rb
+- lib/mdless/version.rb
+homepage: http://brettterpstra.com/project/mdless/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --title
+- mdless
+- --main
+- README.md
+- --markup
+- markdown
+- -ri
+require_paths:
+- lib
+- 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.4.6
+signing_key: 
+specification_version: 4
+summary: A pager like less, but for Markdown files
+test_files: []