multimarkdown 4.5.0.r1

data/MultiMarkdown-4/writer.h

@@ -0,0 +1,34 @@
+#include "parser.h"
+
+#include "text.h"
+#include "html.h"
+#include "latex.h"
+#include "memoir.h"
+#include "beamer.h"
+#include "lyx.h"
+#include "lyxbeamer.h"
+#include "opml.h"
+#include "odf.h"
+#include "rtf.h"
+#include "critic.h"
+
+char * export_node_tree(node *list, int format, unsigned long extensions);
+
+void extract_references(node *list, scratch_pad *scratch);
+link_data * extract_link_data(char *label, scratch_pad *scratch);
+
+void pad(GString *out, int num, scratch_pad *scratch);
+
+int note_number_for_label(char *text, scratch_pad *scratch);
+int note_number_for_node(node *ref, scratch_pad *scratch);
+node * node_matching_label(char *label, node *n);
+int count_node_from_end(node *n);
+int cite_count_node_from_end(node *n);
+node * node_for_count(node *n, int count);
+void move_note_to_used(node *list, scratch_pad *scratch);
+void use_inline_footnote(node *ref, scratch_pad *scratch);
+node * node_for_attribute(char *querystring, node *list);
+
+char * dimension_for_attribute(char *querystring, node *list);
+
+link_data * load_link_data(node *n, scratch_pad *scratch);

data/README.md

@@ -0,0 +1,70 @@
+Ruby MultiMarkdown 4
+====================
+
+[![Build Status](https://travis-ci.org/tillsc/multi_markdown.png?branch=master)](https://travis-ci.org/tillsc/multi_markdown)
+
+An extension library around
+[Fletcher Penney's MultiMarkdown](http://github.com/fletcher/MultiMarkdown-4/)
+library in C. It is based upon the ruby
+[rpeg-markdown](https://github.com/rtomayko/rpeg-markdown/) and
+[rpeg-multimarkdown](https://github.com/djungelvral/rpeg-multimarkdown) libraries by
+[Ryan Tomayko](https://github.com/rtomayko) and  [Oliver "djungelvral"](https://github.com/djungelvral).
+
+Synopsis
+--------
+
+    >> require 'multimarkdown'
+
+    >> MultiMarkdown.new('Hello, world.').to_html
+    #=> "<p>Hello, world.</p>"
+
+    >> MultiMarkdown.new('_Hello World!_', :smart, :filter_html).to_html
+    #=> "<p><em>Hello World!</em></p>"
+
+    >> MultiMarkdown.new('_Hello World!_').to_latex
+    #=> "\emph{Hello World!}"
+
+	>> doc = MultiMarkdown.new("Title: Some document  \n\nSome text in the document")
+
+    >> doc.metadata
+    #=> {"title" => "Some document"}
+
+    >> doc.metadata("Title")
+    #=> "Some document"
+
+See [MultiMarkdown documentation](http://fletcher.github.io/MultiMarkdown-4/)
+and `MultiMarkdown`'s [RDoc](http://rubydoc.info/gems/multimarkdown) for further Details.
+
+Installation / Hacking
+----------------------
+
+This library requires a recent version of glib2. All modern GNU userland
+systems should be fine.
+
+Install from [Rubygems](http://rubygems.org/gems/multimarkdown):
+
+    $ [sudo] gem install multimarkdown
+
+Bundle via [Bundler](http://bundler.io):
+
+    gem 'multimarkdown'
+
+Hacking:
+
+    $ git clone --recursive git://github.com/tillsc/multi_markdown.git
+    $ cd multi_markdown
+    $ bundle install
+    $ bundle exec rake test
+
+Changes
+-------
+
+  * [Version 4.5.0.r1](http://github.com/tillsc/multi_markdown/tree/v4.5.0.r1):
+    First Version based upon  [rpeg-markdown](https://github.com/rtomayko/rpeg-markdown/)
+    and [rpeg-multimarkdown](https://github.com/djungelvral/rpeg-multimarkdown).
+
+COPYING
+-------
+
+MultiMarkdown-4, multi_markdown are both licensed under the GPL and the MIT License.
+See [LICENSE](LICENCSE) for more information.

data/Rakefile

@@ -0,0 +1,85 @@
+require 'rake/clean'
+require 'rdoc/task'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+# ***** Build
+
+DLEXT = RbConfig::CONFIG['DLEXT']
+
+# For Mac OS X -- prevents prevent additional ._* files being added to tarball
+ENV['COPYFILE_DISABLE'] = 'true'
+
+namespace "MultiMarkdown-4" do
+
+  desc "Initialize the submodule"
+  task "init" => "generate_parser"
+
+  desc "Generate needed parser files"
+  task "generate_parser" do
+    chdir('MultiMarkdown-4') do
+      sh 'make parser.c'
+    end
+  end
+
+end
+
+
+file 'ext/Makefile' => ["MultiMarkdown-4:init"] + FileList['ext/{extconf.rb,*.c,*.h,*.rb}', 'MultiMarkdown-4/*.{c,h}'] do
+  chdir('ext') do
+    ruby 'extconf.rb'
+  end
+end
+CLEAN.include 'ext/Makefile'
+
+file "ext/multi_markdown.#{DLEXT}" => FileList['ext/Makefile', 'ext/*.{c,h,rb}', 'MultiMarkdown-4/*.{c,h}'] do |f|
+  chdir('ext') do
+    sh 'make'
+  end
+end
+CLEAN.include 'ext/*.{o,bundle,so}'
+CLEAN.include 'MultiMarkdown-4/*.o'
+
+file "lib/multi_markdown.#{DLEXT}" => "ext/multi_markdown.#{DLEXT}" do |f|
+  cp f.prerequisites, "lib/", :preserve => true
+end
+CLEAN.include "lib/*.{so,bundle}"
+
+desc 'Build the multi_markdown extension'
+task :build => "lib/multi_markdown.#{DLEXT}"
+
+# ***** Test
+
+desc 'Run unit and conformance tests'
+task :test => [ 'test:unit', 'test:conformance' ]
+
+namespace :test do
+
+  desc 'Run unit tests'
+  task :unit => :build do |t|
+    ruby 'test/multi_markdown_test.rb'
+  end
+
+  desc "Run conformance tests"
+  task :conformance => :build do |t|
+    script = "#{pwd}/bin/ruby_multi_markdown"
+    chdir("MultiMarkdown-4/MarkdownTest") do
+      sh "./MarkdownTest.pl --script='#{script}' --flags='-c' --tidy"
+      sh "./MarkdownTest.pl --script='#{script}' --testdir='MultiMarkdownTests'"
+      sh "./MarkdownTest.pl --script='#{script}' --testdir='MultiMarkdownTests' --flags='-t latex' --ext='.tex'"
+      sh "./MarkdownTest.pl --script='#{script}' --testdir='BeamerTests' --flags='-t latex' --ext='.tex'"
+      sh "./MarkdownTest.pl --script='#{script}' --testdir='MemoirTests' --flags='-t latex' --ext='.tex'"
+    end
+  end
+
+end
+
+# ***** RDoc
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "ext/**/*.c", "lib/**/*.rb")
+end

data/bin/ruby_multi_markdown

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'multi_markdown'
+rescue LoadError => boom
+  local_path = File.expand_path(File.dirname(__FILE__))
+  $: << "#{local_path}/../lib"
+  require 'multi_markdown'
+end
+
+# Option parser -- http://florianpilz.github.com/micro-optparse/
+
+require 'ostruct'
+require 'optparse'
+
+class Parser
+  attr_accessor :banner, :version
+  def initialize
+    @options = []
+    @used_short = []
+    yield self if block_given?
+  end
+
+  def option(name, desc, settings = {})
+    @options << [name, desc, settings]
+  end
+
+  def short_from(name)
+    name.to_s.chars.each do |c|
+      next if @used_short.include?(c) || c == "_"
+      return c # returns from short_from method
+    end
+  end
+
+  def validate(options) # remove this method if you want fewer lines of code and don't need validations
+    options.each_pair do |key, value|
+      opt = @options.find_all{ |o| o[0] == key }.first
+      key = "--" << key.to_s.gsub("_", "-")
+      unless opt[2][:value_in_set].nil? || opt[2][:value_in_set].include?(value)
+        puts "Parameter for #{key} must be in [" << opt[2][:value_in_set].join(", ") << "]" ; exit(1)
+      end
+      unless opt[2][:value_matches].nil? || opt[2][:value_matches] =~ value
+        puts "Parameter for #{key} must match /" << opt[2][:value_matches].source << "/" ; exit(1)
+      end
+      unless opt[2][:value_satisfies].nil? || opt[2][:value_satisfies].call(value)
+        puts "Parameter for #{key} must satisfy given conditions (see description)" ; exit(1)
+      end
+    end
+  end
+
+  def process!(arguments = ARGV)
+    @result = (@default_values || {}).clone # reset or new
+    @optionparser ||= OptionParser.new do |p| # prepare only once
+      @options.each do |o|
+        @used_short << short = o[2][:short] || short_from(o[0])
+        @result[o[0]] = o[2][:default] || false # set default
+        klass = o[2][:default].class == Fixnum ? Integer : o[2][:default].class
+        desk = o[1] + (o[2][:nodefault] ? "" : " (default is #{@result[o[0]]})")
+        if [TrueClass, FalseClass, NilClass].include?(klass) # boolean switch
+          p.on("-" << short, "--[no-]" << o[0].to_s.gsub("_", "-"), desk) {|x| @result[o[0]] = x}
+        else # argument with parameter
+          p.on("-" << short, "--" << o[0].to_s.gsub("_", "-") << " " << (o[2][:name] ? "[#{o[2][:name].to_s}]" : ""), klass, desk) {|x| @result[o[0]] = x}
+        end
+      end
+
+      p.banner = @banner unless @banner.nil?
+      p.on_tail("-h", "--help", "Show this message") {puts p ; exit}
+      short = @used_short.include?("v") ? "-V" : "-v"
+      p.on_tail(short, "--version", "Print version") {puts @version ; exit} unless @version.nil?
+      @default_values = @result.clone # save default values to reset @result in subsequent calls
+    end
+
+    begin
+      @optionparser.parse!(arguments)
+    rescue OptionParser::ParseError => e
+      puts e.message ; exit(1)
+    end
+
+    validate(@result) if self.respond_to?("validate")
+    @result
+  end
+end
+
+# Parse options
+options = Parser.new do |p|
+  p.banner = "Ruby interface to MultiMarkdown"
+  p.version = "ruby_multi_markdown #{MultiMarkdown::VERSION}"
+  p.option :compatibility, "markdown compatibility mode", :default => false
+  p.option :filter_html, "filter out raw HTML except styles", :default => false
+  p.option :process_html, "process MultiMarkdown inside of raw HTML", :default => false
+  p.option :filter_styles, "filter out HTML styles", :default => false
+  p.option :smart, "use smart typography extension", :default => true
+  p.option :notes, "use notes extension", :default => true
+  p.option :output, "send output to FILE (default is stdout)", :name => "FILE", :default => "", :nodefault => true
+  p.option :to, "convert to FORMAT", :name => "FORMAT", :default => "html", :value_in_set => ["html","latex","memoir","beamer","odf","opml"]
+  p.option :extract, "extract and display metadata specified by KEY", :name => "KEY", :default => "", :nodefault => true
+end.process!
+
+# Convert options to MultiMarkdown module's options
+mmopts = []
+mmopts << :filter_html   if options[:filter_html]
+mmopts << :filter_styles if options[:filter_styles]
+mmopts << :process_html  if options[:process_html]
+mmopts << :smart         if options[:smart]
+mmopts << :notes         if options[:notes]
+mmopts << :compatibility if options[:compatibility]
+
+# ARGV will now only contain input filename, if it contains anything
+STDIN.reopen(ARGV[0], 'rb') if ARGV.any?
+multimarkdown = MultiMarkdown.new(STDIN.read,*mmopts)
+STDOUT.reopen(options[:output], 'w') if options[:output]!=""
+
+# Print specified metadata if requested
+if options[:extract]!=""
+  puts multimarkdown.extract_metadata(options[:extract])
+  exit(0)
+end
+
+# Do processing
+case options[:to]
+when "html"
+  STDOUT.write(multimarkdown.to_html)
+when "latex"
+  STDOUT.write(multimarkdown.to_latex)
+else
+  puts "Output other than html & latex not currently supported"
+  exit(1)
+end

data/ext/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/ext/extconf.rb

@@ -0,0 +1,17 @@
+require 'mkmf'
+
+dir_config('multi_markdown')
+
+mmd_objs = %w[parse_utilities.o parser.o GLibFacade.o writer.o text.o html.o latex.o memoir.o beamer.o lyx.o lyxbeamer.o opml.o odf.o critic.o rng.o rtf.o transclude.o]
+
+$objs = mmd_objs.map { |s| "../MultiMarkdown-4/#{s}" } + ["multi_markdown.o"]
+
+if pkg_config = find_executable('pkg-config')
+  $CFLAGS = "-fcommon "+`#{pkg_config} --cflags glib-2.0`
+  $LDFLAGS = `#{pkg_config} --libs glib-2.0`
+else
+  fail "glib2 not found"
+end
+
+create_header
+create_makefile('multi_markdown')

data/ext/multi_markdown.c

@@ -0,0 +1,100 @@
+#include "ruby.h"
+#include "../MultiMarkdown-4/parser.h"
+
+static VALUE rb_cMultiMarkdown;
+
+int get_exts(VALUE self) {
+  int extensions = 0;
+  if (rb_funcall(self, rb_intern("smart"), 0) == Qtrue)
+    extensions = extensions | EXT_SMART;
+  if (rb_funcall(self, rb_intern("notes"), 0) == Qtrue)
+    extensions = extensions | EXT_NOTES;
+  if (rb_funcall(self, rb_intern("filter_html"), 0) == Qtrue)
+    extensions = extensions | EXT_FILTER_HTML;
+  if (rb_funcall(self, rb_intern("filter_styles"), 0) == Qtrue)
+    extensions = extensions | EXT_FILTER_STYLES;
+  if (rb_funcall(self, rb_intern("process_html"), 0) == Qtrue)
+    extensions = extensions | EXT_PROCESS_HTML;
+  /* Compatibility overwrites all other extensions */
+  if (rb_funcall(self, rb_intern("compatibility"), 0) == Qtrue)
+    extensions = EXT_COMPATIBILITY;
+  return extensions;
+}
+
+char *get_text(VALUE self) {
+  /* grab char pointer to multimarkdown input text */
+  VALUE text = rb_iv_get(self, "@text");
+  Check_Type(text, T_STRING);
+  return StringValuePtr(text);
+}
+
+static VALUE rb_multimarkdown_to_html(VALUE self) {
+  char *html = markdown_to_string(get_text(self), get_exts(self), HTML_FORMAT);
+  VALUE result = rb_str_new2(html);
+  free(html);
+
+  return result;
+}
+
+static VALUE rb_multimarkdown_to_latex(VALUE self) {
+  char *latex = markdown_to_string(get_text(self), get_exts(self), LATEX_FORMAT);
+  VALUE result = rb_str_new2(latex);
+  free(latex);
+
+  return result;
+}
+
+static VALUE rb_multimarkdown_extract_metadata_keys(VALUE self) {
+  char *metadata_keys = extract_metadata_keys(get_text(self), get_exts(self));
+  VALUE str = rb_str_new2(metadata_keys);
+  free(metadata_keys);
+
+  return rb_funcall(str, rb_intern("split"), 1, rb_str_new2("\n"));
+}
+
+static VALUE rb_multimarkdown_extract_metadata_value(VALUE self, VALUE key) {
+  Check_Type(key, T_STRING);
+  char *pkey = StringValuePtr(key);
+
+  char *metadata = extract_metadata_value(get_text(self), get_exts(self), pkey);
+  VALUE result = rb_str_new2(metadata);
+  free(metadata);
+
+  return result;
+}
+
+void Init_multi_markdown() {
+
+  rb_cMultiMarkdown = rb_define_class("MultiMarkdown", rb_cObject);
+
+  /* Document-method: MultiMarkdown#to_html
+   *
+   * Return string containing HTML generated from MultiMarkdown text
+   */
+  rb_define_method(rb_cMultiMarkdown, "to_html", rb_multimarkdown_to_html, 0);
+
+  /* Document-method: MultiMarkdown#to_latex
+   *
+   * Return string containing latex generated from MultiMarkdown text
+   */
+  rb_define_method(rb_cMultiMarkdown, "to_latex", rb_multimarkdown_to_latex, 0);
+
+  /* Document-method: MultiMarkdown#extract_metadata_keys
+   *
+   * Return Array of metadata keys
+   */
+  rb_define_method(rb_cMultiMarkdown, "extract_metadata_keys", rb_multimarkdown_extract_metadata_keys, 0);
+
+  /* Document-method: MultiMarkdown#extract_metadata_value
+   * :call-seq: extract_metadata_value(key)
+   *
+   * Fetches metadata specified by +key+ from MultiMarkdown text
+   */
+  rb_define_method(rb_cMultiMarkdown, "extract_metadata_value", rb_multimarkdown_extract_metadata_value, 1);
+
+  rb_define_const(rb_cMultiMarkdown, "MMD_VERSION", rb_str_new2(MMD_VERSION));
+  /* Document-const: MultiMarkdown::MMD_VERSION
+   *
+   * The version of the MultiMarkdown-4 library
+   */
+}

data/lib/multi_markdown.rb

@@ -0,0 +1,88 @@
+require 'multi_markdown.so'
+require 'multi_markdown/version'
+
+# Front-end to fletcher penney's implementation of MultiMarkdown
+#
+# A simple processor:
+#     >> puts MultiMarkdown.new("Hello, World.").to_html
+#     <p>Hello, World.</p>
+#
+# With other stuff:
+#     >> puts MultiMarkdown.new("_Hello World!_", :smart, :filter_html).to_html
+#     <p><em>Hello World!</em></p>
+#
+class MultiMarkdown
+
+  # Set `true` to have smarty-like quote translation performed.
+  attr_accessor :smart
+
+  # Set `true` to have footnotes processed.
+  attr_accessor :notes
+
+  # Do not output `<style>` tags included in the source text.
+  attr_accessor :filter_styles
+
+  # Do not output any raw HTML included in the source text.
+  attr_accessor :filter_html
+
+  # Process MultiMarkdown inside of raw HTML
+  attr_accessor :process_html
+
+  # Markdown compatibility mode
+  attr_accessor :compatibility
+
+  # Included for compatibility with RedCloth's interface.
+  attr_accessor :fold_lines
+
+  # Create a new MultiMarkdown processor. The `text` argument is a string
+  # containing MultiMarkdown text. Variable other arguments may be supplied to
+  # set various processing options:
+  #
+  # * `:smart` - Enable SmartyPants processing.
+  # * `:notes` - Enable footnotes.
+  # * `:filter_styles` - Do not output `<style>` tags included in the
+  #   source text.
+  # * `:filter_html` - Do not output raw HTML included in the
+  #   source text.
+  # * `:process_html` - Process MultiMarkdown code inside HTML tags.
+  # * `:compatibility` - Process MultiMarkdown code in Markdown
+  #   compatibility mode (disables all other extensions)
+  # * `:fold_lines` - RedCloth compatible line folding (not used).
+  #
+  def initialize(text, *extensions)
+    @text = text
+    @smart = true
+    @notes = true
+    @filter_styles = false
+    @filter_html = false
+    @process_html = false
+    @compatibility = false
+    extensions.each { |e| send("#{e}=", true) }
+    if @compatibility
+      @smart = false
+      @notes = false
+      @process_html = false
+    end
+  end
+
+  alias extract_metadata extract_metadata_value
+
+  # Returns a Hash cointaining all Metadata
+  #
+  #
+  def metadata(key = nil)
+    if @cached_metadata.nil?
+      @cached_metadata = {}
+      extract_metadata_keys.each do |k|
+        @cached_metadata[k.downcase] = extract_metadata_value(k)
+      end
+    end
+
+    if key
+      @cached_metadata[key.to_s.downcase]
+    else
+      @cached_metadata.dup
+    end
+  end
+
+end