maruku 0.6.0 → 0.7.3

data/lib/maruku/input/extensions.rb

@@ -1,69 +1,68 @@
-module MaRuKu; module In; module Markdown
+module MaRuKu::In::Markdown
+  # Hash Fixnum -> name
+  SpanExtensionsTrigger = {}
 
 
-	# Hash Fixnum -> name
-	SpanExtensionsTrigger = {}
-	
-	
-	class SpanExtension
-		# trigging chars
-		attr_accessor :chars
-		# trigging regexp
-		attr_accessor :regexp
-		# lambda
-		attr_accessor :block
-	end
-	
-	# Hash String -> Extension
-	SpanExtensions = {}
+  class SpanExtension
+    # trigging chars
+    attr_accessor :chars
+    # trigging regexp
+    attr_accessor :regexp
+    # lambda
+    attr_accessor :block
+  end
 
-	def check_span_extensions(src, con)
-		c = src.cur_char
-		if extensions = SpanExtensionsTrigger[c]
-			extensions.each do |e|
-				if e.regexp && (match = src.next_matches(e.regexp))
-					return true if e.block.call(doc, src, con)
-				end
-			end
-		end
-		return false # not special
-	end
-	
-	def self.register_span_extension(args)
-		e = SpanExtension.new
-		e.chars = [*args[:chars]]
-		e.regexp = args[:regexp]
-		e.block = args[:handler] || raise("No blocks passed")
-		e.chars.each do |c|
-			(SpanExtensionsTrigger[c] ||= []).push e
-		end
-	end
+  # Hash String -> Extension
+  SpanExtensions = {}
 
-	def self.register_block_extension(args)
-		regexp = args[:regexp]
-		BlockExtensions[regexp] = (args[:handler] || raise("No blocks passed"))
-	end
+  def check_span_extensions(src, con)
+    c = src.cur_char
+    if extensions = SpanExtensionsTrigger[c]
+      extensions.each do |e|
+        if e.regexp && src.next_matches(e.regexp)
+          return true if e.block.call(doc, src, con)
+        end
+      end
+    end
 
-	# Hash Regexp -> Block
-	BlockExtensions = {}
+    false # not special
+  end
 
-	def check_block_extensions(src, con, line)
-		BlockExtensions.each do |reg, block|
-			if m = reg.match(line)
-				block = BlockExtensions[reg]
-				accepted =  block.call(doc, src, con)
-				return true if accepted
-			end
-		end
-		return false # not special
-	end
-	
-	def any_matching_block_extension?(line)
-		BlockExtensions.each_key do |reg|
-			m = reg.match(line)
-			return m if m
-		end
-		return false
-	end
-	
-end end end
+  def self.register_span_extension(args)
+    e = SpanExtension.new
+    e.chars = [*args[:chars]]
+    e.regexp = args[:regexp]
+    e.block = args[:handler] || raise("No blocks passed")
+    e.chars.each do |c|
+      (SpanExtensionsTrigger[c] ||= []).push e
+    end
+  end
+
+  def self.register_block_extension(args)
+    regexp = args[:regexp]
+    BlockExtensions[regexp] = (args[:handler] || raise("No blocks passed"))
+  end
+
+  # Hash Regexp -> Block
+  BlockExtensions = {}
+
+  def check_block_extensions(src, con, line)
+    BlockExtensions.each do |reg, block|
+      if reg.match(line)
+        block = BlockExtensions[reg]
+        accepted =  block.call(doc, src, con)
+        return true if accepted
+      end
+    end
+    false # not special
+  end
+
+  def any_matching_block_extension?(line)
+    BlockExtensions.each_key do |reg|
+      m = reg.match(line)
+      return m if m
+    end
+    false
+  end
+
+end

data/lib/maruku/input/html_helper.rb

@@ -1,189 +1,233 @@
-#--
-#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
-#
-# This file is part of Maruku.
-# 
-#   Maruku is free software; you can redistribute it and/or modify
-#   it under the terms of the GNU General Public License as published by
-#   the Free Software Foundation; either version 2 of the License, or
-#   (at your option) any later version.
-# 
-#   Maruku is distributed in the hope that it will be useful,
-#   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#   GNU General Public License for more details.
-# 
-#   You should have received a copy of the GNU General Public License
-#   along with Maruku; if not, write to the Free Software
-#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-#++
-
-
-module MaRuKu; module In; module Markdown; module SpanLevelParser
-
-# This class helps me read and sanitize HTML blocks
-
-# I tried to do this with REXML, but wasn't able to. (suggestions?)
-
-	class HTMLHelper
-		include MaRuKu::Strings
-		
-		Tag = %r{^<(/)?(\w+)\s*([^>]*)>}m
-		PartialTag = %r{^<.*}m
-
-		EverythingElse = %r{^[^<]+}m
-		CommentStart = %r{^<!--}x
-		CommentEnd = %r{^.*-->}
-		TO_SANITIZE = ['img','hr','br'] 
-		
-		attr_reader :rest
-		
-		def my_debug(s)
-#			puts "---"*10+"\n"+inspect+"\t>>>\t"s
-		end
-		
-		def initialize 
-			@rest = ""
-			@tag_stack = []
-			@m = nil
-			@already = ""
-			self.state = :inside_element
-		end
-
-		attr_accessor :state # = :inside_element, :inside_tag, :inside_comment,
-		
-		def eat_this(line)
-			@rest = line  + @rest
-			things_read = 0
-			until @rest.empty?
-				case self.state
-					when :inside_comment
-						if @m = CommentEnd.match(@rest)
-							@already += @m.pre_match + @m.to_s
-							@rest = @m.post_match
-							self.state = :inside_element
-						else 
-							@already += @rest 
-							@rest = ""
-							self.state = :inside_comment
-						end
-					when :inside_element 
-						if @m = CommentStart.match(@rest)
-							things_read += 1
-							@already += @m.pre_match + @m.to_s
-							@rest = @m.post_match
-							self.state = :inside_comment
-						elsif @m = Tag.match(@rest) then
-							my_debug "#{@state}: Tag: #{@m.to_s.inspect}"
-							things_read += 1
-							handle_tag
-							self.state = :inside_element
-						elsif @m = PartialTag.match(@rest) then
-							my_debug "#{@state}: PartialTag: #{@m.to_s.inspect}"
-							@already += @m.pre_match 
-							@rest = @m.post_match
-							@partial_tag = @m.to_s
-							self.state = :inside_tag
-						elsif @m = EverythingElse.match(@rest)
-							my_debug "#{@state}: Everything: #{@m.to_s.inspect}"
-							@already += @m.pre_match + @m.to_s
-							@rest = @m.post_match
-							self.state = :inside_element
-						else
-							error "Malformed HTML: not complete: #{@rest.inspect}"
-						end
-					when :inside_tag
-						if @m = /^[^>]*>/.match(@rest) then
-							my_debug "#{@state}: inside_tag: matched #{@m.to_s.inspect}"
-							@partial_tag += @m.to_s
-							my_debug "#{@state}: inside_tag: matched TOTAL: #{@partial_tag.to_s.inspect}"
-							@rest = @partial_tag + @m.post_match
-							@partial_tag = nil
-							self.state = :inside_element
-						else
-							@partial_tag += @rest
-							@rest = ""
-							self.state = :inside_tag
-						end
-					else
-						raise "Bug bug: state = #{self.state.inspect}"
-				end # not inside comment
-				
-#				puts inspect
-#				puts "Read: #{@tag_stack.inspect}"
-				break if is_finished? and things_read>0	
-			end
-		end
-
-		def handle_tag()
-			@already += @m.pre_match
-			@rest = @m.post_match
-
-			is_closing = !!@m[1]
-			tag = @m[2]
-			attributes = @m[3].to_s
-		
-			is_single = false
-			if attributes[-1] == ?/ # =~ /\A(.*)\/\Z/
-				attributes = attributes[0, attributes.size-1]
-				is_single = true
-			end
-
-			my_debug "Attributes: #{attributes.inspect}"
-			my_debug "READ TAG #{@m.to_s.inspect} tag = #{tag} closing? #{is_closing} single = #{is_single}"
-	
-			if TO_SANITIZE.include? tag 
-				attributes.strip!
-		#		puts "Attributes: #{attributes.inspect}"
-				if attributes.size > 0
-					@already +=  '<%s %s />' % [tag, attributes]
-				else
-					@already +=  '<%s />' % [tag]
-				end
-			elsif is_closing
-				@already += @m.to_s
-				if @tag_stack.empty?
-					error "Malformed: closing tag #{tag.inspect} "+
-					      "in empty list"
-				end 
-				if @tag_stack.last != tag
-					error "Malformed: tag <#{tag}> "+
-					      "closes <#{@tag_stack.last}>"
-				end
-				@tag_stack.pop
-			else 
-				@already += @m.to_s
-				
-				if not is_single
-					@tag_stack.push(tag) 
-					my_debug "Pushing #{tag.inspect} when read #{@m.to_s.inspect}"
-				end
-			end
-		end
-		def error(s)
-			raise Exception, "Error: #{s} \n"+ inspect, caller
-		end
-
-		def inspect; "HTML READER\n state=#{self.state} "+
-			"match=#{@m.to_s.inspect}\n"+
-			"Tag stack = #{@tag_stack.inspect} \n"+
-			"Before:\n"+
-			add_tabs(@already,1,'|')+"\n"+
-			"After:\n"+
-			add_tabs(@rest,1,'|')+"\n"
-			
-		end
-		
-		
-		def stuff_you_read
-			@already
-		end
-		
-		def rest() @rest end
-		
-		def is_finished?
-			(self.state == :inside_element)  and @tag_stack.empty?
-		end
-	end # html helper 
-
-end end end end
+module MaRuKu::In::Markdown::SpanLevelParser
+
+  # This class helps me read and sanitize HTML blocks
+  class HTMLHelper
+    Tag = %r{^<(/)?(\w+)\s*([^>]*?)>}m
+    PartialTag = %r{^<.*}m
+    CData = %r{^\s*<!\[CDATA\[}m
+    CDataEnd = %r{\]\]>}m
+
+    EverythingElse = %r{^[^<]+}m
+    CommentStart = %r{^<!--}x
+    CommentEnd = %r{-->}
+    TO_SANITIZE = ['img', 'hr', 'br']
+
+    attr_reader :rest, :first_tag
+
+    def initialize
+      @rest = ""
+      @tag_stack = []
+      @m = nil
+      @already = ""
+      self.state = :inside_element
+    end
+
+    attr_accessor :state # = :inside_element, :inside_tag, :inside_comment, :inside_cdata
+
+    def eat_this(line)
+      @rest = line + @rest
+      things_read = 0
+      until @rest.empty?
+        case self.state
+        when :inside_comment
+          if @m = CommentEnd.match(@rest)
+            debug_state 'Comment End'
+            # Workaround for https://bugs.ruby-lang.org/issues/9277 and another bug in 1.9.2 where even a
+            # single dash in a comment will cause REXML to error.
+            @already << @m.pre_match.gsub(/-(?![^\-])/, '- ') << @m.to_s
+            @rest = @m.post_match
+            self.state = :inside_element
+          else
+            @already << @rest.gsub(/-(?![^\-])/, '- ') # Workaround for https://bugs.ruby-lang.org/issues/9277
+            @rest = ""
+            self.state = :inside_comment
+          end
+        when :inside_element
+          if @m = CommentStart.match(@rest)
+            debug_state 'Comment'
+            things_read += 1
+            @already << @m.pre_match << @m.to_s
+            @rest = @m.post_match
+            self.state = :inside_comment
+          elsif @m = Tag.match(@rest)
+            debug_state 'Tag'
+            things_read += 1
+            self.state = :inside_element
+            handle_tag
+          elsif @m = CData.match(@rest)
+            debug_state 'CDATA'
+            @already << @m.pre_match
+            close_script_style if script_style?
+            @already << @m.to_s
+            @rest = @m.post_match
+            self.state = :inside_cdata
+          elsif @m = PartialTag.match(@rest)
+            debug_state 'PartialTag'
+            @already << @m.pre_match
+            @rest = @m.post_match
+            @partial_tag = @m.to_s
+            self.state = :inside_tag
+          elsif @m = EverythingElse.match(@rest)
+            debug_state 'EverythingElse'
+            @already << @m.pre_match << @m.to_s
+            @rest = @m.post_match
+            self.state = :inside_element
+          else
+            error "Malformed HTML: not complete: #{@rest.inspect}"
+          end
+        when :inside_tag
+          if @m = /^[^>]*>/.match(@rest)
+            @partial_tag << @m.to_s
+            @rest = @partial_tag + @m.post_match
+            @partial_tag = nil
+            self.state = :inside_element
+            if @m = Tag.match(@rest)
+              things_read += 1
+              handle_tag
+            end
+          else
+            @partial_tag << @rest
+            @rest = ""
+            self.state = :inside_tag
+          end
+        when :inside_cdata
+          if @m = CDataEnd.match(@rest)
+            self.state = :inside_element
+            @already << @m.pre_match << @m.to_s
+            @rest = @m.post_match
+            start_script_style if script_style?
+          else
+            @already << @rest
+            @rest = ""
+            self.state = :inside_cdata
+          end
+        else
+          raise "Bug bug: state = #{self.state.inspect}"
+        end
+
+        break if is_finished? && things_read > 0
+      end
+    end
+
+    def handle_tag
+      @already << @m.pre_match
+      @rest = @m.post_match
+
+      is_closing = !!@m[1]
+      tag = @m[2]
+      @first_tag ||= tag
+      attributes = @m[3].to_s
+
+      is_single = false
+      if attributes[-1, 1] == '/'
+        attributes = attributes[0, attributes.size - 1]
+        is_single = true
+      end
+
+      if TO_SANITIZE.include? tag
+        attributes.strip!
+        if attributes.size > 0
+          @already << '<%s %s />' % [tag, attributes]
+        else
+          @already << '<%s />' % [tag]
+        end
+      elsif is_closing
+        if @tag_stack.empty?
+          error "Malformed: closing tag #{tag.inspect} in empty list"
+        elsif @tag_stack.last != tag
+          error "Malformed: tag <#{tag}> closes <#{@tag_stack.last}>"
+        end
+
+        close_script_style if script_style?
+
+        @already << @m.to_s
+        @tag_stack.pop
+      else
+        @already << @m.to_s
+        @tag_stack.push(tag) unless is_single
+
+        start_script_style if script_style?
+      end
+    end
+
+    def stuff_you_read
+      @already
+    end
+
+    def is_finished?
+      self.state == :inside_element && @tag_stack.empty?
+    end
+
+    private
+
+    def debug_state(note)
+      my_debug "#{@state}: #{note}: #{@m.to_s.inspect}"
+    end
+
+    def my_debug(s)
+      #    puts "---" * 10 + "\n" + inspect + "\t>>>\t" + s
+    end
+
+    def error(s)
+      raise "Error: #{s} \n" + inspect, caller
+    end
+
+    def inspect
+      "HTML READER\n state=#{self.state} " +
+        "match=#{@m.to_s.inspect}\n" +
+        "Tag stack = #{@tag_stack.inspect} \n" +
+        "Before:\n" +
+        @already.gsub(/^/, '|') + "\n" +
+        "After:\n" +
+        @rest.gsub(/^/, '|') + "\n"
+    end
+
+    # Script and style tag handling
+    # -----------------------------
+    #
+    # XHTML, and XML parsers like REXML, require that certain characters be
+    # escaped within script or style tags. However, there are conflicts between
+    # documents served as XHTML vs HTML. So we need to be extra careful about
+    # how we escape these tags so they will even parse correctly. However, we
+    # also try to avoid adding that escaping unnecessarily.
+    #
+    # See http://dorward.me.uk/www/comments-cdata/ for a good explanation.
+
+    # Are we within a script or style tag?
+    def script_style?
+      %w(script style).include?(@tag_stack.last)
+    end
+
+    # Save our @already buffer elsewhere, and switch to using @already for the
+    # contents of this script or style tag.
+    def start_script_style
+      @before_already, @already = @already, ""
+    end
+
+    # Finish script or style tag content, wrapping it in CDATA if necessary,
+    # and add it to our original @already buffer.
+    def close_script_style
+      tag = @tag_stack.last
+
+      # See http://www.w3.org/TR/xhtml1/#C_4 for character sequences not allowed within an element body.
+      if @already =~ /<|&|\]\]>|--/
+        new_already = script_style_cdata_start(tag)
+        new_already << "\n" unless @already.start_with?("\n")
+        new_already << @already
+        new_already << "\n" unless @already.end_with?("\n")
+        new_already << script_style_cdata_end(tag)
+        @already = new_already
+      end
+      @before_already << @already
+      @already = @before_already
+    end
+
+    def script_style_cdata_start(tag)
+      (tag == 'script') ? "//<![CDATA[" : "/*<![CDATA[*/"
+    end
+
+    def script_style_cdata_end(tag)
+      (tag == 'script') ? "//]]>" : "/*]]>*/"
+    end
+  end
+end