Class: Orgmode::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/org-ruby/parser.rb

Overview

Simple routines for loading / saving an ORG file.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(lines, offset = 0) ⇒ Parser

I can construct a parser object either with an array of lines or with a single string that I will split along n boundaries.



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/org-ruby/parser.rb', line 84

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 |text|
    line = Line.new text, self
    mode = :normal if line.end_block? and mode == line.paragraph_type
    mode = :normal if line.property_drawer_end_block? and mode == :property_drawer

    case mode
    when :normal, :quote, :center
      if Headline.headline? line.line
        line = Headline.new line.line, self, offset
      elsif line.table_separator?
        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?

    when :example, :html, :src
      # As long as we stay in code mode, force lines to be code.
      # Don't try to interpret structural items, like headings and tables.
      line.assigned_paragraph_type = :code
    end

    if mode == :normal
      @headlines << @current_headline = line if Headline.headline? line.line
      # If there is a setting on this line, remember it.
      line.in_buffer_setting? do |key, value|
        store_in_buffer_setting key.upcase, value
      end

      mode = line.paragraph_type if line.begin_block?
      mode = :property_drawer if line.property_drawer_begin_block?
    end

    unless mode == :comment
      if @current_headline
        @current_headline.body_lines << line
      else
        @header_lines << line
      end
    end

    previous_line = line
  end                       # @lines.each
end

Instance Attribute Details

#custom_keywords ⇒ Object (readonly)

Array of custom keywords.



28
29
30
 
# File 'lib/org-ruby/parser.rb', line 28

def custom_keywords
  @custom_keywords
end

#header_lines ⇒ Object (readonly)

These are any lines before the first headline



18
19
20
 
# File 'lib/org-ruby/parser.rb', line 18

def header_lines
  @header_lines
end

#headlines ⇒ Object (readonly)

All of the headlines in the org file



15
16
17
 
# File 'lib/org-ruby/parser.rb', line 15

def headlines
  @headlines
end

#in_buffer_settings ⇒ Object (readonly)

This contains any in-buffer settings from the org-mode file. See orgmode.org/manual/In_002dbuffer-settings.html#In_002dbuffer-settings



22
23
24
 
# File 'lib/org-ruby/parser.rb', line 22

def in_buffer_settings
  @in_buffer_settings
end

#lines ⇒ Object (readonly)

All of the lines of the orgmode file



12
13
14
 
# File 'lib/org-ruby/parser.rb', line 12

def lines
  @lines
end

#options ⇒ Object (readonly)

This contains in-buffer options; a special case of in-buffer settings.



25
26
27
 
# File 'lib/org-ruby/parser.rb', line 25

def options
  @options
end

Class Method Details

.load(fname) ⇒ Object

Creates a new parser from the data in a given file



149
150
151
152
 
# File 'lib/org-ruby/parser.rb', line 149

def self.load(fname)
  lines = IO.readlines(fname)
  return self.new(lines)
end

Instance Method Details

#custom_keyword_regexp ⇒ Object

Regexp that recognizes words in custom_keywords.



31
32
33
34
 
# File 'lib/org-ruby/parser.rb', line 31

def custom_keyword_regexp
  return nil if @custom_keywords.empty?
  Regexp.new("^(#{@custom_keywords.join('|')})\$")
end

#export_exclude_tags ⇒ Object

A set of tags that, if present on any headlines in the org-file, means that subtree will not get exported.



45
46
47
48
 
# File 'lib/org-ruby/parser.rb', line 45

def export_exclude_tags
  return Array.new unless @in_buffer_settings["EXPORT_EXCLUDE_TAGS"]
  @in_buffer_settings["EXPORT_EXCLUDE_TAGS"].split
end

#export_footnotes? ⇒ Boolean

Returns true if we are to export footnotes

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/org-ruby/parser.rb', line 56

def export_footnotes?
  "t" == @options["f"]
end

#export_heading_number? ⇒ Boolean

Returns true if we are to export heading numbers.

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/org-ruby/parser.rb', line 61

def export_heading_number?
  "t" == @options["num"]
end

#export_select_tags ⇒ Object

A set of tags that, if present on any headlines in the org-file, means only those headings will get exported.



38
39
40
41
 
# File 'lib/org-ruby/parser.rb', line 38

def export_select_tags
  return Array.new unless @in_buffer_settings["EXPORT_SELECT_TAGS"]
  @in_buffer_settings["EXPORT_SELECT_TAGS"].split
end

#export_tables? ⇒ Boolean

Should we export tables? Defaults to true, must be overridden with an explicit “nil”

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/org-ruby/parser.rb', line 72

def export_tables?
  "nil" != @options["|"]
end

#export_todo? ⇒ Boolean

Returns true if we are to export todo keywords on headings.

Returns:

  • (Boolean) 


51
52
53
 
# File 'lib/org-ruby/parser.rb', line 51

def export_todo?
  "t" == @options["todo"]
end

#skip_header_lines? ⇒ Boolean

Should we skip exporting text before the first heading?

Returns:

  • (Boolean) 


66
67
68
 
# File 'lib/org-ruby/parser.rb', line 66

def skip_header_lines?
  "t" == @options["skip"]
end

#to_html ⇒ Object

Converts the loaded org-mode file to HTML.



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/org-ruby/parser.rb', line 167

def to_html
  mark_trees_for_export
  export_options = {
    :decorate_title => @in_buffer_settings["TITLE"],
    :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)
    translate([title], output_buffer)
  end
  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
      translate(headline.body_lines[0, 1], output_buffer)
    when :all
      translate(headline.body_lines, output_buffer)
    end
  end
  output << "\n"

  rp = RubyPants.new(output)
  rp.to_html
end

#to_textile ⇒ Object

Saves the loaded orgmode file as a textile file.



155
156
157
158
159
160
161
162
163
164
 
# File 'lib/org-ruby/parser.rb', line 155

def to_textile
  output = ""
  output_buffer = TextileOutputBuffer.new(output)

  translate(@header_lines, output_buffer)
  @headlines.each do |headline|
    translate(headline.body_lines, output_buffer)
  end
  output
end

#use_sub_superscripts? ⇒ Boolean

Should we export sub/superscripts? (_foo/^foo) only {} mode is currently supported.

Returns:

  • (Boolean) 


78
79
80
 
# File 'lib/org-ruby/parser.rb', line 78

def use_sub_superscripts?
  @options["^"] != "nil"
end