wallyqs-org-ruby 0.6.1

data/announcement.txt

@@ -0,0 +1,24 @@
+org-ruby version 0.6.1
+    by Brian Dewey
+    http://github.com/wallyqs/org-ruby
+
+== DESCRIPTION
+
+This gem contains Ruby routines for parsing org-mode files.The most
+significant thing this library does today is convert org-mode files to
+HTML or textile. Currently, you cannot do much to customize the
+conversion. The supplied textile conversion is optimized for
+extracting "content" from the orgfile as opposed to "metadata." 
+
+== CHANGES
+* Added encoding directive to support Ruby 1.9.2
+* Included .org support for Tilt templates (thanks to crnixon)
+* #+BEGIN/END_SRC lang code blocks are embedded in code tags with class that specifies the coding language
+* CodeRay is used to give code syntax highlight support to #+BEGIN/END_SRC blocks 
+
+* Minor Enhancements
+ * Angle links in org-mode are embedded in anchor tags on html output
+ * Headlines with the COMMENT keyword, and the PROPERTIES drawer are not exported
+
+* Bug fixes
+ * Fixed bug with InlineExampleRegexp when a colon is at the beginning of a block

data/bin/org-ruby

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib org-ruby]))
+require 'optparse'
+
+# Put your code here
+
+options = {}
+options_parser = OptionParser.new do |opts|
+  options[:help] = false
+  options[:format] = :html
+  
+  opts.banner = "Usage: org-ruby <file> [options]"
+
+  opts.on("-h", "--help", "Show this message") do |v|
+    options[:help] = true
+  end
+
+  opts.on("-d", "--debug", "Run with $DEBUG true") do |v|
+    options[:debug] = true
+  end
+
+  opts.on("-t", "--translate FORMAT", [:html, :textile],
+          "Translate the ORG file to the specified format.") do |v|
+    options[:format] = v
+  end
+end
+
+begin
+  options_parser.parse!
+  if (ARGV.length == 0) then
+    puts options_parser
+  else
+    data = IO.read(ARGV[0])
+    p = Orgmode::Parser.new(data)
+    $DEBUG = true if options[:debug]
+    puts p.to_html if options[:format] == :html
+    puts p.to_textile if options[:format] == :textile
+  end
+rescue OptionParser::ParseError
+  puts options_parser
+end
+
+

data/lib/org-ruby.rb

@@ -0,0 +1,55 @@
+unless defined? ::OrgRuby
+
+# Default to UTF-8 in Ruby 1.9 rather than ASCII
+if defined? Encoding and Encoding.respond_to? 'default_external='
+  Encoding.default_external = Encoding.default_internal = Encoding::UTF_8
+end
+
+module OrgRuby
+
+  # :stopdoc:
+  VERSION = '0.6.1'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module OrgmodeParser
+
+OrgRuby.require_all_libs_relative_to(__FILE__)
+
+end                             # unless defined?

data/lib/org-ruby/headline.rb

@@ -0,0 +1,110 @@
+require OrgRuby.libpath(*%w[org-ruby line])
+
+module Orgmode
+
+  # Represents a headline in an orgmode file.
+  class Headline < Line
+
+    # This is the "level" of the headline
+    attr_reader :level
+
+    # This is the headline text -- the part of the headline minus the leading
+    # asterisks, the keywords, and the tags.
+    attr_reader :headline_text
+
+    # This contains the lines that "belong" to the headline.
+    attr_reader :body_lines
+
+    # These are the headline tags
+    attr_reader :tags
+
+    # Optional keyword found at the beginning of the headline.
+    attr_reader :keyword
+
+    # Valid states for partial export.
+    # exclude::       The entire subtree from this heading should be excluded.
+    # headline_only:: The headline should be exported, but not the body.
+    # all::           Everything should be exported, headline/body/children.
+    ValidExportStates = [:exclude, :headline_only, :all]
+
+    # The export state of this headline. See +ValidExportStates+.
+    attr_accessor :export_state
+
+    # This is the regex that matches a line
+    LineRegexp = /^\*+\s+/
+
+    # This matches the tags on a headline
+    TagsRegexp = /\s*:[\w:]*:\s*$/
+
+    # Special keywords allowed at the start of a line.
+    Keywords = %w[TODO DONE]
+
+    KeywordsRegexp = Regexp.new("^(#{Keywords.join('|')})\$")
+
+    # This matches a headline marked as COMMENT
+    CommentHeadlineRegexp = /^COMMENT\s+/
+
+    def initialize(line, parser = nil, offset=0)
+      super(line, parser)
+      @body_lines = []
+      @body_lines << self       # Make @body_lines contain the headline?
+      @tags = []
+      @export_state = :exclude
+      if (@line =~ LineRegexp) then
+        @level = $&.strip.length + offset
+        @headline_text = $'.strip
+        if (@headline_text =~ TagsRegexp) then
+          @tags = $&.split(/:/)              # split tag text on semicolon
+          @tags.delete_at(0)                 # the first item will be empty; discard
+          @headline_text.gsub!(TagsRegexp, "") # Removes the tags from the headline
+        end
+        @keyword = nil
+        parse_keywords
+      else
+        raise "'#{line}' is not a valid headline"
+      end
+    end
+
+    # Override Line.output_text. For a heading, @headline_text
+    # is what we should output.
+    def output_text
+      return @headline_text
+    end
+
+    # Determines if a line is an orgmode "headline":
+    # A headline begins with one or more asterisks.
+    def self.headline?(line)
+      line =~ LineRegexp
+    end
+
+    # Determines if a headline has the COMMENT keyword.
+    def comment_headline?
+      @headline_text =~ CommentHeadlineRegexp
+    end
+
+    # Overrides Line.paragraph_type.
+    def paragraph_type
+      :"heading#{@level}"
+    end
+
+    # Converts this headline and its body to textile.
+    def to_textile
+      output = "h#{@level}. #{@headline_text}\n"
+      output << Line.to_textile(@body_lines[1..-1])
+      output
+    end
+
+    ######################################################################
+    private
+
+    def parse_keywords
+      re = @parser.custom_keyword_regexp if @parser
+      re ||= KeywordsRegexp
+      words = @headline_text.split
+      if words.length > 0 && words[0] =~ re then
+        @keyword = words[0]
+        @headline_text.sub!(Regexp.new("^#{@keyword}\s*"), "")
+      end
+    end
+  end                           # class Headline
+end                             # class Orgmode

data/lib/org-ruby/html_output_buffer.rb

@@ -0,0 +1,273 @@
+require OrgRuby.libpath(*%w[org-ruby html_symbol_replace])
+require OrgRuby.libpath(*%w[org-ruby output_buffer])
+
+begin
+  require 'coderay'
+rescue LoadError
+  # CodeRay is not supported
+end
+
+module Orgmode
+
+  class HtmlOutputBuffer < OutputBuffer
+
+    HtmlBlockTag = {
+      :paragraph => "p",
+      :ordered_list => "li",
+      :unordered_list => "li",
+      :definition_term => "dt",
+      :definition_descr => "dd",
+      :table_row => "tr",
+      :table_header => "tr",
+      :heading1 => "h1",
+      :heading2 => "h2",
+      :heading3 => "h3",
+      :heading4 => "h4",
+      :heading5 => "h5",
+      :heading6 => "h6"
+    }
+
+    ModeTag = {
+      :unordered_list => "ul",
+      :ordered_list => "ol",
+      :definition_list => "dl",
+      :table => "table",
+      :blockquote => "blockquote",
+      :example => "pre",
+      :src => "pre",
+      :inline_example => "pre",
+      :center => "div"
+    }
+
+    attr_reader :options
+
+    def initialize(output, opts = {})
+      super(output)
+      if opts[:decorate_title] then
+        @title_decoration = " class=\"title\""
+      else
+        @title_decoration = ""
+      end
+      @options = opts
+      @footnotes = {}
+      @logger.debug "HTML export options: #{@options.inspect}"
+    end
+
+    # Output buffer is entering a new mode. Use this opportunity to
+    # write out one of the block tags in the ModeTag constant to put
+    # this information in the HTML stream.
+    def push_mode(mode)
+      if ModeTag[mode] then
+        output_indentation
+        css_class = ""
+        css_class = " class=\"src\"" if mode == :src
+        css_class = " class=\"example\"" if (mode == :example || mode == :inline_example)
+        css_class = " style=\"text-align: center\"" if mode == :center
+        @logger.debug "#{mode}: <#{ModeTag[mode]}#{css_class}>\n" 
+        @output << "<#{ModeTag[mode]}#{css_class}>\n" unless mode == :table and skip_tables?
+        # Special case to add code tags to src blogs and specify language
+        if mode == :src
+          @logger.debug "<code class=\"#{@block_lang}\">\n"
+          @output << "<code class=\"#{@block_lang}\">\n"
+        end
+        # Entering a new mode obliterates the title decoration
+        @title_decoration = ""
+      end
+      super(mode)
+    end
+
+    # We are leaving a mode. Close any tags that were opened when
+    # entering this mode.
+    def pop_mode(mode = nil)
+      m = super(mode)
+      if ModeTag[m] then
+        output_indentation
+        if mode == :src
+          @logger.debug "</code>\n"
+          @output << "</code>\n"
+        end
+        @logger.debug "</#{ModeTag[m]}>\n"
+        @output << "</#{ModeTag[m]}>\n" unless mode == :table and skip_tables?
+      end
+    end
+
+    def flush!
+      if mode_is_code(@buffer_mode) then
+        # Only colorize #+BEGIN_SRC blocks with a specified language,
+        # CodeRay already escapes the html once
+        if @buffer_mode == :src and @block_lang != "" and defined?(CodeRay)
+          @logger.debug "Applying syntax coloring for: #{@block_lang}"
+
+          # Also suppress CodeRay warning message when it cannot find the language alias
+          silence_warnings do
+            @buffer = CodeRay.scan(@buffer, @block_lang.to_s).html(:wrap => nil, :css => :style)
+          end
+        else
+          escape_buffer!
+        end
+
+        # Whitespace is significant in :code mode. Always output the buffer
+        # and do not do any additional translation.
+        @logger.debug "FLUSH CODE ==========> #{@buffer.inspect}"
+
+        @output << @buffer << "\n"
+      else
+        escape_buffer!
+        if @buffer.length > 0 and @output_type == :definition_list then
+          unless buffer_mode_is_table? and skip_tables?
+            output_indentation
+            d = @buffer.split("::", 2)
+            @output << "<#{HtmlBlockTag[:definition_term]}#{@title_decoration}>" << inline_formatting(d[0].strip) \
+                    << "</#{HtmlBlockTag[:definition_term]}>"
+            if d.length > 1 then
+              @output << "<#{HtmlBlockTag[:definition_descr]}#{@title_decoration}>" << inline_formatting(d[1].strip) \
+                      << "</#{HtmlBlockTag[:definition_descr]}>\n"
+            else
+              @output << "\n"
+            end
+            @title_decoration = ""
+          end
+        elsif @buffer.length > 0 then
+          unless buffer_mode_is_table? and skip_tables?
+            @logger.debug "FLUSH      ==========> #{@buffer_mode}"
+            output_indentation
+            @output << "<#{HtmlBlockTag[@output_type]}#{@title_decoration}>"
+            if (@buffered_lines[0].kind_of?(Headline)) then
+              headline = @buffered_lines[0]
+              raise "Cannot be more than one headline!" if @buffered_lines.length > 1
+              if @options[:export_heading_number] then
+                level = headline.level
+                heading_number = get_next_headline_number(level)
+                output << "<span class=\"heading-number heading-number-#{level}\">#{heading_number} </span>"
+              end
+              if @options[:export_todo] and headline.keyword then
+                keyword = headline.keyword
+                output << "<span class=\"todo-keyword #{keyword}\">#{keyword} </span>"
+              end
+            end
+            @output << inline_formatting(@buffer) 
+            @output << "</#{HtmlBlockTag[@output_type]}>\n"
+            @title_decoration = ""
+          else
+            @logger.debug "SKIP       ==========> #{@buffer_mode}"
+          end
+        end
+      end
+      clear_accumulation_buffer!
+    end
+
+    def output_footnotes!
+      return false unless @options[:export_footnotes] and not @footnotes.empty?
+
+      @output << "<div id=\"footnotes\">\n<h2 class=\"footnotes\">Footnotes: </h2>\n<div id=\"text-footnotes\">\n"
+
+      @footnotes.each do |name, defi|
+        @output << "<p class=\"footnote\"><sup><a class=\"footnum\" name=\"fn.#{name}\" href=\"#fnr.#{name}\">#{name}</a></sup>" \
+                << inline_formatting(defi) \
+                << "</p>\n"
+      end
+
+      @output << "</div>\n</div>\n"
+
+      return true
+    end
+
+
+    ######################################################################
+    private
+
+    def skip_tables?
+      @options[:skip_tables]
+    end
+
+    def buffer_mode_is_table?
+      @buffer_mode == :table
+    end
+
+    # Escapes any HTML content in the output accumulation buffer @buffer.
+    def escape_buffer!
+      @buffer.gsub!(/&/, "&amp;")
+      @buffer.gsub!(/</, "&lt;")
+      @buffer.gsub!(/>/, "&gt;")
+    end
+
+    def output_indentation
+      indent = "  " * (@mode_stack.length - 1)
+      @output << indent
+    end
+
+    Tags = {
+      "*" => { :open => "<b>", :close => "</b>" },
+      "/" => { :open => "<i>", :close => "</i>" },
+      "_" => { :open => "<span style=\"text-decoration:underline;\">",
+        :close => "</span>" },
+      "=" => { :open => "<code>", :close => "</code>" },
+      "~" => { :open => "<code>", :close => "</code>" },
+      "+" => { :open => "<del>", :close => "</del>" }
+    }
+
+    # Applies inline formatting rules to a string.
+    def inline_formatting(str)
+      str.rstrip!
+      str = @re_help.rewrite_emphasis(str) do |marker, s|
+        "#{Tags[marker][:open]}#{s}#{Tags[marker][:close]}"
+      end
+      if @options[:use_sub_superscripts] then
+        str = @re_help.rewrite_subp(str) do |type, text|
+          if type == "_" then
+            "<sub>#{text}</sub>"
+          elsif type == "^" then
+            "<sup>#{text}</sup>"
+          end
+        end
+      end
+      str = @re_help.rewrite_images(str) do |link|
+        "<a href=\"#{link}\"><img src=\"#{link}\" /></a>"
+      end
+      str = @re_help.rewrite_links(str) do |link, text|
+        text ||= link
+        link = link.sub(/^file:(.*)::(.*?)$/) do
+
+          # We don't support search links right now. Get rid of it.
+
+          "file:#{$1}"
+        end
+        link = link.sub(/^file:/i, "") # will default to HTTP
+        link = link.sub(/\.org$/i, ".html")
+        text = text.gsub(/([^\]]*\.(jpg|jpeg|gif|png))/xi) do |img_link|
+          "<img src=\"#{img_link}\" />"
+        end
+        "<a href=\"#{link}\">#{text}</a>"
+      end
+      if (@output_type == :table_row) then
+        str.gsub!(/^\|\s*/, "<td>")
+        str.gsub!(/\s*\|$/, "</td>")
+        str.gsub!(/\s*\|\s*/, "</td><td>")
+      end
+      if (@output_type == :table_header) then
+        str.gsub!(/^\|\s*/, "<th>")
+        str.gsub!(/\s*\|$/, "</th>")
+        str.gsub!(/\s*\|\s*/, "</th><th>")
+      end
+      if @options[:export_footnotes] then
+        str = @re_help.rewrite_footnote(str) do |name, defi|
+          # TODO escape name for url?
+          @footnotes[name] = defi if defi
+          "<sup><a class=\"footref\" name=\"fnr.#{name}\" href=\"#fn.#{name}\">#{name}</a></sup>"
+        end
+      end
+      Orgmode.special_symbols_to_html(str)
+      str
+    end
+
+    # Helper method taken from Rails
+    # https://github.com/rails/rails/blob/c2c8ef57d6f00d1c22743dc43746f95704d67a95/activesupport/lib/active_support/core_ext/kernel/reporting.rb#L10
+    def silence_warnings
+      warn_level = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = warn_level
+    end
+  end                           # class HtmlOutputBuffer
+end                             # module Orgmode