org-ruby 0.7.2 → 0.8.0

data/lib/org-ruby/line.rb

@@ -14,6 +14,12 @@ module Orgmode
     # Backpointer to the parser that owns this line.
     attr_reader :parser
 
+    # Paragraph type determined for the line.
+    attr_reader :paragraph_type
+
+    # Major modes associate paragraphs with a table, list and so on.
+    attr_reader :major_mode
+
     # A line can have its type assigned instead of inferred from its
     # content. For example, something that parses as a "table" on its
     # own ("| one | two|\n") may just be a paragraph if it's inside
@@ -26,6 +32,8 @@ module Orgmode
       @line = line
       @indent = 0
       @line =~ /\s*/
+      determine_paragraph_type
+      determine_major_mode
       @assigned_paragraph_type = nil
       @indent = $&.length unless blank?
     end
@@ -88,7 +96,7 @@ module Orgmode
       @line.sub(UnorderedListRegexp, "")
     end
 
-    DefinitionListRegexp = /^\s*(-|\+|\s+[*])\s*(.*?)::/
+    DefinitionListRegexp = /^\s*(-|\+|\s+[*])\s+(.*\s+|)::($|\s+)/
 
     def definition_list?
       check_assignment_or_regexp(:definition_list, DefinitionListRegexp)
@@ -116,6 +124,7 @@ module Orgmode
       return strip_ordered_list_tag if ordered_list?
       return strip_unordered_list_tag if unordered_list?
       return @line.sub(InlineExampleRegexp, "") if inline_example?
+      return strip_raw_text_tag if raw_text?
       return line
     end
 
@@ -168,10 +177,6 @@ module Orgmode
       block_type =~ /^(EXAMPLE|SRC)$/i
     end
 
-    def code_block_line?
-      @assigned_paragraph_type == :src
-    end
-
     InlineExampleRegexp = /^\s*:\s/
 
     # Test if the line matches the "inline example" case:
@@ -180,6 +185,21 @@ module Orgmode
       check_assignment_or_regexp(:inline_example, InlineExampleRegexp)
     end
 
+    RawTextRegexp = /^(\s*)#\+(\w+):\s*/
+
+    # Checks if this line is raw text.
+    def raw_text?
+      check_assignment_or_regexp(:raw_text, RawTextRegexp)
+    end
+
+    def raw_text_tag
+      $2.upcase if @line =~ RawTextRegexp
+    end
+
+    def strip_raw_text_tag
+      @line.sub(RawTextRegexp) { |match| $1 }
+    end
+
     InBufferSettingRegexp = /^#\+(\w+):\s*(.*)$/
 
     # call-seq:
@@ -202,25 +222,60 @@ module Orgmode
     end
 
     # Determines the paragraph type of the current line.
-    def paragraph_type
-      return :blank if blank?
-      return :src if code_block_line? # Do not try to guess the type of this line if it is accumulating source code
-      return :definition_list if definition_list? # order is important! A definition_list is also an unordered_list!
-      return :ordered_list if ordered_list?
-      return :unordered_list if unordered_list?
-      return :property_drawer_begin_block if property_drawer_begin_block?
-      return :property_drawer_end_block if property_drawer_end_block?
-      return :property_drawer_item if property_drawer_item?
-      return :metadata if metadata?
-      return :begin_block if begin_block?
-      return :end_block if end_block?
-      return :comment if comment?
-      return :table_separator if table_separator?
-      return :table_row if table_row?
-      return :table_header if table_header?
-      return :inline_example if inline_example?
-      return :horizontal_rule if horizontal_rule?
-      return :paragraph
+    def determine_paragraph_type
+      @paragraph_type = \
+      case
+      when blank?
+        :blank
+      when definition_list? # order is important! A definition_list is also an unordered_list!
+        :definition_term
+      when (ordered_list? or unordered_list?)
+        :list_item
+      when property_drawer_begin_block?
+        :property_drawer_begin_block
+      when property_drawer_end_block?
+        :property_drawer_end_block
+      when property_drawer_item?
+        :property_drawer_item
+      when metadata?
+        :metadata
+      when block_type
+        case block_type.downcase.to_sym
+        when :center, :comment, :example, :html, :quote, :src
+          block_type.downcase.to_sym
+        else
+          :comment
+        end
+      when raw_text? # order is important! Raw text can be also a comment
+        :raw_text
+      when comment?
+        :comment
+      when table_separator?
+        :table_separator
+      when table_row?
+        :table_row
+      when table_header?
+        :table_header
+      when inline_example?
+        :inline_example
+      when horizontal_rule?
+        :horizontal_rule
+      else :paragraph
+      end
+    end
+
+    def determine_major_mode
+      @major_mode = \
+      case
+      when definition_list? # order is important! A definition_list is also an unordered_list!
+        :definition_list
+      when ordered_list?
+        :ordered_list
+      when unordered_list?
+        :unordered_list
+      when table?
+        :table
+      end
     end
 
     ######################################################################

data/lib/org-ruby/output_buffer.rb

@@ -8,40 +8,29 @@ module Orgmode
   # 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
+      # This is the accumulation buffer. It's a holding pen so
+      # consecutive lines of the right type can get stuck together
+      # without intervening newlines.
       @buffer = ""
-      @buffered_lines = []
-      @buffer_mode = nil
+
+      # This stack is used to do proper outline numbering of
+      # headlines.
+      @headline_number_stack = []
+
+      @output = output
       @output_type = :start
       @list_indent_stack = []
-      @paragraph_modifier = nil
-      @cancel_modifier = false
       @mode_stack = []
-      @headline_number_stack = []
+      @code_block_indent = nil
 
       @logger = Logger.new(STDERR)
       if ENV['DEBUG'] or $DEBUG
@@ -51,21 +40,13 @@ module Orgmode
       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
 
@@ -75,40 +56,49 @@ module Orgmode
       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)
+    def insert(line)
+      # Prepares the output buffer to receive content from a line.
+      # As a side effect, this may flush the current accumulated text.
       @logger.debug "Looking at #{line.paragraph_type}(#{current_mode}) : #{line.to_s}"
-      if line.begin_block? and line.code_block?
-        flush!
-        # We try to get the lang from #+BEGIN_SRC blocks
-        @block_lang = line.block_lang
-        @output_type = line.paragraph_type
-      elsif current_mode == :example and line.end_block?
+      # We try to get the lang from #+BEGIN_SRC blocks
+      @block_lang = line.block_lang if line.begin_block?
+      unless should_accumulate_output?(line)
         flush!
-        @output_type = line.paragraph_type
-      elsif not should_accumulate_output?(line)
-        flush!
-        maintain_list_indent_stack(line)
-        @output_type = line.paragraph_type
+        maintain_mode_stack(line)
       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 = []
+
+      # Adds the current line to the output buffer
+      case
+      when line.raw_text?
+        @buffer << "\n" << line.output_text if line.raw_text_tag == @buffer_tag
+      when preserve_whitespace?
+        @buffer << "\n" << line.output_text unless line.block_type
+      when line.assigned_paragraph_type == :code
+        # If the line is contained within a code block but we should
+        # not preserve whitespaces, then we do nothing.
+      when (line.kind_of? Headline)
+        add_line_attributes line
+        @buffer << "\n" << line.output_text.strip
+      when ([:definition_term, :list_item, :table_row, :table_header,
+             :horizontal_rule].include? line.paragraph_type)
+        @buffer << "\n" << line.output_text.strip
+      when line.paragraph_type == :paragraph
+        @buffer << "\n"
+        buffer_indentation
+        @buffer << line.output_text.strip
+      end
+
+      if mode_is_code? current_mode and not line.block_type
+        # Determines the amount of whitespaces to be stripped at the
+        # beginning of each line in code block.
+        if @code_block_indent
+          @code_block_indent = [@code_block_indent, line.indent].min
+        else
+          @code_block_indent = line.indent
+        end
+      end
+
+      @output_type = line.assigned_paragraph_type || line.paragraph_type
     end
 
     # Gets the next headline number for a given level. The intent is
@@ -127,28 +117,6 @@ module Orgmode
       @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
@@ -156,50 +124,76 @@ module Orgmode
 
     # Test if we're in an output mode in which whitespace is significant.
     def preserve_whitespace?
-      mode_is_code current_mode
+      [:example, :inline_example, :raw_text, :src].include? current_mode
     end
 
     ######################################################################
     private
 
-    def mode_is_code(mode)
-      case mode
-      when :src, :inline_example, :example
-        true
-      else
-        false
-      end
+    def mode_is_heading?(mode)
+      [:heading1, :heading2, :heading3,
+       :heading4, :heading5, :heading6].include? mode
     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
+    def mode_is_block?(mode)
+      [:quote, :center, :example, :src].include? mode
+    end
 
-        # Nothing
+    def mode_is_code?(mode)
+      [:example, :src].include? mode
+    end
 
-      elsif ((not line.plain_list?) and
-             (not @list_indent_stack.empty?) and
-             (line.indent > @list_indent_stack.last))
+    def boundary_of_block?(line)
+      # Boundary of inline example
+      return true if ((line.paragraph_type == :inline_example) ^
+                      (@output_type == :inline_example))
+      # Boundary of begin...end block
+      return true if mode_is_block? @output_type
+    end
 
-        # Nothing -- output this paragraph inside
-        # the list block (ul/ol)
+    def maintain_mode_stack(line)
+      # Always close the following lines
+      pop_mode if (mode_is_heading? current_mode or
+                   current_mode == :paragraph or
+                   current_mode == :horizontal_rule or
+                   current_mode == :inline_example or
+                   current_mode == :raw_text)
 
-      else
-        @list_indent_stack = []
-        while ((current_mode == :ordered_list) or
-               (current_mode == :definition_list) or
-               (current_mode == :unordered_list))
-          pop_mode
+      # End-block line closes every mode within block
+      if line.end_block? and @mode_stack.include? line.paragraph_type
+        pop_mode until current_mode == line.paragraph_type
+      end
+
+      if ((not line.paragraph_type == :blank) or
+          @output_type == :blank)
+        # Close previous tags on demand. Two blank lines close all tags.
+        while ((not @list_indent_stack.empty?) and
+               @list_indent_stack.last >= line.indent and
+               # Don't allow an arbitrary line to close block
+               (not mode_is_block? current_mode))
+          # Item can't close its major mode
+          if (@list_indent_stack.last == line.indent and
+              line.major_mode == current_mode)
+            break
+          else
+            pop_mode
+          end
+        end
+      end
+
+      # Special case: Only end-block line closes block
+      pop_mode if line.end_block? and line.paragraph_type == current_mode
+
+      unless line.paragraph_type == :blank
+        if (@list_indent_stack.empty? or
+            @list_indent_stack.last <= line.indent or
+            mode_is_block? current_mode)
+          # Opens the major mode of line if it exists
+          if @list_indent_stack.last != line.indent or mode_is_block? current_mode
+            push_mode(line.major_mode, line.indent) if line.major_mode
+          end
+          # Opens tag that precedes text immediately
+          push_mode(line.paragraph_type, line.indent) unless line.end_block?
         end
       end
     end
@@ -209,39 +203,43 @@ module Orgmode
     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: We are accumulating source code block content for colorizing
-      return true if line.paragraph_type == :src and @output_type == :src
-
-      # 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
+    # output buffer.
+    def should_accumulate_output? line
+      # Special case: Assign mode if not yet done.
+      return false unless current_mode
+
+      # Special case: Handles accumulating block content and example lines
+      if mode_is_code? current_mode
+        return true unless (line.end_block? and
+                            line.paragraph_type == current_mode)
+      end
+      return false if boundary_of_block? line
+      return true if current_mode == :inline_example
+
+      # Special case: Don't accumulate the following lines.
+      return false if (mode_is_heading? @output_type or
+                       @output_type == :comment or
+                       @output_type == :horizontal_rule or
+                       @output_type == :raw_text)
+
+      # Special case: Blank line at least splits paragraphs
+      return false if @output_type == :blank
+
+      if line.paragraph_type == :paragraph
+        # Paragraph gets accumulated only if its indent level is
+        # greater than the indent level of the previous mode.
+        if @mode_stack[-2] and not mode_is_block? @mode_stack[-2]
+          return false if line.indent <= @list_indent_stack[-2]
+        end
+        # Special case: Multiple "paragraphs" get accumulated.
+        return true
       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
+      false
+    end
+
+    def buffer_indentation
+      return false
     end
   end                           # class OutputBuffer
 end                             # module Orgmode