scripts.emitter.Emitter Class Reference

Inheritance diagram for scripts.emitter.Emitter:

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

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__()

def 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

Bind()

def 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()

def 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()

def 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()

def 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
 

---

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

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