maruku 0.4.2.1 → 0.5.0

data/lib/maruku/ext/math/to_latex.rb

@@ -0,0 +1,21 @@
+
+module MaRuKu; module Out; module Latex
+
+	def to_latex_inline_math
+		"$#{self.math.strip}$"
+	end
+
+	def to_latex_equation
+		if self.label
+			l =  "\\label{#{self.label}}"
+			"\\begin{equation}\n#{self.math.strip}\n#{l}\\end{equation}\n"
+		else
+			"\\begin{displaymath}\n#{self.math.strip}\n\\end{displaymath}\n"
+		end
+	end
+	
+	def to_latex_eqref
+		"\\eqref{#{self.eqid}}"
+	end
+
+end end end

data/lib/maruku/helpers.rb

@@ -30,7 +30,17 @@
 module MaRuKu
 module Helpers
 
+	# if the first is a md_ial, it is used as such
 	def md_el(node_type, children=[], meta={}, al=nil)
+		if  (e=children.first).kind_of?(MDElement) and 
+			e.node_type == :ial then
+			if al
+				al += e.ial
+			else
+				al = e.ial
+			end
+			children.shift
+		end 
 		e = MDElement.new(node_type, children, meta, al)
 		e.doc = @doc
 		return e
@@ -173,6 +183,7 @@ module Helpers
 	def md_xml_instr(target, code)
 		md_el(:xml_instr, [], {:target=>target, :code=>code})
 	end
+
 end
 end
 

data/lib/maruku/input/charsource.rb

@@ -33,8 +33,8 @@ class CharSourceDebug; end
 
 # Choose!
 
-#CharSource = CharSourceStrscan
 CharSource = CharSourceManual     # faster! 58ms vs. 65ms
+#CharSource = CharSourceStrscan
 #CharSource = CharSourceDebug
 
 

data/lib/maruku/input/extensions.rb

@@ -0,0 +1,68 @@
+module MaRuKu; module In; module Markdown
+
+
+	# 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 = {}
+
+	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, &block)
+		e = SpanExtension.new
+		e.chars = [*args[:chars]]
+		e.regexp = args[:regexp]
+		e.block = block
+		e.chars.each do |c|
+			(SpanExtensionsTrigger[c] ||= []).push e
+		end
+	end
+
+	def self.register_block_extension(args, &block)
+		regexp = args[:regexp]
+		BlockExtensions[regexp] = block
+	end
+
+	# Hash Regexp -> Block
+	BlockExtensions = {}
+
+	def check_block_extensions(src, con, line)
+		BlockExtensions.each do |reg, block|
+			if m = reg.match(line)
+				block = BlockExtensions[reg]
+				return true if block.call(doc, src, con)
+			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

data/lib/maruku/input/html_helper.rb

@@ -29,12 +29,13 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 		include MaRuKu::Strings
 		
 		Tag = %r{^<(/)?(\w+)\s*([^>]*)>}m
+		PartialTag = %r{^<.*}m
+
 		EverythingElse = %r{^[^<]+}m
 		CommentStart = %r{^<!--}x
 		CommentEnd = %r{^.*-->}
 		TO_SANITIZE = ['img','hr'] 
 		
-#		attr_accessor :inside_comment
 		attr_reader :rest
 		
 		def initialize 
@@ -42,72 +43,61 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 			@tag_stack = []
 			@m = nil
 			@already = ""
-			@inside_comment = false
+			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?
-				if @inside_comment
-					if @m = CommentEnd.match(@rest)
-						@inside_comment = false
-						@already += @m.pre_match + @m.to_s
-						@rest = @m.post_match
-					elsif @m = EverythingElse.match(@rest)
-						@already += @m.pre_match + @m.to_s
-						@rest = @m.post_match
-					end
-				else
-					if @m = CommentStart.match(@rest)
-						things_read += 1
-						@inside_comment = true
-						@already += @m.pre_match + @m.to_s
-						@rest = @m.post_match
-					elsif @m = Tag.match(@rest)
-						things_read += 1
-						@already += @m.pre_match
-						@rest = @m.post_match
-					
-						is_closing = !!@m[1]
-						tag = @m[2]
-						attributes = @m[3]
-						
-						is_single = false
-						if attributes =~ /\A(.*)\/\Z/
-							attributes = $1
-							is_single = true
+				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
-					
-						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
-						elsif not is_single
-							@tag_stack.push tag
-							@already += @m.to_s
+					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
+							things_read += 1
+							handle_tag
+							self.state = :inside_element
+						elsif @m = PartialTag.match(@rest) then
+							@already += @m.pre_match 
+							@rest = @m.post_match
+							@partial_tag = @m.to_s
+							self.state = :inside_tag
+						elsif @m = EverythingElse.match(@rest)
+							@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
+							@partial_tag += @m.to_s
+							@rest = @partial_tag + @m.post_match
+							@partial_tag = nil
+							self.state = :inside_element
+						else
+							@partial_tag += @rest
+							@rest = ""
+							self.state = :inside_tag
 						end
-					elsif @m = EverythingElse.match(@rest)
-						@already += @m.pre_match + @m.to_s
-						@rest = @m.post_match
 					else
-						error "Malformed HTML: not complete: #{@rest.inspect}"
-					end
+						raise "Bug bug: state = #{self.state.inspect}"
 				end # not inside comment
 				
 #				puts inspect
@@ -116,12 +106,53 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 			end
 		end
 
+		def handle_tag()
+			@already += @m.pre_match
+			@rest = @m.post_match
+
+			is_closing = !!@m[1]
+			tag = @m[2]
+			attributes = @m[3]
+
+		
+			is_single = false
+			if attributes =~ /\A(.*)\/\Z/
+				attributes = $1
+				is_single = true
+			end
 
+#			puts "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
+				
+				@tag_stack.push(tag) unless is_single
+			end
+		end
 		def error(s)
 			raise Exception, "Error: #{s} \n"+ inspect, caller
 		end
 
-		def inspect; "HTML READER\n comment=#{@inside_comment} "+
+		def inspect; "HTML READER\n state=#{self.state} "+
 			"match=#{@m.to_s.inspect}\n"+
 			"Tag stack = #{@tag_stack.inspect} \n"+
 			"Before:\n"+
@@ -137,7 +168,7 @@ module MaRuKu; module In; module Markdown; module SpanLevelParser
 		end
 		
 		def is_finished?
-			not @inside_comment and @tag_stack.empty?
+			(self.state == :inside_element)  and @tag_stack.empty?
 		end
 	end # html helper 
 

data/lib/maruku/input/parse_block.rb

@@ -47,6 +47,9 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		
 		# run state machine
 		while src.cur_line
+			
+			next if check_block_extensions(src, output, src.cur_line)
+			
 #  Prints detected type (useful for debugging)
 #			puts "#{src.cur_line.md_type}|#{src.cur_line}"
 			case src.cur_line.md_type
@@ -56,6 +59,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				when :ial
 					m =  InlineAttributeList.match src.shift_line
 					content = m[1] ||  "" 
+#					puts "Content: #{content.inspect}"
 					src2 = CharSource.new(content, src)
 					interpret_extension(src2, output, [nil])
 				when :ald
@@ -101,7 +105,6 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 				when :ref_definition;  output.push read_ref_definition(src)
 				when :abbreviation;    output.push read_abbreviation(src)
 				when :xml_instr;       read_xml_instruction(src, output)
-#				# these do not produce output
 				when :metadata;        
 					maruku_error "Please use the new meta-data syntax: \n"+
 					"  http://maruku.rubyforge.org/proposal.html\n", src
@@ -145,7 +148,8 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		
 		output
 	end
-		 
+	
+	
 	
 	def read_ald(src)
 		if (l=src.shift_line) =~ AttributeDefinitionList
@@ -246,18 +250,15 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 					break
 				when :olist,:ulist
 					break if src.next_line.md_type == t
-				else
-					true
 			end
-			
-			break if src.cur_line.strip.size == 0
-			
+			break if src.cur_line.strip.size == 0			
 			break if [:header1,:header2].include? src.next_line.md_type
+			break if any_matching_block_extension?(src.cur_line)
 			
 			lines << src.shift_line
 		end
 #		dbg_describe_ary(lines, 'PAR')
-		children = parse_lines_as_span(lines)
+		children = parse_lines_as_span(lines, src)
 
 		return md_par(children)
 	end
@@ -468,7 +469,7 @@ module MaRuKu; module In; module Markdown; module BlockLevelParser
 		end
 		
 		id = match[1]; url = match[2]; title = match[3]; 
-		id = id.strip.downcase
+		id = id.strip.downcase.gsub(' ','_')
 		
 		hash = self.refs[id] = {:url=>url,:title=>title}
 		

data/lib/maruku/input/parse_doc.rb

@@ -84,7 +84,8 @@ Conversion happens using the `iconv` library.
 		end
 	
 =begin maruku_doc
-Variable: Maruku::Globals[:unsafe_features]
+Attribute: unsafe_features
+Scope:     global
 Summary:   Enables execution of XML instructions.
 
 Disabled by default because of security concerns.
@@ -181,6 +182,7 @@ Disabled by default because of security concerns.
 		end
 	end
 	
+	include REXML
 	# (PHP Markdown extra) Search for elements that have
 	# markdown=1 or markdown=block defined
 	def substitute_markdown_inside_raw_html
@@ -189,27 +191,33 @@ Disabled by default because of security concerns.
 			if doc # valid html
 				# parse block-level markdown elements in these HTML tags
 				block_tags = ['div']
+
 				# use xpath to find elements with 'markdown' attribute
-				doc.elements.to_a( "//*[attribute::markdown]" ).each do |e|
+				XPath.match(doc, "//*[attribute::markdown]" ).each do |e|
+#					puts "Found #{e}"
 					# should we parse block-level or span-level?
 					parse_blocks = (e.attributes['markdown'] == 'block') || 
 					               block_tags.include?(e.name)
 					# remove 'markdown' attribute
 					e.delete_attribute 'markdown'
 					# Select all text elements of e
-					e.texts.each do |original_text|
-#						puts "parse_blocks = #{parse_blocks} found = #{original_text} "
-						s = original_text.to_s.strip # XXX
-						el = md_el(:dummy,
-						 	parse_blocks ? parse_text_as_markdown(s) :
-						                  parse_lines_as_span([s]) )
-						el.children_to_html.each do |x|
-							e.insert_before(original_text, x)
+					XPath.match(e, "//text()" ).each { |original_text| 
+						s = original_text.value.strip
+						if s.size > 0
+							el = md_el(:dummy,
+							 	parse_blocks ? parse_text_as_markdown(s) :
+							                  parse_lines_as_span([s]) )
+							p = original_text.parent
+							el.children_to_html.each do |x|
+								p.insert_before(original_text, x)
+							end
+							p.delete(original_text)
+							
 						end
-						e.delete(original_text)
-					end
-					
+					}
+						
 				end
+				
 			end
 		end
 	end