Node

class
Superclass
Object
Included Modules
Inversion::AbstractClass
Extended With
Loggability

Inversion template node base class. Template text is parsed by the Inversion::Parser into nodes, and appended to a tree that is later walked when the template is rendered.

This class is abstract; it just defines the API that other nodes are expected to implement.

Attributes

colnum[R]

The column number the node was parsed from in the template source (if known)

linenum[R]

The line number the node was parsed from in the template source (if known)

Public Class Methods

anchor
new( body, linenum=nil, colnum=nil )

Create a new TextNode with the specified source.

# File lib/inversion/template/node.rb, line 24
def initialize( body, linenum=nil, colnum=nil )
        @body    = body
        @linenum = linenum
        @colnum  = colnum
end

Public Instance Methods

anchor
after_append( state )
Alias for: after_appending
anchor
after_appending( state )

Default (no-op) implementation of the #after_appending callback. This exists so defining the append callbacks are optional for Node's subclasses.

# File lib/inversion/template/node.rb, line 83
def after_appending( state )
        # Nothing to do
        return nil
end
Also aliased as: after_append
anchor
after_render( state=nil )
Alias for: after_rendering
anchor
after_rendering( state=nil )

Default (no-op) implementation of the #after_rendering callback. This exists so defining the rendering callbacks are optional for Node's subclasses.

# File lib/inversion/template/node.rb, line 101
def after_rendering( state=nil )
        # Nothing to do
        return nil
end
Also aliased as: after_render
anchor
as_comment_body()

Render the node as a comment

# File lib/inversion/template/node.rb, line 50
def as_comment_body
        return self.inspect
end
anchor
before_append( state )
Alias for: before_appending
anchor
before_appending( state )

Default (no-op) implementation of the #before_appending callback. This exists so defining the append callbacks are optional for Node's subclasses.

# File lib/inversion/template/node.rb, line 74
def before_appending( state )
        # Nothing to do
        return nil
end
Also aliased as: before_append
anchor
before_render( state=nil )
Alias for: before_rendering
anchor
before_rendering( state=nil )

Default (no-op) implementation of the #before_rendering callback. This exists so defining the rendering callbacks are optional for Node's subclasses.

# File lib/inversion/template/node.rb, line 92
def before_rendering( state=nil )
        # Nothing to do
        return nil
end
Also aliased as: before_render
anchor
container?()
Alias for: is_container?
anchor
is_container?()

Returns true if the node introduces a new parsing/rendering scope.

# File lib/inversion/template/node.rb, line 56
def is_container?
        return false
end
Also aliased as: container?
anchor
location()

Return the location of the tag in the template, if it was parsed from one (i.e., if it was created with a StringScanner)

# File lib/inversion/template/node.rb, line 64
def location
        return "line %s, column %s" % [
                self.linenum || '??',
                self.colnum  || '??',
        ]
end
anchor
render( render_state )

Render the node using the given render_state. By default, rendering a node returns nil.

# File lib/inversion/template/node.rb, line 44
def render( render_state )
        return nil
end