marker 0.3.3 → 0.4.0

data/lib/marker/lists.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2009 Ryan Blue.
+# Copyright 2009-2012 Ryan Blue.
 # Distributed under the terms of the GNU General Public License (GPL).
 # See the LICENSE file for further information on the GPL.
 #++
@@ -7,177 +7,206 @@
 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
+    attr_reader :type
+    attr_reader :items
 
-    def initialize( contents, tag, attrs = {} )
-      @contents = [contents].flatten
-      @tag = tag
-      @attrs = attrs
+    def initialize( type, item=nil )
+      @type = type
+      @items = (item ? [item] : [])
     end
 
-    # returns true if the l has the same tag
-    def ===( l )
-      ( l.is_a? self.class and tag == l.tag )
+    def can_merge?( other )
+      type == other.type
     end
 
-    def <<( l )
-      last = contents.last
+    def merge!( list )
+      list.items.each { |item| add( item ) }
+    end
 
-      if last and last === l
-        last += l
+    def add( item )
+      if items.last and items.last.can_merge? item
+        items.last.merge! item
       else
-        contents << l
+        items << item
       end
-
-      self
     end
 
-    def +( l )
-      l.contents.each { |i| self << i } if self === l
-
-      self
+    def empty?
+      items.empty?
     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}>"
+    def to_html( options={} )
+      inner_html = items.map { |item| item.to_html(options) }.join
+      case type
+      when :bulleted
+        "<ul>#{inner_html}</ul>"
+      when :numbered
+        "<ol>#{inner_html}</ol>"
+      when :indented
+        "<div class='indent'>#{inner_html}</div>"
+      when :definition
+        "<dl>#{inner_html}</dl>"
       else
-        contents.map { |i|
-          i.to_html(options)
-        }.join
+        inner_html
       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={} )
+      indent = (options[:indent] ? options[:indent] + 1 : -1)
+      # sublists are already indented because they are part of an item.
+      indent -= 1 if type == :sublist
 
-    def to_s( options = {} )
-      l = ListBuilder.new( [], nil )
-      to_a.each do |item|
-        l << item.structure
+      case type
+      when :numbered
+        items.each_with_index.map { |item, num|
+          item.to_s(options.merge(:indent => indent, :num => num))
+        }.join("\n")
+      else
+        items.map { |item|
+          item.to_s(options.merge(:indent => indent))
+        }.join("\n")
       end
-      l.to_s(options)
     end
   end
 
-  class Bulleted < ParseNode
-    def to_html( options = {} )
-      "<li>#{phrase.to_html(options)}</li>"
+  class ItemBuilder
+    attr_reader :type
+    attr_reader :content
+    attr_reader :sublists
+
+    def initialize( type, content_or_sublist )
+      @type = type
+
+      if content_or_sublist.respond_to? :items
+        @content = nil
+        @sublists = ListBuilder.new(:sublist, content_or_sublist)
+      else
+        @content = content_or_sublist
+        @sublists = ListBuilder.new(:sublist)
+      end
     end
 
-    def to_s( options = {} )
-      indent = (options[:indent] || 0)
-      '    ' * (indent > 0 ? indent - 1 : 0) +
-      '  * ' + phrase.to_s( options )
+    def can_merge?( other )
+      other.content.nil?
+    end
+
+    def merge!( item )
+      sublists.merge! item.sublists
+    end
+
+    def to_html( options={} )
+      case type
+      when :bulleted, :numbered
+        "<li>" +
+          ( content ? content.to_html(options) : "" ) +
+          sublists.to_html(options) +
+        "</li>"
+      when :indented
+        "<div class='indented_item'>" +
+          ( content ? content.to_html(options) : "" ) +
+          sublists.to_html(options) +
+        "</div>"
+      when :definition
+        if content
+          term, definition = content
+          "<dt>#{term.to_html(options)}</dt><dd>#{definition.to_html(options)}#{sublists.to_html(options)}</dd>"
+        else
+          "<dd>#{sublists.to_html(options)}</dd>"
+        end
+      end
     end
 
-    def structure
-      if phrase
-        ListBuilder.new( self, :ul )
+    def to_s( options={} )
+      if content
+        indent = '    ' * options[:indent]
+        item_str = case type
+          when :bulleted
+            '  * ' + content.to_s(options)
+          when :numbered
+            "#{'%2d' % (options[:num]+1)}. " + content.to_s(options)
+          when :indented
+            '    ' + content.to_s(options)
+          when :definition
+            term, definition = content
+            '    ' + term.to_s(options) + ( definition ? ' :: ' + definition.to_s(options) : '' )
+          end
+        sublist_str = ( sublists.empty? ? '' : "\n#{sublists.to_s(options)}" )
+        "#{indent}#{item_str}#{sublist_str}"
       else
-        ListBuilder.new( list_item.structure, :ul )
+        sublists.to_s(options)
       end
     end
+  end
 
-    #-- defaults ++
-    def phrase
-      nil
+  class List < RecursiveList
+    def builder
+      list_builder = ListBuilder.new(:root)
+      to_a.each do |node|
+        list_builder.add( node.builder )
+      end
+      list_builder
     end
-  end
 
-  class Numbered < ParseNode
     def to_html( options = {} )
-      "<li>#{phrase.to_html(options)}</li>"
+      builder.to_html(options)
     end
 
     def to_s( options = {} )
-      indent = (options[:indent] || 0)
-      '    ' * (indent > 0 ? indent - 1 : 0) +
-      "#{'%2d' % options[:num]}. #{phrase.to_s( options )}"
+      builder.to_s(options)
     end
+  end
 
-    def structure
-      if phrase
-        ListBuilder.new( self, :ol )
+  class ListNode < ParseNode
+    def builder
+      if content
+        ListBuilder.new( type, ItemBuilder.new( type, content ) )
       else
-        ListBuilder.new( list_item.structure, :ol )
+        ListBuilder.new( type, ItemBuilder.new( type, item.builder ) )
       end
     end
+  end
+
+  class Bulleted < ListNode
+    def type
+      :bulleted
+    end
 
     #-- defaults ++
-    def phrase
+    def content
       nil
     end
   end
 
-  class Indented < ParseNode
-    def to_html( options = {} )
-      "<div>#{phrase.to_html(options)}</div>"
+  class Numbered < ListNode
+    def type
+      :numbered
     end
 
-    def to_s( options = {} )
-      indent = (options[:indent] || 0)
-      '    ' * (indent > 0 ? indent : 0) +
-      phrase.to_s(options)
+    #-- defaults ++
+    def content
+      nil
     end
+  end
 
-    def structure
-      if phrase
-        ListBuilder.new( self, :div, :class => 'indent' )
-      else
-        ListBuilder.new( list_item.structure, :div, :class => 'indent' )
-      end
+  class Indented < ListNode
+    def type
+      :indented
     end
 
     #-- defaults ++
-    def phrase
+    def content
       nil
     end
   end
 
-  class Definition < ParseNode
-    def to_html( options = {} )
-      "<dt>#{term.to_html(options)}</dt>" +
-      ( definition ? "<dd>#{definition.to_html(options)}</dd>" : "" )
+  class Definition < ListNode
+    def type
+      :definition
     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 )
+    def content
+      [term, definition]
     end
 
     #-- defaults ++
@@ -186,3 +215,4 @@ module Marker #:nodoc:
     end
   end
 end
+

data/lib/marker/markup.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2009 Ryan Blue.
+# Copyright 2009-2012 Ryan Blue.
 # Distributed under the terms of the GNU General Public License (GPL).
 # See the LICENSE file for further information on the GPL.
 #++
@@ -7,25 +7,24 @@
 require 'marker/common'
 
 module Marker #:nodoc:
-  class Markup < RecursiveList
+  class Document < ParseNode
     def to_html( options = {} )
       options = make_options( options )
 
-      [
-        to_a.map{ |b|
-          b.to_html(options)
-        }, options[:footnotes].to_html( options )
-      ].flatten.join("\n")
+      markup ? (
+        markup.to_html( options ) + "\n" +
+        options[:footnotes].to_html( options )
+      ) : ""
     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")
+
+      markup ? (
+        markup.to_s( options ) + "\n\n" +
+        options[:footnotes].to_s( options )
+      ) : ""
     end
 
     def make_options( user_options )
@@ -35,6 +34,25 @@ module Marker #:nodoc:
       o.merge!( user_options )
       o
     end
+
+    #-- defaults ++
+    def markup
+      nil
+    end
+  end
+
+  class Markup < RecursiveList
+    def to_html( options = {} )
+      to_a.map{ |b|
+        b.to_html(options)
+      }.join("\n")
+    end
+
+    def to_s( options = {} )
+      to_a.map{ |b|
+        b.to_s(options)
+      }.join("\n\n")
+    end
   end
 
   class Footnotes
@@ -65,11 +83,11 @@ module Marker #:nodoc:
     def to_s( options = {} )
       return "" unless notes.any?
 
-      s = "\n"
+      s = "\n---- Notes ----\n"
       notes.each_with_index{ |n, i|
-        target = n.shift
-        if n.any?
-          s << "#{'%2d' % (i + 1)}. #{n.join(' ')}: #{target}\n"
+        target, *label_words = n
+        if label_words.any?
+          s << "#{'%2d' % (i + 1)}. #{label_words.join(' ')}: #{target}\n"
         else
           s << "#{'%2d' % (i + 1)}. #{target}\n"
         end

data/lib/marker/templates.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2009 Ryan Blue.
+# Copyright 2009-2011 Ryan Blue.
 # Distributed under the terms of the GNU General Public License (GPL).
 # See the LICENSE file for further information on the GPL.
 #++
@@ -9,7 +9,16 @@ require 'marker/common'
 module Marker #:nodoc:
   class Template < ParseNode
     def to_html( options = {} )
-      render( :html, options )
+      # if this template contains block-style arguments, then it needs to be
+      # wrapped in a div.  otherwise, all arguments are inline and it does not
+      # get wrapped.  the template target is used as the html class.
+      #
+      # it may be a good idea to wrap inline templates in a span
+      if block?
+        "<div class='#{target}'>#{render( :html, options )}</div>"
+      else
+        render( :html, options )
+      end
     end
 
     def to_s( options = {} )
@@ -17,7 +26,13 @@ module Marker #:nodoc:
     end
 
     def render( format, options = {} )
-      Marker.templates.send( target, format, *arg_list( format, options ) )
+      # optionally change the format for argument rendering
+      if options[:template_formats] and options[:template_formats][target]
+        format = options[:template_formats][target]
+      end
+
+      ordered, named = arg_list( format, options )
+      Marker.templates.send( target, format, ordered, named, options )
     end
 
     def target
@@ -29,6 +44,10 @@ module Marker #:nodoc:
       ( args ? args.to_arg_list( format, options ) : [[], {}] )
     end
 
+    def block?
+      ( args ? args.block? : false )
+    end
+
     #-- defaults ++
     def t #:nodoc:
       nil
@@ -45,6 +64,12 @@ module Marker #:nodoc:
       named_params = {}
 
       case format
+      when :raw
+        # don't render the text, just return the original value
+        # this is needed for special templates, like syntax highlighting
+        to_a.each do |a|
+          pos_params << a.text_value if a
+        end
       when :html
         to_a.each do |a|
           next unless a
@@ -70,6 +95,12 @@ module Marker #:nodoc:
       [pos_params, named_params]
     end
 
+    # returns true if there are any block-style arguments and false if all
+    # arguments are inline-style
+    def block?
+      to_a.map(&:block?).reduce { |a, b| a or b }
+    end
+
     def to_html( options = {} )
       to_a.map { |a|
         a ? a.to_html(options) : ''
@@ -85,13 +116,18 @@ module Marker #:nodoc:
 
   class Argument < ParseNode
     def to_html( options = {} )
-      to_s
+      to_s(options)
     end
 
     def to_s( options = {} )
       ( name ? "'#{name}' => '#{val}'" : "'#{val}'" )
     end
 
+    # is this argument a block style?
+    def block?
+      true
+    end
+
     #-- defaults ++
     def name #:nodoc:
       nil
@@ -102,6 +138,17 @@ module Marker #:nodoc:
     end
   end
 
+  # allow the grammar to distinguish between argument styles, but they render
+  # no differently at the argument level.  these allow a template to decide
+  # whether it needs to be wrapped in a div for html output.
+  class InlineArgument < Argument
+    def block?
+      false
+    end
+  end
+
+  class BlockArgument < Argument; end
+
   # A set of basic templates for rendering
   module DefaultTemplates
     def self.method_missing( sym, *args )