scripts.emitter.Emitter Class Reference

Inheritance diagram for scripts.emitter.Emitter:

Public Member Functions
	__init__ (self, bindings=None)
	EmitRaw (self, item)
	Emit (self, template_source, **parameters)
	Fragments (self)
	Bind (self, var, template_source, **parameters)

Protected Member Functions
	_Emit (self, template_source, parameters)
	_ParseTemplate (self, source)

Protected Attributes
	_items
	_bindings

Detailed Description

An Emitter collects string fragments to be assembled into a single string.

Definition at line 20 of file emitter.py.

Constructor & Destructor Documentation

__init__()

scripts.emitter.Emitter.__init__	(		self,
			bindings = None
	)

Definition at line 24 of file emitter.py.

    def __init__(self, bindings=None):
        self._items = []  # A new list
        self._bindings = bindings or Emitter.Frame({}, None)
 

Member Function Documentation

_Emit()

scripts.emitter.Emitter._Emit (   self,   template_source,   parameters  )

protected

Implementation of Emit, with map in place of named parameters.

Definition at line 66 of file emitter.py.

    def _Emit(self, template_source, parameters):
        """Implementation of Emit, with map in place of named parameters."""
        template = self._ParseTemplate(template_source)
        parameter_bindings = self._bindings.Extend(parameters)
 
        hole_names = template._holes
 
        if hole_names:
            hole_map = {}
            replacements = {}
            for name in hole_names:
                emitter = Emitter(parameter_bindings)
                replacements[name] = emitter._items
                hole_map[name] = emitter
            full_bindings = parameter_bindings.Extend(replacements)
        else:
            full_bindings = parameter_bindings
 
        self._ApplyTemplate(template, full_bindings, self._items)
 
        # Return None, a singleton or tuple of the hole names.
        if not hole_names:
            return None
        if len(hole_names) == 1:
            return hole_map[hole_names[0]]
        else:
            return tuple(hole_map[name] for name in hole_names)
 

_ParseTemplate()

scripts.emitter.Emitter._ParseTemplate (   self,   source  )

protected

Converts the template string into a Template object.

Definition at line 142 of file emitter.py.

    def _ParseTemplate(self, source):
        """Converts the template string into a Template object."""
        # TODO(sra): Cache the parsing.
        items = []
        holes = []
 
        # Break source into a sequence of text fragments and substitution lookups.
        pos = 0
        while True:
            match = Emitter._SUBST_RE.search(source, pos)
            if not match:
                items.append(source[pos:])
                break
            text_fragment = source[pos:match.start()]
            if text_fragment:
                items.append(text_fragment)
            pos = match.end()
            term = match.group()
            name = match.group(1) or match.group(2)  # $NAME and $(NAME)
            if name:
                item = Emitter.Lookup(name, term, term)
                items.append(item)
                continue
            name = match.group(3) or match.group(4)  # $!NAME and $(!NAME)
            if name:
                item = Emitter.Lookup(name, term, term)
                items.append(item)
                holes.append(name)
                continue
            name = match.group(5) or match.group(6)  # $?NAME and $(?NAME)
            if name:
                item = Emitter.Lookup(name, term, '')
                items.append(item)
                holes.append(name)
                continue
            name = match.group(7)                    # $#NAME(...)
            if name:
                # Since it's possible for this to nest, find the matching right
                # paren for this left paren.
                paren_count = 1
                curr_pos = pos
                while curr_pos < len(source):
                    if source[curr_pos] == ')':
                        paren_count -= 1
                        if paren_count == 0:
                            break
                    elif source[curr_pos] == '(':
                        # Account for nested parentheses
                        paren_count += 1
                    curr_pos += 1
                if curr_pos == len(source):
                    # No matching right paren, so not a lookup. Ignore and
                    # continue.
                    items.append(term)
                    continue
                matched_template = self._ParseTemplate(source[pos:curr_pos])
                if len(matched_template._holes) > 0:
                    raise RuntimeError(
                        '$#NAME syntax cannot contains holes in its arguments')
                item = Emitter.Lookup(name, term, term, matched_template)
                items.append(item)
                # Continue after the right paren
                pos = curr_pos + 1
                continue
            raise RuntimeError('Unexpected group')
 
        if len(holes) != len(set(holes)):
            raise RuntimeError('Cannot have repeated holes %s' % holes)
        return Emitter.Template(items, holes)
 

Bind()

scripts.emitter.Emitter.Bind	(		self,
			var,
			template_source,
		**	parameters
	)

Adds a binding for var to this emitter.

Definition at line 131 of file emitter.py.

    def Bind(self, var, template_source, **parameters):
        """Adds a binding for var to this emitter."""
        template = self._ParseTemplate(template_source)
        if template._holes:
            raise RuntimeError('Cannot have holes in Emitter.Bind')
        bindings = self._bindings.Extend(parameters)
        value = Emitter(bindings)
        value._ApplyTemplate(template, bindings, self._items)
        self._bindings = self._bindings.Extend({var: value._items})
        return value
 

Emit()

scripts.emitter.Emitter.Emit	(		self,
			template_source,
		**	parameters
	)

Emits a template, substituting named parameters and returning emitters to
fill the named holes.

Ordinary substitution occurs at $NAME or $(NAME).  If there is no parameter
called NAME, the text is left as-is. So long as you don't bind FOO as a
parameter, $FOO in the template will pass through to the generated text.

Substitution of $?NAME and $(?NAME) yields an empty string if NAME is not a
parameter.

Values passed as named parameters should be strings or simple integral
values (int or long).

Named holes are created at $!NAME or $(!NAME).  A hole marks a position in
the template that may be filled in later.  An Emitter is returned for each
named hole in the template.  The holes are filled by emitting to the
corresponding emitter.

Subtemplates can be created by using $#NAME(...), where text can be placed
inside of the parentheses and will conditionally expand depending on if
NAME is set to True or False. The text inside the parentheses may use
further $#NAME and $NAME substitutions, but is not permitted to create
holes.

Emit returns either a single Emitter if the template contains one hole or a
tuple of emitters for several holes, in the order that the holes occur in
the template.

The emitters for the holes remember the parameters passed to the initial
call to Emit.  Holes can be used to provide a binding context.

Definition at line 32 of file emitter.py.

    def Emit(self, template_source, **parameters):
        """Emits a template, substituting named parameters and returning emitters to
    fill the named holes.
 
    Ordinary substitution occurs at $NAME or $(NAME).  If there is no parameter
    called NAME, the text is left as-is. So long as you don't bind FOO as a
    parameter, $FOO in the template will pass through to the generated text.
 
    Substitution of $?NAME and $(?NAME) yields an empty string if NAME is not a
    parameter.
 
    Values passed as named parameters should be strings or simple integral
    values (int or long).
 
    Named holes are created at $!NAME or $(!NAME).  A hole marks a position in
    the template that may be filled in later.  An Emitter is returned for each
    named hole in the template.  The holes are filled by emitting to the
    corresponding emitter.
 
    Subtemplates can be created by using $#NAME(...), where text can be placed
    inside of the parentheses and will conditionally expand depending on if
    NAME is set to True or False. The text inside the parentheses may use
    further $#NAME and $NAME substitutions, but is not permitted to create
    holes.
 
    Emit returns either a single Emitter if the template contains one hole or a
    tuple of emitters for several holes, in the order that the holes occur in
    the template.
 
    The emitters for the holes remember the parameters passed to the initial
    call to Emit.  Holes can be used to provide a binding context.
    """
        return self._Emit(template_source, parameters)
 

EmitRaw()

scripts.emitter.Emitter.EmitRaw	(		self,
			item
	)

Emits literal string with no substitution.

Definition at line 28 of file emitter.py.

    def EmitRaw(self, item):
        """Emits literal string with no substitution."""
        self._items.append(item)
 

Fragments()

scripts.emitter.Emitter.Fragments

(

self

)

Returns a list of all the string fragments emitted.

Definition at line 94 of file emitter.py.

    def Fragments(self):
        """Returns a list of all the string fragments emitted."""
 
        def _FlattenTo(item, output):
            if isinstance(item, list):
                for subitem in item:
                    _FlattenTo(subitem, output)
            elif isinstance(item, Emitter.DeferredLookup):
                value = item._environment.Lookup(item._lookup._name,
                                                 item._lookup._value_if_missing)
                if item._lookup._subtemplate:
                    _FlattenSubtemplate(item, value, output)
                else:
                    _FlattenTo(value, output)
            else:
                output.append(str(item))
 
        def _FlattenSubtemplate(item, value, output):
            """Handles subtemplates created by $#NAME(...)"""
            if value is True:
                # Expand items in subtemplate
                _FlattenTo(item._lookup._subitems, output)
            elif value is not False:
                if value != item._lookup._value_if_missing:
                    raise RuntimeError(
                        'Value for NAME in $#NAME(...) syntax must be a boolean'
                    )
                # Expand it into the string literal composed of $#NAME(,
                # the values inside the parentheses, and ).
                _FlattenTo(value, output)
                _FlattenTo(item._lookup._subitems, output)
                _FlattenTo(')', output)
 
        output = []
        _FlattenTo(self._items, output)
        return output
 

Member Data Documentation

_bindings

scripts.emitter.Emitter._bindings

protected

Definition at line 26 of file emitter.py.

_items

scripts.emitter.Emitter._items

protected

Definition at line 25 of file emitter.py.

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/tools/dom/scripts/emitter.py