org-ruby 0.4.2 → 0.5.0

data/History.txt

@@ -1,3 +1,21 @@
+== 0.5.0 / 2009-12-29
+
+* Parse (but not necessarily *use*) in-buffer settings. The following
+  in-buffer settings *are* used:
+  * Understand the #+TITLE: directive.
+  * Exporting todo keywords (option todo:t)
+  * Numbering headlines (option num:t)
+  * Skipping text before the first headline (option skip:t)
+  * Skipping tables (option |:nil)
+  * Custom todo keywords
+  * EXPORT_SELECT_TAGS and EXPORT_EXLUDE_TAGS for controlling parts of
+    the tree to export
+* Rewrite "file:(blah).org" links to "http:(blah).html" links. This
+  makes the inter-links to other org-mode files work.
+* Uses <th> tags inside table rows that precede table separators.
+* Bugfixes:
+  * Headings now have HTML escaped.
+
 == 0.4.2 / 2009-12-29
 
 * Got rid of the extraneous newline at the start of code blocks.

data/lib/org-ruby.rb

@@ -3,7 +3,7 @@ unless defined? ::OrgRuby
 module OrgRuby
 
   # :stopdoc:
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/org-ruby/headline.rb

@@ -21,6 +21,15 @@ module Orgmode
     # Optional keyword found at the beginning of the headline.
     attr_reader :keyword
 
+    # Valid states for partial export.
+    # exclude::       The entire subtree from this heading should be excluded.
+    # headline_only:: The headline should be exported, but not the body.
+    # all::           Everything should be exported, headline/body/children.
+    ValidExportStates = [:exclude, :headline_only, :all]
+
+    # The export state of this headline. See +ValidExportStates+.
+    attr_accessor :export_state
+
     # This is the regex that matches a line
     LineRegexp = /^\*+\s+/
 
@@ -30,12 +39,13 @@ module Orgmode
     # Special keywords allowed at the start of a line.
     Keywords = %w[TODO DONE]
 
-    KeywordsRegexp = Regexp.new("\\s*(#{Keywords.join('|')})\\s*")
+    KeywordsRegexp = Regexp.new("^(#{Keywords.join('|')})\$")
 
-    def initialize(line)
-      super(line)
+    def initialize(line, parser = nil)
+      super(line, parser)
       @body_lines = []
       @tags = []
+      @export_state = :exclude
       if (@line =~ LineRegexp) then
         @level = $&.strip.length
         @headline_text = $'.strip
@@ -44,10 +54,8 @@ module Orgmode
           @tags.delete_at(0)                 # the first item will be empty; discard
           @headline_text.gsub!(TagsRegexp, "") # Removes the tags from the headline
         end
-        if (@headline_text =~ KeywordsRegexp) then
-          @headline_text = $'
-          @keyword = $1
-        end
+        @keyword = nil
+        parse_keywords
       else
         raise "'#{line}' is not a valid headline"
       end
@@ -67,14 +75,46 @@ module Orgmode
     end
 
     def to_html(opts = {})
+      return "" if @export_state == :exclude
       if opts[:decorate_title]
         decoration = " class=\"title\""
+        opts.delete(:decorate_title)
       else
         decoration = ""
       end
-      output = "<h#{@level}#{decoration}>#{@headline_text}</h#{@level}>\n"
-      output << Line.to_html(@body_lines)
+      output = "<h#{@level}#{decoration}>"
+      if @parser and @parser.export_heading_number? then
+        heading_number = @parser.get_next_headline_number(@level)
+        output << "<span class=\"heading-number heading-number-#{@level}\">#{heading_number} </span>"
+      end
+      if @parser and @parser.export_todo? and @keyword then
+        output << "<span class=\"todo-keyword #{@keyword}\">#{@keyword} </span>"
+      end
+      output << "#{escape(@headline_text)}</h#{@level}>\n"
+      return output if @export_state == :headline_only
+      output << Line.to_html(@body_lines, opts)
       output
     end
+
+    ######################################################################
+    private
+
+    # TODO 2009-12-29 This duplicates escape_buffer! in html_output_buffer. DRY.
+    def escape(str)
+      str = str.gsub(/&/, "&amp;")
+      str = str.gsub(/</, "&lt;")
+      str = str.gsub(/>/, "&gt;")
+      str
+    end
+
+    def parse_keywords
+      re = @parser.custom_keyword_regexp if @parser
+      re ||= KeywordsRegexp
+      words = @headline_text.split
+      if words.length > 0 && words[0] =~ re then
+        @keyword = words[0]
+        @headline_text.sub!(Regexp.new("^#{@keyword}\s*"), "")
+      end
+    end
   end                           # class Headline
 end                             # class Orgmode

data/lib/org-ruby/html_output_buffer.rb

@@ -8,7 +8,8 @@ module Orgmode
       :paragraph => "p",
       :ordered_list => "li",
       :unordered_list => "li",
-      :table_row => "tr"
+      :table_row => "tr",
+      :table_header => "tr"
     }
 
     ModeTag = {
@@ -19,6 +20,8 @@ module Orgmode
       :code => "pre"
     }
 
+    attr_reader :options
+
     def initialize(output, opts = {})
       super(output)
       if opts[:decorate_title] then
@@ -26,13 +29,15 @@ module Orgmode
       else
         @title_decoration = ""
       end
+      @options = opts
+      @logger.debug "HTML export options: #{@options.inspect}"
     end
 
     def push_mode(mode)
       if ModeTag[mode] then
         output_indentation
         @logger.debug "<#{ModeTag[mode]}>\n" 
-        @output << "<#{ModeTag[mode]}>\n" 
+        @output << "<#{ModeTag[mode]}>\n" unless mode == :table and skip_tables?
         # Entering a new mode obliterates the title decoration
         @title_decoration = ""
       end
@@ -44,7 +49,7 @@ module Orgmode
       if ModeTag[m] then
         output_indentation
         @logger.debug "</#{ModeTag[m]}>\n"
-        @output << "</#{ModeTag[m]}>\n"
+        @output << "</#{ModeTag[m]}>\n" unless mode == :table and skip_tables?
       end
     end
 
@@ -60,12 +65,16 @@ module Orgmode
         @output << @buffer << "\n"
       else
         if (@buffer.length > 0) then
-          @logger.debug "FLUSH      ==========> #{@output_type}"
-          output_indentation
-          @output << "<#{HtmlBlockTag[@output_type]}#{@title_decoration}>" \
+          unless buffer_mode_is_table? and skip_tables?
+            @logger.debug "FLUSH      ==========> #{@buffer_mode}"
+            output_indentation
+            @output << "<#{HtmlBlockTag[@output_type]}#{@title_decoration}>" \
             << inline_formatting(@buffer) \
             << "</#{HtmlBlockTag[@output_type]}>\n"
-          @title_decoration = ""
+            @title_decoration = ""
+          else
+            @logger.debug "SKIP       ==========> #{@buffer_mode}"
+          end
         end
       end
       @buffer = ""
@@ -75,6 +84,14 @@ module Orgmode
     ######################################################################
     private
 
+    def skip_tables?
+      @options[:skip_tables]
+    end
+
+    def buffer_mode_is_table?
+      @buffer_mode == :table
+    end
+
     # Escapes any HTML content in the output accumulation buffer @buffer.
     def escape_buffer!
       @buffer.gsub!(/&/, "&amp;")
@@ -105,6 +122,14 @@ module Orgmode
       end
       str = @re_help.rewrite_links(str) do |link, text|
         text ||= link
+        link = link.sub(/^file:(.*)::(.*?)$/) do
+
+          # We don't support search links right now. Get rid of it.
+
+          "file:#{$1}"
+        end
+        link = link.sub(/^file:/i, "") # will default to HTTP
+        link = link.sub(/\.org$/i, ".html")
         "<a href=\"#{link}\">#{text}</a>"
       end
       if (@output_type == :table_row) then
@@ -112,6 +137,11 @@ module Orgmode
         str.gsub!(/\s*\|$/, "</td>")
         str.gsub!(/\s*\|\s*/, "</td><td>")
       end
+      if (@output_type == :table_header) then
+        str.gsub!(/^\|\s*/, "<th>")
+        str.gsub!(/\s*\|$/, "</th>")
+        str.gsub!(/\s*\|\s*/, "</th><th>")
+      end
       str
     end
 

data/lib/org-ruby/line.rb

@@ -11,6 +11,9 @@ module Orgmode
     # TODO 2009-12-20 bdewey: Handle tabs
     attr_reader :indent
 
+    # Backpointer to the parser that owns this line.
+    attr_reader :parser
+
     # 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
@@ -18,7 +21,8 @@ module Orgmode
     # type. This will then affect the value of +paragraph_type+.
     attr_accessor :assigned_paragraph_type
 
-    def initialize(line)
+    def initialize(line, parser = nil)
+      @parser = parser
       @line = line
       @indent = 0
       @line =~ /\s*/
@@ -90,8 +94,13 @@ module Orgmode
       check_assignment_or_regexp(:table_separator, /^\s*\|[-\|\+]*\s*$/)
     end
 
+    # Checks if this line is a table header. 
+    def table_header?
+      @assigned_paragraph_type == :table_header
+    end
+
     def table?
-      table_row? or table_separator?
+      table_row? or table_separator? or table_header?
     end
 
     BlockRegexp = /^\s*#\+(BEGIN|END)_(\w*)/
@@ -108,6 +117,27 @@ module Orgmode
       $2 if @line =~ BlockRegexp
     end
 
+    InBufferSettingRegexp = /^#\+(\w+):\s*(.*)$/
+
+    # call-seq:
+    #     line.in_buffer_setting?         => boolean
+    #     line.in_buffer_setting? { |key, value| ... }
+    #
+    # Called without a block, this method determines if the line
+    # contains an in-buffer setting. Called with a block, the block
+    # will get called if the line contains an in-buffer setting with
+    # the key and value for the setting.
+    def in_buffer_setting?
+      return false if @assigned_paragraph_type && @assigned_paragraph_type != :comment
+      if block_given? then
+        if @line =~ InBufferSettingRegexp
+          yield $1, $2
+        end
+      else
+        @line =~ InBufferSettingRegexp
+      end
+    end
+
     # Determines the paragraph type of the current line.
     def paragraph_type
       return :blank if blank?
@@ -117,6 +147,7 @@ module Orgmode
       return :comment if comment?
       return :table_separator if table_separator?
       return :table_row if table_row?
+      return :table_header if table_header?
       return :paragraph
     end
 
@@ -157,7 +188,7 @@ module Orgmode
             output_buffer << line.line if output_buffer.preserve_whitespace?
           end
 
-        when :table_row
+        when :table_row, :table_header
 
           output_buffer << line.line.lstrip
 

data/lib/org-ruby/output_buffer.rb

@@ -81,13 +81,13 @@ module Orgmode
 
     # Tests if we are entering a table mode.
     def enter_table?
-      ((@output_type == :table_row) || (@output_type == :table_separator)) &&
+      ((@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_separator)) &&
+      ((@output_type != :table_row) && (@output_type != :table_header) && (@output_type != :table_separator)) &&
         (current_mode == :table)
     end
 

data/lib/org-ruby/parser.rb

@@ -17,7 +17,77 @@ module Orgmode
 
     # 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)
@@ -28,20 +98,32 @@ module Orgmode
       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
+            @current_headline = Headline.new line, self
             @headlines << @current_headline
           else
-            line = Line.new line
+            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
@@ -66,7 +148,8 @@ module Orgmode
             @header_lines << line
           end
         end                     # case
-      end
+        previous_line = line
+      end                       # @lines.each
     end                         # initialize
 
     # Creates a new parser from the data in a given file
@@ -87,16 +170,103 @@ module Orgmode
 
     # 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 = ""
-      decorate = true
-      output << Line.to_html(@header_lines, :decorate_title => decorate)
-      decorate = (output.length == 0)
+      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(:decorate_title => decorate)
-        decorate = (output.length == 0)
+        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