Lines Matching refs:self
18 def __init__(self, scalar, empty, multiline, argument
22 self.scalar = scalar
23 self.empty = empty
24 self.multiline = multiline
25 self.allow_flow_plain = allow_flow_plain
26 self.allow_block_plain = allow_block_plain
27 self.allow_single_quoted = allow_single_quoted
28 self.allow_double_quoted = allow_double_quoted
29 self.allow_block = allow_block
38 def __init__(self, stream, canonical=None, indent=None, width=None, argument
42 self.stream = stream
45 self.encoding = None
49 self.states = []
50 self.state = self.expect_stream_start
53 self.events = []
54 self.event = None
57 self.indents = []
58 self.indent = None
61 self.flow_level = 0
64 self.root_context = False
65 self.sequence_context = False
66 self.mapping_context = False
67 self.simple_key_context = False
74 self.line = 0
75 self.column = 0
76 self.whitespace = True
77 self.indention = True
80 self.open_ended = False
83 self.canonical = canonical
84 self.allow_unicode = allow_unicode
85 self.best_indent = 2
87 self.best_indent = indent
88 self.best_width = 80
89 if width and width > self.best_indent*2:
90 self.best_width = width
91 self.best_line_break = '\n'
93 self.best_line_break = line_break
96 self.tag_prefixes = None
99 self.prepared_anchor = None
100 self.prepared_tag = None
103 self.analysis = None
104 self.style = None
106 def dispose(self): argument
108 self.states = []
109 self.state = None
111 def emit(self, event): argument
112 self.events.append(event)
113 while not self.need_more_events():
114 self.event = self.events.pop(0)
115 self.state()
116 self.event = None
120 def need_more_events(self): argument
121 if not self.events:
123 event = self.events[0]
125 return self.need_events(1)
127 return self.need_events(2)
129 return self.need_events(3)
133 def need_events(self, count): argument
135 for event in self.events[1:]:
144 return (len(self.events) < count+1)
146 def increase_indent(self, flow=False, indentless=False): argument
147 self.indents.append(self.indent)
148 if self.indent is None:
150 self.indent = self.best_indent
152 self.indent = 0
154 self.indent += self.best_indent
160 def expect_stream_start(self): argument
161 if isinstance(self.event, StreamStartEvent):
162 if self.event.encoding and not hasattr(self.stream, 'encoding'):
163 self.encoding = self.event.encoding
164 self.write_stream_start()
165 self.state = self.expect_first_document_start
168 % self.event)
170 def expect_nothing(self): argument
171 raise EmitterError("expected nothing, but got %s" % self.event)
175 def expect_first_document_start(self): argument
176 return self.expect_document_start(first=True)
178 def expect_document_start(self, first=False): argument
179 if isinstance(self.event, DocumentStartEvent):
180 if (self.event.version or self.event.tags) and self.open_ended:
181 self.write_indicator('...', True)
182 self.write_indent()
183 if self.event.version:
184 version_text = self.prepare_version(self.event.version)
185 self.write_version_directive(version_text)
186 self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
187 if self.event.tags:
188 handles = sorted(self.event.tags.keys())
190 prefix = self.event.tags[handle]
191 self.tag_prefixes[prefix] = handle
192 handle_text = self.prepare_tag_handle(handle)
193 prefix_text = self.prepare_tag_prefix(prefix)
194 self.write_tag_directive(handle_text, prefix_text)
195 implicit = (first and not self.event.explicit and not self.canonical
196 and not self.event.version and not self.event.tags
197 and not self.check_empty_document())
199 self.write_indent()
200 self.write_indicator('---', True)
201 if self.canonical:
202 self.write_indent()
203 self.state = self.expect_document_root
204 elif isinstance(self.event, StreamEndEvent):
205 if self.open_ended:
206 self.write_indicator('...', True)
207 self.write_indent()
208 self.write_stream_end()
209 self.state = self.expect_nothing
212 % self.event)
214 def expect_document_end(self): argument
215 if isinstance(self.event, DocumentEndEvent):
216 self.write_indent()
217 if self.event.explicit:
218 self.write_indicator('...', True)
219 self.write_indent()
220 self.flush_stream()
221 self.state = self.expect_document_start
224 % self.event)
226 def expect_document_root(self): argument
227 self.states.append(self.expect_document_end)
228 self.expect_node(root=True)
232 def expect_node(self, root=False, sequence=False, mapping=False, argument
234 self.root_context = root
235 self.sequence_context = sequence
236 self.mapping_context = mapping
237 self.simple_key_context = simple_key
238 if isinstance(self.event, AliasEvent):
239 self.expect_alias()
240 elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
241 self.process_anchor('&')
242 self.process_tag()
243 if isinstance(self.event, ScalarEvent):
244 self.expect_scalar()
245 elif isinstance(self.event, SequenceStartEvent):
246 if self.flow_level or self.canonical or self.event.flow_style \
247 or self.check_empty_sequence():
248 self.expect_flow_sequence()
250 self.expect_block_sequence()
251 elif isinstance(self.event, MappingStartEvent):
252 if self.flow_level or self.canonical or self.event.flow_style \
253 or self.check_empty_mapping():
254 self.expect_flow_mapping()
256 self.expect_block_mapping()
258 raise EmitterError("expected NodeEvent, but got %s" % self.event)
260 def expect_alias(self): argument
261 if self.event.anchor is None:
263 self.process_anchor('*')
264 self.state = self.states.pop()
266 def expect_scalar(self): argument
267 self.increase_indent(flow=True)
268 self.process_scalar()
269 self.indent = self.indents.pop()
270 self.state = self.states.pop()
274 def expect_flow_sequence(self): argument
275 self.write_indicator('[', True, whitespace=True)
276 self.flow_level += 1
277 self.increase_indent(flow=True)
278 self.state = self.expect_first_flow_sequence_item
280 def expect_first_flow_sequence_item(self): argument
281 if isinstance(self.event, SequenceEndEvent):
282 self.indent = self.indents.pop()
283 self.flow_level -= 1
284 self.write_indicator(']', False)
285 self.state = self.states.pop()
287 if self.canonical or self.column > self.best_width:
288 self.write_indent()
289 self.states.append(self.expect_flow_sequence_item)
290 self.expect_node(sequence=True)
292 def expect_flow_sequence_item(self): argument
293 if isinstance(self.event, SequenceEndEvent):
294 self.indent = self.indents.pop()
295 self.flow_level -= 1
296 if self.canonical:
297 self.write_indicator(',', False)
298 self.write_indent()
299 self.write_indicator(']', False)
300 self.state = self.states.pop()
302 self.write_indicator(',', False)
303 if self.canonical or self.column > self.best_width:
304 self.write_indent()
305 self.states.append(self.expect_flow_sequence_item)
306 self.expect_node(sequence=True)
310 def expect_flow_mapping(self): argument
311 self.write_indicator('{', True, whitespace=True)
312 self.flow_level += 1
313 self.increase_indent(flow=True)
314 self.state = self.expect_first_flow_mapping_key
316 def expect_first_flow_mapping_key(self): argument
317 if isinstance(self.event, MappingEndEvent):
318 self.indent = self.indents.pop()
319 self.flow_level -= 1
320 self.write_indicator('}', False)
321 self.state = self.states.pop()
323 if self.canonical or self.column > self.best_width:
324 self.write_indent()
325 if not self.canonical and self.check_simple_key():
326 self.states.append(self.expect_flow_mapping_simple_value)
327 self.expect_node(mapping=True, simple_key=True)
329 self.write_indicator('?', True)
330 self.states.append(self.expect_flow_mapping_value)
331 self.expect_node(mapping=True)
333 def expect_flow_mapping_key(self): argument
334 if isinstance(self.event, MappingEndEvent):
335 self.indent = self.indents.pop()
336 self.flow_level -= 1
337 if self.canonical:
338 self.write_indicator(',', False)
339 self.write_indent()
340 self.write_indicator('}', False)
341 self.state = self.states.pop()
343 self.write_indicator(',', False)
344 if self.canonical or self.column > self.best_width:
345 self.write_indent()
346 if not self.canonical and self.check_simple_key():
347 self.states.append(self.expect_flow_mapping_simple_value)
348 self.expect_node(mapping=True, simple_key=True)
350 self.write_indicator('?', True)
351 self.states.append(self.expect_flow_mapping_value)
352 self.expect_node(mapping=True)
354 def expect_flow_mapping_simple_value(self): argument
355 self.write_indicator(':', False)
356 self.states.append(self.expect_flow_mapping_key)
357 self.expect_node(mapping=True)
359 def expect_flow_mapping_value(self): argument
360 if self.canonical or self.column > self.best_width:
361 self.write_indent()
362 self.write_indicator(':', True)
363 self.states.append(self.expect_flow_mapping_key)
364 self.expect_node(mapping=True)
368 def expect_block_sequence(self): argument
369 indentless = (self.mapping_context and not self.indention)
370 self.increase_indent(flow=False, indentless=indentless)
371 self.state = self.expect_first_block_sequence_item
373 def expect_first_block_sequence_item(self): argument
374 return self.expect_block_sequence_item(first=True)
376 def expect_block_sequence_item(self, first=False): argument
377 if not first and isinstance(self.event, SequenceEndEvent):
378 self.indent = self.indents.pop()
379 self.state = self.states.pop()
381 self.write_indent()
382 self.write_indicator('-', True, indention=True)
383 self.states.append(self.expect_block_sequence_item)
384 self.expect_node(sequence=True)
388 def expect_block_mapping(self): argument
389 self.increase_indent(flow=False)
390 self.state = self.expect_first_block_mapping_key
392 def expect_first_block_mapping_key(self): argument
393 return self.expect_block_mapping_key(first=True)
395 def expect_block_mapping_key(self, first=False): argument
396 if not first and isinstance(self.event, MappingEndEvent):
397 self.indent = self.indents.pop()
398 self.state = self.states.pop()
400 self.write_indent()
401 if self.check_simple_key():
402 self.states.append(self.expect_block_mapping_simple_value)
403 self.expect_node(mapping=True, simple_key=True)
405 self.write_indicator('?', True, indention=True)
406 self.states.append(self.expect_block_mapping_value)
407 self.expect_node(mapping=True)
409 def expect_block_mapping_simple_value(self): argument
410 self.write_indicator(':', False)
411 self.states.append(self.expect_block_mapping_key)
412 self.expect_node(mapping=True)
414 def expect_block_mapping_value(self): argument
415 self.write_indent()
416 self.write_indicator(':', True, indention=True)
417 self.states.append(self.expect_block_mapping_key)
418 self.expect_node(mapping=True)
422 def check_empty_sequence(self): argument
423 return (isinstance(self.event, SequenceStartEvent) and self.events
424 and isinstance(self.events[0], SequenceEndEvent))
426 def check_empty_mapping(self): argument
427 return (isinstance(self.event, MappingStartEvent) and self.events
428 and isinstance(self.events[0], MappingEndEvent))
430 def check_empty_document(self): argument
431 if not isinstance(self.event, DocumentStartEvent) or not self.events:
433 event = self.events[0]
437 def check_simple_key(self): argument
439 if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
440 if self.prepared_anchor is None:
441 self.prepared_anchor = self.prepare_anchor(self.event.anchor)
442 length += len(self.prepared_anchor)
443 if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \
444 and self.event.tag is not None:
445 if self.prepared_tag is None:
446 self.prepared_tag = self.prepare_tag(self.event.tag)
447 length += len(self.prepared_tag)
448 if isinstance(self.event, ScalarEvent):
449 if self.analysis is None:
450 self.analysis = self.analyze_scalar(self.event.value)
451 length += len(self.analysis.scalar)
452 return (length < 128 and (isinstance(self.event, AliasEvent)
453 or (isinstance(self.event, ScalarEvent)
454 and not self.analysis.empty and not self.analysis.multiline)
455 or self.check_empty_sequence() or self.check_empty_mapping()))
459 def process_anchor(self, indicator): argument
460 if self.event.anchor is None:
461 self.prepared_anchor = None
463 if self.prepared_anchor is None:
464 self.prepared_anchor = self.prepare_anchor(self.event.anchor)
465 if self.prepared_anchor:
466 self.write_indicator(indicator+self.prepared_anchor, True)
467 self.prepared_anchor = None
469 def process_tag(self): argument
470 tag = self.event.tag
471 if isinstance(self.event, ScalarEvent):
472 if self.style is None:
473 self.style = self.choose_scalar_style()
474 if ((not self.canonical or tag is None) and
475 ((self.style == '' and self.event.implicit[0])
476 or (self.style != '' and self.event.implicit[1]))):
477 self.prepared_tag = None
479 if self.event.implicit[0] and tag is None:
481 self.prepared_tag = None
483 if (not self.canonical or tag is None) and self.event.implicit:
484 self.prepared_tag = None
488 if self.prepared_tag is None:
489 self.prepared_tag = self.prepare_tag(tag)
490 if self.prepared_tag:
491 self.write_indicator(self.prepared_tag, True)
492 self.prepared_tag = None
494 def choose_scalar_style(self): argument
495 if self.analysis is None:
496 self.analysis = self.analyze_scalar(self.event.value)
497 if self.event.style == '"' or self.canonical:
499 if not self.event.style and self.event.implicit[0]:
500 if (not (self.simple_key_context and
501 (self.analysis.empty or self.analysis.multiline))
502 and (self.flow_level and self.analysis.allow_flow_plain
503 or (not self.flow_level and self.analysis.allow_block_plain))):
505 if self.event.style and self.event.style in '|>':
506 if (not self.flow_level and not self.simple_key_context
507 and self.analysis.allow_block):
508 return self.event.style
509 if not self.event.style or self.event.style == '\'':
510 if (self.analysis.allow_single_quoted and
511 not (self.simple_key_context and self.analysis.multiline)):
515 def process_scalar(self): argument
516 if self.analysis is None:
517 self.analysis = self.analyze_scalar(self.event.value)
518 if self.style is None:
519 self.style = self.choose_scalar_style()
520 split = (not self.simple_key_context)
524 if self.style == '"':
525 self.write_double_quoted(self.analysis.scalar, split)
526 elif self.style == '\'':
527 self.write_single_quoted(self.analysis.scalar, split)
528 elif self.style == '>':
529 self.write_folded(self.analysis.scalar)
530 elif self.style == '|':
531 self.write_literal(self.analysis.scalar)
533 self.write_plain(self.analysis.scalar, split)
534 self.analysis = None
535 self.style = None
539 def prepare_version(self, version): argument
545 def prepare_tag_handle(self, handle): argument
557 def prepare_tag_prefix(self, prefix): argument
580 def prepare_tag(self, tag): argument
587 prefixes = sorted(self.tag_prefixes.keys())
591 handle = self.tag_prefixes[prefix]
616 def prepare_anchor(self, anchor): argument
626 def analyze_scalar(self, scalar): argument
704 if not self.allow_unicode:
788 def flush_stream(self): argument
789 if hasattr(self.stream, 'flush'):
790 self.stream.flush()
792 def write_stream_start(self): argument
794 if self.encoding and self.encoding.startswith('utf-16'):
795 self.stream.write('\uFEFF'.encode(self.encoding))
797 def write_stream_end(self): argument
798 self.flush_stream()
800 def write_indicator(self, indicator, need_whitespace, argument
802 if self.whitespace or not need_whitespace:
806 self.whitespace = whitespace
807 self.indention = self.indention and indention
808 self.column += len(data)
809 self.open_ended = False
810 if self.encoding:
811 data = data.encode(self.encoding)
812 self.stream.write(data)
814 def write_indent(self): argument
815 indent = self.indent or 0
816 if not self.indention or self.column > indent \
817 or (self.column == indent and not self.whitespace):
818 self.write_line_break()
819 if self.column < indent:
820 self.whitespace = True
821 data = ' '*(indent-self.column)
822 self.column = indent
823 if self.encoding:
824 data = data.encode(self.encoding)
825 self.stream.write(data)
827 def write_line_break(self, data=None): argument
829 data = self.best_line_break
830 self.whitespace = True
831 self.indention = True
832 self.line += 1
833 self.column = 0
834 if self.encoding:
835 data = data.encode(self.encoding)
836 self.stream.write(data)
838 def write_version_directive(self, version_text): argument
840 if self.encoding:
841 data = data.encode(self.encoding)
842 self.stream.write(data)
843 self.write_line_break()
845 def write_tag_directive(self, handle_text, prefix_text): argument
847 if self.encoding:
848 data = data.encode(self.encoding)
849 self.stream.write(data)
850 self.write_line_break()
854 def write_single_quoted(self, text, split=True): argument
855 self.write_indicator('\'', True)
865 if start+1 == end and self.column > self.best_width and split \
867 self.write_indent()
870 self.column += len(data)
871 if self.encoding:
872 data = data.encode(self.encoding)
873 self.stream.write(data)
878 self.write_line_break()
881 self.write_line_break()
883 self.write_line_break(br)
884 self.write_indent()
890 self.column += len(data)
891 if self.encoding:
892 data = data.encode(self.encoding)
893 self.stream.write(data)
897 self.column += 2
898 if self.encoding:
899 data = data.encode(self.encoding)
900 self.stream.write(data)
906 self.write_indicator('\'', False)
926 def write_double_quoted(self, text, split=True): argument
927 self.write_indicator('"', True)
935 or (self.allow_unicode
940 self.column += len(data)
941 if self.encoding:
942 data = data.encode(self.encoding)
943 self.stream.write(data)
946 if ch in self.ESCAPE_REPLACEMENTS:
947 data = '\\'+self.ESCAPE_REPLACEMENTS[ch]
954 self.column += len(data)
955 if self.encoding:
956 data = data.encode(self.encoding)
957 self.stream.write(data)
960 and self.column+(end-start) > self.best_width and split:
964 self.column += len(data)
965 if self.encoding:
966 data = data.encode(self.encoding)
967 self.stream.write(data)
968 self.write_indent()
969 self.whitespace = False
970 self.indention = False
973 self.column += len(data)
974 if self.encoding:
975 data = data.encode(self.encoding)
976 self.stream.write(data)
978 self.write_indicator('"', False)
980 def determine_block_hints(self, text): argument
984 hints += str(self.best_indent)
991 def write_folded(self, text): argument
992 hints = self.determine_block_hints(text)
993 self.write_indicator('>'+hints, True)
995 self.open_ended = True
996 self.write_line_break()
1009 self.write_line_break()
1013 self.write_line_break()
1015 self.write_line_break(br)
1017 self.write_indent()
1021 if start+1 == end and self.column > self.best_width:
1022 self.write_indent()
1025 self.column += len(data)
1026 if self.encoding:
1027 data = data.encode(self.encoding)
1028 self.stream.write(data)
1033 self.column += len(data)
1034 if self.encoding:
1035 data = data.encode(self.encoding)
1036 self.stream.write(data)
1038 self.write_line_break()
1045 def write_literal(self, text): argument
1046 hints = self.determine_block_hints(text)
1047 self.write_indicator('|'+hints, True)
1049 self.open_ended = True
1050 self.write_line_break()
1061 self.write_line_break()
1063 self.write_line_break(br)
1065 self.write_indent()
1070 if self.encoding:
1071 data = data.encode(self.encoding)
1072 self.stream.write(data)
1074 self.write_line_break()
1080 def write_plain(self, text, split=True): argument
1081 if self.root_context:
1082 self.open_ended = True
1085 if not self.whitespace:
1087 self.column += len(data)
1088 if self.encoding:
1089 data = data.encode(self.encoding)
1090 self.stream.write(data)
1091 self.whitespace = False
1092 self.indention = False
1102 if start+1 == end and self.column > self.best_width and split:
1103 self.write_indent()
1104 self.whitespace = False
1105 self.indention = False
1108 self.column += len(data)
1109 if self.encoding:
1110 data = data.encode(self.encoding)
1111 self.stream.write(data)
1116 self.write_line_break()
1119 self.write_line_break()
1121 self.write_line_break(br)
1122 self.write_indent()
1123 self.whitespace = False
1124 self.indention = False
1129 self.column += len(data)
1130 if self.encoding:
1131 data = data.encode(self.encoding)
1132 self.stream.write(data)