org-ruby 0.2.0

data/lib/org-ruby/line.rb

@@ -0,0 +1,172 @@
+module Orgmode
+
+  # Represents a single line of an orgmode file.
+  class Line
+
+    # This is the line itself.
+    attr_reader :line
+
+    # The indent level of this line. this is important to properly translate
+    # nested lists from orgmode to textile.
+    # TODO 2009-12-20 bdewey: Handle tabs
+    attr_reader :indent
+
+    def initialize(line)
+      @line = line
+      @indent = 0
+      @line =~ /\s*/
+      @indent = $&.length unless blank?
+    end
+
+    def to_s
+      return @line
+    end
+
+    # Tests if a line is a comment.
+    def comment?
+      @line =~ /^\s*#/
+    end
+
+    # Tests if a line contains metadata instead of actual content.
+    def metadata?
+      @line =~ /^\s*(CLOCK|DEADLINE|START|CLOSED|SCHEDULED):/
+    end
+
+    def nonprinting?
+      comment? || metadata?
+    end
+
+    def blank?
+      @line =~ /^\s*$/
+    end
+
+    def plain_list?
+      ordered_list? or unordered_list?
+    end
+
+    UnorderedListRegexp = /^\s*(-|\+)\s*/
+
+    def unordered_list?
+      @line =~ UnorderedListRegexp
+    end
+
+    def strip_unordered_list_tag
+      @line.sub(UnorderedListRegexp, "")
+    end
+
+    OrderedListRegexp = /^\s*\d+(\.|\))\s*/
+
+    def ordered_list?
+      @line =~ OrderedListRegexp
+    end
+
+    def strip_ordered_list_tag
+      @line.sub(OrderedListRegexp, "")
+    end
+
+    def plain_text?
+      not metadata? and not blank? and not plain_list?
+    end
+
+    def table_row?
+      # for an org-mode table, the first non-whitespace character is a
+      # | (pipe).
+      @line =~ /^\s*\|/
+    end
+
+    def table_separator?
+      # an org-mode table separator has the first non-whitespace
+      # character as a | (pipe), then consists of nothing else other
+      # than pipes, hyphens, and pluses.
+
+      @line =~ /^\s*\|[-\|\+]*\s*$/
+    end
+
+    def table?
+      table_row? or table_separator?
+    end
+
+    BlockRegexp = /^\s*#\+(BEGIN|END)_(\w*)/
+
+    def begin_block?
+      @line =~ BlockRegexp && $1 == "BEGIN"
+    end
+
+    def end_block?
+      @line =~ BlockRegexp && $1 == "END"
+    end
+
+    def block_type
+      $2 if @line =~ BlockRegexp
+    end
+
+    # Determines the paragraph type of the current line.
+    def paragraph_type
+      return :blank if blank?
+      return :ordered_list if ordered_list?
+      return :unordered_list if unordered_list?
+      return :metadata if metadata?
+      return :comment if comment?
+      return :table_separator if table_separator?
+      return :table_row if table_row?
+      return :paragraph
+    end
+
+    def self.to_textile(lines)
+      output = ""
+      output_buffer = TextileOutputBuffer.new(output)
+      translate(lines, output_buffer)
+    end
+
+    def self.to_html(lines)
+      output = ""
+      output_buffer = HtmlOutputBuffer.new(output)
+      translate(lines, output_buffer)
+    end
+
+    # Converts an array of lines to textile format.
+    def self.translate(lines, output_buffer)
+      lines.each do |line|
+
+        # See if we're carrying paragraph payload, and output
+        # it if we're about to switch to some other output type.
+        output_buffer.prepare(line)
+
+        case line.paragraph_type
+        when :metadata, :table_separator, :blank
+
+          # IGNORE
+
+        when :comment
+          
+          output_buffer.push_mode(:blockquote) if line.begin_block? and line.block_type == "QUOTE"
+          output_buffer.push_mode(:code) if line.begin_block? and line.block_type == "EXAMPLE"
+          output_buffer.pop_mode(:blockquote) if line.end_block? and line.block_type == "QUOTE"
+          output_buffer.pop_mode(:code) if line.end_block? and line.block_type == "EXAMPLE"
+
+        when :table_row
+
+          output_buffer << line.line.lstrip
+
+        when :ordered_list
+            
+          output_buffer << line.strip_ordered_list_tag << " "
+          
+        when :unordered_list
+          
+          output_buffer << line.strip_unordered_list_tag << " "
+
+        when :paragraph
+
+          if output_buffer.preserve_whitespace? then
+            output_buffer << line.line
+          else
+            output_buffer << line.line.strip << " "
+          end
+        end
+      end
+      output_buffer.flush!
+      output_buffer.output
+    end
+  end                           # class Line
+end                             # module Orgmode

data/lib/org-ruby/output_buffer.rb

@@ -0,0 +1,154 @@
+require 'logger'
+
+module Orgmode
+
+  # The OutputBuffer is used to accumulate multiple lines of orgmode
+  # text, and then emit them to the output all in one go. The class
+  # will do the final textile substitution for inline formatting and
+  # add a newline character prior emitting the output.
+  class OutputBuffer
+
+    # This is the temporary buffer that we accumulate into.
+    attr_reader :buffer
+
+    # This is the overall output buffer
+    attr_reader :output
+
+    # This is the current type of output being accumulated. 
+    attr_accessor :output_type
+
+    # Creates a new OutputBuffer object that is bound to an output object.
+    # The output will get flushed to =output=.
+    def initialize(output)
+      @output = output
+      @buffer = ""
+      @output_type = :start
+      @list_indent_stack = []
+      @paragraph_modifier = nil
+      @cancel_modifier = false
+      @mode_stack = []
+      push_mode(:normal)
+
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger::WARN
+
+      @re_help = RegexpHelper.new
+    end
+
+    Modes = [:normal, :ordered_list, :unordered_list, :blockquote, :code, :table]
+
+    def current_mode
+      @mode_stack.last
+    end
+
+    def current_mode_list?
+      (current_mode == :ordered_list) or (current_mode == :unordered_list)
+    end
+
+    def push_mode(mode)
+      raise "Not a recognized mode: #{mode}" unless Modes.include?(mode)
+      @mode_stack.push(mode)
+    end
+
+    def pop_mode(mode = nil)
+      m = @mode_stack.pop
+      @logger.warn "Modes don't match. Expected to pop #{mode}, but popped #{m}" if mode && mode != m
+      m
+    end
+
+    # Prepares the output buffer to receive content from a line.
+    # As a side effect, this may flush the current accumulated text.
+    def prepare(line)
+      @logger.debug "Looking at #{line.paragraph_type}: #{line.to_s}"
+      if not should_accumulate_output?(line) then
+        flush!
+        maintain_list_indent_stack(line)
+        @output_type = line.paragraph_type 
+      end
+      push_mode(:table) if enter_table?
+      pop_mode(:table) if exit_table?
+    end
+
+    # Tests if we are entering a table mode.
+    def enter_table?
+      ((@output_type == :table_row) || (@output_type == :table_separator)) &&
+        (current_mode != :table)
+    end
+
+    # Tests if we are existing a table mode.
+    def exit_table?
+      ((@output_type != :table_row) && (@output_type != :table_separator)) &&
+        (current_mode == :table)
+    end
+
+    # Accumulate the string @str@.
+    def << (str)
+      @buffer << str
+    end
+
+    # Gets the current list indent level. 
+    def list_indent_level
+      @list_indent_stack.length
+    end
+
+    # Test if we're in an output mode in which whitespace is significant.
+    def preserve_whitespace?
+      return current_mode == :code
+    end
+
+    ######################################################################
+    private
+
+    def maintain_list_indent_stack(line)
+      if (line.plain_list?) then
+        while (not @list_indent_stack.empty? \
+               and (@list_indent_stack.last > line.indent)) 
+          @list_indent_stack.pop
+          pop_mode
+        end
+        if (@list_indent_stack.empty? \
+            or @list_indent_stack.last < line.indent)
+          @list_indent_stack.push(line.indent)
+          push_mode line.paragraph_type
+        end
+      else
+        @list_indent_stack = []
+        while ((current_mode == :ordered_list) or
+               (current_mode == :unordered_list))
+          pop_mode
+        end
+      end
+    end
+
+    # Tests if the current line should be accumulated in the current
+    # output buffer.  (Extraneous line breaks in the orgmode buffer
+    # are removed by accumulating lines in the output buffer without
+    # line breaks.)
+    def should_accumulate_output?(line)
+
+      # Special case: Preserve line breaks in block code mode.
+      return false if preserve_whitespace?
+
+      # Special case: Multiple blank lines get accumulated.
+      return true if line.paragraph_type == :blank and @output_type == :blank
+      
+      # Currently only "paragraphs" get accumulated with previous output.
+      return false unless line.paragraph_type == :paragraph
+      if ((@output_type == :ordered_list) or
+          (@output_type == :unordered_list)) then
+
+        # If the previous output type was a list item, then we only put a paragraph in it
+        # if its indent level is greater than the list indent level.
+
+        return false unless line.indent > @list_indent_stack.last
+      end
+
+      # Only accumulate paragraphs with lists & paragraphs.
+      return false unless
+        ((@output_type == :paragraph) or
+         (@output_type == :ordered_list) or
+         (@output_type == :unordered_list))
+      true
+    end
+  end                           # class OutputBuffer
+end                             # module Orgmode

data/lib/org-ruby/parser.rb

@@ -0,0 +1,72 @@
+##
+##  Simple routines for loading / saving an ORG file.
+##
+
+module Orgmode
+
+  class Parser
+
+    # All of the lines of the orgmode file
+    attr_reader :lines
+
+    # All of the headlines in the org file
+    attr_reader :headlines
+
+    # These are any lines before the first headline
+    attr_reader :header_lines
+    
+    # I can construct a parser object either with an array of lines
+    # or with a single string that I will split along \n boundaries.
+    def initialize(lines)
+      if lines.is_a? Array then
+        @lines = lines
+      elsif lines.is_a? String then
+        @lines = lines.split("\n")
+      else
+        raise "Unsupported type for +lines+: #{lines.class}"
+      end
+        
+      @headlines = Array.new
+      @current_headline = nil
+      @header_lines = []
+      @lines.each do |line|
+        if (Headline.headline? line) then
+          @current_headline = Headline.new line
+          @headlines << @current_headline
+        else
+          line = Line.new line
+          if (@current_headline) then
+            @current_headline.body_lines << line
+          else
+            @header_lines << line
+          end
+        end
+      end
+    end                           # initialize
+
+    # Creates a new parser from the data in a given file
+    def self.load(fname)
+      lines = IO.readlines(fname)
+      return self.new(lines)
+    end
+
+    # Saves the loaded orgmode file as a textile file.
+    def to_textile
+      output = ""
+      output << Line.to_textile(@header_lines)
+      @headlines.each do |headline|
+        output << headline.to_textile
+      end
+      output
+    end
+
+    def to_html
+      output = ""
+      output << Line.to_html(@header_lines)
+      @headlines.each do |headline|
+        output << headline.to_html
+      end
+      output
+    end
+  end                             # class Parser
+end                               # module Orgmode

data/lib/org-ruby/regexp_helper.rb

@@ -0,0 +1,156 @@
+require 'logger'
+
+module Orgmode
+
+  # = Summary
+  # 
+  # This class contains helper routines to deal with the Regexp "black
+  # magic" you need to properly parse org-mode files.
+  #
+  # = Key methods
+  #
+  # * Use +rewrite_emphasis+ to replace org-mode emphasis strings (e.g.,
+  #   \/italic/) with the suitable markup for the output.
+  #
+  # * Use +rewrite_links+ to get a chance to rewrite all org-mode
+  #   links with suitable markup for the output.
+  class RegexpHelper
+
+    ######################################################################
+    # EMPHASIS
+    #
+    # I figure it's best to stick as closely to the elisp implementation
+    # as possible for emphasis. org.el defines the regular expression that
+    # is used to apply "emphasis" (in my terminology, inline formatting
+    # instead of block formatting). Here's the documentation from org.el.
+    #
+    # Terminology: In an emphasis string like " *strong word* ", we
+    # call the initial space PREMATCH, the final space POSTMATCH, the
+    # stars MARKERS, "s" and "d" are BORDER characters and "trong wor"
+    # is the body.  The different components in this variable specify
+    # what is allowed/forbidden in each part:
+    #
+    # pre          Chars allowed as prematch.  Line beginning allowed, too.
+    # post         Chars allowed as postmatch.  Line end will be allowed too.
+    # border       The chars *forbidden* as border characters.
+    # body-regexp  A regexp like \".\" to match a body character.  Don't use
+    #              non-shy groups here, and don't allow newline here.
+    # newline      The maximum number of newlines allowed in an emphasis exp.
+    #
+    # I currently don't use +newline+ because I've thrown this information
+    # away by this point in the code. TODO -- revisit?
+    attr_reader   :pre_emphasis
+    attr_reader   :post_emphasis
+    attr_reader   :border_forbidden
+    attr_reader   :body_regexp
+    attr_reader   :markers
+
+    attr_reader   :org_emphasis_regexp
+
+    def initialize
+      # Set up the emphasis regular expression.
+      @pre_emphasis = " \t\\('\""
+      @post_emphasis = "- \t.,:!?;'\"\\)"
+      @border_forbidden = " \t\r\n,\"'"
+      @body_regexp = ".*?"
+      @markers = "*/_=~+"
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger::WARN
+      build_org_emphasis_regexp
+      build_org_link_regexp
+    end
+
+    # Finds all emphasis matches in a string.
+    # Supply a block that will get the marker and body as parameters.
+    def match_all(str)
+      str.scan(@org_emphasis_regexp) do |match|
+        yield $2, $3
+      end
+    end
+
+    # Compute replacements for all matching emphasized phrases.
+    # Supply a block that will get the marker and body as parameters;
+    # return the replacement string from your block.
+    #
+    # = Example
+    #
+    #   re = RegexpHelper.new
+    #   result = re.rewrite_emphasis("*bold*, /italic/, =code=") do |marker, body|
+    #       "<#{map[marker]}>#{body}</#{map[marker]}>"
+    #   end
+    #
+    # In this example, the block body will get called three times:
+    #
+    # 1. Marker: "*", body: "bold"
+    # 2. Marker: "/", body: "italic"
+    # 3. Marker: "=", body: "code"
+    #
+    # The return from this block is a string that will be used to
+    # replace "*bold*", "/italic/", and "=code=",
+    # respectively. (Clearly this sample string will use HTML-like
+    # syntax, assuming +map+ is defined appropriately.)
+    def rewrite_emphasis(str)
+      str.gsub(@org_emphasis_regexp) do |match|
+        inner = yield $2, $3
+        "#{$1}#{inner}#{$4}"
+      end
+    end
+
+    # = Summary
+    #
+    # Rewrite org-mode links in a string to markup suitable to the
+    # output format.
+    #
+    # = Usage
+    # 
+    # Give this a block that expect the link and optional friendly
+    # text. Return how that link should get formatted.
+    #
+    # = Example
+    #
+    #   re = RegexpHelper.new
+    #   result = re.rewrite_links("[[http://www.bing.com]] and [[http://www.hotmail.com][Hotmail]]") do |link, text}
+    #       text ||= link
+    #       "<a href=\"#{link}\">#{text}</a>"
+    #    end
+    #
+    # In this example, the block body will get called two times. In the
+    # first instance, +text+ will be nil (the org-mode markup gives no
+    # friendly text for the link +http://www.bing.com+. In the second
+    # instance, the block will get text of *Hotmail* and the link
+    # +http://www.hotmail.com+. In both cases, the block returns an
+    # HTML-style link, and that is how things will get recorded in
+    # +result+.
+    def rewrite_links(str)
+      i = str.gsub(@org_link_regexp) do |match|
+        yield $1, nil
+      end
+      i.gsub(@org_link_text_regexp) do |match|
+        yield $1, $2
+      end
+    end
+
+    private
+
+    def build_org_emphasis_regexp
+      @org_emphasis_regexp = Regexp.new("([#{@pre_emphasis}]|^)\n" +
+                                        "(  [#{@markers}]  )\n" + 
+                                        "(  [^#{@border_forbidden}]  | " +
+                                        "  [^#{@border_forbidden}]#{@body_regexp}[^#{@border_forbidden}]  )\n" +
+                                        "\\2\n" +
+                                        "([#{@post_emphasis}]|$)\n", Regexp::EXTENDED)
+      @logger.debug "Just created regexp: #{@org_emphasis_regexp}"
+    end
+
+    def build_org_link_regexp
+      @org_link_regexp = /\[\[
+                             ([^\]]*) # This is the URL
+                          \]\]/x
+      @org_link_text_regexp = /\[\[
+                                 ([^\]]*) # This is the URL
+                               \]\[
+                                 ([^\]]*) # This is the friendly text
+                               \]\]/x
+    end
+  end                           # class Emphasis
+end                             # module Orgmode