def transform_content(self, contentnode: addnodes.desc_content) -> None:
if 'options' in self.options:
code_block_directive = CodeBlock(
name='code-block',
arguments=[],
options={
'caption': 'Options',
},
content=[self.options['options']],
lineno=self.lineno,
content_offset=self.content_offset,
block_text='',
state=self.state,
state_machine=self.state_machine)
contentnode += code_block_directive.run()[0]
if 'examples' in self.options:
code_block_directive = CodeBlock(
name='code-block',
arguments=[],
options={
'caption': 'Examples',
},
content=[self.options['examples'].replace('\n::\n', '\n\n')],
lineno=self.lineno,
content_offset=self.content_offset,
block_text='',
state=self.state,
state_machine=self.state_machine)
contentnode += code_block_directive.run()[0]
if self.display_code_block:
code_block_content = []
for name_prefix in self.names:
name, prefix = name_prefix
line = name
if 'suffix' in self.options:
if self.space_between_suffix:
line += ' '
line += self.options['suffix']
if 'prefix' in self.options:
line = self.options['prefix'] + line
if prefix and self.prefix_in_code_block:
line = prefix + line
code_block_content.append(line)
code_block_directive = CodeBlock(
name='code-block',
arguments=[],
options={},
content=code_block_content,
lineno=self.lineno,
content_offset=self.content_offset,
block_text='',
state=self.state,
state_machine=self.state_machine)
contentnode.insert(0, code_block_directive.run()[0])
def run(self):
node_list = super(PygalWithCode, self).run()
node_list.extend(
CodeBlock(self.name, ['python'], self.options, self.content,
self.lineno, self.content_offset, self.block_text,
self.state, self.state_machine).run())
return [docutils.nodes.compound('', *node_list)]
def run(self):
node = addnodes.desc_content()
self.state.nested_parse(self.content, self.content_offset, node)
return [
CodeBlock(self.name, ['rst'], {}, self.content, self.lineno,
self.content_offset, self.block_text, self.state,
self.state_machine).run()[0], node
]
def create_generic_code_block(self, lexer):
properties = self.supported_lexers[lexer]
content = (
"We don't have a {} code example for this API call yet.\n\n" +
"If you have some time to spare, feel free to open a pull request at:\n"
+ "https://github.com/centrahq/api-documentation").format(
properties["language_text"])
code_block = CodeBlock("generic-code-block", ["html"],
{"linenos": True}, [content], self.lineno,
self.content_offset, self.block_text,
self.state, self.state_machine)
parsed_block = code_block.run()
return parsed_block[0]
def run(self):
ret = []
# Provide a dummy argument to match the spec of GraphvizSimple.
self.arguments = ['Mini_Cylc']
# Generate Cylc code snippet if requested.
if 'snippet' in self.options:
ret.extend(
CodeBlock(
self.name,
['cylc-graph'],
{}, # Opts.
self.content,
self.lineno,
self.content_offset,
self.block_text,
self.state,
self.state_machine).run())
# Clean up graphing.
self.rationalise_graphing()
clean_graphing = self.content
# Generate dotcode for graphviz.
# dotcode = ['bgcolor=none'] now set in conf.py:graphviz_dot_args
dotcode = []
if 'size' in self.options:
dotcode.append('size="%s"' % self.options['size'])
for left, right, conditional in self.get_triggers(self.content):
if left:
dotcode.append(
'%s -> %s%s' %
(left, right, ' [arrowhead=o]' if conditional else ''))
else:
dotcode.append(right)
self.content = dotcode
# Get MiniCylc node.
node = MiniCylc.promote_graphviz(GraphvizSimple.run(self)[0])
node['graph_lines'] = clean_graphing
if 'theme' in self.options:
node['theme'] = self.options['theme']
ret.append(node)
return ret
def run(self):
config = self.state.document.settings.env.config
# Read enabled builders; Defaults to None
chosen_builders = choose_builders(self.arguments)
# Enable 'http' language for http part
self.arguments = ['http']
# process 'query' reST fields
if self.content:
raw = ('\r\n'.join(self.content)).encode('utf-8')
request = parsers.parse_request(raw)
params, _ = request.extract_fields('query')
params = [(p[1], p[2]) for p in params]
new_path = utils.add_url_params(request.path, params)
self.content[0] = ' '.join(
[request.command, new_path, request.request_version])
# split the request and optional response in the content.
# The separator is two empty lines followed by a line starting with
# 'HTTP/' or 'HTTP '
request_content = StringList()
request_content_no_fields = StringList()
response_content = None
emptylines_count = 0
in_response = False
is_field = r':({}) (.+): (.+)'.format('|'.join(AVAILABLE_FIELDS))
for i, line in enumerate(self.content):
source = self.content.source(i)
if in_response:
response_content.append(line, source)
else:
if emptylines_count >= 2 and \
(line.startswith('HTTP/') or line.startswith('HTTP ')):
in_response = True
response_content = StringList()
response_content.append(line, source)
elif line == '':
emptylines_count += 1
else:
request_content.extend(
StringList([''] * emptylines_count, source))
request_content.append(line, source)
if not re.match(is_field, line):
request_content_no_fields.extend(
StringList([''] * emptylines_count, source))
request_content_no_fields.append(line, source)
emptylines_count = 0
# Load optional external request
cwd = os.path.dirname(self.state.document.current_source)
if 'request' in self.options:
request = utils.resolve_path(self.options['request'], cwd)
with open(request) as fp:
request_content = request_content_no_fields = StringList(
list(map(str.rstrip, fp.readlines())), request)
# Load optional external response
if 'response' in self.options:
response = utils.resolve_path(self.options['response'], cwd)
with open(response) as fp:
response_content = StringList(
list(map(str.rstrip, fp.readlines())), response)
# reset the content to the request, stripped of the reST fields
self.content = request_content_no_fields
# Wrap and render main directive as 'http-example-http'
klass = 'http-example-http'
container = nodes.container('', classes=[klass])
container.append(nodes.caption('', 'http'))
container.extend(super(HTTPExample, self).run())
# Init result node list
result = [container]
# reset the content to just the request
self.content = request_content
# Append builder responses
if request_content_no_fields:
raw = ('\r\n'.join(request_content_no_fields)).encode('utf-8')
for name in chosen_builders:
request = parsers.parse_request(raw, config.httpexample_scheme)
builder_, language = AVAILABLE_BUILDERS[name]
command = builder_(request)
content = StringList([command],
request_content_no_fields.source(0))
options = self.options.copy()
options.pop('name', None)
options.pop('caption', None)
block = CodeBlock('code-block', [language], options, content,
self.lineno, self.content_offset,
self.block_text, self.state,
self.state_machine)
# Wrap and render main directive as 'http-example-{name}'
klass = 'http-example-{}'.format(name)
container = nodes.container('', classes=[klass])
container.append(nodes.caption('', name))
container.extend(block.run())
# Append to result nodes
result.append(container)
# Append optional response
if response_content:
options = self.options.copy()
options.pop('name', None)
options.pop('caption', None)
block = CodeBlock('code-block', ['http'], options,
response_content, self.lineno,
self.content_offset, self.block_text, self.state,
self.state_machine)
# Wrap and render main directive as 'http-example-response'
klass = 'http-example-response'
container = nodes.container('', classes=[klass])
container.append(nodes.caption('', 'response'))
container.extend(block.run())
# Append to result nodes
result.append(container)
# Final wrap
container_node = nodes.container('', classes=['http-example'])
container_node.extend(result)
return [container_node]
