maruku 0.6.0 → 0.7.3

data/lib/maruku/defaults.rb

@@ -1,71 +1,49 @@
-#--
-#   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
 
+  Globals = {
+    :unsafe_features => false,
+    :on_error => :warning,
 
-module MaRuKu
-	
-Globals = {
-	:unsafe_features => false,
-	:on_error => :warning,
-	
-	
-	:use_numbered_headers => false,
-	
-	:maruku_signature => false,
-	:code_background_color => '#fef',
-	:code_show_spaces => false,
-	
-	:filter_html => false,
-	
-	:html_math_output_mathml => true, # also set :html_math_engine
-	:html_math_engine => 'none', #ritex, itex2mml
-	
-	:html_math_output_png => false, 	
-	:html_png_engine => 'none',
-	:html_png_dir => 'pngs',
-	:html_png_url => 'pngs/',
-	:html_png_resolution => 200,
-  
-	:html_use_syntax => false,
-	
-	:latex_use_listings => false,
-	:latex_cjk => false,
-  :latex_cache_file  => "blahtex_cache.pstore", # cache file for blahtex filter
-	
-	:debug_keep_ials => false,
-	:doc_prefix => ''
-}
+    :use_numbered_headers => false,
 
-class MDElement
-	def get_setting(sym)
-		if self.attributes.has_key?(sym) then
-			return self.attributes[sym]
-		elsif self.doc && self.doc.attributes.has_key?(sym) then
-			return self.doc.attributes[sym]
-		elsif MaRuKu::Globals.has_key?(sym)
-			return MaRuKu::Globals[sym]
-		else
-			$stderr.puts "Bug: no default for #{sym.inspect}"
-			nil
-		end
-	end
-end
+    :maruku_signature => false,
+    :code_background_color => '#fef',
+    :code_show_spaces => false,
+
+    :filter_html => false,
+
+    :html_parser => 'rexml', # or 'nokogiri'
+
+    :html_math_output_mathml => true, # also set :html_math_engine
+    :html_math_engine => 'none', # none, ritex, itex2mml, blahtex
+
+    :html_math_output_png => false,
+    :html_png_engine => 'none',
+    :html_png_dir => 'pngs',
+    :html_png_url => 'pngs/',
+    :html_png_resolution => 200,
 
-end
+    :fenced_code_blocks => false,
+    :html_use_syntax => false,
+
+    :latex_use_listings => false,
+    :latex_cjk => false,
+
+    :debug_keep_ials => false,
+    :doc_prefix => '',
+
+    :ignore_wikilinks => true
+  }
+
+  class MDElement
+    def get_setting(sym)
+      return attributes[sym] if attributes.has_key?(sym)
+      return doc.attributes[sym] if doc && doc.attributes.has_key?(sym)
+      return MaRuKu::Globals[sym] if MaRuKu::Globals.has_key?(sym)
+
+      $stderr.puts "Bug: no default for #{sym.inspect}"
+      nil
+    end
+  end
+
+end

data/lib/maruku/document.rb

@@ -0,0 +1,44 @@
+module MaRuKu
+  # This represents the whole document and holds global data.
+  class MDDocument # < MDElement
+    # @return [{String => {:url => String, :title => String}}]
+    attr_accessor :refs
+
+    # @return [{String => MDElement}]
+    attr_accessor :footnotes
+
+    # @return [{String => String}]
+    attr_accessor :abbreviations
+
+    # Attribute definition lists.
+    #
+    # @return [{String => AttributeList}]
+    attr_accessor :ald
+
+    # The order in which footnotes are used. Contains the id.
+    #
+    # @return [Array<String>]
+    attr_accessor :footnotes_order
+
+    # @return [{String => {String => MDElement}}]
+    attr_accessor :refid2ref
+
+    # A counter for generating unique IDs [Integer]
+    attr_accessor :id_counter
+
+    def initialize(s=nil)
+      super(:document)
+
+      self.doc = self
+      self.refs = {}
+      self.footnotes = {}
+      self.footnotes_order = []
+      self.abbreviations = {}
+      self.ald = {}
+      self.refid2ref = {}
+      self.id_counter = 0
+
+      parse_doc(s) if s
+    end
+  end
+end

data/lib/maruku/element.rb

@@ -0,0 +1,138 @@
+module MaRuKu
+  # Rather than having a separate class for every possible element,
+  # Maruku has a single {MDElement} class
+  # that represents eveything in the document (paragraphs, headers, etc).
+  # The type of each element is available via \{#node\_type}.
+  class MDElement
+    # The type of this node (e.g. `:quote`, `:image`, `:abbr`).
+    # See {Helpers} for a list of possible values.
+    #
+    # @return [Symbol]
+    attr_accessor :node_type
+
+    # The child nodes of this element.
+    #
+    # @return [Array<String or MDElement>]
+    attr_accessor :children
+
+    # An attribute list. May not be nil.
+    #
+    # @return [AttributeList]
+    attr_accessor :al
+
+    # The processed attributes.
+    #
+    # For the {Maruku document root},
+    # this contains properties listed
+    # at the beginning of the document.
+    # The properties will be downcased and any spaces
+    # will be converted to underscores.
+    # For example, if you write in the source document:
+    #
+    #     !!!text
+    #     Title: test document
+    #     My property: value
+    #
+    #     content content
+    #
+    # Then \{#attributes} will return:
+    #
+    #     {:title => "test document", :my_property => "value"}
+    #
+    # @return [{Symbol => String}]
+    attr_accessor :attributes
+
+    # The root element of the document
+    # to which this element belongs.
+    #
+    # @return [Maruku]
+    attr_accessor :doc
+
+    def initialize(node_type = :unset, children = [], meta = {}, al = nil)
+      self.children = children
+      self.node_type = node_type
+      self.attributes = {}
+
+      # Define a new accessor on the singleton class for this instance
+      # for each metadata key
+      meta.each do |symbol, value|
+        class << self
+          self
+        end.send(:attr_accessor, symbol)
+
+        self.send("#{symbol}=", value)
+      end
+
+      self.al = al || AttributeList.new
+      self.meta_priv = meta
+    end
+
+    # @private
+    attr_accessor :meta_priv
+
+    def ==(o)
+      o.is_a?(MDElement) &&
+        self.node_type == o.node_type &&
+        self.meta_priv == o.meta_priv &&
+        self.children == o.children
+    end
+
+    # Iterates through each {MDElement} child node of this element.
+    # This includes deeply-nested child nodes.
+    # If `e_node_type` is specified, only yields nodes of that type.
+    def each_element(e_node_type=nil, &block)
+      @children.each do |c|
+        if c.is_a? MDElement then
+          yield c if e_node_type.nil? || c.node_type == e_node_type
+          c.each_element(e_node_type, &block)
+        #
+        # This handles the case where the children of an 
+        # element are arranged in a multi-dimensional array 
+        # (as in the case of a table)
+        elsif c.is_a? Array then
+          c.each do |cc|
+            # A recursive call to each_element will ignore the current element
+            # so we handle this case inline
+            if cc.is_a? MDElement then
+              yield cc if e_node_type.nil? || cc.node_type == e_node_type
+              cc.each_element(e_node_type, &block)
+            end
+          end
+        end
+
+      end
+    end
+
+    # Iterates through each String child node of this element,
+    # replacing it with the result of the block.
+    # This includes deeply-nested child nodes.
+    #
+    # This destructively modifies this node and its children.
+    #
+    # @todo Make this non-destructive
+    def replace_each_string(&block)
+      @children.map! do |c|
+        next yield c if c.is_a?(String)
+        c.replace_each_string(&block)
+        c
+      end
+      @children.flatten! unless self.node_type == :table
+    end
+  end
+
+  # A specialization of Element that can keep track of
+  # its parsed HTML as an attribute (rather than metadata)
+  class MDHTMLElement < MDElement
+    attr_accessor :parsed_html # HTMLFragment
+  end
+end
+
+class Array
+  def replace_each_string(&block)
+    self.map! do |c|
+      next yield c if c.is_a?(String)
+      c.replace_each_string(&block)
+      c
+    end
+  end
+end

data/lib/maruku/errors.rb

@@ -0,0 +1,80 @@
+module MaRuKu
+  class Exception < RuntimeError; end
+
+  module Errors
+    FRAME_WIDTH = 75
+
+    # Properly handles a formatting error.
+    # All such errors go through this method.
+    #
+    # The behavior depends on {MaRuKu::Globals `MaRuKu::Globals[:on_error]`}.
+    # If this is `:warning`, this prints the error to stderr
+    # (or `@error_stream` if it's defined) and tries to continue.
+    # If `:on_error` is `:ignore`, this doesn't print anything
+    # and tries to continue. If it's `:raise`, this raises a {MaRuKu::Exception}.
+    #
+    # By default, `:on_error` is set to `:warning`.
+    #
+    # @overload def maruku_error(s, src = nil, con = nil)
+    # @param s [String] The text of the error
+    # @param src [#describe, nil] The source of the error
+    # @param con [#describe, nil] The context of the error
+    # @param recover [String, nil] Recovery text
+    # @raise [MaRuKu::Exception] If `:on_error` is set to `:raise`
+    def maruku_error(s, src=nil, con=nil, recover=nil)
+      policy = get_setting(:on_error)
+
+      case policy
+      when :ignore
+      when :raise
+        raise_error create_frame(describe_error(s, src, con, recover))
+      when :warning
+        tell_user create_frame(describe_error(s, src, con, recover))
+      else
+        raise "Unknown on_error policy: #{policy.inspect}"
+      end
+    end
+
+    # This is like {#maruku_error} but will never raise.
+    def maruku_recover(s, src=nil, con=nil, recover=nil)
+      policy = get_setting(:on_error)
+
+      case policy
+      when :ignore
+      when :raise, :warning
+        tell_user create_frame(describe_error(s, src, con, recover))
+      else
+        raise "Unknown on_error policy: #{policy.inspect}"
+      end
+    end
+
+    def raise_error(s)
+      raise MaRuKu::Exception, s, caller
+    end
+
+    def tell_user(s)
+      (self.attributes[:error_stream] || $stderr) << s << "\n"
+    end
+
+    private
+
+    def create_frame(s)
+      "\n" + <<FRAME
+ #{"_" * FRAME_WIDTH}
+| Maruku tells you:
++#{"-" * FRAME_WIDTH}
+#{s.gsub(/^/, '| ').rstrip}
++#{"-" * FRAME_WIDTH}
+#{caller[1...5].join("\n").gsub(/^/, '!')}
+\\#{"_" * FRAME_WIDTH}
+FRAME
+    end
+
+    def describe_error(s, src=nil, con=nil, recover=nil)
+      s += "\n#{src.describe}\n" if src
+      s += "\n#{con.describe}\n" if con
+      s += "\nRecovering: #{recover}\n" if recover
+      s
+    end
+  end
+end

data/lib/maruku/ext/div.rb

@@ -1,5 +1,3 @@
-
-
 #+-----------------------------------{.warning}------
 #| this is the last warning!
 #|
@@ -10,124 +8,118 @@
 #| +--------------------------------------------------
 #+---------------------------------------------------
 
-OpenDiv = /^[ ]{0,3}\+\-\-+\s*(\{([^{}]*|".*"|'.*')*\})?\s*\-*\s*$/
-CloseDiv = /^[ ]{0,3}\=\-\-+\s*(\{([^{}]*|".*"|'.*')*\})?\s*\-*\s*$/
-# note these are not enough for parsing the above example:
-#OpenDiv = /^[ ]{0,3}\+\-\-+\s*(.*)$/
-#CloseDiv = /^[ ]{0,3}\=\-\-+\s*(.*)$/
+# TODO: Scope these properly
+OpenDiv = /^[ ]{0,3}\+\-\-+\s*(\{([^{}]*?|".*?"|'.*?')*\})?\s*\-*\s*$/
+CloseDiv = /^[ ]{0,3}\=\-\-+\s*(\{([^{}]*?|".*?"|'.*?')*\})?\s*\-*\s*$/
 StartPipe = /^[ ]{0,3}\|(.*)$/ # $1 is rest of line
 DecorativeClosing = OpenDiv
 
-MaRuKu::In::Markdown::register_block_extension(
-	:regexp  => OpenDiv,
-	:handler => lambda { |doc, src, context|
-		# return false if not doc.is_math_enabled?
-		first = src.shift_line
-		first =~ OpenDiv
-		ial_at_beginning = $1
-		ial_at_end = nil
-		
-		lines = []
-		# if second line starts with "|"
-		if src.cur_line =~ StartPipe
-			# then we read until no more "|"
-			while src.cur_line && (src.cur_line =~ StartPipe)
-				content = $1
-				lines.push content
-				src.shift_line
-			end
-			if src.cur_line =~ DecorativeClosing
-				ial_at_end = $1
-				src.shift_line 
-			end
-		else
-			# else we read until CloseDiv
-			divs_open = 1
-			while src.cur_line && (divs_open>0)
-				if src.cur_line =~ CloseDiv
-					divs_open -= 1
-					if divs_open == 0
-						ial_at_end = $1
-						src.shift_line
-						break
-					else
-						lines.push src.shift_line
-					end
-				else
-					if src.cur_line =~ OpenDiv
-						divs_open += 1 
-					end
-					lines.push src.shift_line
-				end
-			end
-			
-			if divs_open > 0
-				e = "At end of input, I still have #{divs_open} DIVs open."
-				doc.maruku_error(e, src, context)
-				return true
-			end
-		end
-		
-		ial_at_beginning = nil unless 
-			(ial_at_beginning&&ial_at_beginning.size > 0)
-		ial_at_end = nil unless (ial_at_end && ial_at_end.size > 0)
+MaRuKu::In::Markdown.register_block_extension(
+  :regexp  => OpenDiv,
+  :handler => lambda do |doc, src, context|
+    first = src.shift_line
+    ial_at_beginning = first[OpenDiv, 1]
+    ial_at_end = nil
+
+    lines = []
+    # if second line starts with "|"
+    if src.cur_line =~ StartPipe
+      # then we read until no more "|"
+      while src.cur_line && src.cur_line =~ StartPipe
+        lines.push $1
+        src.shift_line
+      end
+      if src.cur_line =~ DecorativeClosing
+        ial_at_end = $1
+        src.shift_line
+      end
+    else
+      # else we read until CloseDiv
+      divs_open = 1
+      while src.cur_line && divs_open > 0
+        if src.cur_line =~ CloseDiv
+          divs_open -= 1
+          if divs_open == 0
+            ial_at_end = $1
+            src.shift_line
+            break
+          else
+            lines.push src.shift_line
+          end
+        else
+          if src.cur_line =~ OpenDiv
+            divs_open += 1
+          end
+          lines.push src.shift_line
+        end
+      end
+
+      if divs_open > 0
+        doc.maruku_error("At end of input, I still have #{divs_open} DIVs open.",
+          src, context)
+        next true
+      end
+    end
+
+    ial_at_beginning = nil unless ial_at_beginning && ial_at_beginning.size > 0
+    ial_at_end = nil unless ial_at_end && ial_at_end.size > 0
+
+    if ial_at_beginning && ial_at_end
+      doc.maruku_error("Found two conflicting IALs: #{ial_at_beginning.inspect} and #{ial_at_end.inspect}",
+        src, context)
+    end
 
-		if ial_at_beginning && ial_at_end
-			e = "Found two conflicting IALs: #{ial_at_beginning.inspect} and #{ial_at_end.inspect}"
-			doc.maruku_error(e, src, context)
-		end
-		
-		al_string = ial_at_beginning || ial_at_end
-		al = nil
-		
-		if al_string =~ /^\{(.*)\}\s*$/
-			inside = $1
-		cs = MaRuKu::In::Markdown::SpanLevelParser::CharSource
-		al = al_string &&
-			doc.read_attribute_list(cs.new(inside), its_context=nil, break_on=[nil])
-		end
-		
-		src = MaRuKu::In::Markdown::BlockLevelParser::LineSource.new(lines)
-		children = doc.parse_blocks(src)
+    al_string = ial_at_beginning || ial_at_end
+    al = nil
 
-		context.push doc.md_div(children, al)
-		true
-	})
-	
+    if al_string =~ /^\{(.*)\}\s*$/
+      al = al_string && doc.read_attribute_list(
+        MaRuKu::In::Markdown::SpanLevelParser::CharSource.new($1),
+        nil, [nil])
+    end
 
-module MaRuKu; class MDElement
+    context.push(
+      doc.md_div(
+        doc.parse_blocks(
+          MaRuKu::In::Markdown::BlockLevelParser::LineSource.new(lines)),
+        al))
+    true
+  end)
 
-	def md_div(children, al=nil)
-		type = label = num = nil
-		doc.refid2ref ||= {}
-		if al
-			al.each do |k, v|
-				case k
-				when :class
-					type = $1 if v =~ /^num_(\w*)/
-        	                when :id
-					label = v
-				end
-			end
-		end
-		if type
-			doc.refid2ref[type] ||= {}
-			num = doc.refid2ref[type].length + 1 || 1
-		end
-		e = self.md_el(:div, children, meta={:label => label, :type => type, :num => num}, al)
-		if type && label
-			doc.refid2ref[type].update({label => e})
-		end
-		e
-	end
-	
-end end
+module MaRuKu
+  class MDElement
+    def md_div(children, al = nil)
+      type = label = num = nil
+      doc.refid2ref ||= {}
+      if al
+        al.each do |k, v|
+          case k
+          when :class; type = $1 if v =~ /^num_(\w*)/
+          when :id; label = v
+          end
+        end
+      end
 
+      if type
+        doc.refid2ref[type] ||= {}
+        num = doc.refid2ref[type].length + 1
+        if !label
+          doc.id_counter += 1
+      		label =  "div_" + doc.id_counter.to_s
+        end
+      end
 
-module MaRuKu; module Out; module HTML
+      e = self.md_el(:div, children, {:label => label, :type => type, :num => num}, al)
+      doc.refid2ref[type].update(label => e) if type && label
+      e
+    end
+  end
 
-	def to_html_div
-		add_ws  wrap_as_element('div')
-	end
-	
-end end end
+  module Out
+    module HTML
+      def to_html_div
+        add_ws wrap_as_element('div')
+      end
+    end
+  end
+end