https://github.com/rdblue/marker

A markup parser that outputs html and text. Syntax is similar to MediaWiki.
https://github.com/rdblue/marker

Last synced: 8 days ago
JSON representation

A markup parser that outputs html and text. Syntax is similar to MediaWiki.

• Host: GitHub
• URL: https://github.com/rdblue/marker
• Owner: rdblue
• License: gpl-3.0
• Created: 2009-12-12T16:53:16.000Z (almost 15 years ago)
• Default Branch: master
• Last Pushed: 2012-07-15T14:45:08.000Z (over 12 years ago)
• Last Synced: 2024-05-12T21:42:12.867Z (6 months ago)
• Language: Ruby
• Homepage: http://github.com/rdblue/marker
• Size: 183 KB
• Stars: 15
• Watchers: 3
• Forks: 6
• Open Issues: 0
• Metadata Files:
  • Readme: README.html
  • License: LICENSE

Awesome Lists containing this project

README

        
        

        a {

          color: #CC0000;

          text-decoration: none;

        }

        a:hover {

          text-decoration: underline;

        }

        h1, h2, hr {

          border: 0;

          border-bottom: 1px solid #BABDB6;

        }

        div.indent, ol, ul, dl {

          padding-left: 2.5em;

          margin: 0em;

        }

        ol.footnotes {

          margin-left: 1em;

          border-left: 1px solid #BABDB6;

        }

        pre {

          margin: 0.5em;

          padding: 0.5em;

          border: 1px dashed #BABDB6;

          background-color: #EEEEEC;

          -moz-border-radius: 3px;

        }

        



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 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 "{{template_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"} )



Template names from markup are converted to lower case and have spaces replaced with underscores to match ruby method naming conventions and to be case insensitive for markup writers. For example,


"{{ My Template }}"  => :my_template

"{{NaMe}}"           => :name



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


Unlabelled, or "bare" links are detected if they start with a recognized URL scheme such as http or https. The URL is used as the link text.


Command Line Program


Marker comes with a command-line program that will render both HTML and text. If no input file is given, it reads from stdin.



Usage: marker [--format (html|text)] [input-file]



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/.