marker 0.1.0

data/README

@@ -0,0 +1,98 @@
+== Marker
+
+Marker is a markup language parser designed for two needs:
+# Need to mimic MediaWiki syntax
+# Need to provide multiple output formats
+
+Mimicing MediaWiki syntax is not exact.  One reason is that the MediaWiki
+parser itself is very complicated and handles many cases specially.  It would
+be very difficult to exactly copy the MediaWiki parser and it probably wouldn't
+be worth the time because MediaWiki is intended for a wiki and needs to be
+adapted to be used as a markup lanaguage--especially for multiple output
+formats.  The purpose of mimicing MediaWiki syntax is so that users don't have
+to learn more than one markup language, so the implementation doesn't *need* to
+be exact anyway.
+
+Marker differs from MediaWiki in several ways, because it is a grammar-based
+implementation.  The grammar is written as a
+Treetop[http://treetop.rubyforge.org/] parsing expression grammar (PEG).
+
+Not implemented:
+# Table of contents
+# Tables
+
+== Use
+
+Parsing is done with either Marker.parse or Marker.parse_file.  Both parse
+methods will return a parse tree that has to_html and to_s methods that
+"render" the markup.  Both render methods will accept an options hash.
+
+Example:
+ >> require 'marker'
+ => true
+ >> m = Marker.parse "== heading ==\nparagraph with '''bold''' text"
+ => Markup+...
+ >> puts m.to_s
+ heading
+ --------------------------------------------------------------------------------
+ paragraph with *bold* text
+ => nil
+ >> puts m.to_html
+ <h2>heading</h2>
+ <p>paragraph with <b>bold</b> text</p>
+ => nil
+
+=== Templates
+
+Templates are implemented as method calls to a templates module.  Each method
+in the templates module is considered a template and can be called using the
+"{{ name }}" syntax.  Each template method is expected to take three arguments:
+the render format (:html or :text), an array of positional parameters, and a
+hash of named parameters.  For example,
+ module MyTemplates
+   def logo( format, pos_params, name_params )
+     case format
+     when :html
+       '<img src="/images/logo.png" />'
+     else
+       ''
+     end
+   end
+ end
+
+Template modules are passed to Marker by setting the +templates+ property:
+ require 'my_templates'
+ require 'marker'
+ 
+ Marker.templates = Templates
+
+If no template method is found, the template call is printed for debugging:
+ >> puts Marker.parse( '{{t|one|two|name=val}}' ).to_s
+ render:t( :text, ["one", "two"], {"name"=>"val"} )
+
+=== Internal Links
+
+Internal links are implemented as links with default prefixes.  The link prefix
+is specified by setting the +link_base+ property:
+ require 'marker'
+ 
+ Marker.link_base = 'http://example.com/pages/'
+
+ >> puts Marker.parse( '[[target|name]]' ).to_html
+ <p><a href='http://example.com/pages/target'>name</a></p>
+
+The link target is appended to the link prefix, along with a beginning '/'.  If
+no link base is given, links are just the link target with a beginning '/'.
+The link base can also be given as a render option.
+
+=== Unlabelled Links
+
+(write me)
+
+== Command Line Program
+
+== License
+
+Marker is copyright 2009 Ryan Blue and distributed under the terms of the GNU
+General Public License (GPL).  See the LICENSE file for further information on
+the GPL, or visit http://creativecommons.org/licenses/GPL/2.0/.

data/bin/marker

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+require 'rubygems'
+
+begin
+  require 'marker'
+rescue LoadError
+  $: << File.join( File.dirname(__FILE__), '..', 'lib' )
+  require 'marker'
+end
+
+options = OpenStruct.new
+options.format = :text
+OptionParser.new do |opts|
+  opts.on( '--format FORMAT', [:text, :html],
+        'Specify the output format (text, html)' ) do |format|
+    options.format = format
+  end
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+end.parse!
+
+files = {}
+
+if ARGV.empty? or ARGV.include? '-'
+  s = ''
+  # the parser expects a full block of text, grab it all
+  $stdin.each_line { |l| s << l }
+  files[:stdin] = Marker.parse( s )
+end
+
+ARGV.each do |f|
+  next if f == '-'
+  files[f] = Marker.parse_file( f )
+end
+
+if files.size > 1
+  files.each do |f, t|
+    puts "\n==> #{f} <=="
+    case options.format
+    when :html
+      puts t.to_html
+    else
+      puts t
+    end
+  end
+else
+  # only one, so leave out the file name
+  case options.format
+  when :html
+    puts files.values.first.to_html
+  else
+    puts files.values.first
+  end
+end

data/lib/marker/common.rb

@@ -0,0 +1,40 @@
+#--
+# 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 'treetop'
+
+module Treetop #:nodoc:
+  module Runtime #:nodoc:
+    class SyntaxNode #:nodoc:
+      # returns whether the ParseNode matched any text
+      def present?
+        text_value.any?
+      end
+    end
+  end
+end
+
+module Marker #:nodoc:
+  # used to add methods to all parse nodes.
+  class ParseNode < Treetop::Runtime::SyntaxNode
+  end
+
+  # implements collection methods on a list using a recursive grammar definition
+  # requires defining +h+ and +r+
+  class RecursiveList < ParseNode
+    def to_a
+      if r
+        [h] + r.to_a
+      else
+        [h]
+      end
+    end
+
+    def r
+      nil
+    end
+  end
+end

data/lib/marker/headings.rb

@@ -0,0 +1,79 @@
+#--
+# 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 Heading < ParseNode
+    # HTML-rendered headings, using <h#> tags.
+    def to_html( options = {} )
+      # find out how deep it is
+      d = [s.text_value.size, e.text_value.size].min
+      sn = s.text_value.size - d
+      en = e.text_value.size - d
+      if sn > 0
+        "<h#{d}>#{'=' * sn} #{label( :html, options )}</h#{d}>"
+      elsif en > 0
+        "<h#{d}>#{label( :html, options )} #{'=' * en}</h#{d}>"
+      else
+        "<h#{d}>#{label( :html, options )}</h#{d}>"
+      end
+    end
+
+    # Text-rendered headings.  Should look like this:
+    #
+    # Heading Level 1
+    # ==========================================================================
+    #
+    # Heading Level 2
+    # --------------------------------------------------------------------------
+    #
+    # - Heading Level 3 --------------------------------------------------------
+    #
+    # --- Heading Level 4 ------------------------------------------------------
+    #
+    def to_s( options = {} )
+      width = options[:width] || 80
+      d = [s.text_value.size, e.text_value.size].min
+      sn = s.text_value.size - d
+      en = e.text_value.size - d
+
+      l = if sn > 0
+        "#{'=' * sn} #{label( :text, options )}"
+      elsif en > 0
+        "#{label( :text, options )} #{'=' * en}"
+      else
+        label( :text, options )
+      end
+
+      case d
+      when 1
+        "#{l}\n" + ('=' * width)
+      when 2
+        "#{l}\n" + ('-' * width)
+      else
+        l = " #{l} "
+        h = '-'*width
+        h[2*(d-3)+1, l.size] = l # slice substitution
+        h
+      end
+    end
+
+    def label( format, options = {} )
+      case format
+      when :html
+        l.to_html( options )
+      else
+        l.to_s( options )
+      end
+    end
+
+    #-- defaults ++
+    def l #:nodoc:
+      nil
+    end
+  end
+end