mmd-ruby 5.2.0.1

data/MultiMarkdown-5/src/writer.h

@@ -0,0 +1,38 @@
+#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"
+#include "toc.h"
+
+char * export_node_tree(node *list, int format, unsigned long extensions);
+
+void extract_references(node *list, scratch_pad *scratch);
+void extract_abbreviations(node *list, scratch_pad *scratch);
+void find_abbreviations(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,77 @@
+mmd-ruby - MultiMarkdown for Ruby
+=================================
+
+A Ruby wrapper for [Fletcher Penney's MultiMarkdown](http://github.com/fletcher/MultiMarkdown-5/)
+C library. Based on [rmultimarkdown by Till Schulte-Coerne](http://github.com/tillsc/multimarkdown/)
+
+How to use?
+-----------
+
+    >> require 'mmd-ruby' or require 'mmd' or require 'multimarkdown' or require 'multimarkdown-ruby'
+    
+	Parse (output HTML):
+    >> MultiMarkdown.new('Hello, world.').to_html
+    #=> "<p>Hello, world.</p>"
+	
+	Parse with Extensions:
+    >> MultiMarkdown.new('_Hello World!_', :smart, :filter_html).to_html
+    #=> "<p><em>Hello World!</em></p>"
+    
+    *Available Extensions:
+	:compatibility - Markdown compatibility mode (disables all other options)
+    :complete - Force complete document
+    :snippet - Force snippet only
+    :no_smart_quotes - Disable Smart quotes
+    :no_footnotes - Disable Footnotes
+    :no_anchors - Don't add anchors to headers, etc.
+    :filter_styles - Filter out style blocks
+    :filter_html - Filter out raw HTML
+    :process_html - Process Markdown inside HTML
+    :no_metadata - Don't parse Metadata
+    :obfuscate_email_addresses - Mask email addresses
+    :critic_markup_accept_all - CriticMarkup: Accept all proposed changes
+    :critic_markup_reject_all - CriticMarkup: Reject all proposed changes
+    :random_footnote_anchor_numbers - Use random numbers for footnote link anchors
+    :escaped_line_breaks - Escaped line breaks
+    
+	Parse (output LaTeX):
+    >> MultiMarkdown.new('_Hello World!_').to_latex
+    #=> "\emph{Hello World!}"
+
+	Add Metadata:
+	>> doc = MultiMarkdown.new("Title: Some document  \n\nSome text in the document")
+	
+	Extract All Metadata:
+    >> doc.metadata
+    #=> {"title" => "Some document"}
+	
+	Extract Metadata Value by Key:
+    >> doc.metadata("Title")
+    #=> "Some document"
+
+See the [MultiMarkdown User's Guide](http://fletcher.github.io/MultiMarkdown-5/) for more information.
+
+Installation
+------------
+Install from [Rubygems](http://rubygems.org/gems/mmd-ruby):
+
+    $ [sudo] gem install mmd-ruby
+
+Bundle via [Bundler](http://bundler.io):
+
+    gem 'mmd-ruby'
+
+Changelog
+-------
+
+**Beware**: The versioning scheme isn't based upon 
+[Semantic Versioning](http://semver.org)! The first three version numbers are
+inherited from the underlying C library. Only the last number is used to indicate
+changes in the Ruby wrapper itself.
+
+  * [5.2.0.1](tree/v5.2.0.1): Initial Release. Based on MultiMarkdown 5.2.0.
+
+License
+-------
+MultiMarkdown and mmd-ruby are both licensed under the MIT License.
+See [LICENSE](LICENSE) for more information.

data/Rakefile

@@ -0,0 +1,88 @@
+require 'rake/clean'
+require 'rdoc/task'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+task :default => "test:unit"
+
+# ***** Build
+
+DLEXT = RbConfig::CONFIG['DLEXT']
+
+# For Mac OS X -- prevents prevent additional ._* files being added to tarball
+ENV['COPYFILE_DISABLE'] = 'true'
+
+namespace "MultiMarkdown-5" do
+
+  desc "Initialize the submodule"
+  task "init" => "generate_parser"
+
+  desc "Generate needed parser files"
+  task "generate_parser" do
+    chdir('MultiMarkdown-5') do
+      sh 'make src/parser.c'
+      sh 'make src/version.h'
+    end
+  end
+
+end
+
+
+file 'ext/Makefile' => ["MultiMarkdown-5:init"] + FileList['ext/{extconf.rb,*.c,*.h,*.rb}', 'MultiMarkdown-5/src/*.{c,h}', 'MultiMarkdown-5/build/*.{c,h}'] do
+  chdir('ext') do
+    ruby 'extconf.rb'
+  end
+end
+CLEAN.include 'ext/Makefile'
+
+file "ext/multimarkdown.#{DLEXT}" => FileList['ext/Makefile', 'ext/*.{c,h,rb}', 'MultiMarkdown-5/src/*.{c,h}', 'MultiMarkdown-5/build/*.{c,h}'] do |f|
+  chdir('ext') do
+    sh 'make'
+  end
+end
+CLEAN.include 'ext/*.{o,bundle,so}'
+CLEAN.include 'MultiMarkdown-5/src/*.o'
+
+file "lib/multimarkdown.#{DLEXT}" => "ext/multimarkdown.#{DLEXT}" do |f|
+  cp f.prerequisites, "lib/", :preserve => true
+end
+CLEAN.include "lib/*.{so,bundle}"
+
+desc 'Build the multimarkdown extension'
+task :build => "lib/multimarkdown.#{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|
+    FileList['test/*.rb'].each do |f|
+      ruby f
+    end
+  end
+
+  desc "Run conformance tests"
+  task :conformance => :build do |t|
+    script = "#{pwd}/bin/mmd-ruby"
+    chdir("MultiMarkdown-5/submodules/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/mmd-ruby

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'multimarkdown'
+rescue LoadError => boom
+  local_path = File.expand_path(File.dirname(__FILE__))
+  $: << "#{local_path}/../lib"
+  require 'multimarkdown'
+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
+    nil
+  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] == false ? nil : 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 && "-" << short, "--" << o[0].to_s.gsub("_", "-"), desk) {|x| @result[o[0]] = x}
+        else # argument with parameter
+          p.on(short && "-" << 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 wrapper for MultiMarkdown"
+  p.version = "mmd-ruby #{MultiMarkdown::VERSION}"
+   p.option :output, "send output to FILE (default is stdout)", :name => "FILE", :default => "", :nodefault => true, :short => "o"
+   p.option :to, "convert to FORMAT", :name => "FORMAT", :default => "html", :value_in_set => ["html","latex"], :short => "t"
+   p.option :extract, "extract and display metadata specified by KEY", :name => "KEY", :default => "", :nodefault => true, :short => "e"
+  MultiMarkdown::EXTENSIONS.each do |ext, opts|
+    p.option ext.to_sym, opts[:desc], :default => false, :short => opts[:short] || false
+  end
+end.process!
+
+# Convert options to MultiMarkdown module's options
+mmopts = []
+MultiMarkdown::EXTENSIONS.each do |ext, description|
+  mmopts << ext.to_sym if options[ext.to_sym]
+end
+
+# 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,10 @@
+require 'mkmf'
+
+dir_config('multimarkdown')
+
+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-5/src/#{s}" } + ["multimarkdown.o"]
+
+create_header
+create_makefile('multimarkdown')

data/ext/multimarkdown.c

@@ -0,0 +1,133 @@
+#include "ruby.h"
+#include <ruby/encoding.h>
+
+#include "../MultiMarkdown-5/src/parser.h"
+
+// Tries to convert a C string into an encoded ruby String
+static VALUE encoded_str_new2(char *str, char *encoding) {
+  VALUE result = rb_str_new2(str);
+
+  int enc = rb_enc_find_index(encoding);
+  if (enc > 0) {
+    rb_enc_associate_index(result, enc);
+  }
+
+  return result;
+}
+
+static VALUE rb_cMultiMarkdown;
+
+static int get_exts(VALUE self) {
+  int extensions = 0;
+  if (rb_funcall(self, rb_intern("complete"), 0) == Qtrue)
+    extensions = extensions | EXT_COMPLETE;
+  if (rb_funcall(self, rb_intern("snippet"), 0) == Qtrue)
+    extensions = extensions | EXT_SNIPPET;
+  if (rb_funcall(self, rb_intern("no_smart_quotes"), 0) != Qtrue)
+    extensions = extensions | EXT_SMART;
+  if (rb_funcall(self, rb_intern("no_footnotes"), 0) != Qtrue)
+    extensions = extensions | EXT_NOTES;
+  if (rb_funcall(self, rb_intern("no_anchors"), 0) == Qtrue)
+    extensions = extensions | EXT_NO_LABELS;
+  if (rb_funcall(self, rb_intern("filter_styles"), 0) == Qtrue)
+    extensions = extensions | EXT_FILTER_STYLES;
+  if (rb_funcall(self, rb_intern("filter_html"), 0) == Qtrue)
+    extensions = extensions | EXT_FILTER_HTML;
+  if (rb_funcall(self, rb_intern("process_html"), 0) == Qtrue)
+    extensions = extensions | EXT_PROCESS_HTML;
+  if (rb_funcall(self, rb_intern("no_metadata"), 0) == Qtrue)
+    extensions = extensions | EXT_NO_METADATA;
+  if (rb_funcall(self, rb_intern("obfuscate_email_addresses"), 0) == Qtrue)
+    extensions = extensions | EXT_OBFUSCATE;
+  if (rb_funcall(self, rb_intern("critic_markup_accept_all"), 0) == Qtrue)
+    extensions = extensions | EXT_CRITIC | EXT_CRITIC_ACCEPT;
+  if (rb_funcall(self, rb_intern("critic_markup_reject_all"), 0) == Qtrue)
+    extensions = extensions | EXT_CRITIC | EXT_CRITIC_REJECT;
+  if (rb_funcall(self, rb_intern("random_footnote_anchor_numbers"), 0) == Qtrue)
+    extensions = extensions | EXT_RANDOM_FOOT;
+  if (rb_funcall(self, rb_intern("escaped_line_breaks"), 0) == Qtrue)
+    extensions = extensions | EXT_ESCAPED_LINE_BREAKS;
+
+  /* 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 = encoded_str_new2(html, "UTF-8");
+  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 = encoded_str_new2(latex, "UTF-8");
+  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 = encoded_str_new2(metadata_keys, "UTF-8");
+  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 = encoded_str_new2(metadata, "UTF-8");
+  free(metadata);
+
+  return result;
+}
+
+void Init_multimarkdown() {
+
+  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("5.2.0"));
+  /* Document-const: MultiMarkdown::MMD_VERSION
+   *
+   * The version of the MultiMarkdown library
+   */
+}