maruku 0.6.1 → 0.7.0.beta1

data/lib/maruku/input/rubypants.rb

@@ -1,33 +1,13 @@
-#--
-#   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
-#++
-
-#
-# NOTA BENE: 
-#
-# The following algorithm is a rip-off of RubyPants written by 
-# Christian Neukirchen. 
+#
+# NOTA BENE:
+#
+# The following algorithm is a rip-off of RubyPants written by
+# Christian Neukirchen.
 #
 # RubyPants is a Ruby port of SmartyPants written by John Gruber.
 #
-# This file is distributed under the GPL, which I guess is compatible
-# with the terms of the RubyPants license.
+# This file is distributed under the MIT license, which is compatible
+# with the terms of the RubyPants license (3-clause BSD).
 #
 # -- Andrea Censi
 
@@ -51,39 +31,39 @@
 # [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
@@ -96,23 +76,23 @@
 # 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
@@ -125,7 +105,7 @@
 # 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
 #
@@ -137,89 +117,181 @@
 # Christian Neukirchen:: http://kronavita.de/chris
 
 
-module MaRuKu; module In; module Markdown; module SpanLevelParser
-	Punct_class = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
-	Close_class = %![^\ \t\r\n\\[\{\(\-]!
-
-	Rules = [
-		[/---/,   :mdash          ],
-		[/--/,    :ndash          ],
-		['...',   :hellip         ],
-		['. . .', :hellip         ],
-		["``",    :ldquo          ],
-		["''",    :rdquo          ],
-		[/<<\s/,  [:laquo, :nbsp] ],
-		[/\s>>/,  [:nbsp, :raquo] ],
-		[/<</,    :laquo          ],
-		[/>>/,    :raquo          ],
-		
-#		def educate_single_backticks(str)
-#		["`", :lsquo]
-#		["'", :rsquo]
-
-		# Special case if the very first character is a quote followed by
-		# punctuation at a non-word-break. Close the quotes by brute
-		# force:
-		[/^'(?=#{Punct_class}\B)/, :rsquo],
-		[/^"(?=#{Punct_class}\B)/, :rdquo],
-		# Special case for double sets of quotes, e.g.:
-		#   <p>He said, "'Quoted' words in a larger quote."</p>
-		[/"'(?=\w)/, [:ldquo, :lsquo]    ],
-		[/'"(?=\w)/, [:lsquo, :ldquo]    ],
-		# Special case for decade abbreviations (the '80s):
-		[/'(?=\d\ds)/, :rsquo            ],
-		# Get most opening single quotes:
-		[/(\s)'(?=\w)/, [:one, :lsquo]   ],
-		# Single closing quotes:
-		[/(#{Close_class})'/, [:one, :rsquo]],
-		[/'(\s|s\b|$)/, [:rsquo, :one]],
-		# Any remaining single quotes should be opening ones:
-		[/'/, :lsquo],
-		# Get most opening double quotes:
-		[/(\s)"(?=\w)/, [:one, :ldquo]],
-		# Double closing quotes:
-		[/(#{Close_class})"/, [:one, :rdquo]],
-		[/"(\s|s\b|$)/, [:rdquo, :one]],
-		# Any remaining quotes should be opening ones:
-		[/"/, :ldquo]
-	].
-	map{|reg, subst| # People should do the thinking, machines should do the work.
-		reg = Regexp.new(Regexp.escape(reg)) if not reg.kind_of? Regexp
-		subst = [subst] if not subst.kind_of?Array
-		[reg, subst]}
-
-# note: input will be destroyed
-def apply_one_rule(reg, subst, input)
-	output = []
-	while first = input.shift
-		if first.kind_of?(String) && (m = reg.match(first))
-			output.push    m. pre_match if m. pre_match.size > 0
-			 input.unshift m.post_match if m.post_match.size > 0
-			subst.reverse.each do |x|
-				input.unshift( x == :one ? m[1] : md_entity(x.to_s) ) end
-		else
-			output.push first
-		end
-	end
-	return output
-end
-	
-def educate(elements)
-	Rules.each do |reg, subst|
-		elements = apply_one_rule(reg, subst, elements)
-	end
-	# strips empty strings
-	elements.delete_if {|x| x.kind_of?(String) && x.size == 0}
-	final = []
-	# join consecutive strings
-	elements.each do |x|
-		if x.kind_of?(String) && final.last.kind_of?(String)
-			final.last << x
-		else
-			final << x
-		end
-	end
-	return final
-end
+module MaRuKu::In::Markdown::SpanLevelParser
+  Punct_class = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
+  Close_class = "[^\ \t\r\n\\[\{\(\-]"
+
+  # A rule to apply a particular pattern (like double quotes)
+  # against a list of strings and MDElements, replacing that
+  # pattern with the smartypants version.
+  class Rule
+    # The pattern to search for
+    attr_accessor :pattern
+
+    # The replacement tokens (entities or other instructions)
+    attr_accessor :replacement
+
+    # This is a hack to allow us to build entities.
+    attr_accessor :doc
+
+    def initialize(pattern, replacement)
+      @pattern = pattern
+      @replacement = replacement
+    end
+
+    private
+
+    # Add something to the output array. If it's
+    # not a string (like an MDElement) just add it direcltly,
+    # otherwise attempt to add on to the last element in the
+    # output if it's a string.
+    def append_to_output(output, str)
+      if !str.kind_of?(String)
+        output << str
+        return
+      end
+      return if str.empty?
+      if output.last.kind_of?(String)
+        output.last << str
+      else
+        output << str
+      end
+    end
+  end
+
+  # Simple rule that says "Replace this pattern with these entities"
+  class ReplaceRule < Rule
+    # Replace all matches in the input at once with the
+    # same elements from "replacement".
+    def apply(first, input, output)
+      intersperse(first.split(pattern), replacement).each do |x|
+        append_to_output(output, x)
+      end
+    end
 
-end end end end
+    private
+
+    # Sort of like "join" - places the elements in "elem"
+    # between each adjacent element in the array.
+    def intersperse(ary, elem)
+      return ary if ary.length <= 1
+      h, *t = ary
+      t.inject([h]) do |r, e|
+        entities = elem.map do |el|
+          en = el.clone
+          en.doc = doc
+          en
+        end
+        r.concat entities
+        r << e
+      end
+    end
+  end
+
+  # A more complex rule that uses a capture group from the
+  # pattern in its replacement.
+  class CaptureRule < Rule
+    # One at a time, replace each match, including
+    # some part of the match, and put the rest back into
+    # input to be processed next.
+    def apply(first, input, output)
+      if pattern =~ first
+        m = Regexp.last_match
+        append_to_output(output, m.pre_match)
+        input.unshift m.post_match unless m.post_match.empty?
+        replacement.reverse_each do |sub|
+          if sub == :one
+            input.unshift m[1]
+          else
+            entity = sub.clone
+            sub.doc = doc
+            input.unshift entity
+          end
+        end
+      else
+        append_to_output(output, first)
+      end
+    end
+  end
+
+  # All the rules that will be applied (in order) to smarten the document.
+  Rules =
+    [
+     ['---',   :mdash          ],
+     ['--',    :ndash          ],
+     ['...',   :hellip         ],
+     ['. . .', :hellip         ],
+     ["``",    :ldquo          ],
+     ["''",    :rdquo          ],
+     [/<<\s/,  [:laquo, :nbsp] ],
+     [/\s>>/,  [:nbsp, :raquo] ],
+     ['<<',    :laquo          ],
+     ['>>',    :raquo          ],
+
+     # Special case if the very first character is a quote followed by
+     # punctuation at a non-word-break. Close the quotes by brute
+     # force:
+     [/\A'(?=#{Punct_class}\B)/, :rsquo],
+     [/\A"(?=#{Punct_class}\B)/, :rdquo],
+     # Special case for double sets of quotes, e.g.:
+     #   <p>He said, "'Quoted' words in a larger quote."</p>
+     [/"'(?=\w)/, [:ldquo, :lsquo]    ],
+     [/'"(?=\w)/, [:lsquo, :ldquo]    ],
+     # Special case for decade abbreviations (the '80s):
+     [/'(?=\d\ds)/, :rsquo            ],
+     # Get most opening single quotes:
+     [/(\s)'(?=\w)/, [:one, :lsquo]   ],
+     # Single closing quotes:
+     [/(#{Close_class})'/, [:one, :rsquo]],
+     [/'(\s|s\b|$)/, [:rsquo, :one]],
+     # Any remaining single quotes should be opening ones:
+     ["'", :lsquo],
+     # Get most opening double quotes:
+     [/(\s)"(?=\w)/, [:one, :ldquo]],
+     # Double closing quotes:
+     [/(#{Close_class})"/, [:one, :rdquo]],
+     [/"(\s|s\b|$)/, [:rdquo, :one]],
+     # Any remaining quotes should be opening ones:
+     ['"', :ldquo]
+    ].
+  map do |reg, subst| # People should do the thinking, machines should do the work.
+    captures = false
+    subst = Array(subst).map do |s|
+      if s == :one
+        captures = true
+        s
+      else
+        MaRuKu::MDElement.new(:entity, [], { :entity_name => s.to_s.freeze }, nil)
+      end
+    end.freeze
+
+    if captures
+      CaptureRule.new reg, subst
+    else
+      ReplaceRule.new reg, subst
+    end
+  end
+
+  # Fully apply a single rule to an entire array
+  # of elements.
+  # note: input will be modified in place
+  def apply_one_rule!(rule, input)
+    output = []
+    while first = input.shift
+      if first.kind_of?(String)
+        rule.doc = @doc
+        rule.apply(first, input, output)
+      else
+        output << first
+      end
+    end
+    output
+  end
+
+  # Transform elements to have SmartyPants punctuation.
+  def educate(elements)
+    Rules.inject(elements) do |elems, rule|
+      apply_one_rule!(rule, elems)
+    end
+  end
+end

data/lib/maruku/inspect_element.rb

@@ -0,0 +1,60 @@
+module MaRuKu
+  class MDElement
+    INSPECT_FORMS = {
+      :paragraph          => ["par",      :children],
+      :footnote_reference => ["foot_ref", :footnote_id],
+      :entity             => ["entity",   :entity_name],
+      :email_address      => ["email",    :email],
+      :inline_code        => ["code",     :raw_code],
+      :raw_html           => ["html",     :raw_html],
+      :emphasis           => ["em",       :children],
+      :strong             => ["strong",   :children],
+      :immediate_link     => ["url",      :url],
+      :image              => ["image",    :children, :ref_id],
+      :im_image           => ["im_image", :children, :url, :title],
+      :link               => ["link",     :children, :ref_id],
+      :im_link            => ["im_link",  :children, :url, :title],
+      :ref_definition     => ["ref_def",  :ref_id, :url, :title],
+      :ial                => ["ial",      :ial],
+      :li                 => ["li",       :children, :want_my_paragraph]
+    }
+
+    # Outputs the document AST as calls to document helpers.
+    # (this should be `eval`-able to get a copy of the original element).
+    def inspect
+      if INSPECT_FORMS.has_key? @node_type
+        name, *params = INSPECT_FORMS[@node_type]
+
+        params = params.map do |p|
+          if p == :children
+            children_inspect
+          else
+            send(p).inspect
+          end
+        end
+        params << @al.inspect if @al && !@al.empty?
+      else
+        name = 'el'
+        params = [self.node_type.inspect, children_inspect]
+        params << @meta_priv.inspect unless @meta_priv.empty? && self.al.empty?
+        params << self.al.inspect unless self.al.empty?
+      end
+
+      "md_#{name}(#{params.join(', ')})"
+    end
+
+    private
+
+    def children_inspect
+      kids = @children.map(&:inspect)
+      return kids.first if kids.size == 1
+
+      comma = kids.join(", ")
+      if comma.size < 70
+        "[#{comma}]"
+      else
+        "[\n\t#{kids.join(",\n\t")}\n]"
+      end
+    end
+  end
+end