def contribute_properties(self, parent):
if not self.props_schemata:
return
props = dict((k, v) for k, v in self.props_schemata.items()
if v.support_status.status != support.HIDDEN)
required_props = dict((k, v) for k, v in props.items()
if v.required)
if required_props:
section = self._section(
parent, _('Required Properties'), '%s-props-req')
definition_list = nodes.definition_list()
section.append(definition_list)
for prop_key, prop in sorted(required_props.items(),
key=cmp_to_key(self.cmp_prop)):
self.contribute_property(definition_list, prop_key, prop)
optional_props = dict((k, v) for k, v in props.items()
if not v.required)
if optional_props:
section = self._section(
parent, _('Optional Properties'), '%s-props-opt')
definition_list = nodes.definition_list()
section.append(definition_list)
for prop_key, prop in sorted(optional_props.items(),
key=cmp_to_key(self.cmp_prop)):
self.contribute_property(definition_list, prop_key, prop)
def _generate_documentation(self, tree):
unvisited = [tree]
while len(unvisited) > 0:
node = unvisited[-1]
if len(node.children) > 0:
unvisited.append(node.remove_child())
continue
if node.parent is None or node.comment is None:
unvisited.pop()
continue
with switch_source_input(self.state, node.comment):
definition = nodes.definition()
if isinstance(node.comment, ViewList):
self.state.nested_parse(node.comment, 0, definition)
else:
definition += node.comment
node.comment = nodes.definition_list_item(
"",
nodes.term("", node.value.value),
definition,
)
if node.parent.comment is None:
node.parent.comment = nodes.definition_list()
elif not isinstance(node.parent.comment,
nodes.definition_list):
with switch_source_input(self.state, node.parent.comment):
dlist = nodes.definition_list()
self.state.nested_parse(node.parent.comment, 0, dlist)
node.parent.comment = dlist
node.parent.comment += node.comment
unvisited.pop()
return tree.comment
def contribute_properties(self, parent):
if not self.props_schemata:
return
props = dict((k, v) for k, v in self.props_schemata.items()
if v.support_status.status != support.HIDDEN)
required_props = dict((k, v) for k, v in props.items()
if v.required)
if required_props:
section = self._section(
parent, _('Required Properties'), '%s-props-req')
definition_list = nodes.definition_list()
section.append(definition_list)
for prop_key, prop in sorted(required_props.items(),
key=cmp_to_key(self.cmp_prop)):
self.contribute_property(definition_list, prop_key, prop)
optional_props = dict((k, v) for k, v in props.items()
if not v.required)
if optional_props:
section = self._section(
parent, _('Optional Properties'), '%s-props-opt')
definition_list = nodes.definition_list()
section.append(definition_list)
for prop_key, prop in sorted(optional_props.items(),
key=cmp_to_key(self.cmp_prop)):
self.contribute_property(definition_list, prop_key, prop)
def contribute_attributes(self, parent):
if not self.attrs_schemata:
return
section = self._section(parent, _('Attributes'), '%s-attrs')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key, prop in sorted(self.attrs_schemata.items()):
description = prop.description
prop_item = nodes.definition_list_item(
'', nodes.term('', prop_key))
prop_list.append(prop_item)
definition = nodes.definition()
prop_item.append(definition)
if prop.support_status.status != support.SUPPORTED:
sstatus = prop.support_status.to_dict()
msg = _('%(status)s')
if sstatus['message'] is not None:
msg = _('%(status)s - %(message)s')
para = nodes.inline('', msg % sstatus)
warning = nodes.note('', para)
definition.append(warning)
if description:
def_para = nodes.paragraph('', description)
definition.append(def_para)
def print_subcommand_list(data, nested_content):
definitions = map_nested_definitions(nested_content)
items = []
if 'children' in data:
for child in data['children']:
my_def = [nodes.paragraph(
text=child['help'])] if child['help'] else []
name = child['name']
nested_def = definitions[name] if name in definitions else []
my_def = apply_definition(definitions, my_def, name)
if len(my_def) == 0:
my_def.append(nodes.paragraph(text='Undocumented'))
my_def.append(nodes.literal_block(text=child['usage']))
my_def.append(
print_command_args_and_opts(
print_arg_list(child, nested_content),
print_opt_list(child, nested_content)))
items.append(
nodes.definition_list_item(
'', nodes.term('', '', nodes.strong(text=name)),
nodes.definition('', *my_def)))
return nodes.definition_list('', *items)
def run(self):
result = nodes.definition_list()
for option in sorted(self.options.keys()):
if option == 'added':
continue
term = option.capitalize()
result += nodes.term(text=term)
definition = nodes.definition()
if option in ['kerk', 'predikant', 'tags']:
taglink = {'kerk': SERMONCHURHLINK,
'predikant': SERMONREFERENTLINK,
'tags': SERMONTAGLINK}[option]
value = self.options[option]
values = [value.strip() for value in value.split(',')]
paragraph = nodes.paragraph()
for i, value in enumerate(values):
link = taglink % value
paragraph += nodes.reference(refuri=link, text=value)
if not i == len(values) - 1:
paragraph += nodes.inline(text=', ')
definition += paragraph
else:
paragraph = nodes.paragraph()
paragraph += nodes.inline(text=self.options[option])
definition += paragraph
result += definition
return [result]
def _build_definition_list(self, defaults):
from oauth2_provider import settings
items = []
for setting, default_value in defaults:
text_nodes, messages = self.state.inline_text(
DESCRIPTIONS.get(setting, "TODO").strip(), self.lineno)
node_name = nodes.literal(text=setting)
node_default = nodes.paragraph(text="Default value: ")
node_default += nodes.literal(text=repr(default_value))
node_description = nodes.paragraph()
node_description.extend(text_nodes)
subitems = [node_default, node_description]
if setting in settings.MANDATORY:
notice = nodes.paragraph()
notice += nodes.strong(text="The value cannot be empty.")
subitems.append(notice)
term = nodes.term()
term += node_name
items.append(
nodes.definition_list_item('', term,
nodes.definition('', *subitems)))
deflist = nodes.definition_list('', *items)
return [deflist]
def _build_markup(self, commits):
list_node = nodes.definition_list()
for commit in commits:
date_str = datetime.fromtimestamp(commit.authored_date)
if '\n' in commit.message:
message, detailed_message = commit.message.split('\n', 1)
else:
message = commit.message
detailed_message = None
item = nodes.list_item()
item += [
nodes.emphasis(text="Last Updated by "),
nodes.strong(text=str(commit.author)),
nodes.inline(text=" at "),
nodes.emphasis(text=str(date_str)),
nodes.inline(text=" with message "),
nodes.strong(text=message),
]
if detailed_message:
detailed_message = detailed_message.strip()
if self.options.get('detailed-message-pre', False):
item.append(
nodes.literal_block(text=detailed_message))
else:
item.append(nodes.paragraph(text=detailed_message))
list_node.append(item)
return [list_node]
def run(self):
# import the modules, which will populate the SERVICES variable.
module = self._get_module(self.options.get('module'))
klass = getattr(module, self.options.get('document'))
result = []
# section_id = self.options.get('id', klass_name)
result.append(rst2node("**{} " "JSON object**".format(klass.__name__)))
klass_doc = klass.__doc__
if klass_doc and len(klass_doc):
result.append(rst2node(klass_doc))
if len(klass.__dict__):
result.append(rst2node("*Members documentation:*"))
members_list = nodes.definition_list()
for name, member in klass.__dict__.items():
if isinstance(member, BaseField):
members_list += self._document_member(name, member)
result.append(members_list)
return result
def add_coqtop_output(self):
"""Add coqtop's responses to a Sphinx AST
Finds nodes to process using is_coqtop_block."""
with CoqTop(color=True) as repl:
for node in self.document.traverse(CoqtopBlocksTransform.is_coqtop_block):
options = node['coqtop_options']
opt_undo, opt_reset, opt_input, opt_output = self.parse_options(options)
if opt_reset:
repl.sendone("Reset Initial.")
pairs = []
for sentence in self.split_sentences(node.rawsource):
pairs.append((sentence, repl.sendone(sentence)))
if opt_undo:
repl.sendone("Undo {}.".format(len(pairs)))
dli = nodes.definition_list_item()
for sentence, output in pairs:
# Use Coqdoq to highlight input
in_chunks = highlight_using_coqdoc(sentence)
dli += nodes.term(sentence, '', *in_chunks, classes=self.block_classes(opt_input))
# Parse ANSI sequences to highlight output
out_chunks = AnsiColorsParser().colorize_str(output)
dli += nodes.definition(output, *out_chunks, classes=self.block_classes(opt_output, output))
node.clear()
node.rawsource = self.make_rawsource(pairs, opt_input, opt_output)
node['classes'].extend(self.block_classes(opt_input or opt_output))
node += nodes.inline('', '', classes=['coqtop-reset'] * opt_reset)
node += nodes.definition_list(node.rawsource, dli)
def extract_non_paragraph_node(self, deflist):
"""Extract non paragraph node (ex. literal_block) to after the list."""
ALLOWED_NODES = (nodes.paragraph, nodes.image)
for i, item in reversed(list(enumerate(deflist))):
found = []
for node in reversed(item[1]):
if not isinstance(node, ALLOWED_NODES):
logger.warning('In Re:VIEW, definition list can\'t contain %s. '
'Moved it after the list.',
node.tagname, location=node)
found.append(node)
if found:
pos = deflist.parent.index(deflist)
# separate definition list if non paragraph nodes found
if deflist[i + 1:]:
new_deflist = nodes.definition_list()
for item in deflist[i + 1:]:
deflist.remove(item)
new_deflist += item
deflist.parent.insert(pos + 1, new_deflist)
# move non paragraph nodes after the definition list
for node in found:
node.parent.remove(node)
deflist.parent.insert(pos + 1, node)
def document_transitions(self) -> docutils.nodes.section:
"""Document workflow transitions.
:returns: A section node containing the doctree for transitions description.
"""
transitions = self.wf_elements.get('transitions')
wf_name = self.wf_name
node = nodes.section(
ids=['workflows-{wf_name}-transitions'.format(wf_name=wf_name)])
node += nodes.title(text='Transitions')
dl = nodes.definition_list()
for transition in transitions:
transition_id = 'workflows-{wf_name}-transitions-{transition}'.format(
wf_name=wf_name, transition=transition.name)
t_node = nodes.definition_list_item()
title = '{title} ({from_} → {to_})'.format(
title=transition.title,
from_=transition.state_from().name,
to_=transition.state_to().name,
)
t_node += nodes.term(text=title, ids=[transition_id])
dd = nodes.definition()
dd += self._rst2node(transition.__doc__)
dd += nodes.paragraph(text='Permission: {permission}'.format(
permission=transition.permission))
t_node += dd
dl += t_node
node += dl
return node
def document_permissions(self) -> docutils.nodes.section:
"""Document workflow permissions.
:returns: A section node containing the doctree for permissions description.
"""
permissions = self.wf_elements.get('permissions')
wf_name = self.wf_name
node = nodes.section(
ids=['workflows-{wf_name}-permissions'.format(wf_name=wf_name)])
node += nodes.title(text='Permissions')
dl = nodes.definition_list()
for permission in permissions:
permission_id = 'workflows-{wf_name}-permissions-{permission}'.format(
wf_name=wf_name, permission=permission.name)
t_node = nodes.definition_list_item()
t_node += nodes.term(text=permission.name, ids=[permission_id])
dd = nodes.definition()
dd += self._rst2node(permission.__doc__)
if hasattr(permission, 'groups'):
dd += nodes.paragraph(text='Groups: {groups}'.format(
groups=', '.join(permission.groups)))
t_node += dd
dl += t_node
node += dl
return node
def document_states(self) -> docutils.nodes.section:
"""Document workflow states.
:returns: A section node containing the doctree for states description.
"""
states = self.wf_elements.get('states')
wf_name = self.wf_name
node = nodes.section(
ids=['workflows-{wf_name}-states'.format(wf_name=wf_name)])
node += nodes.title(text='States')
dl = nodes.definition_list()
for state in states:
state_id = 'workflows-{wf_name}-states-{state}'.format(
wf_name=wf_name, state=state.name)
state_node = nodes.definition_list_item()
state_node += nodes.term(text=state.title, ids=[state_id])
dd = nodes.definition()
dd += self._rst2node(state.description)
transitions = nodes.bullet_list()
for t_name in state._transitions:
t = state._transitions[t_name]
temp = nodes.list_item()
temp += nodes.inline(text=t.name)
temp += nodes.inline(text=' ({state_to})'.format(
state_to=t.state_to().name))
transitions += temp
dd += transitions
state_node += dd
dl += state_node
node += dl
return node
def contribute_property(self, prop_list, prop_key, prop):
prop_item = nodes.definition_list_item(
'', nodes.term('', prop_key))
prop_list.append(prop_item)
prop_item.append(nodes.classifier('', prop.type))
definition = nodes.definition()
prop_item.append(definition)
if not prop.implemented:
para = nodes.inline('', _('Not implemented.'))
warning = nodes.note('', para)
definition.append(warning)
return
if prop.description:
para = nodes.paragraph('', prop.description)
definition.append(para)
if prop.update_allowed:
para = nodes.paragraph('',
_('Can be updated without replacement.'))
definition.append(para)
else:
para = nodes.paragraph('', _('Updates cause replacement.'))
definition.append(para)
if prop.required:
para = nodes.paragraph('', _('Required property.'))
elif prop.default is not None:
para = nodes.paragraph(
'',
_('Optional property, defaults to "%s".') % prop.default)
else:
para = nodes.paragraph('', _('Optional property.'))
definition.append(para)
for constraint in prop.constraints:
para = nodes.paragraph('', str(constraint))
definition.append(para)
sub_schema = None
if prop.schema and prop.type == properties.MAP:
para = nodes.emphasis('', _('Map properties:'))
definition.append(para)
sub_schema = prop.schema
elif prop.schema and prop.type == properties.LIST:
para = nodes.emphasis(
'', _('List contents:'))
definition.append(para)
sub_schema = prop.schema
if sub_schema:
sub_prop_list = nodes.definition_list()
definition.append(sub_prop_list)
for sub_prop_key in sorted(sub_schema.keys()):
sub_prop = sub_schema[sub_prop_key]
self.contribute_property(sub_prop_list, sub_prop_key, sub_prop)
def run(self):
# import the modules, which will populate the SERVICES variable.
module = self._get_module(self.options.get('module'))
klass = getattr(module, self.options.get('document'))
result = []
# section_id = self.options.get('id', klass_name)
result.append(rst2node("**{} "
"JSON object**".format(klass.__name__)))
klass_doc = klass.__doc__
if klass_doc and len(klass_doc):
result.append(rst2node(klass_doc))
if len(klass.__dict__):
result.append(rst2node("*Members documentation:*"))
members_list = nodes.definition_list()
for name, member in klass.__dict__.items():
if isinstance(member, BaseField):
members_list += self._document_member(name, member)
result.append(members_list)
return result
def render(self, app, doctree):
rootnode = nodes.bullet_list()
rootnode = nodes.paragraph()
rootnode = nodes.definition_list()
prepend = ""
append = ""
if self.scope == "global":
prepend = "Global "
if self.scope == "class":
append = " (class %s)" % self.refname
elif self.scope == "namespace":
append = " (namespace %s)" % self.refname
n = self.render_sub(app, doctree, self.namespaces,
prepend + "Namespaces" + append,
"namespace ")
if n : rootnode.append(n)
n = self.render_sub(app, doctree, self.classes,
prepend + "Classes" + append,
"class ")
if n : rootnode.append(n)
n = self.render_simple(app, doctree, self.functions,
prepend + "Functions" + append,
"functions")
if n : rootnode.append(n)
n = self.render_simple(app, doctree, self.members,
prepend + "Members" + append,
"members")
if n : rootnode.append(n)
n = self.render_simple(app, doctree, self.types,
prepend + "Types" + append,
"types")
if n : rootnode.append(n)
return rootnode
def add_coq_output_1(self, repl, node):
options = self.parse_options(node)
pairs = []
if options['restart']:
repl.sendone("Restart.")
if options['reset']:
repl.sendone("Reset Initial.")
repl.sendone("Set Coqtop Exit On Error.")
if options['fail']:
repl.sendone("Unset Coqtop Exit On Error.")
for sentence in self.split_sentences(node.rawsource):
pairs.append((sentence, repl.sendone(sentence)))
if options['abort']:
repl.sendone("Abort All.")
if options['fail']:
repl.sendone("Set Coqtop Exit On Error.")
dli = nodes.definition_list_item()
for sentence, output in pairs:
# Use Coqdoc to highlight input
in_chunks = highlight_using_coqdoc(sentence)
dli += nodes.term(sentence, '', *in_chunks, classes=self.block_classes(options['input']))
# Parse ANSI sequences to highlight output
out_chunks = AnsiColorsParser().colorize_str(output)
dli += nodes.definition(output, *out_chunks, classes=self.block_classes(options['output'], output))
node.clear()
node.rawsource = self.make_rawsource(pairs, options['input'], options['output'])
node['classes'].extend(self.block_classes(options['input'] or options['output']))
node += nodes.inline('', '', classes=['coqtop-reset'] * options['reset'])
node += nodes.definition_list(node.rawsource, dli)
def run(self):
env = self.state.document.settings.env
node = addnodes.glossary()
node.document = self.state.document
self.state.nested_parse(self.content, self.content_offset, node)
# the content should be definition lists
dls = [child for child in node
if isinstance(child, nodes.definition_list)]
# now, extract definition terms to enable cross-reference creation
new_dl = nodes.definition_list()
new_dl['classes'].append('glossary')
items = []
for dl in dls:
for li in dl.children:
if not li.children or not isinstance(li[0], nodes.term):
continue
termtext = li.children[0].astext()
new_id = 'term-' + nodes.make_id(termtext)
if new_id in env.gloss_entries:
new_id = 'term-' + str(len(env.gloss_entries))
env.gloss_entries.add(new_id)
li[0]['names'].append(new_id)
li[0]['ids'].append(new_id)
env.note_reftarget('term', termtext.lower(), new_id)
# add an index entry too
indexnode = addnodes.index()
indexnode['entries'] = [('single', termtext, new_id, termtext)]
li.insert(0, indexnode)
items.append((termtext, li))
if 'sorted' in self.options:
items.sort(key=lambda x: x[0].lower())
new_dl.extend(item[1] for item in items)
node.children = [new_dl]
return [node]
def run(self):
# Raise an error if the directive does not have contents.
self.assert_has_content()
self.document = self.state_machine.document
text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name=self.arguments[0].strip()
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
configuration_def = nodes.definition_list_item()
configuration_def += term
defn = nodes.definition()
configuration_def += defn
deflist += configuration_def
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset,
defn)
option_map = {}
option_map['features'] = 'Required for features'
field_list = self.options_to_field_list(option_map)
if (field_list != None):
defn += field_list
self.parsed('configuration').append(self)
return [targetnode, deflist]
def make_binary_properties(self, data):
x = nodes.definition_list()
for key, value in data.items():
if value == 'undefined':
continue
add_df_item(x, key.title(), nodes.paragraph(text=yes_no(value)))
return x
def print_subcommand_list(data, nested_content):
definitions = map_nested_definitions(nested_content)
items = []
if 'children' in data:
for child in data['children']:
my_def = [nodes.paragraph(
text=child['help'])] if child['help'] else []
name = child['name']
my_def = apply_definition(definitions, my_def, name)
if len(my_def) == 0:
my_def.append(nodes.paragraph(text='Undocumented'))
my_def.append(nodes.literal_block(text=child['usage']))
my_def.append(print_command_args_and_opts(
print_arg_list(child, nested_content),
print_opt_list(child, nested_content),
text_from_rst(child.get('description', ""), is_rst=True),
print_subcommand_list(child, nested_content),
))
items.append(
nodes.definition_list_item(
'',
nodes.term('', '', nodes.strong(text=name)),
nodes.definition('', *my_def)
)
)
return nodes.definition_list('', *items)
def add_coqtop_output(self):
"""Add coqtop's responses to a Sphinx AST
Finds nodes to process using is_coqtop_block."""
with CoqTop(color=True) as repl:
for node in self.document.traverse(CoqtopBlocksTransform.is_coqtop_block):
options = node['coqtop_options']
opt_undo, opt_reset, opt_input, opt_output = self.parse_options(options)
if opt_reset:
repl.sendone("Reset Initial.")
pairs = []
for sentence in self.split_sentences(node.rawsource):
pairs.append((sentence, repl.sendone(sentence)))
if opt_undo:
repl.sendone("Undo {}.".format(len(pairs)))
dli = nodes.definition_list_item()
for sentence, output in pairs:
# Use Coqdoq to highlight input
in_chunks = highlight_using_coqdoc(sentence)
dli += nodes.term(sentence, '', *in_chunks, classes=self.block_classes(opt_input))
# Parse ANSI sequences to highlight output
out_chunks = AnsiColorsParser().colorize_str(output)
dli += nodes.definition(output, *out_chunks, classes=self.block_classes(opt_output, output))
node.clear()
node.rawsource = self.make_rawsource(pairs, opt_input, opt_output)
node['classes'].extend(self.block_classes(opt_input or opt_output))
node += nodes.inline('', '', classes=['coqtop-reset'] * opt_reset)
node += nodes.definition_list(node.rawsource, dli)
def get_table(self, items):
"""Return a definition list rather than a table."""
# See original implementation:
# https://github.com/sphinx-doc/sphinx/blob/master/sphinx/ext/autosummary/__init__.py
source, line = self.state_machine.get_source_and_line()
src = f"{source}:{line}:<dlistsummary>"
# We're going to build out a StringList by formatting a definition list and then
# parsing it at the end. Definition list syntax:
#
# **First Item**
# First item description, indented by four spaces.
# **Second Item**
# Second item description, indented by four spaces.
s_list = StringList()
for name, signature, summary_string, real_name in items:
# Add the definition item.
s_list.append(f"**{name}**\n", src)
# Add the autosummary description for this demo, including a link to the
# full demonstration. This is the definition of the item.
summary_string += f" :any:`Go to demo ↱ <{real_name}>`\n"
s_list.append(" " + summary_string, src)
# Now that we have a fully populated StringList, let Sphinx handle the dirty
# work of evaluating the rst as actual nodes.
node = definition_list("")
self.state.nested_parse(s_list, 0, node)
try:
if isinstance(node[0], definition_list):
node = node[0]
except IndexError:
pass
return [node]
def run(self):
# Raise an error if the directive does not have contents.
self.assert_has_content()
self.document = self.state_machine.document
text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name = self.arguments[0].strip()
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
configuration_def = nodes.definition_list_item()
configuration_def += term
defn = nodes.definition()
configuration_def += defn
deflist += configuration_def
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset, defn)
option_map = {}
option_map['features'] = 'Required for features'
field_list = self.options_to_field_list(option_map)
if (field_list != None):
defn += field_list
self.parsed('configuration').append(self)
return [targetnode, deflist]
def _build_markup(self, commits):
list_node = nodes.definition_list()
for commit in commits:
date_str = datetime.fromtimestamp(commit.authored_date)
if '\n' in commit.message:
message, detailed_message = commit.message.split('\n', 1)
else:
message = commit.message
detailed_message = None
item = nodes.list_item()
item += [
nodes.emphasis(text="Last Updated by "),
nodes.strong(text=str(commit.author)),
nodes.inline(text=" at "),
nodes.emphasis(text=str(date_str)),
nodes.inline(text=" with message "),
nodes.strong(text=message),
]
if detailed_message:
detailed_message = detailed_message.strip()
if self.options.get('detailed-message-pre', False):
item.append(nodes.literal_block(text=detailed_message))
else:
item.append(nodes.paragraph(text=detailed_message))
list_node.append(item)
return [list_node]
def contribute_attributes(self, parent):
if not self.attrs_schemata:
return
section = self._section(parent, _('Attributes'), '%s-attrs')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key, prop in sorted(self.attrs_schemata.items()):
description = prop.description
prop_item = nodes.definition_list_item(
'', nodes.term('', prop_key))
prop_list.append(prop_item)
definition = nodes.definition()
prop_item.append(definition)
if prop.support_status.status != support.SUPPORTED:
sstatus = prop.support_status.to_dict()
msg = _('%(status)s')
if sstatus['message'] is not None:
msg = _('%(status)s - %(message)s')
para = nodes.inline('', msg % sstatus)
warning = nodes.note('', para)
definition.append(warning)
if description:
def_para = nodes.paragraph('', description)
definition.append(def_para)
def after_contentnode(self, node):
# derived_from:
if (
self.ent_name not in ROOT_TYPES and
self.section != 'data_types'
):
deriv = self.data['derived_from']
xref_node = addnodes.pending_xref(
'', refdomain='cfy', reftype=self.kind,
reftarget=deriv,
modname=None, classname=None,
)
xref_node += nodes.Text(deriv, deriv)
node.append(nodes.paragraph(
'Derived from: ', 'Derived from: ',
xref_node,
))
if 'properties' in self.data:
node.append(nodes.rubric('', 'Properties:'))
props = nodes.definition_list()
node.append(props)
self.generate_properties(props, self.data['properties'])
def run(self):
# Do not put this at the top-level to avoid nasty circular dependency
# issues.
#
# TODO: this is just a workaround. We should remove this circular
# dependency instead, but this deserves its own refactoring:
# compiled_types imports langkit.expressions at import time and
# conversely. This works only when loading compiled_types first
# "thanks" to the way the dependencies are used.
from langkit.expressions import AbstractExpression
document = self.state.document
def_list = nodes.definition_list()
result = [def_list]
what_str, = self.arguments
what_list = {
'attr': AbstractExpression.attrs_dict.values(),
'cls': AbstractExpression.constructors,
}
what = what_list[what_str]
for doc_expr in sorted(what, key=lambda doc_expr: doc_expr.name):
def_list.append(self._process_one(doc_expr, document))
return result
def process_form(self, formclass, parent):
assert issubclass(formclass, Form)
fields = nodes.definition_list()
parent.append(nodes.definition('', fields))
forminstance = formclass()
for field in forminstance:
self.process_field_delegate(field, fields)
def process_form(self, formclass, parent):
assert issubclass(formclass, Form)
fields = nodes.definition_list()
parent.append(nodes.definition('', fields))
forminstance = formclass()
for field in forminstance:
self.process_field_delegate(field, fields)
def contribute_property(self, prop_list, prop_key, prop):
prop_item = nodes.definition_list_item('', nodes.term('', prop_key))
prop_list.append(prop_item)
prop_item.append(nodes.classifier('', prop.type))
definition = nodes.definition()
prop_item.append(definition)
if not prop.implemented:
para = nodes.inline('', _('Not implemented.'))
warning = nodes.note('', para)
definition.append(warning)
return
if prop.description:
para = nodes.paragraph('', prop.description)
definition.append(para)
if prop.update_allowed:
para = nodes.paragraph('',
_('Can be updated without replacement.'))
definition.append(para)
else:
para = nodes.paragraph('', _('Updates cause replacement.'))
definition.append(para)
if prop.required:
para = nodes.paragraph('', _('Required property.'))
elif prop.default is not None:
para = nodes.paragraph(
'',
_('Optional property, defaults to "%s".') % prop.default)
else:
para = nodes.paragraph('', _('Optional property.'))
definition.append(para)
for constraint in prop.constraints:
para = nodes.paragraph('', str(constraint))
definition.append(para)
sub_schema = None
if prop.schema and prop.type == properties.MAP:
para = nodes.emphasis('', _('Map properties:'))
definition.append(para)
sub_schema = prop.schema
elif prop.schema and prop.type == properties.LIST:
para = nodes.emphasis('', _('List contents:'))
definition.append(para)
sub_schema = prop.schema
if sub_schema:
sub_prop_list = nodes.definition_list()
definition.append(sub_prop_list)
for sub_prop_key in sorted(sub_schema.keys()):
sub_prop = sub_schema[sub_prop_key]
self.contribute_property(sub_prop_list, sub_prop_key, sub_prop)
def run(self):
options = io.get_options_for_format(self.arguments[0])
field_list_node = nodes.definition_list()
for name, description, value in options:
item = nodes.definition_list_item()
item.append(nodes.term(name + ' ', name + ' '))
item.append(nodes.definition('', nodes.paragraph('', description)))
field_list_node.append(item)
return [field_list_node]
def run(self):
options = io.get_options_for_format(self.arguments[0])
field_list_node = nodes.definition_list()
for name, description, value in options:
item = nodes.definition_list_item()
item.append(nodes.term(name + ' ',name+ ' '))
item.append(nodes.definition('', nodes.paragraph('', description)))
field_list_node.append(item)
return [field_list_node]
def rst_nodes(self):
nodelist = []
for entry in self.parameteritem:
nodelist.extend(entry.rst_nodes())
def_list = nodes.definition_list("", *nodelist)
return [def_list]
def contribute_properties(self, parent):
if not self.props_schemata:
return
section = self._section(parent, _('Properties'), '%s-props')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key in sorted(self.props_schemata.keys()):
prop = self.props_schemata[prop_key]
self.contribute_property(prop_list, prop_key, prop)
def contribute_properties(self, parent):
if not self.props_schemata:
return
section = self._section(parent, _('Properties'), '%s-props')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key in sorted(self.props_schemata.keys()):
prop = self.props_schemata[prop_key]
self.contribute_property(prop_list, prop_key, prop)
def contribute_update_policy(self, parent):
if not self.update_policy_schemata:
return
section = self._section(parent, _('UpdatePolicy'), '%s-updpolicy')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key, prop in sorted(self.update_policy_schemata.items(),
self.cmp_prop):
self.contribute_property(prop_list, prop_key, prop)
def run(self):
# Raise an error if the directive does not have contents.
self.assert_has_content()
self.document = self.state_machine.document
text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name = self.arguments[0]
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
test_def = nodes.definition_list_item()
test_def += term
defn = nodes.definition()
test_def += defn
deflist += test_def
# CURRENT : Parse direction list if provided, which is comma-separated
if 'direction' in self.options:
input = 0
output = 0
for p in self.options['direction'].split(","):
# print "Testing `" + p.strip() + "' in test_procedure `" + self.name + "'..."
if p == "input":
input = 1
if p == "output":
output = 2
self.direction = input + output
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset, defn)
option_map = {}
option_map['setup'] = 'Required setup'
option_map['direction'] = 'Direction (input|output|both)'
field_list = self.options_to_field_list(option_map)
if (field_list != None):
defn += field_list
#print "*** TestProcedure options setup = " + self.options['setup']
if 'setup' in self.options:
self.setup = self.options['setup']
self.parsed('test_procedure').append(self)
return [targetnode, deflist]
def contribute_properties(self, section):
schema = self.resource_class.properties_schema
if not schema:
return
section.append(nodes.strong('', _('Properties')))
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key in sorted(schema.keys()):
prop = schema[prop_key]
self.contribute_property(prop_list, prop_key, prop)
def contribute_properties(self, parent):
schema = self.resource_class.properties_schema
if not schema:
return
section = self._section(parent, _("Properties"), "%s-props")
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key in sorted(schema.keys()):
prop = schema[prop_key]
self.contribute_property(prop_list, prop_key, prop)
def format_properties(model):
list = nodes.definition_list()
for prop in model['properties']:
term = nodes.term('', prop['name'])
definition = nodes.definition('')
definition += nodes.strong('', '(' + prop['type'] + ') ')
definition += format_javadoc(prop['doc'])
item = nodes.definition_list_item('', term, definition)
list.append(item)
return list
def contribute_update_policy(self, parent):
if not self.update_policy_schemata:
return
section = self._section(parent, _('update_policy'), '%s-updpolicy')
definition_list = nodes.definition_list()
section.append(definition_list)
for _key, _prop in sorted(self.update_policy_schemata.items(),
key=cmp_to_key(self.cmp_prop)):
self.contribute_property(definition_list, _key, _prop)
def _create_def_list(self, parent):
"""Creates a definition list
:returns: Definition list node
"""
definition_list = nodes.definition_list()
parent.append(definition_list)
return definition_list
def run(self):
# Raise an error if the directive does not have contents.
self.assert_has_content()
self.document = self.state_machine.document
text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name = self.arguments[0]
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
test_def = nodes.definition_list_item()
test_def += term
defn = nodes.definition()
test_def += defn
deflist += test_def
# CURRENT : Parse direction list if provided, which is comma-separated
if 'direction' in self.options:
input = 0
output = 0
for p in self.options['direction'].split(","):
# print "Testing `" + p.strip() + "' in test_procedure `" + self.name + "'..."
if p == "input":
input = 1
if p == "output":
output = 2
self.direction = input + output
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset, defn)
option_map = {}
option_map['setup'] = 'Required setup'
option_map['direction'] = 'Direction (input|output|both)'
field_list = self.options_to_field_list(option_map)
if (field_list != None):
defn += field_list
#print "*** TestProcedure options setup = " + self.options['setup']
if 'setup' in self.options:
self.setup = self.options['setup']
self.parsed('test_procedure').append(self)
return [targetnode, deflist]
def run(self):
#self.assert_has_content()
self.document = self.state_machine.document
#text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name = self.arguments[0]
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
test_def = nodes.definition_list_item()
test_def += term
defn = nodes.definition()
test_def += defn
deflist += test_def
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset, defn)
option_map = {}
option_map['runtests'] = 'Tests to run'
field_list = self.options_to_field_list(option_map)
if 'runtests' in self.options:
self.runtests = []
for p in self.options['runtests'].split(","):
# print "Testing for `" + p.strip() + "' in prepare_setup `" + self.name + "'..."
newruntests = [
t for t in self.parsed('test') if p.strip() == t.name
]
if len(newruntests) == 0:
sys.stderr.write(
"ERROR : runtests field couldn't expand to any tests for name `"
+ p.strip() + "'\n")
if (self.check_errors()):
exit(1)
# for t in newruntests :
# print "Runtests adding test : " + t.name
self.runtests.extend(newruntests)
else:
self.runtests = []
if (field_list != None):
defn += field_list
self.parsed('prepare_setup').append(self)
return [targetnode, deflist]
def codeitem_directive(dirname, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
if not content:
content = [u""]
m = _CALLABLE_RE.match(u"".join(arguments))
m2 = _OTHER_RE.match(u"".join(arguments))
if m:
g = m.groupdict()
if g['rest'] is None:
g['rest'] = ''
if g['args'].strip():
firstline = "%s%s **%s** (``%s``) %s" % (g['pre'].replace('*', r'\*'),
g['module'], g['name'],
g['args'], g['rest'])
else:
firstline = "%s%s **%s** () %s" % (g['pre'].replace('*', r'\*'),
g['module'], g['name'],
g['rest'])
if g['module']:
target = '%s%s' % (g['module'], g['name'])
else:
target = g['name']
elif m2:
g = m2.groupdict()
firstline = "%s%s **%s**" % (g['pre'].replace('*', r'\*'),
g['module'], g['name'])
if g['module']:
target = '%s%s' % (g['module'], g['name'])
else:
target = g['name']
else:
firstline = u"".join(arguments)
target = None
dl = nodes.definition_list()
di = nodes.definition_list_item()
dl += di
title_stuff, messages = state.inline_text(firstline, lineno)
dt = nodes.term(firstline, *title_stuff)
di += dt
dd = nodes.definition()
di += dd
if target:
dt['ids'] += [rst.make_target_id(target)]
dl['classes'] += [dirname, 'code-item']
_nested_parse(state, content, dd)
return [dl]
def contribute_properties(self, parent):
if not self.props_schemata:
return
section = self._section(parent, _('Properties'), '%s-props')
prop_list = nodes.definition_list()
section.append(prop_list)
for prop_key, prop in sorted(self.props_schemata.items(),
self.cmp_prop):
if prop.support_status.status != support.HIDDEN:
self.contribute_property(prop_list, prop_key, prop)
def rst_nodes(self):
defs = []
# Get all the memberdef info
for memberdef in self.memberdef:
defs.extend(memberdef.rst_nodes())
def_list = nodes.definition_list("", *defs)
# Return with information about which section this is
return [def_list]
def render(self):
symbol = self.symbol()
if not symbol.exceptions:
yield nodes.paragraph(text=_('None.'))
else:
definition_list = nodes.definition_list()
for k, v in symbol.exceptions.iteritems():
definition_list_item = nodes.definition_list_item('',
nodes.term('', '', nodes.literal('', k)),
nodes.definition('', nodes.paragraph(text=v)))
definition_list.append(definition_list_item)
yield definition_list
def codeitem_directive(dirname, arguments, options, content, lineno, content_offset, block_set, state, state_machine):
if not content:
content = [u""]
m = _CALLABLE_RE.match(u"".join(arguments))
m2 = _OTHER_RE.match(u"".join(arguments))
if m:
g = m.groupdict()
if g["rest"] is None:
g["rest"] = ""
if g["args"].strip():
firstline = "%s%s **%s** (``%s``) %s" % (
g["pre"].replace("*", r"\*"),
g["module"],
g["name"],
g["args"],
g["rest"],
)
else:
firstline = "%s%s **%s** () %s" % (g["pre"].replace("*", r"\*"), g["module"], g["name"], g["rest"])
if g["module"]:
target = "%s%s" % (g["module"], g["name"])
else:
target = g["name"]
elif m2:
g = m2.groupdict()
firstline = "%s%s **%s**" % (g["pre"].replace("*", r"\*"), g["module"], g["name"])
if g["module"]:
target = "%s%s" % (g["module"], g["name"])
else:
target = g["name"]
else:
firstline = u"".join(arguments)
target = None
dl = nodes.definition_list()
di = nodes.definition_list_item()
dl += di
title_stuff, messages = state.inline_text(firstline, lineno)
dt = nodes.term(firstline, *title_stuff)
di += dt
dd = nodes.definition()
di += dd
if target:
dt["ids"] += [target]
dl["classes"] += [dirname, "code-item"]
_nested_parse(state, content, dd)
return [dl]
def contribute_properties(self, parent):
if not self.props_schemata:
return
section = self._section(parent, _('Properties'), '%s-props')
prop_list_required = nodes.definition_list()
subsection_required = self._section(section, _('required'),
'%s-props-req')
subsection_required.append(prop_list_required)
prop_list_optional = nodes.definition_list()
subsection_optional = self._section(section, _('optional'),
'%s-props-opt')
subsection_optional.append(prop_list_optional)
for prop_key, prop in sorted(self.props_schemata.items(),
self.cmp_prop):
if prop.support_status.status != support.HIDDEN:
if prop.required:
prop_list = prop_list_required
else:
prop_list = prop_list_optional
self.contribute_property(prop_list, prop_key, prop)
def run(self):
refid = 'cmdoption-arg-' + nodes.make_id(self.arguments[0])
target = nodes.target(names=[refid], ids=[refid])
dl = nodes.definition_list()
dt = nodes.definition_list_item()
term = nodes.term()
term += nodes.literal(self.arguments[0], self.arguments[0], classes=["descname"])
dt += term
definition = nodes.definition()
dt += definition
definition.document = self.state.document
self.state.nested_parse(self.content, self.content_offset, definition)
dl += dt
return [target, dl]
def run(self):
#self.assert_has_content()
self.document = self.state_machine.document
#text = '\n'.join(self.content)
# Create the admonition node, to be populated by `nested_parse`.
self.name = self.arguments[0]
term = nodes.term()
term += nodes.strong(text=self.arguments[0])
targetnode = self.make_targetnode()
deflist = nodes.definition_list()
test_def = nodes.definition_list_item()
test_def += term
defn = nodes.definition()
test_def += defn
deflist += test_def
# Parse the directive contents.
self.state.nested_parse(self.content, self.content_offset, defn)
option_map = {}
option_map['runtests'] = 'Tests to run'
field_list = self.options_to_field_list(option_map)
if 'runtests' in self.options:
self.runtests = []
for p in self.options['runtests'].split(","):
# print "Testing for `" + p.strip() + "' in prepare_setup `" + self.name + "'..."
newruntests = [t for t in self.parsed('test') if p.strip() == t.name]
if len(newruntests) == 0:
sys.stderr.write("ERROR : runtests field couldn't expand to any tests for name `" + p.strip() + "'\n")
if (self.check_errors()):
exit(1)
# for t in newruntests :
# print "Runtests adding test : " + t.name
self.runtests.extend(newruntests)
else:
self.runtests = []
if (field_list != None):
defn += field_list
self.parsed('prepare_setup').append(self)
return [targetnode, deflist]
def document_group(self):
rv = nodes.definition_list()
try:
(children, groups) = \
self.get_child_elements(self.entity, nodeclass=nodes.paragraph)
except TypeError:
return [build_paragraph(nodes.strong("Any", "Any"),
" arbitrary element allowed")]
append_node(rv, nodes.term, text("Elements:"))
append_node(rv, nodes.definition, *children)
if len(groups):
append_node(rv, nodes.term, text("Element groups:"))
append_node(rv, nodes.definition, *groups)
return rv
def render(self):
symbol = self.symbol()
if not symbol.params:
yield nodes.paragraph(text=_('None.'))
else:
definition_list = nodes.definition_list()
for param in symbol.params:
param_name = param.get('declname')
if param_name is not None:
param_desc = param.get('briefdescription', '')
definition_list_item = nodes.definition_list_item('',
nodes.term('', '', nodes.literal('', param_name)),
nodes.definition('', nodes.paragraph(text=param_desc)))
definition_list.append(definition_list_item)
yield definition_list
def print_command_args_and_opts(arg_list, opt_list, sub_list=None):
items = []
if arg_list:
items.append(nodes.definition_list_item(
'', nodes.term(text='Positional arguments:'),
nodes.definition('', arg_list)))
if opt_list:
items.append(nodes.definition_list_item(
'', nodes.term(text='Options:'),
nodes.definition('', opt_list)))
if sub_list and len(sub_list):
items.append(nodes.definition_list_item(
'', nodes.term(text='Sub-commands:'),
nodes.definition('', sub_list)))
return nodes.definition_list('', *items)