def render_steps(steps, conf):
r = RstCloth()
header_html = ('<div class="sequence-block">'
'<div class="bullet-block">'
'<div class="sequence-step">'
'{0}'
'</div>'
'</div>')
for idx, step in enumerate(steps.steps):
step.render() # run replacements
if 'number' not in step:
step.number = idx
r.directive('only', 'html or dirhtml or singlehtml')
r.newline()
r.directive(name='raw',
arg='html',
content=header_html.format(step.number),
indent=3)
r.newline()
if 'heading' in step:
r.heading(text=step.heading,
char=character_levels[step.level],
indent=3)
r.newline()
render_step_content(step, 3, r)
r.directive(name='raw',
arg='html',
content="</div>",
indent=3)
r.newline()
r.directive('only', 'latex or epub')
r.newline()
if 'heading' in step:
r.heading(text="Step {0}: {1}".format(step.number, step.heading),
char=character_levels[step.level],
indent=3)
r.newline()
else:
r.heading(text="Step {0}".format(step.number),
char=character_levels[step.level],
indent=3)
r.newline()
render_step_content(step, 3, r)
return r
def render_steps(steps, conf):
r = RstCloth()
header_html = ('<div class="sequence-block">'
'<div class="bullet-block">'
'<div class="sequence-step">'
'{0}'
'</div>'
'</div>')
for idx, step in enumerate(steps.ordered_content()):
step.render() # run replacements
if 'number' not in step:
step.number = idx
r.directive('only', 'html or dirhtml or singlehtml')
r.newline()
r.directive(name='raw',
arg='html',
content=header_html.format(step.number),
indent=3)
r.newline()
if 'heading' in step:
r.heading(text=step.heading,
char=character_levels[step.level],
indent=3)
r.newline()
render_step_content(step, 3, r)
r.directive(name='raw',
arg='html',
content="</div>",
indent=3)
r.newline()
r.directive('only', 'not(html or dirhtml or singlehtml)')
r.newline()
if 'heading' in step:
r.heading(text="Step {0}: {1}".format(step.number, step.heading),
char=character_levels[step.level],
indent=3)
r.newline()
else:
r.heading(text="Step {0}".format(step.number),
char=character_levels[step.level],
indent=3)
r.newline()
render_step_content(step, 3, r)
return r
class StepsOutput(object):
"""
Base class for rendered step form. The render() method generates the rst in
the internal RstCloth object.
"""
def __init__(self, steps, conf):
if not isinstance(steps, Steps):
raise TypeError
else:
self.steps = steps
self.conf = conf
self.current_step = 1
self.rst = RstCloth()
self.hook()
def hook(self):
self.indent = 3
def edition_check(self, step):
return giza.content.helper.edition_check(step, self.conf)
@staticmethod
def annotate_optional(step):
if 'optional' in step and step['optional'] is True:
if isinstance(step['title'], dict):
step['title']['text'] = 'Optional. ' + step['title']['text']
else:
if 'title' in step:
step['title'] = 'Optional. ' + step['title']
elif 'heading' in step:
step['heading'] = 'Optional. ' + step['heading']
del step['optional']
return step
else:
return step
def render(self):
for step in self.steps.source_list:
if self.edition_check(step) is False:
continue
step = self.annotate_optional(step)
self.heading(step)
self.pre(step)
self.current_step = step['stepnum']
if 'action' in step:
if isinstance(step['action'], list):
for block in step['action']:
self.code_step(block)
else:
self.code_step(step['action'])
self.content(step)
self.post(step)
def content(self, doc):
if 'content' in doc and doc['content'] is not None:
self.rst.content(doc['content'], wrap=False, indent=self.indent)
self.rst.newline()
def pre(self, doc):
if 'pre' in doc and doc['pre'] is not None:
self.rst.content(doc['pre'], wrap=False, indent=self.indent)
self.rst.newline()
def post(self, doc, code_step=False):
if 'post' in doc and doc['post'] is not None:
self.rst.content(doc['post'], wrap=False, indent=self.indent)
self.rst.newline()
if code_step is False:
self.post_step_hook()
def post_step_hook(self):
pass
def _heading(self, block, override_char=None, indent=0):
if 'heading' in block:
if isinstance(block['heading'], dict):
if 'character' in block['heading']:
pass
else:
block['heading']['character'] = override_char
else:
block['heading'] = { 'text': block['heading'],
'character': override_char }
if block['heading']['text'] is None:
logger.error('step in "{0}" is missing a heading'.format(os.path.basename(self.steps.source_fn)))
return
self.rst.heading(text=block['heading']['text'],
char=block['heading']['character'],
indent=indent)
self.rst.newline()
def code_step(self, block):
if 'code' in block and 'content' in block:
raise InvalidStep
if 'heading' in block:
self.block_heading(block)
self.pre(block)
if 'code' in block:
if 'language' not in block:
block['language'] = 'none'
if not isinstance(block['code'], list):
block['code'] = block['code'].split('\n')
self.rst.directive(name='code-block',
arg=block['language'],
content=block['code'],
indent=self.indent)
self.rst.newline()
if 'content' in block:
self.content(block['content'])
self.post(block, code_step=True)
def key_name(self):
key_name = os.path.splitext(os.path.basename(self.steps.source_fn))[0]
if key_name.startswith('step-') or key_name.startswith('steps-'):
key_name = key_name.split('-', 1)[1]
return key_name
class TestRstCloth(TestCase):
@classmethod
def setUp(self):
self.r = RstCloth()
def test_adding_without_blocks(self):
self.r._add('foo')
self.assertEqual(self.r.data[0], 'foo')
def test_newline(self):
self.r.newline()
self.assertEqual(len(self.r.data), 1)
def test_multi_newline(self):
self.r.newline(count=4)
self.assertEqual(len(self.r.data[0]), 4 - 1)
def test_directive_simple(self):
self.r.directive('test', block='d0')
self.assertEqual(self.r.data[0], '.. test::')
def test_directive_arg_named(self):
self.r.directive('test', arg='what', block='d3')
self.assertEqual(self.r.data[0], '.. test:: what')
def test_directive_arg_positional(self):
self.r.directive('test', 'what', block='d1')
self.assertEqual(self.r.data[0], '.. test:: what')
def test_directive_fields(self):
self.r.directive('test', fields=[('a', 'b')], block='d2')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], ' :a: b')
def test_directive_fields_with_arg(self):
self.r.directive('test', arg='what', fields=[('a', 'b')], block='d4')
self.assertEqual(self.r.data[0], '.. test:: what')
self.assertEqual(self.r.data[1], ' :a: b')
def test_directive_fields_multiple(self):
self.r.directive('test', fields=[('a', 'b'), ('c', 'd')], block='d5')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], ' :a: b')
self.assertEqual(self.r.data[2], ' :c: d')
def test_directive_fields_multiple_arg(self):
self.r.directive('test', arg='new', fields=[('a', 'b'), ('c', 'd')], block='d6')
self.assertEqual(self.r.data[0], '.. test:: new')
self.assertEqual(self.r.data[1], ' :a: b')
self.assertEqual(self.r.data[2], ' :c: d')
def test_directive_content(self):
self.r.directive('test', content='string', block='d7')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], '')
self.assertEqual(self.r.data[2], ' string')
def test_directive_with_multiline_content(self):
self.r.directive('test', content=['string', 'second'], block='d8')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], '')
self.assertEqual(self.r.data[2], ' string')
self.assertEqual(self.r.data[3], ' second')
def test_directive_simple_indent(self):
self.r.directive('test', indent=3, block='di0')
self.assertEqual(self.r.data, [' .. test::'])
def test_directive_arg_named_indent(self):
self.r.directive('test', arg='what', indent=3, block='di3')
self.assertEqual(self.r.data, [' .. test:: what'])
def test_directive_arg_positional_indent(self):
self.r.directive('test', 'what', indent=3, block='di1')
self.assertEqual(self.r.data, [' .. test:: what'])
def test_directive_fields_indent(self):
self.r.directive('test', fields=[('a', 'b')], indent=3, block='di2')
self.assertEqual(self.r.data, [' .. test::', ' :a: b'])
def test_directive_fields_with_arg_indent(self):
self.r.directive('test', arg='what', fields=[('a', 'b')], indent=3, block='di4')
self.assertEqual(self.r.data, [' .. test:: what', ' :a: b'])
def test_directive_fields_multiple_indent(self):
self.r.directive('test', indent=3, fields=[('a', 'b'), ('c', 'd')], block='di5')
self.assertEqual(self.r.data, [' .. test::', ' :a: b', ' :c: d'])
def test_directive_fields_multiple_arg_indent(self):
self.r.directive('test', arg='new', indent=3, fields=[('a', 'b'), ('c', 'd')], block='di6')
self.assertEqual(self.r.data, [' .. test:: new', ' :a: b', ' :c: d'])
def test_directive_content_indent(self):
self.r.directive('test', content='string', indent=3, block='di7')
self.assertEqual(self.r.data, [' .. test::', ' ', ' string'])
def test_directive_with_multiline_content_indent(self):
self.r.directive('test', indent=3, content=['string', 'second'], block='di8')
self.assertEqual(self.r.data, [' .. test::', ' ', ' string', ' second'])
def test_single_role_no_text(self):
ret = self.r.role('test', 'value')
self.assertEqual(ret, ':test:`value`')
def test_multi_role_no_text(self):
ret = self.r.role(['test', 'role'], 'value')
self.assertEqual(ret, ':test:role:`value`')
def test_single_role_text(self):
ret = self.r.role('test', 'value', 'link')
self.assertEqual(ret, ':test:`link <value>`')
def test_multi_role_text(self):
ret = self.r.role(['test', 'role'], 'value', 'link')
self.assertEqual(ret, ':test:role:`link <value>`')
def test_single_role_no_text_args(self):
ret = self.r.role(name='test', value='value')
self.assertEqual(ret, ':test:`value`')
def test_multi_role_no_text_args(self):
ret = self.r.role(name=['test', 'role'], value='value')
self.assertEqual(ret, ':test:role:`value`')
def test_single_role_text_args(self):
ret = self.r.role(name='test', value='value', text='link')
self.assertEqual(ret, ':test:`link <value>`')
def test_multi_role_text_args(self):
ret = self.r.role(name=['test', 'role'], value='value', text='link')
self.assertEqual(ret, ':test:role:`link <value>`')
def test_bold(self):
ret = self.r.bold('text')
self.assertEqual(ret, '**text**')
def test_emph(self):
ret = self.r.emph('text')
self.assertEqual(ret, '*text*')
def test_pre(self):
ret = self.r.pre('text')
self.assertEqual(ret, '``text``')
def test_inline_link(self):
ret = self.r.inline_link('text', 'link')
self.assertEqual(ret, '`text <link>`_')
def test_footnote_ref(self):
ret = self.r.footnote_ref('name')
self.assertEqual(ret, '[#name]_')
def test_codeblock_simple(self):
self.r.codeblock('ls -lha', block='cb0')
self.assertEqual(self.r.data, ['::', ' ls -lha'])
def test_codeblock_with_language(self):
self.r.codeblock('ls -lha', language='shell',block='cb1')
self.assertEqual(self.r.data, ['.. code-block:: shell', '', ' ls -lha'])
def test_footnote(self):
self.r.footnote('footsnotes', 'text of the note', block='fn0')
self.assertEqual(self.r.data[0], '.. [#footsnotes] text of the note')
def test_footnote_with_indent(self):
self.r.footnote('footsnotes', 'text of the note', block='fn1', indent=3)
self.assertEqual(self.r.data[0], ' .. [#footsnotes] text of the note')
def test_footnote_with_wrap(self):
self.r.footnote('footsnotes', 'the ' * 40, block='fn2', wrap=True)
self.assertEqual(self.r.data[0],
'.. [#footsnotes]' + ' the' * 14 + '\n ' + ' the' * 17 + '\n ' + ' the' * 9)
def test_definition(self):
self.r.definition('defitem', 'this is def text', block='dfn0')
self.assertEqual(self.r.data, ['defitem', ' this is def text'])
def test_definition_with_indent(self):
self.r.definition('defitem', 'this is def text', indent=3, block='dfn1')
self.assertEqual(self.r.data, [' defitem', ' this is def text'])
def test_title_default(self):
self.r.title('test text', block='hd0')
self.assertEqual(self.r.data, ['=========', 'test text', '========='])
def test_title_alt(self):
self.r.title('test text', char='-', block='hd1')
self.assertEqual(self.r.data, ['---------', 'test text', '---------'])
def test_heading_one(self):
self.r.heading('test heading', char='-', indent=0, block='hd2')
self.assertEqual(self.r.data, ['test heading', '------------'])
def test_heading_two(self):
self.r.heading('test heading', char='^', indent=0, block='hd3')
self.assertEqual(self.r.data, ['test heading', '^^^^^^^^^^^^'])
def test_h1(self):
self.r.h1('test', block='hd4')
self.assertEqual(self.r.data, ['test', '===='])
def test_h2(self):
self.r.h2('test', block='hd5')
self.assertEqual(self.r.data, ['test', '----'])
def test_h3(self):
self.r.h3('test', block='hd6')
self.assertEqual(self.r.data, ['test', '~~~~'])
def test_h4(self):
self.r.h4('test', block='hd7')
self.assertEqual(self.r.data, ['test', '++++'])
def test_h5(self):
self.r.h5('test', block='hd8')
self.assertEqual(self.r.data, ['test', '^^^^'])
def test_h6(self):
self.r.h6('test', block='hd9')
self.assertEqual(self.r.data, ['test', ';;;;'])
def test_replacement(self):
self.r.replacement('foo', 'replace-with-bar', block='sub0')
self.assertEqual(self.r.data, ['.. |foo| replace:: replace-with-bar'])
def test_replacement_with_indent(self):
self.r.replacement('foo', 'replace-with-bar', indent=3, block='sub1')
self.assertEqual(self.r.data, [' .. |foo| replace:: replace-with-bar'])
def test_li_simple(self):
self.r.li('foo', block='li0')
self.assertEqual(self.r.data, ['- foo'])
def test_li_simple_indent(self):
self.r.li('foo', indent=3, block='li1')
self.assertEqual(self.r.data, [' - foo'])
def test_li_simple_alt(self):
self.r.li('foo', bullet='*', block='li2')
self.assertEqual(self.r.data, ['* foo'])
def test_li_simple_alt_indent(self):
self.r.li('foo', bullet='*', indent=3, block='li3')
self.assertEqual(self.r.data, [' * foo'])
def test_li_complex(self):
self.r.li(['foo', 'bar'], block='li0')
self.assertEqual(self.r.data, ['- foo bar'])
def test_li_complex_indent(self):
self.r.li(['foo', 'bar'], indent=3, block='li1')
self.assertEqual(self.r.data, [' - foo bar'])
def test_li_complex_alt(self):
self.r.li(['foo', 'bar'], bullet='*', block='li2')
self.assertEqual(self.r.data, ['* foo bar'])
def test_li_complex_alt_indent(self):
self.r.li(['foo', 'bar'], bullet='*', indent=3, block='li3')
self.assertEqual(self.r.data, [' * foo bar'])
def test_field_simple(self):
self.r.field('fname', 'fvalue', block='fld0')
self.assertEqual(self.r.data, [':fname: fvalue'])
def test_field_long_simple(self):
self.r.field('fname is fname', 'fvalue', block='fld1')
self.assertEqual(self.r.data, [':fname is fname: fvalue'])
def test_field_simple_long(self):
self.r.field('fname', 'v' * 54, block='fld2')
self.assertEqual(self.r.data, [':fname: ' + 'v' * 54])
def test_field_simple_long_long(self):
self.r.field('fname', 'v' * 55, block='fld3')
self.assertEqual(self.r.data, [':fname:', '', ' ' + 'v' * 55])
def test_field_indent_simple(self):
self.r.field('fname', 'fvalue', indent=3, block='fld4')
self.assertEqual(self.r.data, [' :fname: fvalue'])
def test_field_indent_long_simple(self):
self.r.field('fname is fname', 'fvalue', indent=3, block='fld5')
self.assertEqual(self.r.data, [' :fname is fname: fvalue'])
def test_field_indent_simple_long(self):
self.r.field('fname', 'v' * 54, indent=3, block='fld6')
self.assertEqual(self.r.data, [' :fname: ' + 'v' * 54])
def test_field_indent_simple_long_long(self):
self.r.field('fname', 'v' * 55, indent=3, block='fld7')
self.assertEqual(self.r.data, [' :fname:', ' ', ' ' + 'v' * 55])
def test_field_wrap_simple(self):
self.r.field('fname', 'the ' * 100, block='fld8')
self.assertEqual(self.r.data, [':fname:', '', ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 10])
def test_field_wrap_indent_simple(self):
self.r.field('fname', 'the ' * 100, indent=3, block='fld8')
self.assertEqual(self.r.data, [' :fname:', ' ', ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 10])
def test_content_string(self):
self.r.content('this is sparta', block='ct0')
self.assertEqual(self.r.data, ['this is sparta'])
def test_content_list(self):
self.r.content(['this is sparta', 'this is spinal tap'], block='ct1')
self.assertEqual(self.r.data, ['this is sparta', 'this is spinal tap'])
def test_content_indent_string(self):
self.r.content('this is sparta', indent=3, block='ct2')
self.assertEqual(self.r.data, [' this is sparta'])
def test_content_indent_list(self):
self.r.content(['this is sparta', 'this is spinal tap'], indent=3, block='ct3')
self.assertEqual(self.r.data, [' this is sparta', ' this is spinal tap'])
def test_content_long(self):
self.r.content('the ' * 100, block='ct4')
self.assertEqual(self.r.data, [ 'the' + ' the' * 17, 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 9 + 'the' ])
def test_ontent_indent_long(self):
self.r.content('the ' * 100, indent=3 ,block='ct5')
self.assertEqual(self.r.data, [ ' the' + ' the' * 17, " " + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 9 + 'the' ])
def test_ontent_indent_long_nowrap(self):
self.r.content('the ' * 100, wrap=False, indent=3 ,block='ct5')
self.assertEqual(self.r.data, [ ' ' + 'the ' * 99 + 'the'])
def test_ref_target_named(self):
self.r.ref_target(name="foo-are-magic-ref0", block='ref0')
self.assertEqual(self.r.data, ['.. _foo-are-magic-ref0:'])
def test_ref_target_unnamed(self):
self.r.ref_target("foo-are-magic-ref1", block='ref1')
self.assertEqual(self.r.data, ['.. _foo-are-magic-ref1:'])
def test_ref_target_named_with_indent(self):
self.r.ref_target(name="foo-are-magic-ref2", indent=3, block='ref2')
self.assertEqual(self.r.data, [' .. _foo-are-magic-ref2:'])
def test_ref_target_unnamed_wo_indent(self):
self.r.ref_target("foo-are-magic-ref3", 3, block='ref3')
self.assertEqual(self.r.data, [' .. _foo-are-magic-ref3:'])
def build_page(data, conf):
if 'includes' not in conf.system.files.data:
return
else:
iconf = conf.system.files.data.includes
r = RstCloth()
r.title(iconf['title'])
r.newline()
r.directive('default-domain', iconf['domain'])
r.newline()
try:
r.content(iconf['introduction'])
r.newline()
except KeyError:
logger.debug('include meta file lacks an introduction.')
r.directive(name='contents', arg='Included Files',
fields=[ ('backlinks', 'none'),
('class', 'long-toc'),
('depth', 1),
('local', ''),
])
r.newline()
data = data.items()
data.sort()
for _, record in data:
page_name = r.pre(record['name'])
r.heading(text=page_name, char='-', indent=0)
r.newline()
r.heading('Meta', char='~', indent=0)
r.newline()
if record['num_clients'] == 0:
r.content('{0} is not included in any files.'.format(page_name))
r.newline()
add_content(r, record)
elif record['num_clients'] == 1:
if record['yaml_only']:
r.content('{0} is only included in yaml files.'.format(page_name))
r.newline()
else:
link = r.role('doc', record['clients'][0])
r.content('{0} is only included in {1}.'.format(page_name, link))
r.newline()
add_meta(r, page_name, record)
add_content(r, record)
else:
r.content('{0} is included in **{1}** files.'.format(page_name, record['num_clients']),
wrap=False)
r.newline()
add_meta(r, page_name, record)
if record['yaml_only'] is False:
clients = [ p for p in
record['clients']
if not p.startswith('/includes')
]
if len(clients) == 1:
client_link = r.role('doc', clients[0])
inc_str = '{0} is the only file that includes {1} that is not also an include.'
r.content(inc_str.format(client_link, page_name))
r.newline()
else:
r.heading('Client Pages', char='~', indent=0)
r.newline()
for pg in clients:
client_link = r.role('doc', pg)
r.li(client_link, wrap=False)
r.newline()
add_include_example(r, page_name, record['path'])
add_content(r, record)
return r
def build_page(data, conf):
if 'includes' not in conf.system.files.data:
return
else:
iconf = conf.system.files.data.includes
r = RstCloth()
r.title(iconf['title'])
r.newline()
r.directive('default-domain', iconf['domain'])
r.newline()
try:
r.content(iconf['introduction'])
r.newline()
except KeyError:
logger.debug('include meta file lacks an introduction.')
r.directive(name='contents', arg='Included Files',
fields=[ ('backlinks', 'none'),
('class', 'long-toc'),
('depth', 1),
('local', ''),
])
r.newline()
data = data.items()
data.sort()
for _, record in data:
page_name = r.pre(record['name'])
r.heading(text=page_name, char='-', indent=0)
r.newline()
r.heading('Meta', char='~', indent=0)
r.newline()
if record['num_clients'] == 0:
r.content('{0} is not included in any files.'.format(page_name))
r.newline()
add_content(r, record)
elif record['num_clients'] == 1:
if record['yaml_only']:
r.content('{0} is only included in yaml files.'.format(page_name))
r.newline()
else:
link = r.role('doc', record['clients'][0])
r.content('{0} is only included in {1}.'.format(page_name, link))
r.newline()
add_meta(r, page_name, record)
add_content(r, record)
else:
r.content('{0} is included in **{1}** files.'.format(page_name, record['num_clients']),
wrap=False)
r.newline()
add_meta(r, page_name, record)
if record['yaml_only'] is False:
clients = [ p for p in
record['clients']
if not p.startswith('/includes')
]
if len(clients) == 1:
client_link = r.role('doc', clients[0])
inc_str = '{0} is the only file that includes {1} that is not also an include.'
r.content(inc_str.format(client_link, page_name))
r.newline()
else:
r.heading('Client Pages', char='~', indent=0)
r.newline()
for pg in clients:
client_link = r.role('doc', pg)
r.li(client_link, wrap=False)
r.newline()
add_include_example(r, page_name, record['path'])
add_content(r, record)
return r
class StepsOutput(object):
"""
Base class for rendered step form. The render() method generates the rst in
the internal RstCloth object.
"""
def __init__(self, steps, conf):
if not isinstance(steps, Steps):
raise TypeError
else:
self.steps = steps
self.conf = conf
self.current_step = 1
self.rst = RstCloth()
self.hook()
def hook(self):
self.indent = 3
def edition_check(self, step):
return giza.content.helper.edition_check(step, self.conf)
@staticmethod
def annotate_optional(step):
if 'optional' in step and step['optional'] is True:
if isinstance(step['title'], dict):
step['title']['text'] = 'Optional. ' + step['title']['text']
else:
if 'title' in step:
step['title'] = 'Optional. ' + step['title']
elif 'heading' in step:
step['heading'] = 'Optional. ' + step['heading']
del step['optional']
return step
else:
return step
def render(self):
for step in self.steps.source_list:
if self.edition_check(step) is False:
continue
step = self.annotate_optional(step)
self.heading(step)
self.pre(step)
self.current_step = step['stepnum']
if 'action' in step:
if isinstance(step['action'], list):
for block in step['action']:
self.code_step(block)
else:
self.code_step(step['action'])
self.content(step)
self.post(step)
def content(self, doc):
if 'content' in doc and doc['content'] is not None:
self.rst.content(doc['content'], wrap=False, indent=self.indent)
self.rst.newline()
def pre(self, doc):
if 'pre' in doc and doc['pre'] is not None:
self.rst.content(doc['pre'], wrap=False, indent=self.indent)
self.rst.newline()
def post(self, doc, code_step=False):
if 'post' in doc and doc['post'] is not None:
self.rst.content(doc['post'], wrap=False, indent=self.indent)
self.rst.newline()
if code_step is False:
self.post_step_hook()
def post_step_hook(self):
pass
def _heading(self, block, override_char=None, indent=0):
if 'heading' in block:
if isinstance(block['heading'], dict):
if 'character' in block['heading']:
pass
else:
block['heading']['character'] = override_char
else:
block['heading'] = {
'text': block['heading'],
'character': override_char
}
if block['heading']['text'] is None:
logger.error('step in "{0}" is missing a heading'.format(
os.path.basename(self.steps.source_fn)))
return
self.rst.heading(text=block['heading']['text'],
char=block['heading']['character'],
indent=indent)
self.rst.newline()
def code_step(self, block):
if 'code' in block and 'content' in block:
raise InvalidStep
if 'heading' in block:
self.block_heading(block)
self.pre(block)
if 'code' in block:
if 'language' not in block:
block['language'] = 'none'
if not isinstance(block['code'], list):
block['code'] = block['code'].split('\n')
self.rst.directive(name='code-block',
arg=block['language'],
content=block['code'],
indent=self.indent)
self.rst.newline()
if 'content' in block:
self.content(block['content'])
self.post(block, code_step=True)
def key_name(self):
key_name = os.path.splitext(os.path.basename(self.steps.source_fn))[0]
if key_name.startswith('step-') or key_name.startswith('steps-'):
key_name = key_name.split('-', 1)[1]
return key_name
class TestRstCloth(TestCase):
@classmethod
def setUp(self):
self.r = RstCloth()
def test_adding_without_blocks(self):
self.r._add('foo')
self.assertEqual(self.r.data[0], 'foo')
def test_newline(self):
self.r.newline()
self.assertEqual(len(self.r.data), 1)
def test_multi_newline(self):
self.r.newline(count=4)
self.assertEqual(len(self.r.data[0]), 4 - 1)
def test_directive_simple(self):
self.r.directive('test', block='d0')
self.assertEqual(self.r.data[0], '.. test::')
def test_directive_arg_named(self):
self.r.directive('test', arg='what', block='d3')
self.assertEqual(self.r.data[0], '.. test:: what')
def test_directive_arg_positional(self):
self.r.directive('test', 'what', block='d1')
self.assertEqual(self.r.data[0], '.. test:: what')
def test_directive_fields(self):
self.r.directive('test', fields=[('a', 'b')], block='d2')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], ' :a: b')
def test_directive_fields_with_arg(self):
self.r.directive('test', arg='what', fields=[('a', 'b')], block='d4')
self.assertEqual(self.r.data[0], '.. test:: what')
self.assertEqual(self.r.data[1], ' :a: b')
def test_directive_fields_multiple(self):
self.r.directive('test', fields=[('a', 'b'), ('c', 'd')], block='d5')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], ' :a: b')
self.assertEqual(self.r.data[2], ' :c: d')
def test_directive_fields_multiple_arg(self):
self.r.directive('test', arg='new', fields=[('a', 'b'), ('c', 'd')], block='d6')
self.assertEqual(self.r.data[0], '.. test:: new')
self.assertEqual(self.r.data[1], ' :a: b')
self.assertEqual(self.r.data[2], ' :c: d')
def test_directive_content(self):
self.r.directive('test', content='string', block='d7')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], '')
self.assertEqual(self.r.data[2], ' string')
def test_directive_with_multiline_content(self):
self.r.directive('test', content=['string', 'second'], block='d8')
self.assertEqual(self.r.data[0], '.. test::')
self.assertEqual(self.r.data[1], '')
self.assertEqual(self.r.data[2], ' string')
self.assertEqual(self.r.data[3], ' second')
def test_directive_simple_indent(self):
self.r.directive('test', indent=3, block='di0')
self.assertEqual(self.r.data, [' .. test::'])
def test_directive_arg_named_indent(self):
self.r.directive('test', arg='what', indent=3, block='di3')
self.assertEqual(self.r.data, [' .. test:: what'])
def test_directive_arg_positional_indent(self):
self.r.directive('test', 'what', indent=3, block='di1')
self.assertEqual(self.r.data, [' .. test:: what'])
def test_directive_fields_indent(self):
self.r.directive('test', fields=[('a', 'b')], indent=3, block='di2')
self.assertEqual(self.r.data, [' .. test::', ' :a: b'])
def test_directive_fields_with_arg_indent(self):
self.r.directive('test', arg='what', fields=[('a', 'b')], indent=3, block='di4')
self.assertEqual(self.r.data, [' .. test:: what', ' :a: b'])
def test_directive_fields_multiple_indent(self):
self.r.directive('test', indent=3, fields=[('a', 'b'), ('c', 'd')], block='di5')
self.assertEqual(self.r.data, [' .. test::', ' :a: b', ' :c: d'])
def test_directive_fields_multiple_arg_indent(self):
self.r.directive('test', arg='new', indent=3, fields=[('a', 'b'), ('c', 'd')], block='di6')
self.assertEqual(self.r.data, [' .. test:: new', ' :a: b', ' :c: d'])
def test_directive_content_indent(self):
self.r.directive('test', content='string', indent=3, block='di7')
self.assertEqual(self.r.data, [' .. test::', ' ', ' string'])
def test_directive_with_multiline_content_indent(self):
self.r.directive('test', indent=3, content=['string', 'second'], block='di8')
self.assertEqual(self.r.data, [' .. test::', ' ', ' string', ' second'])
def test_single_role_no_text(self):
ret = self.r.role('test', 'value')
self.assertEqual(ret, ':test:`value`')
def test_multi_role_no_text(self):
ret = self.r.role(['test', 'role'], 'value')
self.assertEqual(ret, ':test:role:`value`')
def test_single_role_text(self):
ret = self.r.role('test', 'value', 'link')
self.assertEqual(ret, ':test:`link <value>`')
def test_multi_role_text(self):
ret = self.r.role(['test', 'role'], 'value', 'link')
self.assertEqual(ret, ':test:role:`link <value>`')
def test_single_role_no_text_args(self):
ret = self.r.role(name='test', value='value')
self.assertEqual(ret, ':test:`value`')
def test_multi_role_no_text_args(self):
ret = self.r.role(name=['test', 'role'], value='value')
self.assertEqual(ret, ':test:role:`value`')
def test_single_role_text_args(self):
ret = self.r.role(name='test', value='value', text='link')
self.assertEqual(ret, ':test:`link <value>`')
def test_multi_role_text_args(self):
ret = self.r.role(name=['test', 'role'], value='value', text='link')
self.assertEqual(ret, ':test:role:`link <value>`')
def test_bold(self):
ret = self.r.bold('text')
self.assertEqual(ret, '**text**')
def test_emph(self):
ret = self.r.emph('text')
self.assertEqual(ret, '*text*')
def test_pre(self):
ret = self.r.pre('text')
self.assertEqual(ret, '``text``')
def test_inline_link(self):
ret = self.r.inline_link('text', 'link')
self.assertEqual(ret, '`text <link>`_')
def test_footnote_ref(self):
ret = self.r.footnote_ref('name')
self.assertEqual(ret, '[#name]')
def test_codeblock_simple(self):
self.r.codeblock('ls -lha', block='cb0')
self.assertEqual(self.r.data, ['::', ' ls -lha'])
def test_codeblock_with_language(self):
self.r.codeblock('ls -lha', language='shell',block='cb1')
self.assertEqual(self.r.data, ['.. code-block:: shell', '', ' ls -lha'])
def test_footnote(self):
self.r.footnote('footsnotes', 'text of the note', block='fn0')
self.assertEqual(self.r.data[0], '.. [#footsnotes] text of the note')
def test_footnote_with_indent(self):
self.r.footnote('footsnotes', 'text of the note', block='fn1', indent=3)
self.assertEqual(self.r.data[0], ' .. [#footsnotes] text of the note')
def test_footnote_with_wrap(self):
self.r.footnote('footsnotes', 'the ' * 40, block='fn2', wrap=True)
self.assertEqual(self.r.data[0],
'.. [#footsnotes]' + ' the' * 14 + '\n ' + ' the' * 17 + '\n ' + ' the' * 9)
def test_definition(self):
self.r.definition('defitem', 'this is def text', block='dfn0')
self.assertEqual(self.r.data, ['defitem', ' this is def text'])
def test_definition_with_indent(self):
self.r.definition('defitem', 'this is def text', indent=3, block='dfn1')
self.assertEqual(self.r.data, [' defitem', ' this is def text'])
def test_title_default(self):
self.r.title('test text', block='hd0')
self.assertEqual(self.r.data, ['=========', 'test text', '========='])
def test_title_alt(self):
self.r.title('test text', char='-', block='hd1')
self.assertEqual(self.r.data, ['---------', 'test text', '---------'])
def test_heading_one(self):
self.r.heading('test heading', char='-', indent=0, block='hd2')
self.assertEqual(self.r.data, ['test heading', '------------'])
def test_heading_two(self):
self.r.heading('test heading', char='^', indent=0, block='hd3')
self.assertEqual(self.r.data, ['test heading', '^^^^^^^^^^^^'])
def test_h1(self):
self.r.h1('test', block='hd4')
self.assertEqual(self.r.data, ['test', '===='])
def test_h2(self):
self.r.h2('test', block='hd5')
self.assertEqual(self.r.data, ['test', '----'])
def test_h3(self):
self.r.h3('test', block='hd6')
self.assertEqual(self.r.data, ['test', '~~~~'])
def test_h4(self):
self.r.h4('test', block='hd7')
self.assertEqual(self.r.data, ['test', '++++'])
def test_h5(self):
self.r.h5('test', block='hd8')
self.assertEqual(self.r.data, ['test', '^^^^'])
def test_h6(self):
self.r.h6('test', block='hd9')
self.assertEqual(self.r.data, ['test', ';;;;'])
def test_replacement(self):
self.r.replacement('foo', 'replace-with-bar', block='sub0')
self.assertEqual(self.r.data, ['.. |foo| replace:: replace-with-bar'])
def test_replacement_with_indent(self):
self.r.replacement('foo', 'replace-with-bar', indent=3, block='sub1')
self.assertEqual(self.r.data, [' .. |foo| replace:: replace-with-bar'])
def test_li_simple(self):
self.r.li('foo', block='li0')
self.assertEqual(self.r.data, ['- foo'])
def test_li_simple_indent(self):
self.r.li('foo', indent=3, block='li1')
self.assertEqual(self.r.data, [' - foo'])
def test_li_simple_alt(self):
self.r.li('foo', bullet='*', block='li2')
self.assertEqual(self.r.data, ['* foo'])
def test_li_simple_alt_indent(self):
self.r.li('foo', bullet='*', indent=3, block='li3')
self.assertEqual(self.r.data, [' * foo'])
def test_li_complex(self):
self.r.li(['foo', 'bar'], block='li0')
self.assertEqual(self.r.data, ['- foo bar'])
def test_li_complex_indent(self):
self.r.li(['foo', 'bar'], indent=3, block='li1')
self.assertEqual(self.r.data, [' - foo bar'])
def test_li_complex_alt(self):
self.r.li(['foo', 'bar'], bullet='*', block='li2')
self.assertEqual(self.r.data, ['* foo bar'])
def test_li_complex_alt_indent(self):
self.r.li(['foo', 'bar'], bullet='*', indent=3, block='li3')
self.assertEqual(self.r.data, [' * foo bar'])
def test_field_simple(self):
self.r.field('fname', 'fvalue', block='fld0')
self.assertEqual(self.r.data, [':fname: fvalue'])
def test_field_long_simple(self):
self.r.field('fname is fname', 'fvalue', block='fld1')
self.assertEqual(self.r.data, [':fname is fname: fvalue'])
def test_field_simple_long(self):
self.r.field('fname', 'v' * 54, block='fld2')
self.assertEqual(self.r.data, [':fname: ' + 'v' * 54])
def test_field_simple_long_long(self):
self.r.field('fname', 'v' * 55, block='fld3')
self.assertEqual(self.r.data, [':fname:', '', ' ' + 'v' * 55])
def test_field_indent_simple(self):
self.r.field('fname', 'fvalue', indent=3, block='fld4')
self.assertEqual(self.r.data, [' :fname: fvalue'])
def test_field_indent_long_simple(self):
self.r.field('fname is fname', 'fvalue', indent=3, block='fld5')
self.assertEqual(self.r.data, [' :fname is fname: fvalue'])
def test_field_indent_simple_long(self):
self.r.field('fname', 'v' * 54, indent=3, block='fld6')
self.assertEqual(self.r.data, [' :fname: ' + 'v' * 54])
def test_field_indent_simple_long_long(self):
self.r.field('fname', 'v' * 55, indent=3, block='fld7')
self.assertEqual(self.r.data, [' :fname:', ' ', ' ' + 'v' * 55])
def test_field_wrap_simple(self):
self.r.field('fname', 'the ' * 100, block='fld8')
self.assertEqual(self.r.data, [':fname:', '', ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 10])
def test_field_wrap_indent_simple(self):
self.r.field('fname', 'the ' * 100, indent=3, block='fld8')
self.assertEqual(self.r.data, [' :fname:', ' ', ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 18, ' ' + ' the' * 10])
def test_content_string(self):
self.r.content('this is sparta', block='ct0')
self.assertEqual(self.r.data, ['this is sparta'])
def test_content_list(self):
self.r.content(['this is sparta', 'this is spinal tap'], block='ct1')
self.assertEqual(self.r.data, ['this is sparta', 'this is spinal tap'])
def test_content_indent_string(self):
self.r.content('this is sparta', indent=3, block='ct2')
self.assertEqual(self.r.data, [' this is sparta'])
def test_content_indent_list(self):
self.r.content(['this is sparta', 'this is spinal tap'], indent=3, block='ct3')
self.assertEqual(self.r.data, [' this is sparta', ' this is spinal tap'])
def test_content_long(self):
self.r.content('the ' * 100, block='ct4')
self.assertEqual(self.r.data, [ 'the' + ' the' * 17, 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 17 + 'the', 'the ' * 9 + 'the' ])
def test_ontent_indent_long(self):
self.r.content('the ' * 100, indent=3 ,block='ct5')
self.assertEqual(self.r.data, [ ' the' + ' the' * 17, " " + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 17 + 'the', ' ' + 'the ' * 9 + 'the' ])
def test_ontent_indent_long_nowrap(self):
self.r.content('the ' * 100, wrap=False, indent=3 ,block='ct5')
self.assertEqual(self.r.data, [ ' ' + 'the ' * 99 + 'the'])
def test_ref_target_named(self):
self.r.ref_target(name="foo-are-magic-ref0", block='ref0')
self.assertEqual(self.r.data, ['.. _foo-are-magic-ref0:'])
def test_ref_target_unnamed(self):
self.r.ref_target("foo-are-magic-ref1", block='ref1')
self.assertEqual(self.r.data, ['.. _foo-are-magic-ref1:'])
def test_ref_target_named_with_indent(self):
self.r.ref_target(name="foo-are-magic-ref2", indent=3, block='ref2')
self.assertEqual(self.r.data, [' .. _foo-are-magic-ref2:'])
def test_ref_target_unnamed_wo_indent(self):
self.r.ref_target("foo-are-magic-ref3", 3, block='ref3')
self.assertEqual(self.r.data, [' .. _foo-are-magic-ref3:'])
