Class: Inversion::Parser

Inherits:
Object
  • Object
show all
Extended by:
Loggability
Defined in:
lib/inversion/parser.rb

Overview

This is the parser for Inversion templates. It takes template source and returns a tree of Inversion::Template::Node objects (if parsing is successful).

Defined Under Namespace

Classes: State

Constant Summary collapse

TAG_OPEN =

The pattern for matching a tag opening

/[\[<]\?/
TAG_PATTERN =

The pattern for matching a tag.

%r{
	(?<tagstart>#{TAG_OPEN})    # Tag opening: either <? or [?
	(?<tagname>[a-z]\w*)        # The name of the tag
	(?:\s+                      # At least once whitespace character between the tagname and body
	    (?<body>.+?)            # The body of the tag
	)?
	\s*
	(?<tagend>\?[\]>])          # Tag closing: either ?] or ?>
}x
MATCHING_BRACKETS =

Valid tagends by tagstart

{
	'<?' => '?>',
	'[?' => '?]',
}
DEFAULT_OPTIONS =

Default values for parser configuration options.

{
	:ignore_unknown_tags => true,
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(template, options = {}) ⇒ Parser

Create a new Inversion::Parser with the specified config ‘options`.



48
49
50
51
 
# File 'lib/inversion/parser.rb', line 48

def initialize( template, options={} )
	@template = template
	@options  = DEFAULT_OPTIONS.merge( options )
end

Instance Attribute Details

#options ⇒ Object (readonly)

The parser’s config options



59
60
61
 
# File 'lib/inversion/parser.rb', line 59

def options
  @options
end

Instance Method Details

#parse(source, inherited_state = nil) ⇒ Object

Parse the given ‘source` into one or more Inversion::Template::Nodes and return it as an Array.



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
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
147
148
 
# File 'lib/inversion/parser.rb', line 64

def parse( source, inherited_state=nil )
	state = nil

	if inherited_state
		inherited_state.template = @template
		state = inherited_state
	else
		state = Inversion::Parser::State.new( @template, self.options )
	end

	self.log.debug "Starting parse of template source (%0.2fK, %s)" %
		[ source.bytesize/1024.0, source.encoding ]

	t0 = Time.now
	last_pos = last_linenum = last_colnum = 0
	source.scan( TAG_PATTERN ) do |*|
		match = Regexp.last_match
		start_pos, end_pos = match.offset( 0 )
		linenum            = match.pre_match.count( "\n" ) + 1
		colnum             = match.pre_match.length - (match.pre_match.rindex("\n") || -1)

		# Error on <?...?] and vice-versa.
		unless match[:tagend] == MATCHING_BRACKETS[match[:tagstart]]
			raise Inversion::ParseError,
				"malformed tag %p: mismatched start and end brackets at line %d, column %d" %
				[ match[0], linenum, colnum ]
		end

		# Check for nested tags
		if match[0].index( TAG_OPEN, 2 )
			raise Inversion::ParseError, "unclosed or nested tag %p at line %d, column %d" %
				[ match[0], linenum, colnum ]
		end

		# self.log.debug "  found a tag at offset: %d (%p) (line %d, col %d)" %
		#     [ start_pos, abbrevstring(match[0]), linenum, colnum ]

		# If there were characters between the end of the last match and
		# the beginning of the tag, create a text node with them
		unless last_pos == start_pos
			text = match.pre_match[ last_pos..-1 ]
			# self.log.debug "  adding literal text node: %p" % [ abbrevstring(text) ]
			state << Inversion::Template::TextNode.new( text, last_linenum, last_colnum )
		end

		# self.log.debug "  creating tag with tagname: %p, body: %p" %
		#    [ match[:tagname], match[:body] ]

		tag = Inversion::Template::Tag.create( match[:tagname], match[:body], linenum, colnum )
		if tag.nil?
			unless state.options[ :ignore_unknown_tags ]
				raise Inversion::ParseError, "Unknown tag %p at line %d, column %d" %
					[ match[:tagname], linenum, colnum ]
			end

		    tag = Inversion::Template::TextNode.new( match[0], linenum, colnum )
		end

		# self.log.debug "  created tag: %p" % [ tag ]
		state << tag

		# Keep offsets for the next match
		last_pos     = end_pos
		last_linenum = linenum + match[0].count( "\n" )
		last_colnum  = match[0].length - ( match[0].rindex("\n") || -1 )
	end

	# If there are any characters left over after the last tag
	remainder = source[ last_pos..-1 ]
	if remainder && !remainder.empty?
		# self.log.debug "Remainder after last tag: %p" % [ abbrevstring(remainder) ]

		# Detect unclosed tags
		if remainder.index( "<?" ) || remainder.index( "[?" )
			raise Inversion::ParseError,
				"unclosed tag after line %d, column %d" % [ last_linenum, last_colnum ]
		end

		# Add any remaining text as a text node
		state << Inversion::Template::TextNode.new( remainder, last_linenum, last_colnum )
	end
	self.log.debug "  done parsing: %0.5fs" % [ Time.now - t0 ]

	return state.tree
end