org-ruby 0.5.1 → 0.5.2

data/lib/org-ruby/output_buffer.rb

@@ -1,191 +1,227 @@
-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 accumulation buffer. It's a holding pen so
-    # consecutive lines of the right type can get stuck together
-    # without intervening newlines.
-    attr_reader :buffer
-
-    # This is the output mode of the accumulation buffer.
-    attr_reader :buffer_mode
-
-    # 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 = ""
-      @buffer_mode = nil
-      @output_type = :start
-      @list_indent_stack = []
-      @paragraph_modifier = nil
-      @cancel_modifier = false
-      @mode_stack = []
-
-      @logger = Logger.new(STDERR)
-      if ENV['DEBUG']
-        @logger.level = Logger::DEBUG
-      else
-        @logger.level = Logger::WARN
-      end
-
-      @re_help = RegexpHelper.new
-      push_mode(:normal)
-    end
-
-    Modes = [:normal, :ordered_list, :unordered_list, :blockquote, :src, :example, :table, :inline_example]
-
-    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(:inline_example) if line.inline_example? and current_mode != :inline_example
-      pop_mode(:inline_example) if current_mode == :inline_example && !line.inline_example?
-      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_header) || (@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_header) && (@output_type != :table_separator)) &&
-        (current_mode == :table)
-    end
-
-    # Accumulate the string @str@.
-    def << (str)
-      if @buffer_mode && @buffer_mode != current_mode then
-        raise "Accumulation buffer is mixing modes: @buffer_mode == #{@buffer_mode}, current_mode == #{current_mode}"
-      else
-        @buffer_mode = current_mode
-      end
-      @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?
-      mode_is_code current_mode
-    end
-
-    ######################################################################
-    private
-
-    def mode_is_code(mode)
-      case mode
-      when :src, :inline_example, :example
-        true
-      else
-        false
-      end
-    end
-
-    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
-      elsif line.blank? then
-
-        # Nothing
-
-      elsif ((line.paragraph_type == :paragraph) and
-             (not @list_indent_stack.empty? and
-              line.indent > @list_indent_stack.last))
-
-        # Nothing -- output this paragraph inside
-        # the list block (ul/ol)
-
-      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
+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 accumulation buffer. It's a holding pen so
+    # consecutive lines of the right type can get stuck together
+    # without intervening newlines.
+    attr_reader :buffer
+
+    # These are the Line objects that are currently in the accumulation
+    # buffer.
+    attr_reader :buffered_lines
+
+    # This is the output mode of the accumulation buffer.
+    attr_reader :buffer_mode
+
+    # This is the overall output buffer
+    attr_reader :output
+
+    # This is the current type of output being accumulated. 
+    attr_accessor :output_type
+
+    # This stack is used to do proper outline numbering of headlines.
+    attr_accessor :headline_number_stack
+
+    # 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 = ""
+      @buffered_lines = []
+      @buffer_mode = nil
+      @output_type = :start
+      @list_indent_stack = []
+      @paragraph_modifier = nil
+      @cancel_modifier = false
+      @mode_stack = []
+      @headline_number_stack = []
+
+      @logger = Logger.new(STDERR)
+      if ENV['DEBUG']
+        @logger.level = Logger::DEBUG
+      else
+        @logger.level = Logger::WARN
+      end
+
+      @re_help = RegexpHelper.new
+      push_mode(:normal)
+    end
+
+    Modes = [:normal, :ordered_list, :unordered_list, :blockquote, :src, :example, :table, :inline_example]
+
+    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(:inline_example) if line.inline_example? and current_mode != :inline_example
+      pop_mode(:inline_example) if current_mode == :inline_example && !line.inline_example?
+      push_mode(:table) if enter_table?
+      pop_mode(:table) if exit_table?
+      @buffered_lines.push(line)
+    end
+
+    # Flushes everything currently in the accumulation buffer into the 
+    # output buffer. Derived classes must override this to actually move
+    # content into the output buffer with the appropriate markup. This
+    # method just does common bookkeeping cleanup.
+    def clear_accumulation_buffer!
+      @buffer = ""
+      @buffer_mode = nil
+      @buffered_lines = []
+    end
+
+    # Gets the next headline number for a given level. The intent is
+    # this function is called sequentially for each headline that
+    # needs to get numbered. It does standard outline numbering.
+    def get_next_headline_number(level)
+      raise "Headline level not valid: #{level}" if level <= 0
+      while level > @headline_number_stack.length do
+        @headline_number_stack.push 0
+      end
+      while level < @headline_number_stack.length do
+        @headline_number_stack.pop
+      end
+      raise "Oops, shouldn't happen" unless level == @headline_number_stack.length
+      @headline_number_stack[@headline_number_stack.length - 1] += 1
+      @headline_number_stack.join(".")
+    end
+
+    # Tests if we are entering a table mode.
+    def enter_table?
+      ((@output_type == :table_row) || (@output_type == :table_header) || (@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_header) && (@output_type != :table_separator)) &&
+        (current_mode == :table)
+    end
+
+    # Accumulate the string @str@.
+    def << (str)
+      if @buffer_mode && @buffer_mode != current_mode then
+        raise "Accumulation buffer is mixing modes: @buffer_mode == #{@buffer_mode}, current_mode == #{current_mode}"
+      else
+        @buffer_mode = current_mode
+      end
+      @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?
+      mode_is_code current_mode
+    end
+
+    ######################################################################
+    private
+
+    def mode_is_code(mode)
+      case mode
+      when :src, :inline_example, :example
+        true
+      else
+        false
+      end
+    end
+
+    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
+      elsif line.blank? then
+
+        # Nothing
+
+      elsif ((line.paragraph_type == :paragraph) and
+             (not @list_indent_stack.empty? and
+              line.indent > @list_indent_stack.last))
+
+        # Nothing -- output this paragraph inside
+        # the list block (ul/ol)
+
+      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

@@ -1,272 +1,320 @@
-require 'rubygems'
-require 'rubypants'
-
-module Orgmode
-
-  ##
-  ##  Simple routines for loading / saving an ORG file.
-  ##
-
-  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
-
-    # This contains any in-buffer settings from the org-mode file.
-    # See http://orgmode.org/manual/In_002dbuffer-settings.html#In_002dbuffer-settings
-    attr_reader :in_buffer_settings
-
-    # This contains in-buffer options; a special case of in-buffer settings.
-    attr_reader :options
-
-    # Array of custom keywords.
-    attr_reader :custom_keywords
-
-    # Regexp that recognizes words in custom_keywords.
-    def custom_keyword_regexp
-      return nil if @custom_keywords.empty?
-      Regexp.new("^(#{@custom_keywords.join('|')})\$")
-    end
-
-    # A set of tags that, if present on any headlines in the org-file, means
-    # only those headings will get exported.
-    def export_select_tags
-      return Array.new unless @in_buffer_settings["EXPORT_SELECT_TAGS"]
-      @in_buffer_settings["EXPORT_SELECT_TAGS"].split
-    end
-
-    # A set of tags that, if present on any headlines in the org-file, means
-    # that subtree will not get exported.
-    def export_exclude_tags
-      return Array.new unless @in_buffer_settings["EXPORT_EXCLUDE_TAGS"]
-      @in_buffer_settings["EXPORT_EXCLUDE_TAGS"].split
-    end
-
-    # Returns true if we are to export todo keywords on headings.
-    def export_todo?
-      "t" == @options["todo"]
-    end
-
-    # This stack is used to do proper outline numbering of headlines.
-    attr_accessor :headline_number_stack
-
-    # Returns true if we are to export heading numbers.
-    def export_heading_number?
-      "t" == @options["num"]
-    end
-
-    # Should we skip exporting text before the first heading?
-    def skip_header_lines?
-      "t" == @options["skip"]
-    end
-
-    # Should we export tables? Defaults to true, must be overridden
-    # with an explicit "nil"
-    def export_tables?
-      "nil" != @options["|"]
-    end
-
-    # Gets the next headline number for a given level. The intent is
-    # this function is called sequentially for each headline that
-    # needs to get numbered. It does standard outline numbering.
-    def get_next_headline_number(level)
-      raise "Headline level not valid: #{level}" if level <= 0
-      while level > @headline_number_stack.length do
-        @headline_number_stack.push 0
-      end
-      while level < @headline_number_stack.length do
-        @headline_number_stack.pop
-      end
-      raise "Oops, shouldn't happen" unless level == @headline_number_stack.length
-      @headline_number_stack[@headline_number_stack.length - 1] += 1
-      @headline_number_stack.join(".")
-    end
-
-    # 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
-
-      @custom_keywords = []
-      @headlines = Array.new
-      @current_headline = nil
-      @header_lines = []
-      @in_buffer_settings = { }
-      @headline_number_stack = []
-      @options = { }
-      mode = :normal
-      previous_line = nil
-      @lines.each do |line|
-        case mode
-        when :normal
-
-          if (Headline.headline? line) then
-            @current_headline = Headline.new line, self
-            @headlines << @current_headline
-          else
-            line = Line.new line, self
-            # If there is a setting on this line, remember it.
-            line.in_buffer_setting? do |key, value|
-              store_in_buffer_setting key, value
-            end
-            if line.table_separator? then
-              previous_line.assigned_paragraph_type = :table_header if previous_line and previous_line.paragraph_type == :table_row
-            end
-            mode = :code if line.begin_block? and line.block_type == "EXAMPLE"
-            if (@current_headline) then
-              @current_headline.body_lines << line
-            else
-              @header_lines << line
-            end
-          end
-
-        when :code
-
-          # As long as we stay in code mode, force lines to be either blank or paragraphs.
-          # Don't try to interpret structural items, like headings and tables.
-          line = Line.new line
-          if line.end_block? and line.block_type == "EXAMPLE"
-            mode = :normal
-          else
-            line.assigned_paragraph_type = :paragraph unless line.blank?
-          end
-          if (@current_headline) then
-            @current_headline.body_lines << line
-          else
-            @header_lines << line
-          end
-        end                     # case
-        previous_line = line
-      end                       # @lines.each
-    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
-
-    # Converts the loaded org-mode file to HTML.
-    def to_html
-      mark_trees_for_export
-      @headline_number_stack = []
-      export_options = { }
-      export_options[:skip_tables] = true if not export_tables?
-      output = ""
-      if @in_buffer_settings["TITLE"] then
-        output << "<p class=\"title\">#{@in_buffer_settings["TITLE"]}</p>\n"
-      else
-        export_options[:decorate_title] = true
-      end
-      output << Line.to_html(@header_lines, export_options) unless skip_header_lines?
-      
-      # If we've output anything at all, remove the :decorate_title option.
-      export_options.delete(:decorate_title) if (output.length > 0)
-      @headlines.each do |headline|
-        output << headline.to_html(export_options)
-        export_options.delete(:decorate_title) if (output.length > 0)
-      end
-      rp = RubyPants.new(output)
-      rp.to_html
-    end
-
-    ######################################################################
-    private
-
-    # Uses export_select_tags and export_exclude_tags to determine
-    # which parts of the org-file to export.
-    def mark_trees_for_export
-      marked_any = false
-      # cache the tags
-      select = export_select_tags
-      exclude = export_exclude_tags
-      inherit_export_level = nil
-      ancestor_stack = []
-
-      # First pass: See if any headlines are explicitly selected
-      @headlines.each do |headline|
-        ancestor_stack.pop while not ancestor_stack.empty? and headline.level <= ancestor_stack.last.level
-        if inherit_export_level and headline.level > inherit_export_level
-          headline.export_state = :all
-        else
-          inherit_export_level = nil
-          headline.tags.each do |tag|
-            if (select.include? tag) then
-              marked_any = true
-              headline.export_state = :all
-              ancestor_stack.each { |a| a.export_state = :headline_only unless a.export_state == :all }
-              inherit_export_level = headline.level
-            end
-          end
-        end
-        ancestor_stack.push headline
-      end
-
-      # If nothing was selected, then EVERYTHING is selected.
-      @headlines.each { |h| h.export_state = :all } unless marked_any
-
-      # Second pass. Look for things that should be excluded, and get rid of them.
-      @headlines.each do |headline|
-        if inherit_export_level and headline.level > inherit_export_level
-          headline.export_state = :exclude
-        else
-          inherit_export_level = nil
-          headline.tags.each do |tag|
-            if (exclude.include? tag) then
-              headline.export_state = :exclude
-              inherit_export_level = headline.level
-            end
-          end
-        end
-      end
-    end
-
-    # Stores an in-buffer setting.
-    def store_in_buffer_setting(key, value)
-      if key == "OPTIONS" then
-
-        # Options are stored in a hash. Special-case.
-
-        value.split.each do |opt|
-          if opt =~ /^(.*):(.*?)$/ then
-            @options[$1] = $2
-          else
-            raise "Unexpected option: #{opt}"
-          end
-        end
-      elsif key =~ /^(TODO|SEQ_TODO|TYP_TODO)$/ then
-        # Handle todo keywords specially.
-        value.split.each do |keyword|
-          keyword.gsub!(/\(.*\)/, "") # Get rid of any parenthetical notes
-          keyword = Regexp.escape(keyword)
-          next if keyword == "\\|"      # Special character in the todo format, not really a keyword
-          @custom_keywords << keyword
-        end
-      else
-        @in_buffer_settings[key] = value
-      end
-    end
-  end                             # class Parser
-end                               # module Orgmode
+require 'rubygems'
+require 'rubypants'
+
+module Orgmode
+
+  ##
+  ##  Simple routines for loading / saving an ORG file.
+  ##
+
+  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
+
+    # This contains any in-buffer settings from the org-mode file.
+    # See http://orgmode.org/manual/In_002dbuffer-settings.html#In_002dbuffer-settings
+    attr_reader :in_buffer_settings
+
+    # This contains in-buffer options; a special case of in-buffer settings.
+    attr_reader :options
+
+    # Array of custom keywords.
+    attr_reader :custom_keywords
+
+    # Regexp that recognizes words in custom_keywords.
+    def custom_keyword_regexp
+      return nil if @custom_keywords.empty?
+      Regexp.new("^(#{@custom_keywords.join('|')})\$")
+    end
+
+    # A set of tags that, if present on any headlines in the org-file, means
+    # only those headings will get exported.
+    def export_select_tags
+      return Array.new unless @in_buffer_settings["EXPORT_SELECT_TAGS"]
+      @in_buffer_settings["EXPORT_SELECT_TAGS"].split
+    end
+
+    # A set of tags that, if present on any headlines in the org-file, means
+    # that subtree will not get exported.
+    def export_exclude_tags
+      return Array.new unless @in_buffer_settings["EXPORT_EXCLUDE_TAGS"]
+      @in_buffer_settings["EXPORT_EXCLUDE_TAGS"].split
+    end
+
+    # Returns true if we are to export todo keywords on headings.
+    def export_todo?
+      "t" == @options["todo"]
+    end
+
+    # Returns true if we are to export heading numbers.
+    def export_heading_number?
+      "t" == @options["num"]
+    end
+
+    # Should we skip exporting text before the first heading?
+    def skip_header_lines?
+      "t" == @options["skip"]
+    end
+
+    # Should we export tables? Defaults to true, must be overridden
+    # with an explicit "nil"
+    def export_tables?
+      "nil" != @options["|"]
+    end
+
+    # 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
+
+      @custom_keywords = []
+      @headlines = Array.new
+      @current_headline = nil
+      @header_lines = []
+      @in_buffer_settings = { }
+      @options = { }
+      mode = :normal
+      previous_line = nil
+      @lines.each do |line|
+        case mode
+        when :normal
+
+          if (Headline.headline? line) then
+            @current_headline = Headline.new line, self
+            @headlines << @current_headline
+          else
+            line = Line.new line, self
+            # If there is a setting on this line, remember it.
+            line.in_buffer_setting? do |key, value|
+              store_in_buffer_setting key, value
+            end
+            if line.table_separator? then
+              previous_line.assigned_paragraph_type = :table_header if previous_line and previous_line.paragraph_type == :table_row
+            end
+            mode = :code if line.begin_block? and line.block_type == "EXAMPLE"
+            if (@current_headline) then
+              @current_headline.body_lines << line
+            else
+              @header_lines << line
+            end
+          end
+
+        when :code
+
+          # As long as we stay in code mode, force lines to be either blank or paragraphs.
+          # Don't try to interpret structural items, like headings and tables.
+          line = Line.new line, self
+          if line.end_block? and line.block_type == "EXAMPLE"
+            mode = :normal
+          else
+            line.assigned_paragraph_type = :paragraph unless line.blank?
+          end
+          if (@current_headline) then
+            @current_headline.body_lines << line
+          else
+            @header_lines << line
+          end
+        end                     # case
+        previous_line = line
+      end                       # @lines.each
+    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
+
+    # Converts the loaded org-mode file to HTML.
+    def to_html
+      mark_trees_for_export
+      export_options = {
+        :decorate_title => true,
+        :export_heading_number => export_heading_number?,
+        :export_todo => export_todo?
+      }
+      export_options[:skip_tables] = true if not export_tables?
+      output = ""
+      output_buffer = HtmlOutputBuffer.new(output, export_options)
+      
+      if @in_buffer_settings["TITLE"] then
+
+        # If we're given a new title, then just create a new line
+        # for that title.
+        title = Line.new(@in_buffer_settings["TITLE"], self)
+        Parser.translate([title], output_buffer)
+      end
+      Parser.translate(@header_lines, output_buffer) unless skip_header_lines?
+      
+      # If we've output anything at all, remove the :decorate_title option.
+      export_options.delete(:decorate_title) if (output.length > 0)
+      @headlines.each do |headline|
+        next if headline.export_state == :exclude
+        case headline.export_state
+        when :exclude
+          # NOTHING
+        when :headline_only
+          Parser.translate(headline.body_lines[0, 1], output_buffer)
+        when :all
+          Parser.translate(headline.body_lines, output_buffer)
+        end
+      end
+      rp = RubyPants.new(output)
+      rp.to_html
+    end
+
+    ######################################################################
+    private
+
+    # Converts an array of lines to the appropriate format.
+    # Writes the output to +output_buffer+.
+    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
+
+          output_buffer << line.line if output_buffer.preserve_whitespace?          
+
+        when :comment
+          
+          if line.begin_block?
+            output_buffer.push_mode(:blockquote) if line.block_type == "QUOTE"
+            output_buffer.push_mode(:src) if line.block_type == "SRC"
+            output_buffer.push_mode(:example) if line.block_type == "EXAMPLE"
+          elsif line.end_block?
+            output_buffer.pop_mode(:blockquote) if line.block_type == "QUOTE"
+            output_buffer.pop_mode(:src) if line.block_type == "SRC"
+            output_buffer.pop_mode(:example) if line.block_type == "EXAMPLE"
+          else
+            output_buffer << line.line if output_buffer.preserve_whitespace?
+          end
+
+        when :table_row, :table_header
+
+          output_buffer << line.line.lstrip
+
+        when :unordered_list, :ordered_list
+          
+          output_buffer << line.output_text << " "
+
+        when :inline_example
+
+          output_buffer << line.output_text
+
+        else
+
+          if output_buffer.preserve_whitespace? then
+            output_buffer << line.output_text
+          else
+            output_buffer << line.output_text.strip << " "
+          end
+        end
+      end
+      output_buffer.flush!
+      output_buffer.pop_mode until output_buffer.current_mode == :normal
+      output_buffer.output
+    end
+
+    # Uses export_select_tags and export_exclude_tags to determine
+    # which parts of the org-file to export.
+    def mark_trees_for_export
+      marked_any = false
+      # cache the tags
+      select = export_select_tags
+      exclude = export_exclude_tags
+      inherit_export_level = nil
+      ancestor_stack = []
+
+      # First pass: See if any headlines are explicitly selected
+      @headlines.each do |headline|
+        ancestor_stack.pop while not ancestor_stack.empty? and headline.level <= ancestor_stack.last.level
+        if inherit_export_level and headline.level > inherit_export_level
+          headline.export_state = :all
+        else
+          inherit_export_level = nil
+          headline.tags.each do |tag|
+            if (select.include? tag) then
+              marked_any = true
+              headline.export_state = :all
+              ancestor_stack.each { |a| a.export_state = :headline_only unless a.export_state == :all }
+              inherit_export_level = headline.level
+            end
+          end
+        end
+        ancestor_stack.push headline
+      end
+
+      # If nothing was selected, then EVERYTHING is selected.
+      @headlines.each { |h| h.export_state = :all } unless marked_any
+
+      # Second pass. Look for things that should be excluded, and get rid of them.
+      @headlines.each do |headline|
+        if inherit_export_level and headline.level > inherit_export_level
+          headline.export_state = :exclude
+        else
+          inherit_export_level = nil
+          headline.tags.each do |tag|
+            if (exclude.include? tag) then
+              headline.export_state = :exclude
+              inherit_export_level = headline.level
+            end
+          end
+        end
+      end
+    end
+
+    # Stores an in-buffer setting.
+    def store_in_buffer_setting(key, value)
+      if key == "OPTIONS" then
+
+        # Options are stored in a hash. Special-case.
+
+        value.split.each do |opt|
+          if opt =~ /^(.*):(.*?)$/ then
+            @options[$1] = $2
+          else
+            raise "Unexpected option: #{opt}"
+          end
+        end
+      elsif key =~ /^(TODO|SEQ_TODO|TYP_TODO)$/ then
+        # Handle todo keywords specially.
+        value.split.each do |keyword|
+          keyword.gsub!(/\(.*\)/, "") # Get rid of any parenthetical notes
+          keyword = Regexp.escape(keyword)
+          next if keyword == "\\|"      # Special character in the todo format, not really a keyword
+          @custom_keywords << keyword
+        end
+      else
+        @in_buffer_settings[key] = value
+      end
+    end
+  end                             # class Parser
+end                               # module Orgmode