motion-kramdown 0.5.0

data/lib/kramdown/utils/entities.rb

@@ -0,0 +1,347 @@
+# -*- 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 Utils
+
+    # Provides convenience methods for handling named and numeric entities.
+    module Entities
+
+      # Represents an entity that has a +code_point+ and +name+.
+      class Entity < Struct.new(:code_point, :name)
+
+        # Return the UTF8 representation of the entity.
+        def char
+          [code_point] ? [code_point].pack('U*') : nil # RM can't use rescue nil
+        end
+
+      end
+
+      # Array of arrays. Each sub-array specifies a code point and the associated name.
+      #
+      # This table is not used directly -- Entity objects are automatically created from it and put
+      # into a Hash map when this file is loaded.
+      ENTITY_TABLE = [
+                      [913, 'Alpha'],
+                      [914, 'Beta'],
+                      [915, 'Gamma'],
+                      [916, 'Delta'],
+                      [917, 'Epsilon'],
+                      [918, 'Zeta'],
+                      [919, 'Eta'],
+                      [920, 'Theta'],
+                      [921, 'Iota'],
+                      [922, 'Kappa'],
+                      [923, 'Lambda'],
+                      [924, 'Mu'],
+                      [925, 'Nu'],
+                      [926, 'Xi'],
+                      [927, 'Omicron'],
+                      [928, 'Pi'],
+                      [929, 'Rho'],
+                      [931, 'Sigma'],
+                      [932, 'Tau'],
+                      [933, 'Upsilon'],
+                      [934, 'Phi'],
+                      [935, 'Chi'],
+                      [936, 'Psi'],
+                      [937, 'Omega'],
+                      [945, 'alpha'],
+                      [946, 'beta'],
+                      [947, 'gamma'],
+                      [948, 'delta'],
+                      [949, 'epsilon'],
+                      [950, 'zeta'],
+                      [951, 'eta'],
+                      [952, 'theta'],
+                      [953, 'iota'],
+                      [954, 'kappa'],
+                      [955, 'lambda'],
+                      [956, 'mu'],
+                      [957, 'nu'],
+                      [958, 'xi'],
+                      [959, 'omicron'],
+                      [960, 'pi'],
+                      [961, 'rho'],
+                      [963, 'sigma'],
+                      [964, 'tau'],
+                      [965, 'upsilon'],
+                      [966, 'phi'],
+                      [967, 'chi'],
+                      [968, 'psi'],
+                      [969, 'omega'],
+                      [962, 'sigmaf'],
+                      [977, 'thetasym'],
+                      [978, 'upsih'],
+                      [982, 'piv'],
+                      [8204, 'zwnj'],
+                      [8205, 'zwj'],
+                      [8206, 'lrm'],
+                      [8207, 'rlm'],
+                      [8230, 'hellip'],
+                      [8242, 'prime'],
+                      [8243, 'Prime'],
+                      [8254, 'oline'],
+                      [8260, 'frasl'],
+                      [8472, 'weierp'],
+                      [8465, 'image'],
+                      [8476, 'real'],
+                      [8501, 'alefsym'],
+                      [8226, 'bull'],
+                      [8482, 'trade'],
+                      [8592, 'larr'],
+                      [8594, 'rarr'],
+                      [8593, 'uarr'],
+                      [8595, 'darr'],
+                      [8596, 'harr'],
+                      [8629, 'crarr'],
+                      [8657, 'uArr'],
+                      [8659, 'dArr'],
+                      [8656, 'lArr'],
+                      [8658, 'rArr'],
+                      [8660, 'hArr'],
+                      [8704, 'forall'],
+                      [8706, 'part'],
+                      [8707, 'exist'],
+                      [8709, 'empty'],
+                      [8711, 'nabla'],
+                      [8712, 'isin'],
+                      [8715, 'ni'],
+                      [8713, 'notin'],
+                      [8721, 'sum'],
+                      [8719, 'prod'],
+                      [8722, 'minus'],
+                      [8727, 'lowast'],
+                      [8730, 'radic'],
+                      [8733, 'prop'],
+                      [8734, 'infin'],
+                      [8736, 'ang'],
+                      [8743, 'and'],
+                      [8744, 'or'],
+                      [8745, 'cup'],
+                      [8746, 'cap'],
+                      [8747, 'int'],
+                      [8756, 'there4'],
+                      [8764, 'sim'],
+                      [8776, 'asymp'],
+                      [8773, 'cong'],
+                      [8800, 'ne'],
+                      [8801, 'equiv'],
+                      [8804, 'le'],
+                      [8805, 'ge'],
+                      [8834, 'sub'],
+                      [8835, 'sup'],
+                      [8838, 'sube'],
+                      [8839, 'supe'],
+                      [8836, 'nsub'],
+                      [8853, 'oplus'],
+                      [8855, 'otimes'],
+                      [8869, 'perp'],
+                      [8901, 'sdot'],
+                      [8942, 'vellip'],
+                      [8968, 'rceil'],
+                      [8969, 'lceil'],
+                      [8970, 'lfloor'],
+                      [8971, 'rfloor'],
+                      [9001, 'rang'],
+                      [9002, 'lang'],
+                      [9674, 'loz'],
+                      [9824, 'spades'],
+                      [9827, 'clubs'],
+                      [9829, 'hearts'],
+                      [9830, 'diams'],
+                      [38, 'amp'],
+                      [34, 'quot'],
+                      [39, 'apos'],
+                      [169, 'copy'],
+                      [60, 'lt'],
+                      [62, 'gt'],
+                      [338, 'OElig'],
+                      [339, 'oelig'],
+                      [352, 'Scaron'],
+                      [353, 'scaron'],
+                      [376, 'Yuml'],
+                      [710, 'circ'],
+                      [732, 'tilde'],
+                      [8211, 'ndash'],
+                      [8212, 'mdash'],
+                      [8216, 'lsquo'],
+                      [8217, 'rsquo'],
+                      [8220, 'ldquo'],
+                      [8221, 'rdquo'],
+                      [8224, 'dagger'],
+                      [8225, 'Dagger'],
+                      [8240, 'permil'],
+                      [8364, 'euro'],
+                      [8249, 'lsaquo'],
+                      [8250, 'rsaquo'],
+                      [160, 'nbsp'],
+                      [161, 'iexcl'],
+                      [163, 'pound'],
+                      [164, 'curren'],
+                      [165, 'yen'],
+                      [166, 'brvbar'],
+                      [167, 'sect'],
+                      [168, 'uml'],
+                      [171, 'laquo'],
+                      [187, 'raquo'],
+                      [174, 'reg'],
+                      [170, 'ordf'],
+                      [172, 'not'],
+                      [173, 'shy'],
+                      [175, 'macr'],
+                      [176, 'deg'],
+                      [177, 'plusmn'],
+                      [180, 'acute'],
+                      [181, 'micro'],
+                      [182, 'para'],
+                      [183, 'middot'],
+                      [184, 'cedil'],
+                      [186, 'ordm'],
+                      [162, 'cent'],
+                      [185, 'sup1'],
+                      [178, 'sup2'],
+                      [179, 'sup3'],
+                      [189, 'frac12'],
+                      [188, 'frac14'],
+                      [190, 'frac34'],
+                      [191, 'iquest'],
+                      [192, 'Agrave'],
+                      [193, 'Aacute'],
+                      [194, 'Acirc'],
+                      [195, 'Atilde'],
+                      [196, 'Auml'],
+                      [197, 'Aring'],
+                      [198, 'AElig'],
+                      [199, 'Ccedil'],
+                      [200, 'Egrave'],
+                      [201, 'Eacute'],
+                      [202, 'Ecirc'],
+                      [203, 'Euml'],
+                      [204, 'Igrave'],
+                      [205, 'Iacute'],
+                      [206, 'Icirc'],
+                      [207, 'Iuml'],
+                      [208, 'ETH'],
+                      [209, 'Ntilde'],
+                      [210, 'Ograve'],
+                      [211, 'Oacute'],
+                      [212, 'Ocirc'],
+                      [213, 'Otilde'],
+                      [214, 'Ouml'],
+                      [215, 'times'],
+                      [216, 'Oslash'],
+                      [217, 'Ugrave'],
+                      [218, 'Uacute'],
+                      [219, 'Ucirc'],
+                      [220, 'Uuml'],
+                      [221, 'Yacute'],
+                      [222, 'THORN'],
+                      [223, 'szlig'],
+                      [224, 'agrave'],
+                      [225, 'aacute'],
+                      [226, 'acirc'],
+                      [227, 'atilde'],
+                      [228, 'auml'],
+                      [229, 'aring'],
+                      [230, 'aelig'],
+                      [231, 'ccedil'],
+                      [232, 'egrave'],
+                      [233, 'eacute'],
+                      [234, 'ecirc'],
+                      [235, 'euml'],
+                      [236, 'igrave'],
+                      [237, 'iacute'],
+                      [238, 'icirc'],
+                      [239, 'iuml'],
+                      [240, 'eth'],
+                      [241, 'ntilde'],
+                      [242, 'ograve'],
+                      [243, 'oacute'],
+                      [244, 'ocirc'],
+                      [245, 'otilde'],
+                      [246, 'ouml'],
+                      [247, 'divide'],
+                      [248, 'oslash'],
+                      [249, 'ugrave'],
+                      [250, 'uacute'],
+                      [251, 'ucirc'],
+                      [252, 'uuml'],
+                      [253, 'yacute'],
+                      [254, 'thorn'],
+                      [255, 'yuml'],
+
+                      [8218, 'sbquo'],
+                      [402, 'fnof'],
+                      [8222, 'bdquo'],
+
+                      [128, 8364],
+                      [130, 8218],
+                      [131, 402],
+                      [132, 8222],
+                      [133, 8230],
+                      [134, 8224],
+                      [135, 8225],
+                      [136, 710],
+                      [137, 8240],
+                      [138, 352],
+                      [139, 8249],
+                      [140, 338],
+                      [142, 381],
+                      [145, 8216],
+                      [146, 8217],
+                      [147, 8220],
+                      [148, 8221],
+                      [149, 8226],
+                      [150, 8211],
+                      [151, 8212],
+                      [152, 732],
+                      [153, 8482],
+                      [154, 353],
+                      [155, 8250],
+                      [156, 339],
+                      [158, 382],
+                      [159, 376],
+
+                      [8194, 'ensp'],
+                      [8195, 'emsp'],
+                      [8201, 'thinsp'],
+                     ]
+
+      # Contains the mapping of code point (or name) to the actual Entity object.
+      ENTITY_MAP = Hash.new do |h,k|
+        if k.kind_of?(Integer)
+          h[k] = Entity.new(k, nil)
+        else
+          raise Kramdown::Error, "Can't handle generic non-integer character reference '#{k}'"
+        end
+      end
+
+      ENTITY_TABLE.each do |code_point, data|
+        if data.kind_of?(String)
+          ENTITY_MAP[code_point] = ENTITY_MAP[data] = Entity.new(code_point, data)
+        else
+          ENTITY_MAP[code_point] = ENTITY_MAP[data]
+        end
+      end
+
+      # Return the entity for the given code point or name +point_or_name+.
+      def entity(point_or_name)
+        ENTITY_MAP[point_or_name]
+      end
+
+      module_function :entity
+
+    end
+
+  end
+
+end
+

data/lib/kramdown/utils/html.rb

@@ -0,0 +1,75 @@
+# -*- 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 Utils
+
+    # Provides convenience methods for HTML related tasks.
+    #
+    # *Note* that this module has to be mixed into a class that has a @root (containing an element
+    # of type :root) and an @options (containing an options hash) instance variable so that some of
+    # the methods can work correctly.
+    module Html
+
+      # Convert the entity +e+ to a string. The optional parameter +original+ may contain the
+      # original representation of the entity.
+      #
+      # This method uses the option +entity_output+ to determine the output form for the entity.
+      def entity_to_str(e, original = nil)
+        entity_output = @options[:entity_output]
+
+        if e.char.respond_to?(:encoding) && entity_output == :as_char &&
+            (c = (@root.options[:encoding] ? e.char.encode(@root.options[:encoding]) : nil)) &&  # RM can't use rescue nil
+            ((c = e.char) == '"' || !ESCAPE_MAP.has_key?(c))
+          c
+        elsif (entity_output == :as_input || entity_output == :as_char) && original
+          original
+        elsif (entity_output == :symbolic || ESCAPE_MAP.has_key?(e.char)) && !e.name.nil?
+          "&#{e.name};"
+        else # default to :numeric
+          "&##{e.code_point};"
+        end
+      end
+
+      # Return the HTML representation of the attributes +attr+.
+      def html_attributes(attr)
+        attr.map {|k,v| v.nil? || (k == 'id' && v.strip.empty?) ? '' : " #{k}=\"#{escape_html(v.to_s, :attribute)}\"" }.join('')
+      end
+
+      # :stopdoc:
+      ESCAPE_MAP = {
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '&' => '&amp;',
+        '"' => '&quot;'
+      }
+      ESCAPE_ALL_RE = /<|>|&/
+      ESCAPE_TEXT_RE = Regexp.union(REXML::Parsers::BaseParser::REFERENCE_RE, /<|>|&/)
+      ESCAPE_ATTRIBUTE_RE = Regexp.union(REXML::Parsers::BaseParser::REFERENCE_RE, /<|>|&|"/)
+      ESCAPE_RE_FROM_TYPE = {
+        :all => ESCAPE_ALL_RE,
+        :text => ESCAPE_TEXT_RE,
+        :attribute => ESCAPE_ATTRIBUTE_RE
+      }
+      # :startdoc:
+
+      # Escape the special HTML characters in the string +str+. The parameter +type+ specifies what
+      # is escaped: :all - all special HTML characters except the quotation mark as well as
+      # entities, :text - all special HTML characters except the quotation mark but no entities and
+      # :attribute - all special HTML characters including the quotation mark but no entities.
+      def escape_html(str, type = :all)
+        str.gsub(ESCAPE_RE_FROM_TYPE[type]) {|m| ESCAPE_MAP[m] || m}
+      end
+
+    end
+
+  end
+
+end

data/lib/kramdown/utils/ordered_hash.rb

@@ -0,0 +1,87 @@
+# -*- 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 Utils
+
+    if RUBY_VERSION < '1.9'
+
+      # A partial hash implementation which preserves the insertion order of the keys.
+      #
+      # *Note* that this class is only used on Ruby 1.8 since the built-in Hash on Ruby 1.9
+      # automatically preserves the insertion order. However, to remain compatibility only the
+      # methods defined in this class may be used when working with OrderedHash on Ruby 1.9.
+      class OrderedHash
+
+        include Enumerable
+
+        # Initialize the OrderedHash object.
+        def initialize
+          @data =  {}
+          @order = []
+        end
+
+        # Iterate over the stored keys in insertion order.
+        def each
+          @order.each {|k| yield(k, @data[k])}
+        end
+
+        # Return the value for the +key+.
+        def [](key)
+          @data[key]
+        end
+
+        # Return +true+ if the hash contains the key.
+        def has_key?(key)
+          @data.has_key?(key)
+        end
+
+        # Set the value for the +key+ to +val+.
+        def []=(key, val)
+          @order << key if !@data.has_key?(key)
+          @data[key] = val
+        end
+
+        # Delete the +key+.
+        def delete(key)
+          @order.delete(key)
+          @data.delete(key)
+        end
+
+        def merge!(other)
+          other.each {|k,v| self[k] = v}
+          self
+        end
+
+        def dup #:nodoc:
+          new_object = super
+          new_object.instance_variable_set(:@data, @data.dup)
+          new_object.instance_variable_set(:@order, @order.dup)
+          new_object
+        end
+
+        def ==(other) #:nodoc:
+          return false unless other.kind_of?(self.class)
+          @data == other.instance_variable_get(:@data) && @order == other.instance_variable_get(:@order)
+        end
+
+        def inspect #:nodoc:
+          "{" + map {|k,v| "#{k.inspect}=>#{v.inspect}"}.join(" ") + "}"
+        end
+
+      end
+
+    else
+      OrderedHash = Hash
+    end
+
+  end
+
+end

data/lib/kramdown/utils/string_scanner.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+# RM require 'strscan'
+
+module Kramdown
+  module Utils
+
+    # This patched StringScanner adds line number information for current scan position and a
+    # start_line_number override for nested StringScanners.
+    class StringScanner < ::StringScanner
+
+      # The start line number. Used for nested StringScanners that scan a sub-string of the source
+      # document. The kramdown parser uses this, e.g., for span level parsers.
+      attr_reader :start_line_number
+
+      # Takes the start line number as optional second argument.
+      #
+      # Note: The original second argument is no longer used so this should be safe.
+      def initialize(string, start_line_number = 1)
+        super(string)
+        @start_line_number = start_line_number || 1
+        @previous_pos = 0
+        @previous_line_number = @start_line_number
+      end
+
+      # Sets the byte position of the scan pointer.
+      #
+      # Note: This also resets some internal variables, so always use pos= when setting the position
+      # and don't use any other method for that!
+      def pos=(pos)
+        if self.pos > pos
+          @previous_line_number = @start_line_number
+          @previous_pos = 0
+        end
+        super
+      end
+
+      # Return information needed to revert the byte position of the string scanner in a performant
+      # way.
+      #
+      # The returned data can be fed to #revert_pos to revert the position to the saved one.
+      #
+      # Note: Just saving #pos won't be enough.
+      def save_pos
+        [pos, @previous_pos, @previous_line_number]
+      end
+
+      # Revert the position to one saved by #save_pos.
+      def revert_pos(data)
+        self.pos = data[0]
+        @previous_pos, @previous_line_number = data[1], data[2]
+      end
+
+      # Returns the line number for current charpos.
+      #
+      # NOTE: Requires that all line endings are normalized to '\n'
+      #
+      # NOTE: Normally we'd have to add one to the count of newlines to get the correct line number.
+      # However we add the one indirectly by using a one-based start_line_number.
+      def current_line_number
+        # Not using string[@previous_pos..best_pos].count('\n') because it is slower
+        strscan = ::StringScanner.new(string)
+        strscan.pos = @previous_pos
+        old_pos = pos + 1
+        @previous_line_number += 1 while strscan.skip_until(/\n/) && strscan.pos <= old_pos
+
+        @previous_pos = (eos? ? pos : pos + 1)
+        @previous_line_number
+      end
+
+    end
+
+  end
+end

data/lib/kramdown/utils/unidecoder.rb

@@ -0,0 +1,51 @@
+# -*- 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.
+#++
+#
+# This file is based on code originally from the Stringex library and needs the data files from
+# Stringex to work correctly.
+
+module Kramdown
+  module Utils
+
+    # Provides the ability to tranliterate Unicode strings into plain ASCII ones.
+    module Unidecoder
+
+      # RM gem 'stringex' if defined?(Gem)
+      # RM TODO path = $:.find {|dir| File.directory?(File.join(File.expand_path(dir), "stringex", "unidecoder_data"))}
+      path = 'lib' # RM TODO
+
+      if RUBY_VERSION <= '1.8.6' || !path
+        def self.decode(string)
+          string
+        end
+      else
+
+        CODEPOINTS = Hash.new do |h, k|
+          if File.exists?(File.join(path, "stringex", "unidecoder_data", "#{k}.yml")) # RM
+            h[k] = YAML::load(File.join(path, "stringex", "unidecoder_data", "#{k}.yml")) # RM
+          end # RM
+        end
+
+        # Transliterate string from Unicode into ASCII.
+        def self.decode(string)
+          string.gsub(/[^\x00-\x7f]/u) do |codepoint|
+            begin
+              unpacked = codepoint.unpack("U")[0]
+              CODEPOINTS["x%02x" % (unpacked >> 8)][unpacked & 255]
+            rescue
+              "?"
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/kramdown/utils.rb

@@ -0,0 +1,58 @@
+# -*- 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
+
+  # == \Utils Module
+  #
+  # This module contains utility class/modules/methods that can be used by both parsers and
+  # converters.
+  module Utils
+
+    # RM autoload :Entities, 'kramdown/utils/entities'
+    # RM autoload :Html, 'kramdown/utils/html'
+    # RM autoload :OrderedHash, 'kramdown/utils/ordered_hash'
+    # RM autoload :Unidecoder, 'kramdown/utils/unidecoder'
+    # RM autoload :StringScanner, 'kramdown/utils/string_scanner'
+    # RM autoload :Configurable, 'kramdown/utils/configurable'
+
+    # Treat +name+ as if it were snake cased (e.g. snake_case) and camelize it (e.g. SnakeCase).
+    def self.camelize(name)
+      name.split('_').inject('') {|s,x| s << x[0..0].upcase << x[1..-1] }
+    end
+
+    # Treat +name+ as if it were camelized (e.g. CamelizedName) and snake-case it (e.g. camelized_name).
+    def self.snake_case(name)
+      name = name.dup
+      name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      name.gsub!(/([a-z])([A-Z])/,'\1_\2')
+      name.downcase!
+      name
+    end
+
+    if RUBY_VERSION < '2.0'
+
+      # Resolve the recursive constant +str+.
+      def self.deep_const_get(str)
+        names = str.split(/::/)
+        names.shift if names.first.empty?
+        names.inject(::Object) {|mod, s| mod.const_get(s)}
+      end
+
+    else
+
+      def self.deep_const_get(str)
+        ::Object.const_get(str)
+      end
+
+    end
+
+  end
+
+end