### Home Classes Methods

### In Files

- lib/maruku/defaults.rb
- lib/maruku/ext/div.rb
- lib/maruku/ext/math/elements.rb
- lib/maruku/helpers.rb
- lib/maruku/output/to_s.rb
- lib/maruku/structures.rb
- lib/maruku/structures_inspect.rb
- lib/maruku/structures_iterators.rb
- lib/maruku.rb

### Parent

Object

### Methods

- ::new
- #==
- #children_inspect
- #children_to_s
- #each_element
- #generate_id
- #get_setting
- #inspect
- #inspect2
- #md_div
- #md_equation
- #md_inline_math
- #replace_each_string
- #to_s

### Included Modules

- REXML
- MaRuKu
- MaRuKu::Out::Markdown
- MaRuKu::Out::HTML
- MaRuKu::Out::Latex
- MaRuKu::Strings
- MaRuKu::Helpers
- MaRuKu::Errors

### Class/Module Index

Quicksearch

- MaRuKu
- MaRuKu::Errors
- MaRuKu::Exception
- MaRuKu::Helpers
- MaRuKu::In
- MaRuKu::In::Markdown
- MaRuKu::In::Markdown::BlockLevelParser
- MaRuKu::In::Markdown::BlockLevelParser::BlockContext
- MaRuKu::In::Markdown::BlockLevelParser::LineSource
- MaRuKu::In::Markdown::SpanExtension
- MaRuKu::In::Markdown::SpanLevelParser
- MaRuKu::In::Markdown::SpanLevelParser::CharSourceDebug
- MaRuKu::In::Markdown::SpanLevelParser::CharSourceManual
- MaRuKu::In::Markdown::SpanLevelParser::CharSourceStrscan
- MaRuKu::In::Markdown::SpanLevelParser::HTMLHelper
- MaRuKu::In::Markdown::SpanLevelParser::SpanContext
- MaRuKu::MDDocument
- MaRuKu::MDElement
- MaRuKu::Out
- MaRuKu::Out::HTML
- MaRuKu::Out::Latex
- MaRuKu::Out::Latex::LatexEntity
- MaRuKu::Out::Markdown
- MaRuKu::Section
- MaRuKu::Strings
- MaRuKu::Tests
- Array
- Hash
- Maruku
- Module
- NilClass
- Object
- String
- Textile2Signature

No matching classes.

# MaRuKu::MDElement

I did not want to have a class for each possible element. Instead I opted to have only the class "MDElement" that represents eveything in the document (paragraphs, headers, etc).

You can tell what it is by the variable `node_type`.

In the instance-variable `children` there are the children. These can be of class 1) String or 2) MDElement.

The @doc variable points to the document to which the MDElement belongs (which is an instance of Maruku, subclass of MDElement).

Attributes are contained in the hash `attributes`. Keys are symbols (downcased, with spaces substituted by underscores)

For example, if you write in the source document.

    Title: test document
    My property: value

    content content

You can access `value` by writing:

    @doc.attributes[:my_property] # => 'value'

from whichever MDElement in the hierarchy.

### Attributes

doc[RW]

Reference of the document (which is of class Maruku)

meta_priv[RW]

### Public Class Methods

new(node_type=:unset, children=[], meta={}, al=MaRuKu::AttributeList.new ) click to toggle source

    # File lib/maruku/structures.rb, line 95
    def initialize(node_type=:unset, children=[], meta={},
                    al=MaRuKu::AttributeList.new )
            super();
            self.children = children
            self.node_type = node_type

            @attributes = {}

            meta.each do |symbol, value|
                    self.instance_eval "
                      def #{symbol}; @#{symbol}; end
                      def #{symbol}=(val); @#{symbol}=val; end"
                    self.send "#{symbol}=", value
            end

            self.al = al || AttributeList.new

            self.meta_priv = meta
    end

### Public Instance Methods

==(o) click to toggle source

    # File lib/maruku/structures.rb, line 117
            def ==(o)
                    ok = o.kind_of?(MDElement) &&
                    (self.node_type == o.node_type) &&
                    (self.meta_priv == o.meta_priv) &&
                    (self.children == o.children)

                    if not ok
    #                       puts "This:\n"+self.inspect+"\nis different from\n"+o.inspect+"\n\n"
                    end
                    ok
            end

children_inspect(compact=true) click to toggle source

    # File lib/maruku/structures_inspect.rb, line 71
    def children_inspect(compact=true)
            s = @children.inspect_more(compact,', ')
            if @children.empty?
                    "[]"
            elsif s.size < 70
                    s
            else
                    "[\n"+
                    add_tabs(@children.inspect_more(compact,",\n",false))+
                    "\n]"
            end
    end

children_to_s() click to toggle source

    # File lib/maruku/output/to_s.rb, line 31
    def children_to_s
            @children.join
    end

each_element(e_node_type=nil, &block) click to toggle source

Yields to each element of specified node_type All elements if e_node_type is nil.

    # File lib/maruku/structures_iterators.rb, line 28
    def each_element(e_node_type=nil, &block)
            @children.each do |c|
                    if c.kind_of? MDElement
                            if (not e_node_type) || (e_node_type == c.node_type)
                                    block.call c
                            end
                            c.each_element(e_node_type, &block)
                    end
            end
    end

generate_id() click to toggle source

Generate an id for headers. Assumes @children is set.

    # File lib/maruku/output/to_s.rb, line 36
            def generate_id

                    title = children_to_s
                    title.gsub!(/ /,'_')
                    title.downcase!
                    title.gsub!(/[^\w_]/,'')
                    title.strip!

                    if title.size == 0
                            $uid ||= 0
                            $uid += 1
                            title = "id#{$uid}"
                    end

                    # random is a very bad idea
    #               title << "_" + rand(10000).to_s
                    title
            end

get_setting(sym) click to toggle source

    # File lib/maruku/defaults.rb, line 57
    def get_setting(sym)
            if self.attributes.has_key?(sym) then
                    return self.attributes[sym]
            elsif self.doc && self.doc.attributes.has_key?(sym) then
                    return self.doc.attributes[sym]
            elsif MaRuKu::Globals.has_key?(sym)
                    return MaRuKu::Globals[sym]
            else
                    $stderr.puts "Bug: no default for #{sym.inspect}"
                    nil
            end
    end

inspect(compact=true) click to toggle source

    # File lib/maruku/structures_inspect.rb, line 56
    def inspect(compact=true)
            if compact
                    i2 = inspect2
                    return i2 if i2
            end

            "md_el(:%s,%s,%s,%s)" %
            [
                    self.node_type,
                    children_inspect(compact),
                    @meta_priv.inspect_ordered,
                    self.al.inspect
            ]
    end

inspect2() click to toggle source

outputs abbreviated form (this should be eval()uable to get the document)

    # File lib/maruku/helpers.rb, line 195
    def inspect2
            s =
            case @node_type
            when :paragraph
                    "md_par(%s)" % children_inspect
            when :footnote_reference
                    "md_foot_ref(%s)" % self.footnote_id.inspect
            when :entity
                    "md_entity(%s)" % self.entity_name.inspect
            when :email_address
                    "md_email(%s)" % self.email.inspect
            when :inline_code
                    "md_code(%s)" % self.raw_code.inspect
            when :raw_html
                    "md_html(%s)" % self.raw_html.inspect
            when :emphasis
                    "md_em(%s)" % children_inspect
            when :strong
                    "md_strong(%s)" % children_inspect
            when :immediate_link
                    "md_url(%s)" % self.url.inspect
            when :image
                    "md_image(%s, %s)" % [
                            children_inspect,
                            self.ref_id.inspect]
            when :im_image
                    "md_im_image(%s, %s, %s)" % [
                            children_inspect,
                            self.url.inspect,
                            self.title.inspect]
            when :link
                            "md_link(%s,%s)" % [
                                    children_inspect, self.ref_id.inspect]
            when :im_link
                            "md_im_link(%s, %s, %s)" % [
                                    children_inspect,
                                    self.url.inspect,
                                    self.title.inspect,
                            ]
            when :ref_definition
                    "md_ref_def(%s, %s, %s)" % [
                                    self.ref_id.inspect,
                                    self.url.inspect,
                                    self.title.inspect
                            ]
            when :ial
                    "md_ial(%s)" % self.ial.inspect
            else
                    return nil
            end
            if @al and not @al.empty? then
                    s = s.chop + ", #{@al.inspect})"
            end
            s
    end

md_div(children, al=nil) click to toggle source

    # File lib/maruku/ext/div.rb, line 100
    def md_div(children, al=nil)
            type = label = num = nil
            doc.refid2ref ||= {}
            if al
                    al.each do |k, v|
                            case k
                            when :class
                                    type = $1 if v =~ /^num_(\w*)/
                            when :id
                                    label = v
                            end
                    end
            end
            if type
                    doc.refid2ref[type] ||= {}
                    num = doc.refid2ref[type].length + 1 || 1
            end
            e = self.md_el(:div, children, meta={:label => label, :type => type, :num => num}, al)
            if type && label
                    doc.refid2ref[type].update({label => e})
            end
            e
    end

md_equation(math, label, numerate) click to toggle source

    # File lib/maruku/ext/math/elements.rb, line 7
            def md_equation(math, label, numerate)
                    reglabel= /\\label\{(\w+)\}/
                    if math =~ reglabel
                            label = $1
                            math.gsub!(reglabel,'')
                    end
    #               puts "Found label = #{label} math #{math.inspect} "
                    num = nil
                    if (label || numerate) && @doc #take number
                            @doc.eqid2eq ||= {}
                            num = @doc.eqid2eq.size + 1
                            label = "eq#{num}" if not label      # FIXME do id for document
                    end
                    e = self.md_el(:equation, [], meta={:math=>math, :label=>label,:num=>num})
                    if label && @doc #take number
                            @doc.eqid2eq[label] = e
                    end
                    e
            end

md_inline_math(math) click to toggle source

    # File lib/maruku/ext/math/elements.rb, line 3
    def md_inline_math(math)
            self.md_el(:inline_math, [], meta={:math=>math})
    end

replace_each_string(&block) click to toggle source

Apply passed block to each String in the hierarchy.

    # File lib/maruku/structures_iterators.rb, line 40
    def replace_each_string(&block)
            for c in @children
                    if c.kind_of? MDElement
                            c.replace_each_string(&block)
                    end
            end

            processed = []
            until @children.empty?
                    c = @children.shift
                    if c.kind_of? String
                            result = block.call(c)
                            [*result].each do |e| processed << e end
                    else
                            processed << c
                    end
            end
            @children = processed
    end

to_s() click to toggle source

Strips all formatting from the string

    # File lib/maruku/output/to_s.rb, line 27
    def to_s
             children_to_s
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.