piecrust2: piecrust/page.py comparison

comparison piecrust/page.py @ 924:1bb704434ee2

formatting: Remove segment parts, you can use template tags instead. Segment parts were used to switch formatters insides a given content segment, but that's also achievable with template tags like `pcformat` in Jinja to some degree. It's not totally the same but removing it simplifies the code and improves performance.

author	Ludovic Chabant <ludovic@chabant.com>
date	Sun, 01 Oct 2017 20:36:04 -0700
parents	d1095774bfcf
children	84d8fadf9e67

comparison

equal deleted inserted replaced

-:5713b6a2850d
+:1bb704434ee2
 class ContentSegment(object):
 debug_render_func = 'debug_render'
-def __init__(self):
-self.parts = []
-def debug_render(self):
-return '\n'.join([p.content for p in self.parts])
-class ContentSegmentPart(object):
 def __init__(self, content, fmt=None, offset=-1, line=-1):
 self.content = content
 self.fmt = fmt
 self.offset = offset
 self.line = line
-def __str__(self):
+def debug_render(self):
-return '%s [%s]' % (self.content, self.fmt or '<default>')
+return '[%s] %s' % (self.fmt or '<none>', self.content)
 def json_load_segments(data):
 segments = {}
-for key, seg_data in data.items():
+for key, sd in data.items():
-seg = ContentSegment()
+seg = ContentSegment(sd['c'], sd['f'], sd['o'], sd['l'])
-for p_data in seg_data:
-part = ContentSegmentPart(p_data['c'], p_data['f'], p_data['o'],
-p_data['l'])
-seg.parts.append(part)
 segments[key] = seg
 return segments
 def json_save_segments(segments):
 data = {}
 for key, seg in segments.items():
-seg_data = []
+seg_data = {
-for part in seg.parts:
+'c': seg.content, 'f': seg.fmt, 'o': seg.offset, 'l': seg.line}
-p_data = {'c': part.content, 'f': part.fmt, 'o': part.offset,
-'l': part.line}
-seg_data.append(p_data)
 data[key] = seg_data
 return data
 def load_page(source, content_item):
 segment_pattern = re.compile(
 r"""^\-\-\-\s*(?P<name>\w+)(\:(?P<fmt>\w+))?\s*\-\-\-\s*$""",
 re.M)
-part_pattern = re.compile(
-r"""^<\-\-\s*(?P<fmt>\w+)\s*\-\->\s*$""",
-re.M)
+def _count_lines(txt, start=0, end=-1):
+cur = start
+line_count = 1
-def _count_lines(s):
+while True:
-return len(s.split('\n'))
+nex = txt.find('\n', cur)
+if nex < 0:
+break
+cur = nex + 1
+line_count += 1
+if end >= 0 and cur >= end:
+break
+return line_count
 def _string_needs_parsing(txt, offset):
 txtlen = len(txt)
 index = txt.find('-', offset)
 while index >= 0 and index < txtlen - 8:
-# Look for a potential `<--format-->`
-if index > 0 and txt[index - 1] == '<' and txt[index + 1] == '-':
-return True
 # Look for a potential `---segment---`
-if txt[index + 1] == '-' and txt[index + 2] == '-':
+if (index > 0 and
+txt[index - 1] == '\n' and
+txt[index + 1] == '-' and txt[index + 2] == '-'):
 return True
 index = txt.find('-', index + 1)
 return False
 def parse_segments(raw, offset=0):
 # Get the number of lines in the header.
-header_lines = _count_lines(raw[:offset].rstrip())
+header_lines = _count_lines(raw, 0, offset)
 current_line = header_lines
 # Figure out if we need any parsing.
 do_parse = _string_needs_parsing(raw, offset)
 if not do_parse:
-seg = ContentSegment()
+seg = ContentSegment(raw[offset:], None, offset, current_line)
-seg.parts = [
-ContentSegmentPart(raw[offset:], None, offset, current_line)]
 return {'content': seg}
-# Start parsing segments and parts.
+# Start parsing segments.
 matches = list(segment_pattern.finditer(raw, offset))
 num_matches = len(matches)
 if num_matches > 0:
 contents = {}
 first_offset = matches[0].start()
 if first_offset > 0:
 # There's some default content segment at the beginning.
-seg = ContentSegment()
+seg = ContentSegment(
-seg.parts, current_line = parse_segment_parts(
+raw[offset:first_offset], None, offset, current_line)
-raw, offset, first_offset, current_line)
+current_line += _count_lines(seg.content)
 contents['content'] = seg
 for i in range(1, num_matches):
 m1 = matches[i - 1]
 m2 = matches[i]
-seg = ContentSegment()
-seg.parts, current_line = parse_segment_parts(
+cur_seg_start = m1.end() + 1
-raw, m1.end() + 1, m2.start(), current_line,
+cur_seg_end = m2.start()
-m1.group('fmt'))
+seg = ContentSegment(
+raw[cur_seg_start:cur_seg_end],
+m1.group('fmt'),
+cur_seg_start,
+current_line)
+current_line += _count_lines(seg.content)
 contents[m1.group('name')] = seg
 # Handle text past the last match.
 lastm = matches[-1]
-seg = ContentSegment()
-seg.parts, current_line = parse_segment_parts(
+last_seg_start = lastm.end()
-raw, lastm.end() + 1, len(raw), current_line,
-lastm.group('fmt'))
+seg = ContentSegment(
+raw[last_seg_start:],
+lastm.group('fmt'),
+last_seg_start,
+current_line)
 contents[lastm.group('name')] = seg
+# No need to count lines for the last one.
 return contents
 else:
 # No segments, just content.
-seg = ContentSegment()
+seg = ContentSegment(raw[offset:], None, offset, current_line)
-seg.parts, current_line = parse_segment_parts(
-raw, offset, len(raw), current_line)
 return {'content': seg}
-def parse_segment_parts(raw, start, end, line_offset, first_part_fmt=None):
-matches = list(part_pattern.finditer(raw, start, end))
-num_matches = len(matches)
-if num_matches > 0:
-parts = []
-# First part, before the first format change.
-part_text = raw[start:matches[0].start()]
-parts.append(
-ContentSegmentPart(part_text, first_part_fmt, start,
-line_offset))
-line_offset += _count_lines(part_text)
-for i in range(1, num_matches):
-m1 = matches[i - 1]
-m2 = matches[i]
-part_text = raw[m1.end() + 1:m2.start()]
-parts.append(
-ContentSegmentPart(
-part_text, m1.group('fmt'), m1.end() + 1,
-line_offset))
-line_offset += _count_lines(part_text)
-lastm = matches[-1]
-part_text = raw[lastm.end() + 1:end]
-parts.append(ContentSegmentPart(
-part_text, lastm.group('fmt'), lastm.end() + 1,
-line_offset))
-return parts, line_offset
-else:
-part_text = raw[start:end]
-parts = [ContentSegmentPart(part_text, first_part_fmt, start,
-line_offset)]
-return parts, line_offset

Mercurial > piecrust2

comparison piecrust/page.py @ 924:1bb704434ee2