motion-kramdown 0.5.0

data/lib/kramdown/parser/kramdown/paragraph.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+# RM require 'kramdown/parser/kramdown/blank_line'
+# RM require 'kramdown/parser/kramdown/extensions'
+# RM require 'kramdown/parser/kramdown/eob'
+# RM require 'kramdown/parser/kramdown/list'
+# RM require 'kramdown/parser/kramdown/html'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      LAZY_END_HTML_SPAN_ELEMENTS = Kramdown::Parser::Html::HTML_SPAN_ELEMENTS + %w{script}  # RM
+      LAZY_END_HTML_START = /<(?>(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR})\s*(?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}\s*=\s*(["']).*?\1)*\s*\/?>/m
+      LAZY_END_HTML_STOP = /<\/(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR}\s*>/m
+
+      OPT_SPACE_LAZY_END_HTML_START = /^#{OPT_SPACE}#{LAZY_END_HTML_START}/m  # RM Oniguruma -> ICU
+      OPT_SPACE_LAZY_END_HTML_STOP  = /^#{OPT_SPACE}#{LAZY_END_HTML_STOP}/m   # RM Oniguruma -> ICU
+
+      LAZY_END = /#{BLANK_LINE}|#{IAL_BLOCK_START}|#{EOB_MARKER}|#{OPT_SPACE_LAZY_END_HTML_STOP}|#{OPT_SPACE_LAZY_END_HTML_START}|\Z/  # RM
+
+      PARAGRAPH_START = /^#{OPT_SPACE}[^ \t].*?\n/
+      PARAGRAPH_MATCH = /^.*?\n/
+      PARAGRAPH_END = /#{LAZY_END}|#{DEFINITION_LIST_START}/
+
+      # Parse the paragraph at the current location.
+      def parse_paragraph
+        start_line_number = @src.current_line_number
+        result = @src.scan(PARAGRAPH_MATCH)
+        while !@src.match?(self.class::PARAGRAPH_END)
+          result << @src.scan(PARAGRAPH_MATCH)
+        end
+        result.chomp!
+        if @tree.children.last && @tree.children.last.type == :p
+          @tree.children.last.children.first.value << "\n" << result
+        else
+          @tree.children << new_block_el(:p, nil, nil, :location => start_line_number)
+          result.lstrip!
+          add_text(result, @tree.children.last)
+        end
+        true
+      end
+      define_parser(:paragraph, PARAGRAPH_START)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/smart_quotes.rb

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+#--
+# Parts of this file are based on code from RubyPants:
+#
+# = RubyPants -- SmartyPants ported to Ruby
+#
+# Ported by Christian Neukirchen <mailto:chneukirchen@gmail.com>
+#   Copyright (C) 2004 Christian Neukirchen
+#
+# Incooporates ideas, comments and documentation by Chad Miller
+#   Copyright (C) 2004 Chad Miller
+#
+# Original SmartyPants by John Gruber
+#   Copyright (C) 2003 John Gruber
+#
+#
+# = RubyPants -- SmartyPants ported to Ruby
+#
+#
+# [snip]
+#
+# == Authors
+#
+# John Gruber did all of the hard work of writing this software in
+# Perl for Movable Type and almost all of this useful documentation.
+# Chad Miller ported it to Python to use with Pyblosxom.
+#
+# Christian Neukirchen provided the Ruby port, as a general-purpose
+# library that follows the *Cloth API.
+#
+#
+# == Copyright and License
+#
+# === SmartyPants license:
+#
+# Copyright (c) 2003 John Gruber
+# (http://daringfireball.net)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+# * Neither the name "SmartyPants" nor the names of its contributors
+#   may be used to endorse or promote products derived from this
+#   software without specific prior written permission.
+#
+# This software is provided by the copyright holders and contributors
+# "as is" and any express or implied warranties, including, but not
+# limited to, the implied warranties of merchantability and fitness
+# for a particular purpose are disclaimed. In no event shall the
+# copyright owner or contributors be liable for any direct, indirect,
+# incidental, special, exemplary, or consequential damages (including,
+# but not limited to, procurement of substitute goods or services;
+# loss of use, data, or profits; or business interruption) however
+# caused and on any theory of liability, whether in contract, strict
+# liability, or tort (including negligence or otherwise) arising in
+# any way out of the use of this software, even if advised of the
+# possibility of such damage.
+#
+# === RubyPants license
+#
+# RubyPants is a derivative work of SmartyPants and smartypants.py.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+# This software is provided by the copyright holders and contributors
+# "as is" and any express or implied warranties, including, but not
+# limited to, the implied warranties of merchantability and fitness
+# for a particular purpose are disclaimed. In no event shall the
+# copyright owner or contributors be liable for any direct, indirect,
+# incidental, special, exemplary, or consequential damages (including,
+# but not limited to, procurement of substitute goods or services;
+# loss of use, data, or profits; or business interruption) however
+# caused and on any theory of liability, whether in contract, strict
+# liability, or tort (including negligence or otherwise) arising in
+# any way out of the use of this software, even if advised of the
+# possibility of such damage.
+#
+# == Links
+#
+# John Gruber:: http://daringfireball.net
+# SmartyPants:: http://daringfireball.net/projects/smartypants
+#
+# Chad Miller:: http://web.chad.org
+#
+# Christian Neukirchen:: http://kronavita.de/chris
+#
+#++
+#
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      SQ_PUNCT = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
+      SQ_CLOSE = %![^\ \\\\\t\r\n\\[{(-]!
+
+      SQ_RULES = [
+                  [/("|')(?=[_*]{1,2}\S)/, [:lquote1]],
+                  [/("|')(?=#{SQ_PUNCT}\B)/, [:rquote1]],
+                  # Special case for double sets of quotes, e.g.:
+                  #   <p>He said, "'Quoted' words in a larger quote."</p>
+                  [/(\s?)"'(?=\w)/, [1, :ldquo, :lsquo]],
+                  [/(\s?)'"(?=\w)/, [1, :lsquo, :ldquo]],
+                  # Special case for decade abbreviations (the '80s):
+                  [/(\s?)'(?=\d\ds)/, [1, :rsquo]],
+
+                  # Get most opening single/double quotes:
+                  [/(\s)('|")(?=\w)/, [1, :lquote2]],
+                  # Single/double closing quotes:
+                  [/(#{SQ_CLOSE})('|")/, [1, :rquote2]],
+                  # Special case for e.g. "<i>Custer</i>'s Last Stand."
+                  [/("|')(\s|s\b|$)/, [:rquote1, 2]],
+                  # Any remaining single quotes should be opening ones:
+                  [/(.?)'/m, [1, :lsquo]],
+                  [/(.?)"/m, [1, :ldquo]],
+                 ] #'"
+
+      SQ_SUBSTS = {
+        [:rquote1, '"'] => :rdquo,
+        [:rquote1, "'"] => :rsquo,
+        [:rquote2, '"'] => :rdquo,
+        [:rquote2, "'"] => :rsquo,
+        [:lquote1, '"'] => :ldquo,
+        [:lquote1, "'"] => :lsquo,
+        [:lquote2, '"'] => :ldquo,
+        [:lquote2, "'"] => :lsquo,
+      }
+      SMART_QUOTES_RE = /[^\\]?["']/
+
+      # Parse the smart quotes at current location.
+      def parse_smart_quotes
+        start_line_number = @src.current_line_number
+        substs = SQ_RULES.find {|reg, subst| @src.scan(reg)}[1]
+        substs.each do |subst|
+          if subst.kind_of?(Integer)
+            add_text(@src[subst])
+          else
+            val = SQ_SUBSTS[[subst, @src[subst.to_s[-1,1].to_i]]] || subst
+            @tree.children << Element.new(:smart_quote, val, nil, :location => start_line_number)
+          end
+        end
+      end
+      define_parser(:smart_quotes, SMART_QUOTES_RE, '[^\\\\]?["\']')
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/table.rb

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+# RM require 'kramdown/parser/kramdown/block_boundary'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      TABLE_SEP_LINE = /^([+|: -]*?-[+|: -]*?)[ \t]*\n/
+      TABLE_HSEP_ALIGN = /[ ]?(:?)-+(:?)[ ]?/
+      TABLE_FSEP_LINE = /^[+|: =]*?=[+|: =]*?[ \t]*\n/
+      TABLE_ROW_LINE = /^(.*?)[ \t]*\n/
+      TABLE_PIPE_CHECK = /(?:\||.*?[^\\\n]\|)/
+      TABLE_LINE = /#{TABLE_PIPE_CHECK}.*?\n/
+      TABLE_START = /^#{OPT_SPACE}(?=\S)#{TABLE_LINE}/
+
+      # Parse the table at the current location.
+      def parse_table
+        return false if !after_block_boundary?
+
+        saved_pos = @src.save_pos
+        orig_pos = @src.pos
+        table = new_block_el(:table, nil, nil, :alignment => [], :location => @src.current_line_number)
+        leading_pipe = (@src.check(TABLE_LINE) =~ /^\s*\|/)
+        @src.scan(TABLE_SEP_LINE)
+
+        rows = []
+        has_footer = false
+        columns = 0
+
+        add_container = lambda do |type, force|
+          if !has_footer || type != :tbody || force
+            cont = Element.new(type)
+            cont.children, rows = rows, []
+            table.children << cont
+          end
+        end
+
+        while !@src.eos?
+          break if !@src.check(TABLE_LINE)
+          if @src.scan(TABLE_SEP_LINE) && !rows.empty?
+            if table.options[:alignment].empty? && !has_footer
+              add_container.call(:thead, false)
+              table.options[:alignment] = @src[1].scan(TABLE_HSEP_ALIGN).map do |left, right|
+                (left.empty? && right.empty? && :default) || (right.empty? && :left) || (left.empty? && :right) || :center
+              end
+            else # treat as normal separator line
+              add_container.call(:tbody, false)
+            end
+          elsif @src.scan(TABLE_FSEP_LINE)
+            add_container.call(:tbody, true) if !rows.empty?
+            has_footer = true
+          elsif @src.scan(TABLE_ROW_LINE)
+            trow = Element.new(:tr)
+
+            # parse possible code spans on the line and correctly split the line into cells
+            env = save_env
+            cells = []
+            @src[1].split(/(<code.*?>.*?<\/code>)/).each_with_index do |str, i|
+              if i % 2 == 1
+                (cells.empty? ? cells : cells.last) << str
+              else
+                reset_env(:src => Kramdown::Utils::StringScanner.new(str, @src.current_line_number))
+                root = Element.new(:root)
+                parse_spans(root, nil, [:codespan])
+
+                root.children.each do |c|
+                  if c.type == :raw_text
+                    # Only on Ruby 1.9: f, *l = c.value.split(/(?<!\\)\|/).map {|t| t.gsub(/\\\|/, '|')}
+                    f, *l = c.value.split(/\\\|/, -1).map {|t| t.split(/\|/, -1)}.inject([]) do |memo, t|
+                      memo.last << "|#{t.shift}" if memo.size > 0
+                      memo.concat(t)
+                    end
+                    (cells.empty? ? cells : cells.last) << f
+                    cells.concat(l)
+                  else
+                    delim = (c.value.scan(/`+/).max || '') + '`'
+                    tmp = "#{delim}#{' ' if delim.size > 1}#{c.value}#{' ' if delim.size > 1}#{delim}"
+                    (cells.empty? ? cells : cells.last) << tmp
+                  end
+                end
+              end
+            end
+            restore_env(env)
+
+            cells.shift if leading_pipe && cells.first.strip.empty?
+            cells.pop if cells.last.strip.empty?
+            cells.each do |cell_text|
+              tcell = Element.new(:td)
+              tcell.children << Element.new(:raw_text, cell_text.strip)
+              trow.children << tcell
+            end
+            columns = [columns, cells.length].max
+            rows << trow
+          else
+            break
+          end
+        end
+
+        if !before_block_boundary?
+          @src.revert_pos(saved_pos)
+          return false
+        end
+
+        # Parse all lines of the table with the code span parser
+        env = save_env
+        l_src = ::Kramdown::Utils::StringScanner.new(extract_string(orig_pos...(@src.pos-1), @src),
+                                                     @src.current_line_number)
+        reset_env(:src => l_src)
+        root = Element.new(:root)
+        parse_spans(root, nil, [:codespan, :span_html])
+        restore_env(env)
+
+        # Check if each line has at least one unescaped pipe that is not inside a code span/code
+        # HTML element
+        # Note: It doesn't matter that we parse *all* span HTML elements because the row splitting
+        # algorithm above only takes <code> elements into account!
+        pipe_on_line = false
+        while (c = root.children.shift)
+          lines = c.value.split(/\n/)
+          if c.type == :codespan
+            if lines.size > 2 || (lines.size == 2 && !pipe_on_line)
+              break
+            elsif lines.size == 2 && pipe_on_line
+              pipe_on_line = false
+            end
+          else
+            break if lines.size > 1 && !pipe_on_line && lines.first !~ /^#{TABLE_PIPE_CHECK}/
+            pipe_on_line = (lines.size > 1 ? false : pipe_on_line) || (lines.last =~ /^#{TABLE_PIPE_CHECK}/)
+          end
+        end
+        @src.revert_pos(saved_pos) and return false if !pipe_on_line
+
+        add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
+
+        if !table.children.any? {|el| el.type == :tbody}
+          warning("Found table without body on line #{table.options[:location]} - ignoring it")
+          @src.revert_pos(saved_pos)
+          return false
+        end
+
+        # adjust all table rows to have equal number of columns, same for alignment defs
+        table.children.each do |kind|
+          kind.children.each do |row|
+            (columns - row.children.length).times do
+              row.children << Element.new(:td)
+            end
+          end
+        end
+        if table.options[:alignment].length > columns
+          table.options[:alignment] = table.options[:alignment][0...columns]
+        else
+          table.options[:alignment] += [:default] * (columns - table.options[:alignment].length)
+        end
+
+        @tree.children << table
+
+        true
+      end
+      define_parser(:table, TABLE_START)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      TYPOGRAPHIC_SYMS = [['---', :mdash], ['--', :ndash], ['...', :hellip],
+                          ['\\<<', '&lt;&lt;'], ['\\>>', '&gt;&gt;'],
+                          ['<< ', :laquo_space], [' >>', :raquo_space],
+                          ['<<', :laquo], ['>>', :raquo]]
+      TYPOGRAPHIC_SYMS_SUBST = Hash[*TYPOGRAPHIC_SYMS.flatten]
+      TYPOGRAPHIC_SYMS_RE = /#{TYPOGRAPHIC_SYMS.map {|k,v| Regexp.escape(k)}.join('|')}/
+
+      # Parse the typographic symbols at the current location.
+      def parse_typographic_syms
+        start_line_number = @src.current_line_number
+        @src.pos += @src.matched_size
+        val = TYPOGRAPHIC_SYMS_SUBST[@src.matched]
+        if val.kind_of?(Symbol)
+          @tree.children << Element.new(:typographic_sym, val, nil, :location => start_line_number)
+        elsif @src.matched == '\\<<'
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
+                                        nil, :location => start_line_number)
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
+                                        nil, :location => start_line_number)
+        else
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
+                                        nil, :location => start_line_number)
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
+                                        nil, :location => start_line_number)
+        end
+      end
+      define_parser(:typographic_syms, TYPOGRAPHIC_SYMS_RE, '--|\\.\\.\\.|(?:\\\\| )?(?:<<|>>)')
+
+    end
+  end
+end