def run(self):
env = self.state.document.settings.env
arg0 = self.arguments[0]
is_nextversion = env.config.django_next_version == arg0
ret = []
node = addnodes.versionmodified()
ret.append(node)
if not is_nextversion:
if len(self.arguments) == 1:
linktext = u'リリースノートを参照してください </releases/%s>' % (arg0)
xrefs = roles.XRefRole()('doc', linktext, linktext,
self.lineno, self.state)
node.extend(xrefs[0])
node['version'] = arg0
else:
node['version'] = "Development version"
node['type'] = self.name
if len(self.arguments) == 2:
inodes, messages = self.state.inline_text(self.arguments[1],
self.lineno + 1)
node.extend(inodes)
if self.content:
self.state.nested_parse(self.content, self.content_offset,
node)
ret = ret + messages
env.note_versionchange(node['type'], node['version'], node,
self.lineno)
return ret
def run(self):
env = self.state.document.settings.env
arg0 = self.arguments[0]
is_nextversion = env.config.next_version == arg0
ret = []
node = addnodes.versionmodified()
ret.append(node)
if is_nextversion:
node['version'] = "Development version"
else:
if len(self.arguments) == 1:
# linktext = 'Please, see the Changelog <0_0_4>'
# xrefs = roles.XRefRole()('release', linktext, linktext, self.lineno, self.state)
# node.extend(xrefs[0])
linktext = 'Please, see the Changelog <changes>'
xrefs = roles.XRefRole()('doc', linktext, linktext, self.lineno, self.state)
node.extend(xrefs[0])
node['version'] = arg0
node['type'] = self.name
if len(self.arguments) == 2:
inodes, messages = self.state.inline_text(self.arguments[1], self.lineno + 1)
node.extend(inodes)
if self.content:
self.state.nested_parse(self.content, self.content_offset, node)
ret = ret + messages
env.note_versionchange(node['type'], node['version'], node, self.lineno)
return ret
def txtref_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
xref_role = roles.XRefRole(lowercase=True,
innernodeclass=nodes.inline,
warn_dangling=True)
def extract_ref_words(ref):
return [item for sub in ref.split('-') for item in sub.split('_')]
def make_term_text(words, ref, suffix=''):
txt = ' '.join(words).strip()
txt = txt[0].lower() + txt[1:]
return f"{txt}{suffix} <{ref.strip()}>"
term_match = _term_txt_ref_re.match(text)
if term_match:
alias, ref, suffix = term_match.group(1), term_match.group(
2), term_match.group(3)
if len(alias) > 0 and len(suffix) == 0:
fixed_term = text
elif len(alias) == 0 and len(suffix) > 0:
words = extract_ref_words(ref)
fixed_term = make_term_text(words, ref, suffix)
else:
raise RuntimeError('Unexpected role syntax: ' + rawtext)
else:
ref, words = text, extract_ref_words(text)
fixed_term = make_term_text(words, ref)
return xref_role('std:ref', rawtext, fixed_term, lineno, inliner, options,
content)
def parse_version_directive(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
env = state.document.settings.env
is_nextversion = env.config.django_next_version == arguments[0]
ret = []
node = addnodes.versionmodified()
ret.append(node)
if not is_nextversion:
if len(arguments) == 1:
linktext = 'Please, see the release notes <releases-%s>' % (
arguments[0])
try:
xrefs = roles.XRefRole()('ref', linktext, linktext, lineno,
state) # Sphinx >= 1.0
except:
xrefs = roles.xfileref_role('ref', linktext, linktext, lineno,
state) # Sphinx < 1.0
node.extend(xrefs[0])
node['version'] = arguments[0]
else:
node['version'] = "Development version"
node['type'] = name
if len(arguments) == 2:
inodes, messages = state.inline_text(arguments[1], lineno + 1)
node.extend(inodes)
if content:
state.nested_parse(content, content_offset, node)
ret = ret + messages
env.note_versionchange(node['type'], node['version'], node, lineno)
return ret
def run(self):
env = self.state.document.settings.env
arg0 = self.arguments[0]
is_nextversion = env.config.django_next_version == arg0
ret = []
node = addnodes.versionmodified()
ret.append(node)
if not is_nextversion:
if len(self.arguments) == 1:
linktext = 'Please, see the release notes <releases-%s>' % \
(arg0,)
try:
# Sphinx >= 1.0
xrefs = roles.XRefRole()('std:ref', linktext, linktext,
self.lineno, self.state)
except AttributeError:
# Sphinx < 1.0
xrefs = roles.xfileref_role('ref', linktext, linktext,
self.lineno, self.state)
node.extend(xrefs[0])
node['version'] = arg0
else:
node['version'] = "Development version"
node['type'] = self.name
if len(self.arguments) == 2:
inodes, messages = self.state.inline_text(self.arguments[1],
self.lineno + 1)
node.extend(inodes)
if self.content:
self.state.nested_parse(self.content, self.content_offset,
node)
ret = ret + messages
env.note_versionchange(node['type'], node['version'], node,
self.lineno)
return ret
def capterm_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
xref_role = roles.XRefRole(innernodeclass=nodes.inline, warn_dangling=True)
term_match = _term_ref_re.match(text)
if term_match:
txt, ref = term_match.group(1), term_match.group(2)
else:
txt, ref = text, text
fixed_term = f'{txt.strip()} <{ref.strip().capitalize()}>'
return xref_role('std:term', rawtext, fixed_term, lineno, inliner, options,
content)
def run(self):
env = self.state.document.settings.env
arg0 = self.arguments[0]
ret = []
node = addnodes.versionmodified()
ret.append(node)
node['type'] = self.name
if env.config.next_version == arg0:
version = "Development version"
link = None
else:
version = arg0
link = 'release-%s' % arg0
node['version'] = version
# inodes, messages = self.state.inline_text(self.version_text[self.name] % version, self.lineno+1)
# node.extend(inodes)
if link:
text = ' Please see the changelog <%s>' % link
xrefs = roles.XRefRole()('std:ref', text, text, self.lineno, self.state)
node.extend(xrefs[0])
env.note_versionchange(node['type'], node['version'], node, self.lineno)
return ret
class EdgeQLDomain(s_domains.Domain):
name = "eql"
label = "EdgeQL"
object_types = {
'function': s_domains.ObjType('function', 'func', 'func-desc'),
'constraint': s_domains.ObjType('constraint', 'constraint'),
'type': s_domains.ObjType('type', 'type'),
'keyword': s_domains.ObjType('keyword', 'kw'),
'operator': s_domains.ObjType('operator', 'op', 'op-desc'),
'statement': s_domains.ObjType('statement', 'stmt'),
}
_role_to_object_type = {
role: tn
for tn, td in object_types.items() for role in td.roles
}
directives = {
'function': EQLFunctionDirective,
'constraint': EQLConstraintDirective,
'type': EQLTypeDirective,
'keyword': EQLKeywordDirective,
'operator': EQLOperatorDirective,
'synopsis': EQLSynopsisDirective,
'react-element': EQLReactElement,
'struct': EQLStructElement,
}
roles = {
'func': EQLFunctionXRef(),
'func-desc': EQLFunctionDescXRef(),
'constraint': EQLConstraintXRef(),
'type': EQLTypeXRef(),
'kw': s_roles.XRefRole(),
'op': s_roles.XRefRole(),
'op-desc': EQLOperatorDescXRef(),
'stmt': s_roles.XRefRole(),
'gh': GitHubLinkRole(),
}
desc_roles = {
'func-desc',
'op-desc',
}
initial_data = {
'objects': {} # fullname -> docname, objtype, description
}
def resolve_xref(self, env, fromdocname, builder,
type, target, node, contnode):
objects = self.data['objects']
expected_type = self._role_to_object_type[type]
target = target.replace(' ', '-')
if expected_type == 'keyword':
targets = [f'keyword::{target}']
elif expected_type == 'operator':
targets = [f'operator::{target}']
elif expected_type == 'statement':
targets = [f'statement::{target}']
elif expected_type in {'type', 'function', 'constraint'}:
targets = [f'{expected_type}::{target}']
if '::' not in target:
targets.append(f'{expected_type}::std::{target}')
else:
targets = [target]
docname = None
obj_type = None
obj_desc = None
for target in targets:
try:
docname, obj_type, obj_desc = objects[target]
except KeyError:
continue
if docname is None:
if not node.get('eql-auto-link'):
raise shared.DomainError(
f'cannot resolve :eql:{type}: targeting {target!r}')
else:
return
if obj_type != expected_type:
raise shared.DomainError(
f'cannot resolve :eql:{type}: targeting {target!r}: '
f'the type of referred object {expected_type!r} '
f'does not match the reftype')
if node['reftype'] in self.desc_roles:
node = d_nodes.Text(obj_desc)
else:
node = s_nodes_utils.make_refnode(
builder, fromdocname, docname, target, contnode, None)
node['eql-type'] = obj_type
return node
def clear_doc(self, docname):
for fullname, (fn, _l, _d) in list(self.data['objects'].items()):
if fn == docname:
del self.data['objects'][fullname]
def merge_domaindata(self, docnames, otherdata):
for fullname, (fn, objtype, desc) in otherdata['objects'].items():
if fn in docnames:
self.data['objects'][fullname] = (fn, objtype, desc)
def get_objects(self):
for refname, (docname, type, _desc) in self.data['objects'].items():
yield (refname, refname, type, docname, refname, 1)
def get_full_qualified_name(self, node):
fn = node.get('eql-fullname')
if not fn:
raise shared.DirectiveParseError(
self, 'no eql-fullname attribute')
return fn
class EdgeQLDomain(s_domains.Domain):
name = "eql"
label = "EdgeQL"
object_types = {
'function': s_domains.ObjType('function', 'func', 'func-desc'),
'constraint': s_domains.ObjType('constraint', 'constraint'),
'type': s_domains.ObjType('type', 'type'),
'keyword': s_domains.ObjType('keyword', 'kw'),
'operator': s_domains.ObjType('operator', 'op', 'op-desc'),
'statement': s_domains.ObjType('statement', 'stmt'),
}
_role_to_object_type = {
role: tn
for tn, td in object_types.items() for role in td.roles
}
directives = {
'function': EQLFunctionDirective,
'constraint': EQLConstraintDirective,
'type': EQLTypeDirective,
'keyword': EQLKeywordDirective,
'operator': EQLOperatorDirective,
'synopsis': EQLSynopsisDirective,
'react-element': EQLReactElement,
'section-intro-page': EQLSectionIntroPage,
'struct': EQLStructElement,
}
roles = {
'func': EQLFunctionXRef(),
'func-desc': EQLFunctionDescXRef(),
'constraint': EQLConstraintXRef(),
'type': EQLTypeXRef(),
'kw': s_roles.XRefRole(),
'op': s_roles.XRefRole(),
'op-desc': EQLOperatorDescXRef(),
'stmt': s_roles.XRefRole(),
'gh': GitHubLinkRole(),
}
desc_roles = {
'func-desc',
'op-desc',
}
initial_data: Dict[str, Dict[str, Any]] = {
'objects': {} # fullname -> docname, objtype, description
}
def resolve_xref(self, env, fromdocname, builder, type, target, node,
contnode):
objects = self.data['objects']
expected_type = self._role_to_object_type[type]
target = target.replace(' ', '-')
if expected_type == 'keyword':
targets = [f'keyword::{target}']
elif expected_type == 'operator':
targets = [f'operator::{target}']
elif expected_type == 'statement':
targets = [f'statement::{target}']
elif expected_type in {'type', 'function', 'constraint'}:
targets = [f'{expected_type}::{target}']
if '::' not in target:
targets.append(f'{expected_type}::std::{target}')
else:
targets = [target]
docname = None
obj_type = None
obj_desc = None
for target in targets:
try:
docname, obj_type, obj_desc = objects[target]
except KeyError:
continue
if docname is None:
if not node.get('eql-auto-link'):
# if ref was not found, the :eql: xref may be being used
# outside of the docs, so try resolving ref from intersphinx
# inventories
inventories = InventoryAdapter(env)
for target in targets:
obj_type, name = target.split('::', 1)
if ':' not in name:
continue
docset_name, name = name.split(':', 1)
docset = inventories.named_inventory.get(docset_name)
if docset is None:
continue
refs = docset.get('eql:' + obj_type)
if refs is None:
continue
ref = refs.get(obj_type + '::' + name)
if ref is None:
continue
newnode = d_nodes.reference(
'',
'',
internal=False,
refuri=ref[2],
)
if node.get('refexplicit'):
newnode.append(d_nodes.Text(contnode.astext()))
else:
title = contnode.astext()
newnode.append(
contnode.__class__(title[len(docset_name) + 1:],
title[len(docset_name) + 1:]))
return newnode
raise shared.DomainError(
f'cannot resolve :eql:{type}: targeting {target!r}')
else:
return
if obj_type != expected_type:
raise shared.DomainError(
f'cannot resolve :eql:{type}: targeting {target!r}: '
f'the type of referred object {expected_type!r} '
f'does not match the reftype')
if node['reftype'] in self.desc_roles:
node = d_nodes.Text(obj_desc)
else:
node = s_nodes_utils.make_refnode(builder, fromdocname, docname,
target, contnode, None)
node['eql-type'] = obj_type
return node
def resolve_any_xref(self, env, fromdocname, builder, target, node,
contnode):
# 'myst-parser' resolves all markdown links as :any: xrefs, so return
# empty list to prevent sphinx trying to resolve these as :eql: refs
return []
def clear_doc(self, docname):
for fullname, (fn, _l, _d) in list(self.data['objects'].items()):
if fn == docname:
del self.data['objects'][fullname]
def merge_domaindata(self, docnames, otherdata):
for fullname, (fn, objtype, desc) in otherdata['objects'].items():
if fn in docnames:
self.data['objects'][fullname] = (fn, objtype, desc)
def get_objects(self):
for refname, (docname, type, _desc) in self.data['objects'].items():
yield (refname, refname, type, docname, refname, 1)
def get_full_qualified_name(self, node):
fn = node.get('eql-fullname')
if not fn:
raise self.error('no eql-fullname attribute')
return fn
