marker 0.1.0

data/lib/marker/links.rb

@@ -0,0 +1,153 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  class InternalLink < ParseNode
+    def to_html( options = {} )
+      "<a href='#{path(options)}'>#{label(:html, options)}</a>"
+    end
+
+    def to_s( options = {} )
+      f = options[:footnotes]
+      if f
+        l = label(:text, options)
+        n = f.add( path(options), l )
+        "#{l} [#{n}]"
+      else
+        "#{label(:text, options)} [#{path}]"
+      end
+    end
+
+    def path( options = {} )
+      p = options[:link_base] || ''
+      p.chomp! '/'
+      p += '/' + target
+    end
+
+    def label( format, options = {} )
+      if l
+        case format
+        when :html
+          l.to_html(options)
+        else
+          l.to_s(options)
+        end
+      else
+        if a
+          # an arg delimiter was present, but without a label
+          # sanitize: remove trailing parenthetical remarks
+          target.gsub(/\s*\([^)]*\)$/, '')
+        else
+          target
+        end
+      end
+    end
+
+    def target
+      if t
+        t.text_value
+      else
+        ''
+      end
+    end
+
+    #-- defaults ++
+    def t #:nodoc:
+      nil
+    end
+
+    def a #:nodoc:
+      nil
+    end
+
+    def l #:nodoc:
+      nil
+    end
+  end
+
+  class ExternalLink < ParseNode
+    def to_html( options = {} )
+      if l
+        "<a href='#{target}'>#{label(:html, options)}</a>"
+      else
+        f = options[:footnotes]
+        if f
+          n = f.add( target )
+          "<a href='#{target}'>[#{n}]</a>"
+        else
+          "<a href='#{target}'></a>"
+        end
+      end
+    end
+
+    def to_s( options = {} )
+      f = options[:footnotes]
+      if l
+        if f
+          n = f.add( target, label(:text, options) )
+          "#{label(:text, options)} [#{n}]"
+        else
+          "#{label(:text, options)} [#{target}]"
+        end
+      else
+        if f
+          n = f.add( target )
+          "[#{n}]"
+        else
+          target
+        end
+      end
+    end
+
+    def label( format, options = {} )
+      if l
+        case format
+        when :html
+          l.to_html(options)
+        else
+          l.to_s(options)
+        end
+      else
+        ''
+      end
+    end
+
+    def target
+      if t
+        t.text_value
+      else
+        ''
+      end
+    end
+
+    #-- defaults ++
+    def t #:nodoc:
+      nil
+    end
+
+    def l #:nodoc:
+      nil
+    end
+  end
+
+  class URL < ParseNode
+    # TODO: these should output links just like "[url]".  The link tags
+    # shouldn't call these methods, these are called when the URL is not in a
+    # link.  The link templates should grab the URL themselves.
+    def to_html( options = {} )
+      text_value
+    end
+
+    def to_s( options = {} )
+      text_value
+    end
+  end
+
+  class Protocol < ParseNode
+  end
+end

data/lib/marker/lists.rb

@@ -0,0 +1,188 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  # used to collect list lines into lists structured hierarchically, like in HTML
+  class ListBuilder
+    attr_reader :tag, :contents, :attrs
+
+    def initialize( contents, tag, attrs = {} )
+      @contents = [contents].flatten
+      @tag = tag
+      @attrs = attrs
+    end
+
+    # returns true if the l has the same tag
+    def ===( l )
+      ( l.is_a? self.class and tag == l.tag )
+    end
+
+    def <<( l )
+      last = contents.last
+
+      if last and last === l
+        last += l
+      else
+        contents << l
+      end
+
+      self
+    end
+
+    def +( l )
+      l.contents.each { |i| self << i } if self === l
+
+      self
+    end
+
+    def to_html( options = {} )
+      if tag
+        "<#{tag}" +
+        ( attrs.any?? ' ' : '' ) +
+        attrs.map { |k, v|
+          "#{k}='#{v}'"
+        }.join(' ') +
+        ">" +
+        contents.map { |i|
+          i.to_html(options)
+        }.join +
+        "</#{tag}>"
+      else
+        contents.map { |i|
+          i.to_html(options)
+        }.join
+      end
+    end
+
+    def to_s( options = {} )
+      strs = []
+      contents.each_with_index { |i, ind|
+        strs << i.to_s( options.merge( 
+            :indent => ( options[:indent] || 0 ) + ( tag ? 1 : 0 ),
+            :num => ind + 1
+          ) )
+      }
+      strs.join("\n")
+    end
+  end
+
+  class List < RecursiveList
+    def to_html( options = {} )
+      l = ListBuilder.new( [], nil )
+      to_a.each do |item|
+        l << item.structure
+      end
+      l.to_html(options)
+    end
+
+    def to_s( options = {} )
+      l = ListBuilder.new( [], nil )
+      to_a.each do |item|
+        l << item.structure
+      end
+      l.to_s(options)
+    end
+  end
+
+  class Bulleted < ParseNode
+    def to_html( options = {} )
+      "<li>#{phrase.to_html(options)}</li>"
+    end
+
+    def to_s( options = {} )
+      indent = (options[:indent] || 0)
+      '    ' * (indent > 0 ? indent - 1 : 0) +
+      '  * ' + phrase.to_s( options )
+    end
+
+    def structure
+      if phrase
+        ListBuilder.new( self, :ul )
+      else
+        ListBuilder.new( list_item.structure, :ul )
+      end
+    end
+
+    #-- defaults ++
+    def phrase
+      nil
+    end
+  end
+
+  class Numbered < ParseNode
+    def to_html( options = {} )
+      "<li>#{phrase.to_html(options)}</li>"
+    end
+
+    def to_s( options = {} )
+      indent = (options[:indent] || 0)
+      '    ' * (indent > 0 ? indent - 1 : 0) +
+      "#{'%2d' % options[:num]}. #{phrase.to_s( options )}"
+    end
+
+    def structure
+      if phrase
+        ListBuilder.new( self, :ol )
+      else
+        ListBuilder.new( list_item.structure, :ol )
+      end
+    end
+
+    #-- defaults ++
+    def phrase
+      nil
+    end
+  end
+
+  class Indented < ParseNode
+    def to_html( options = {} )
+      "<div>#{phrase.to_html(options)}</div>"
+    end
+
+    def to_s( options = {} )
+      indent = (options[:indent] || 0)
+      '    ' * (indent > 0 ? indent : 0) +
+      phrase.to_s(options)
+    end
+
+    def structure
+      if phrase
+        ListBuilder.new( self, :div, :class => 'indent' )
+      else
+        ListBuilder.new( list_item.structure, :div, :class => 'indent' )
+      end
+    end
+
+    #-- defaults ++
+    def phrase
+      nil
+    end
+  end
+
+  class Definition < ParseNode
+    def to_html( options = {} )
+      "<dt>#{term.to_html(options)}</dt>" +
+      ( definition ? "<dd>#{definition.to_html(options)}</dd>" : "" )
+    end
+
+    def to_s( options = {} )
+      indent = (options[:indent] || 0)
+      '    ' * (indent > 0 ? indent - 1: 0) +
+      "#{term.to_s(options)} :: #{definition.to_s(options)}"
+    end
+
+    def structure
+      ListBuilder.new( self, :dl )
+    end
+
+    #-- defaults ++
+    def definition
+      nil
+    end
+  end
+end

data/lib/marker/markup.rb

@@ -0,0 +1,81 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  class Markup < RecursiveList
+    def to_html( options = {} )
+      options = make_options( options )
+
+      [
+        to_a.map{ |b|
+          b.to_html(options)
+        }, options[:footnotes].to_html( options )
+      ].flatten.join("\n")
+    end
+
+    def to_s( options = {} )
+      options = make_options( options )
+
+      [
+        to_a.map{ |b|
+          b.to_s(options)
+        }, options[:footnotes].to_s( options )
+      ].flatten.join("\n")
+    end
+
+    def make_options( user_options )
+      o = Marker.render_options.dup
+      o.merge!( :link_base => Marker.link_base )
+      o.merge!( :footnotes => Footnotes.new ) unless user_options[:nofootnotes]
+      o.merge!( user_options )
+      o
+    end
+  end
+
+  class Footnotes
+    def notes
+      @notes ||= []
+    end
+
+    def add( *args )
+      notes << args
+      notes.size
+    end
+
+    def to_html( options = {} )
+      return "" unless notes.any?
+
+      "<ol>" +
+      notes.map { |n|
+        target = n.shift
+        if n.any?
+          "<li><a href='#{target}'>#{n.join(' ')}</a></li>"
+        else
+          "<li><a href='#{target}'>#{target}</a></li>"
+        end
+      }.join +
+      "</ol>"
+    end
+
+    def to_s( options = {} )
+      return "" unless notes.any?
+
+      s = "\n"
+      notes.each_with_index{ |n, i|
+        target = n.shift
+        if n.any?
+          s << "#{'%2d' % (i + 1)}. #{n.join(' ')}: #{target}\n"
+        else
+          s << "#{'%2d' % (i + 1)}. #{target}\n"
+        end
+      }
+
+      s
+    end
+  end
+end

data/lib/marker/templates.rb

@@ -0,0 +1,105 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  class Template < ParseNode
+    def to_html( options = {} )
+      render( :html, options )
+    end
+
+    def to_s( options = {} )
+      render( :text, options )
+    end
+
+    def render( format, options = {} )
+      Marker.templates.send( target, format, *arg_list( format, options ) )
+    end
+
+    def target
+      # sanitize the string to get a method name
+      t.text_value.gsub(/\s/, '_').to_sym
+    end
+
+    def arg_list( format, options )
+      ( args ? args.to_arg_list( format, options ) : [[], {}] )
+    end
+
+    #-- defaults ++
+    def t #:nodoc:
+      nil
+    end
+
+    def args #:nodoc:
+      nil
+    end
+  end
+
+  class Arguments < RecursiveList
+    def to_arg_list( format, options = {} )
+      pos_params = []
+      named_params = {}
+
+      case format
+      when :html
+        to_a.each do |a|
+          next unless a
+          if a.name
+            named_params[a.name.to_html( options )] = a.val.to_html( options )
+          else
+            pos_params << a.val.to_html( options )
+          end
+        end
+      else
+        to_a.each do |a|
+          next unless a
+          if a.name
+            named_params[a.name.to_s( options )] = a.val.to_s( options )
+          else
+            pos_params << a.val.to_s( options )
+          end
+        end
+      end
+
+      [pos_params, named_params]
+    end
+
+    def to_html( options = {} )
+      to_a.map { |a|
+        a ? a.to_html(options) : ''
+      }.join(', ')
+    end
+
+    def to_s( options = {} )
+      to_a.map { |a|
+        a ? a.to_s(options) : ''
+      }.join(', ')
+    end
+  end
+
+  class Argument < ParseNode
+    def to_html( options = {} )
+      to_s
+    end
+
+    def to_s( options = {} )
+      ( name ? "'#{name}' => '#{val}'" : "'#{val}'" )
+    end
+
+    #-- defaults ++
+    def name #:nodoc:
+      nil
+    end
+  end
+
+  # A set of basic templates for rendering
+  module DefaultTemplates
+    def self.method_missing( sym, *args )
+      "render:#{sym}( #{args.map(&:inspect).join(', ')} )"
+    end
+  end
+end

data/lib/marker/text.rb

@@ -0,0 +1,96 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  class Paragraph < RecursiveList
+    def to_html( options = {} )
+      '<p>' +
+      to_a.map { |p|
+        p.to_html(options)
+      }.join(' ') +
+      '</p>'
+    end
+
+    # TODO: add wordwrap
+    def to_s( options = {} )
+      to_a.map { |p|
+        p.to_s(options)
+      }.join(' ')
+    end
+  end
+
+  class Phrase < RecursiveList
+    def to_html( options = {} )
+      s = h.to_html(options)
+      s << ' ' if space?
+      s << r.to_html(options) if r
+      s
+    end
+
+    def to_s( options = {} )
+      s = h.to_s(options)
+      s << ' ' if space?
+      s << r.to_s(options) if r
+      s
+    end
+
+    # returns true if there was white space after the first "word"
+    def space?
+      (ws and ws.present?) or (aws and aws.present?)
+    end
+
+    #-- defaults ++
+    def ws
+      nil
+    end
+
+    def aws
+      nil
+    end
+  end
+
+  class Word < ParseNode
+    def to_html( options = {} )
+      text_value
+    end
+
+    def to_s( options = {} )
+      text_value
+    end
+  end
+
+  class Delimiter < ParseNode
+    def to_html( options = {} )
+      text_value
+    end
+
+    def to_s( options = {} )
+      text_value
+    end
+  end
+
+  class Bold < ParseNode
+    def to_html( options = {} )
+      "<b>#{bold_enclosed_text.to_html(options)}</b>"
+    end
+
+    def to_s( options = {} )
+      "*#{bold_enclosed_text.to_s(options)}*"
+    end
+  end
+
+  class Italic < ParseNode
+    def to_html( options = {} )
+      "<i>#{italic_enclosed_text.to_html(options)}</i>"
+    end
+
+    def to_s( options = {} )
+      "/#{italic_enclosed_text.to_s(options)}/"
+    end
+  end
+end

data/lib/marker/verbatim.rb

@@ -0,0 +1,48 @@
+#--
+# Copyright 2009 Ryan Blue.
+# Distributed under the terms of the GNU General Public License (GPL).
+# See the LICENSE file for further information on the GPL.
+#++
+
+require 'marker/common'
+
+module Marker #:nodoc:
+  class VerbatimArea < RecursiveList
+    def to_html( options = {} )
+      "<pre>\n" +
+      to_a.map { |l|
+        l.to_html(options)
+      }.join("\n") +
+      "\n</pre>"
+    end
+
+    def to_s( options = {} )
+      "-- \n" +
+      to_a.map { |l|
+        l.to_s(options)
+      }.join("\n") +
+      "\n-- "
+    end
+  end
+
+  class Verbatim < ParseNode
+    def to_html( options = {} )
+      v.text_value
+    end
+
+    def to_s( options = {} )
+      v.text_value
+    end
+  end
+
+  class HorizRule < ParseNode
+    def to_html( options = {} )
+      "<hr />"
+    end
+
+    def to_s( options = {} )
+      width = options[:width] || 80
+      "-" * width
+    end
+  end
+end