org-ruby 0.3.0 → 0.4.0

data/lib/org-ruby/output_buffer.rb

@@ -1,154 +1,172 @@
-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
+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
+
+    # call-seq:
+    #     continue_current_list?  => boolean
+    #
+    # Tests if the line should continue the current list.
+    def continue_current_list?(line)
+    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,76 +1,80 @@
-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
-    
-    # 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
-
-    # Converts the loaded org-mode file to HTML.
-    def to_html
-      output = ""
-      output << Line.to_html(@header_lines)
-      @headlines.each do |headline|
-        output << headline.to_html
-      end
-      rp = RubyPants.new(output)
-      rp.to_html
-    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
+    
+    # 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
+
+    # Converts the loaded org-mode file to HTML.
+    def to_html
+      output = ""
+      decorate = true
+      output << Line.to_html(@header_lines, :decorate_title => decorate)
+      decorate = (output.length == 0)
+      @headlines.each do |headline|
+        output << headline.to_html(:decorate_title => decorate)
+        decorate = (output.length == 0)
+      end
+      rp = RubyPants.new(output)
+      rp.to_html
+    end
+  end                             # class Parser
+end                               # module Orgmode