wallyqs-org-ruby 0.6.1

data/lib/org-ruby/output_buffer.rb

@@ -0,0 +1,237 @@
+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'] or $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, :definition_list, :blockquote, :src, :example, :table, :inline_example, :center, :property_drawer]
+
+    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
+        @block_lang = line.block_lang if line.begin_block? and line.code_block_type?
+        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 and not line.property_drawer?
+      pop_mode(:inline_example) if current_mode == :inline_example and !line.inline_example?
+      push_mode(:property_drawer) if line.property_drawer? and current_mode != :property_drawer
+      pop_mode(:property_drawer) if current_mode == :property_drawer and line.property_drawer_end_block?
+      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 == :definition_list) or
+               (current_mode == :unordered_list))
+          pop_mode
+        end
+      end
+    end
+
+    def output_footnotes!
+      return false
+    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 == :definition_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 == :definition_list) or
+         (@output_type == :unordered_list))
+      true
+    end
+  end                           # class OutputBuffer
+end                             # module Orgmode

data/lib/org-ruby/parser.rb

@@ -0,0 +1,366 @@
+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 footnotes
+    def export_footnotes?
+      "t" == @options["f"]
+    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
+
+    # Should we export sub/superscripts? (_{foo}/^{foo})
+    # only {} mode is currently supported.
+    def use_sub_superscripts?
+      @options["^"] != "nil"
+    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, offset=0)
+      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
+      table_header_set = false
+      @lines.each do |line|
+        case mode
+        when :normal
+
+          if (Headline.headline? line) then
+            @current_headline = Headline.new line, self, offset
+            @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
+              if previous_line and previous_line.paragraph_type == :table_row and !table_header_set
+                previous_line.assigned_paragraph_type = :table_header
+                table_header_set = true
+              end
+            end
+            table_header_set = false if !line.table?
+            mode = :code if line.begin_block? and line.block_type == "EXAMPLE"
+            mode = :block_comment if line.begin_block? and line.block_type == "COMMENT"
+            mode = :property_drawer if line.property_drawer_begin_block?
+            if (@current_headline) then
+              @current_headline.body_lines << line
+            else
+              @header_lines << line
+            end
+          end
+
+        when :block_comment
+          line = Line.new line, self
+          if line.end_block? and line.block_type == "COMMENT"
+            mode = :normal
+          else
+            line.assigned_paragraph_type = :comment
+          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
+
+        when :property_drawer
+
+          line = Line.new line, self
+          if line.property_drawer_end_block?
+            mode = :normal
+          else
+            line.assigned_paragraph_type = :property_drawer 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?,
+        :use_sub_superscripts =>  use_sub_superscripts?,
+        :export_footnotes => export_footnotes?
+      }
+      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, :comment, :property_drawer_item, :property_drawer_begin_block, :property_drawer_end_block
+
+          output_buffer << line.line if output_buffer.preserve_whitespace?
+
+        when :begin_block
+
+          output_buffer.push_mode(:blockquote) if line.block_type.casecmp("QUOTE") == 0
+          output_buffer.push_mode(:src) if line.block_type.casecmp("SRC") == 0
+          output_buffer.push_mode(:example) if line.block_type.casecmp("EXAMPLE") == 0
+          output_buffer.push_mode(:center) if line.block_type.casecmp("CENTER") == 0
+
+        when :end_block
+
+          output_buffer.pop_mode(:blockquote) if line.block_type.casecmp("QUOTE") == 0
+          output_buffer.pop_mode(:src) if line.block_type.casecmp("SRC") == 0
+          output_buffer.pop_mode(:example) if line.block_type.casecmp("EXAMPLE") == 0
+          output_buffer.pop_mode(:center) if line.block_type.casecmp("CENTER") == 0
+
+        when :table_row, :table_header
+
+          output_buffer << line.line.lstrip
+
+        when :unordered_list, :ordered_list, :definition_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_footnotes!
+      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
+          if headline.comment_headline?
+            headline.export_state = :exclude
+            inherit_export_level = headline.level
+          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