def class_sig(self, interface, inheritance):
fixtures = '@pytest.mark.usefixtures("{0}_class_fixture", "{0}_test_fixture")'.format(
camel_to_under(interface['shortname']))
return '{0}\nclass Test{1}{2}:'.format(fixtures,
interface['shortname'],
inheritance)
def get_relationship_form_args(self, source_type, destination_type):
arg_list = []
for object_type in [source_type, destination_type]:
if object_type == 'UNKNOWN':
pass
elif object_type == 'osid.authentication.Agent':
arg_list.append('AGENT_ID')
elif object_type.split('.')[-1] in self.patterns[
'package_cataloged_objects_caps']:
arg_list.append('request.cls.' +
camel_to_under(object_type.split('.')[-1]) +
'.ident')
else:
arg_list.append(
camel_to_under(object_type.split('.')[-1]) + '_id')
arg_list.append('[]')
return ', '.join(arg_list)
def get_object_tear_down(self, object_type):
if object_type.split(
'.')[-1] in self.patterns['package_cataloged_objects_caps']:
cat_name_under = self.patterns['package_catalog_under']
object_name_under = camel_to_under(object_type.split('.')[-1])
return '\n request.cls.{0}_list[0].delete_{1}(request.cls.{1}.ident)'.format(
cat_name_under, object_name_under)
else:
return ''
def update_relationships_detail(relationships,
interface,
source=None,
dest=None,
source_unknown=False,
dest_unknown=False):
if source is None and dest is None:
relationships[camel_to_under(interface['shortname'])] = {
'source_name': 'source',
'source_type': 'osid.id.Id',
'destination_name': 'destination',
'destination_type': 'osid.id.Id'
}
else:
if not source_unknown and not dest_unknown:
relationships[camel_to_under(interface['shortname'])] = {
'source_name': source['name'][4:],
'source_type': source['return_type'],
'destination_name': dest['name'][4:],
'destination_type': dest['return_type']
}
elif not source_unknown and dest_unknown:
relationships[camel_to_under(interface['shortname'])] = {
'source_name': source['name'][4:],
'source_type': source['return_type'],
'destination_name': dest['name'][4:-3],
'destination_type': 'UNKNOWN'
}
elif source_unknown and not dest_unknown:
relationships[camel_to_under(interface['shortname'])] = {
'source_name': source['name'][4:-3],
'source_type': 'UNKNOWN',
'destination_name': dest['name'][4:],
'destination_type': dest['return_type']
}
else:
relationships[camel_to_under(interface['shortname'])] = {
'source_name': 'UNKNOWN',
'source_type': 'UNKNOWN',
'destination_name': 'UNKNOWN',
'destination_type': 'UNKNOWN'
}
def interface_iterator(root):
interface = OrderedDict()
interface['fullname'] = root.get(XOSID_NS + 'name')
interface['shortname'] = root.get(XOSID_NS + 'name').split('.')[-1]
# Initialize the various dictionary elements so as to assure that there
# will always be a return value, even if it is empty, since not all of
# these will be caught in the for loop. This also helps ensure that the
# ordering matches the example package, not that it matters.
interface['category'] = ''
interface['doc'] = {'headline': '', 'body': ''}
interface['inherit_fullnames'] = []
interface['inherit_shortnames'] = []
interface['inherit_pkg_names'] = []
interface['inheritance'] = []
interface['method_names'] = []
interface['methods'] = []
for child in root:
if child.tag == (XOSID_NS + 'implements'):
if child.get(XOSID_NS + 'interface'):
interface['inherit_fullnames'].append(
child.get(XOSID_NS + 'interface'))
interface['inherit_shortnames'].append(
child.get(XOSID_NS + 'interface').split('.')[-1])
interface['inherit_pkg_names'].append(
child.get(XOSID_NS + 'interface').split('.')[-2])
interface['inheritance'].append({
'name':
child.get(XOSID_NS + 'interface').split('.')[-1],
'pkg_name':
get_pkg_name(child.get(XOSID_NS + 'interface'))
})
# 'pkg_name': child.get(XOSID_NS + 'interface').split('.')[-2]})
if child.tag == (XOSID_NS + 'description'):
interface['doc'] = parse_docstring(process_text(child, ' '),
' ')
# Clean trailing whitespace issues:
body = interface['doc']['body']
interface['doc']['body'] = '\n\n'.join(body.split('\n \n'))
if child.tag == (XOSID_NS + 'method'):
interface['method_names'].append(
camel_to_under(child.get(XOSID_NS + 'name')))
interface['methods'].append(
add_missing_args(method_iterator(child),
interface['shortname']))
# add_missing_args(method_iterator(child), interface['shortname'])
interface['category'] = get_interface_category(
interface['inherit_shortnames'], interface['shortname'])
add_missing_methods(interface)
return interface
def make_sphinx_param_doc(root):
# Iterate through the method tree and return the Sphinx-style documentation
# strings regarding method parameters.
from binder_helpers import wrap_and_indent, camel_to_under
param_str = ':param ' + camel_to_under(root.get(XOSID_NS + 'name')) + ': '
type_str = ':type ' + camel_to_under(root.get(XOSID_NS + 'name')) + ': '
for child in root:
if child.tag == (XOSID_NS + 'interfaceType'):
type_str = type_str + '``' + child.get(XOSID_NS + 'type')
if child.get(XOSID_NS + 'array') == 'true':
type_str += '[]``'
else:
type_str += '``'
if child.tag == (XOSID_NS + 'primitiveType'):
type_str = type_str + '``' + child.get(XOSID_NS + 'type')
if child.get(XOSID_NS + 'array') == 'true':
type_str += '[]``'
else:
type_str += '``'
if child.tag == (XOSID_NS + 'description'):
param_str = param_str + process_text(child, '', '', width=200)
return ' ' + param_str.strip() + '\n ' + type_str.strip(
) + '\n'
def get_create_object(self, object_type, relationship_object_name_under):
if object_type in ['UNKNOWN', 'osid.authentication.Agent']:
return ''
elif object_type.split(
'.')[-1] in self.patterns['package_cataloged_objects_caps']:
cat_name_under = self.patterns['package_catalog_under']
object_name = object_type.split('.')[-1]
object_name_under = camel_to_under(object_name)
relationship_object_name = under_to_caps(
relationship_object_name_under)
return """
create_form = request.cls.{0}_list[0].get_{1}_form_for_create([])
create_form.display_name = '{2} for {3} Tests'
create_form.description = '{2} for authz adapter tests for {3}'
request.cls.{1} = request.cls.{0}_list[0].create_{1}(create_form)""".format(
cat_name_under, object_name_under, object_name,
relationship_object_name)
else:
object_name = object_type.split('.')[-1]
object_name_under = camel_to_under(object_name)
pkg_name = object_type.split('.')[1]
return """
{0}_id = Id(authority='TEST', namespace='{1}.{2}', identifier='TEST')""".format(
object_name_under, pkg_name, object_name)
def write_class(self, interface, imports, body):
# Writes one java class per file:
if body != '' and len(interface['fullname'].split(
'.')) != 2: # Hack to not build osid
class_name = 'test_' + camel_to_under(
interface['shortname'][:-13]) + '_authz'
# module_dir = self._abc_pkg_path(abc=True) + '/authz_tests/'
module_dir = self._app_name(
) + '/functional/test_authz/' + self._abc_pkg_name(abc=True) + '/'
module_path = module_dir + class_name + '.py'
# module_path = self._abc_module(class_name, extension='py')
self._make_dir(module_dir, python=True)
with open(module_path, 'wb') as write_file:
write_file.write('{0}\n\n{1}\n{2}\n'.format(
self.module_doc(interface), '\n'.join(imports),
body.strip()).encode('utf-8'))
def _get_init_context(self, init_pattern, interface):
context = super(TestAuthZBuilder,
self)._get_init_context(init_pattern, interface)
if init_pattern == 'commenting.CommentLookupSession':
print ' building relationship -', interface['shortname']
obj_name_under = camel_to_under(interface['shortname'].replace(
'LookupSession', ''))
try:
source_type = self.patterns['package_relationships_detail'][
obj_name_under]['source_type']
except KeyError:
source_type = 'KEY_ERROR'
try:
destination_type = self.patterns[
'package_relationships_detail'][obj_name_under][
'destination_type']
except KeyError:
destination_type = 'KEY_ERROR'
print ' source_type =', source_type
print ' destination_type =', destination_type
# source_obj_name = source_type.split('.')[-1]
# source_pkg_name = source_type.split('.')[-2]
# destination_obj_name = destination_type.split('.')[-1]
# destination_pkg_name = destination_type.split('.')[-2]
context['create_source_object'] = self.get_create_object(
source_type, obj_name_under)
context['create_destination_object'] = self.get_create_object(
destination_type, obj_name_under)
if context['create_destination_object'] == context[
'create_source_object']:
context['create_destination_object'] = ''
context[
'relationship_form_args'] = self.get_relationship_form_args(
source_type, destination_type)
source_tear_down = self.get_object_tear_down(source_type)
destination_tear_down = self.get_object_tear_down(destination_type)
context['tear_down_source_and_dest'] = source_tear_down
if destination_tear_down != source_tear_down:
context['tear_down_source_and_dest'] += destination_tear_down
return context
def make_param_doc(root):
# Iterate through the method tree and return the documentation strings
# regarding method parameters.
from binder_helpers import wrap_and_indent, camel_to_under
param_str = 'arg: ' + camel_to_under(root.get(XOSID_NS + 'name'))
for child in root:
if child.tag == (XOSID_NS + 'interfaceType'):
param_str = param_str + ' (' + child.get(XOSID_NS + 'type')
if child.get(XOSID_NS + 'array') == 'true':
param_str += '[]): '
else:
param_str += '): '
if child.tag == (XOSID_NS + 'primitiveType'):
param_str = param_str + ' (' + child.get(XOSID_NS + 'type')
if child.get(XOSID_NS + 'array') == 'true':
param_str += '[]): '
else:
param_str += '): '
if child.tag == (XOSID_NS + 'description'):
param_str = param_str + process_text(child, '', '')
return wrap_and_indent(param_str.strip(), ' ',
' ') + '\n'
def construct_arg_context(arg_number, arg_type_full):
arg_type = self.last(arg_type_full).strip('[]')
arg_context = {
arg_number + '_type':
arg_type,
arg_number + '_type_under':
camel_to_under(arg_type),
arg_number + '_type_mixed':
camel_to_mixed(arg_type),
arg_number + '_abcapp_name':
self._app_name(package_name=get_pkg_name(
arg_type_full.strip('[]')),
abstract=True),
arg_number + '_abcpkg_name':
self._abc_pkg_name(package_name=get_pkg_name(
arg_type_full.strip('[]')),
abc=False),
arg_number + '_module':
self.get_interface_module(
self._abc_pkg_name(
package_name=get_pkg_name(arg_type_full), abc=False),
arg_type)
}
return arg_context
def _make_mdata_maps(self, interface):
from jsonosid_templates import options
pd = interface['shortname'] + '.persisted_data'
rt = interface['shortname'] + '.return_types'
mdata = ('def get_' + camel_to_under(interface['shortname']) +
'_mdata():\n \"\"\"Return default mdata map for ' +
interface['shortname'] + '\"\"\"\n return {\n')
if pd in self.patterns and self.patterns[pd] != {}:
for data_name in self.patterns[pd]:
if self.patterns[pd][data_name] == 'OsidCatalog':
pass
elif (rt in self.patterns and
data_name in self.patterns[rt] and
self.patterns[rt][data_name] == 'osid.locale.DisplayText'):
mdata += self._make_mdata_map(interface['shortname'],
data_name,
'DisplayText',
options) # + '\n'
else:
mdata += self._make_mdata_map(interface['shortname'],
data_name,
self.patterns[pd][data_name],
options) # + '\n'
return mdata + ' }'
def method_iterator(root):
from binder_helpers import fix_reserved_word, camel_to_under, fix_bad_name
method = OrderedDict()
method['name'] = fix_bad_name(camel_to_under(root.get(XOSID_NS + 'name')))
# Initialize the various dictionary elements so as to assure that there
# will always be a return value, even if it is empty, since not all of
# these will be caught in the for loop. This also helps ensure that the
# ordering matches the example package, not that it matters.
method['doc'] = {'headline': '', 'body': ''}
method['arg_doc'] = ''
method['return_doc'] = ''
method['error_doc'] = ''
method['sphinx_param_doc'] = ''
method['sphinx_return_doc'] = ''
method['sphinx_error_doc'] = ''
method['compliance_doc'] = ''
method['impl_notes_doc'] = ''
method['args'] = []
method['arg_types'] = []
method['return_type'] = ''
method['errors'] = OrderedDict()
for child in root:
# Process main method documentation:
if child.tag == (XOSID_NS + 'description'):
method['doc'] = parse_docstring(process_text(child, ' '),
' ')
body = method['doc']['body']
method['doc']['body'] = '\n\n'.join(body.split('\n \n'))
# Process parameter info into args dictionary and doc:
if child.tag == (XOSID_NS + 'parameter'):
param = fix_reserved_word(
camel_to_under(child.get(XOSID_NS + 'name')))
array = False
for grand_child in child:
if grand_child.tag == (XOSID_NS + 'interfaceType'):
param_type = grand_child.get(XOSID_NS + 'type')
if grand_child.get(XOSID_NS + 'array') == 'true':
array = True
if grand_child.tag == (XOSID_NS + 'primitiveType'):
param_type = grand_child.get(XOSID_NS + 'type')
if grand_child.get(XOSID_NS + 'array') == 'true':
array = True
if array is True:
param_type += '[]'
method['args'].append({
'var_name': param,
'arg_type': param_type,
'array': array
})
method['arg_types'].append(param_type)
method['arg_doc'] = method['arg_doc'] + make_param_doc(child)
method['sphinx_param_doc'] += make_sphinx_param_doc(child)
# Process return info into return type and doc:
if child.tag == (XOSID_NS + 'return'):
for grand_child in child:
if grand_child.tag == (XOSID_NS + 'interfaceType'):
return_type = grand_child.get(XOSID_NS + 'type')
if grand_child.tag == (XOSID_NS + 'primitiveType'):
return_type = grand_child.get(XOSID_NS + 'type')
method['return_type'] = fix_bad_name(return_type, method['name'])
method['return_doc'] = make_return_doc(child)
method['sphinx_return_doc'] = make_sphinx_return_doc(child)
# Process error info into error doc. Note that at this time I
# am not parsing the exceptions. I have not found a need to do
# this as of yet.
if child.tag == (XOSID_NS + 'error'):
method['errors'][child.get(XOSID_NS +
'type')] = child.get(XOSID_NS +
'category')
if method['error_doc']:
method['error_doc'] += '\n'
if method['sphinx_error_doc']:
method['sphinx_error_doc'] += '\n'
method['error_doc'] = method['error_doc'] + make_error_doc(child)
method['sphinx_error_doc'] += make_sphinx_error_doc(child)
# Process compliance info into compliance doc.
if child.tag == (XOSID_NS + 'compliance'):
method['compliance_doc'] = make_compliance_doc(child)
# Process implementation notes into impl notes doc.
if child.tag == (XOSID_NS + 'implNotes'):
method['impl_notes_doc'] = make_implnotes_doc(child)
return method
def _get_method_context(self, method, interface):
"""Get the method context vars, to be used in the template"""
def construct_arg_context(arg_number, arg_type_full):
arg_type = self.last(arg_type_full).strip('[]')
arg_context = {
arg_number + '_type':
arg_type,
arg_number + '_type_under':
camel_to_under(arg_type),
arg_number + '_type_mixed':
camel_to_mixed(arg_type),
arg_number + '_abcapp_name':
self._app_name(package_name=get_pkg_name(
arg_type_full.strip('[]')),
abstract=True),
arg_number + '_abcpkg_name':
self._abc_pkg_name(package_name=get_pkg_name(
arg_type_full.strip('[]')),
abc=False),
arg_number + '_module':
self.get_interface_module(
self._abc_pkg_name(
package_name=get_pkg_name(arg_type_full), abc=False),
arg_type)
}
return arg_context
context = {}
if interface['shortname'] + '.' + method['name'] in self.patterns:
context = self.patterns[interface['shortname'] + '.' +
method['name']]['kwargs']
arg_list = []
for arg in method['args']:
arg_list.append(arg['var_name'])
context['arg_list'] = ', '.join(arg_list)
if 'package_name' in context:
# Add keyword arguments to template kwargs that are particular
# to the json implementation
fixed_package_name = fix_reserved_word(self.package['name'],
is_module=True)
context['app_name'] = self._app_name()
context['implpkg_name'] = self._abc_pkg_name(abc=False,
reserved_word=False)
context['abcapp_name'] = self._app_name()
context['abcpkg_name'] = self._abc_pkg_name(abc=False)
context['interface_name_under'] = camel_to_under(
context['interface_name'])
context['interface_name_dot'] = '.'.join(
context['interface_name_under'].split('_')[:-1])
context['package_name_caps'] = self.replace(
self.package['name'].title(), desired='')
context['package_name_upper'] = self.package['name'].upper()
context['package_name_replace'] = self.replace(
self.package['name'])
context['package_name_replace_reserved'] = self.replace(
fixed_package_name)
context['package_name_replace_upper'] = self.replace(
self.package['name']).upper()
if method['args']:
context['args_kwargs_or_nothing'] = '*args, **kwargs'
else:
context['args_kwargs_or_nothing'] = ''
if context['interface_name_under'].endswith('_session'):
context['session_shortname_dot'] = '.'.join(
context['interface_name_under'].split('_')[:-1])
if 'arg0_type_full' in context:
context.update(
construct_arg_context('arg0', context['arg0_type_full']))
if 'arg1_type_full' in context:
context.update(
construct_arg_context('arg1', context['arg1_type_full']))
if 'arg2_type_full' in context:
context.update(
construct_arg_context('arg2', context['arg2_type_full']))
if 'arg3_type_full' in context:
context.update(
construct_arg_context('arg3', context['arg3_type_full']))
if 'arg0_object' in context:
context['arg0_object_under'] = camel_to_under(
context['arg0_object'])
context['arg0_object_mixed'] = camel_to_mixed(
context['arg0_object'])
if 'return_type_full' in context:
context['return_type'] = context['return_type_full'].split(
'.')[-1]
context['return_pkg'] = get_pkg_name(
context['return_type_full'])
context['return_module'] = self.get_interface_module(
self._abc_pkg_name(
package_name=get_pkg_name(context['return_type_full']),
abc=False), context['return_type_full'].split('.')[-1])
if 'return_pkg' in context:
context['return_app_name'] = self._app_name(
package_name=context['return_pkg'])
context['return_implpkg_name'] = self._abc_pkg_name(
package_name=context['return_pkg'], abc=False)
context['return_pkg_title'] = context['return_pkg'].title()
context['return_pkg_caps'] = context['return_pkg'].upper()
context['return_pkg_replace_caps'] = self.replace(
context['return_pkg'].upper())
context['return_pkg_replace_title'] = self.replace(
context['return_pkg'].title())
if 'return_cat_name' in context:
context['return_cat_name_under'] = camel_to_under(
context['return_cat_name'])
if 'object_name_under' in context:
context['object_name_upper'] = context[
'object_name_under'].upper()
context['object_name_mixed'] = under_to_mixed(
context['object_name_under'])
# Might want to add creating kwargs['object_name' from this as well]
if 'object_name' in context and 'package_name' in context:
context['object_app_name'] = self._app_name()
context['object_implpkg_name'] = self._abc_pkg_name(abc=False)
context['object_module'] = self.get_interface_module(
'package_name', 'object_name')
if 'var_name' in context:
context['var_name_upper'] = context['var_name'].upper()
context['var_name_mixed'] = under_to_mixed(context['var_name'])
context['var_name_plural'] = make_plural(context['var_name'])
context['var_name_plural_mixed'] = under_to_mixed(
context['var_name_plural'])
context['var_name_singular'] = remove_plural(
context['var_name'])
context['var_name_singular_mixed'] = under_to_mixed(
context['var_name_singular'])
if 'return_type' in context:
context['return_type_under'] = camel_to_under(
context['return_type'])
if 'return_type' in context and context['return_type'].endswith(
'List'):
context['return_type_list_object'] = context[
'return_type'][:-4]
context['return_type_list_object_under'] = camel_to_under(
context['return_type_list_object'])
context['return_type_list_object_plural_under'] = make_plural(
context['return_type_list_object_under'])
if ('containable_object_name' in context
and 'containable_object_name_under' not in context
and 'containable_object_name_upper' not in context):
context['containable_object_name_under'] = camel_to_under(
context['containable_object_name'])
context['containable_object_name_plural'] = make_plural(
context['containable_object_name'])
context[
'containable_object_name_plural_under'] = camel_to_under(
context['containable_object_name_plural'])
context['containable_object_name_mixed'] = camel_to_mixed(
context['containable_object_name'])
context['containable_object_name_upper'] = camel_to_under(
context['containable_object_name']).upper()
if 'object_namespace' in context:
context['object_package_name'] = '.'.join(
context['object_namespace'].split('.')[:-1])
context['object_package_name_replace'] = '_'.join(
context['object_package_name'].split('.'))
context['object_package_name_replace_upper'] = context[
'object_package_name_replace'].upper()
context['object_namespace_replace'] = '_'.join(
context['object_namespace'].split('.'))
if ('object_name' in context and 'object_name_under' not in context
and 'object_name_upper' not in context):
context['object_name_plural'] = make_plural(
context['object_name'])
context['object_name_under'] = camel_to_under(
context['object_name'])
context['object_name_mixed'] = camel_to_mixed(
context['object_name'])
context['object_name_upper'] = camel_to_under(
context['object_name']).upper()
if 'object_name_under' in context:
context['object_name_plural_under'] = make_plural(
context['object_name_under'])
if 'aggregated_object_name' in context:
context['aggregated_object_name_under'] = camel_to_under(
context['aggregated_object_name'])
context['aggregated_object_name_mixed'] = camel_to_mixed(
context['aggregated_object_name'])
context['aggregated_objects_name_under'] = camel_to_under(
make_plural(context['aggregated_object_name']))
context['aggregated_objects_name_mixed'] = camel_to_mixed(
make_plural(context['aggregated_object_name']))
if 'source_name' in context:
context['source_name_mixed'] = under_to_mixed(
context['source_name'])
if 'destination_name' in context:
context['destination_name_mixed'] = under_to_mixed(
context['destination_name'])
if 'cat_name' in context:
context['cat_name_under'] = camel_to_under(context['cat_name'])
context['cat_name_lower'] = context['cat_name'].lower()
context['cat_name_mixed'] = camel_to_mixed(context['cat_name'])
context['cat_name_plural'] = make_plural(context['cat_name'])
context['cat_name_plural_under'] = camel_to_under(
context['cat_name_plural'])
context['cat_name_plural_lower'] = context[
'cat_name_plural'].lower()
context['cat_name_plural_mixed'] = camel_to_mixed(
context['cat_name_plural'])
if 'return_cat_name' in context:
context['return_cat_name_under'] = camel_to_under(
context['return_cat_name'])
context['return_cat_name_lower'] = context[
'return_cat_name'].lower()
context['return_cat_name_mixed'] = camel_to_mixed(
context['return_cat_name'])
if 'Proxy' in context['interface_name']:
context['non_proxy_interface_name'] = ''.join(
context['interface_name'].split('Proxy'))
if ('return_pkg' in context and 'return_module' in context
and context['package_name'] == context['return_pkg']
and context['module_name'] == context['return_module']):
context['import_str'] = ''
elif ('package_name' in context and 'return_pkg' in context
and 'return_type' in context and 'return_module' in context):
context[
'import_str'] = '{0}from ..{1}.{2} import {3}\n'.format(
self._dind, context['return_implpkg_name'],
context['return_module'], context['return_type'])
if 'method_name' in context and context['method_name'].startswith(
'can_'):
context['func_name'] = context['method_name'].split('_')[1]
if 'method_name' in context:
context['method_session_name'] = context[
'method_name'].replace('get_', '')
if 'syntax' in context:
context['syntax_under'] = syntax_to_under(context['syntax'])
# Special one for services test builder:
if self._is_manager_session(interface, self.package['name']):
context['svc_mgr_or_catalog'] = 'svc_mgr'
else:
context['svc_mgr_or_catalog'] = 'catalog'
return context
def map_patterns(package, index, base_package=None):
if base_package is None:
catalog_name_caps = 'NoCatalog'
catalog_name_under = 'no_catalog'
object_namespace_table = OrderedDict()
object_names_caps = []
object_names_under = []
containable_object_names_caps = []
containable_object_names_under = []
cataloged_object_names_caps = []
cataloged_object_names_under = []
object_names_under_to_caps = OrderedDict()
relationship_names_caps = []
relationship_names_under = []
rule_names_caps = []
rule_names_under = []
relationships_detail = {}
else:
catalog_name_caps = base_package['package_catalog_caps']
catalog_name_under = base_package['package_catalog_under']
object_namespace_table = base_package['package_object_namespace_table']
object_names_caps = base_package['package_objects_caps']
object_names_under = base_package['package_objects_under']
containable_object_names_caps = base_package[
'package_containable_objects_caps']
containable_object_names_under = base_package[
'package_containable_objects_under']
cataloged_object_names_caps = base_package[
'package_cataloged_objects_caps']
cataloged_object_names_under = base_package[
'package_cataloged_objects_under']
object_names_under_to_caps = base_package[
'package_objects_under_to_caps']
relationship_names_caps = base_package['package_relationships_caps']
relationship_names_under = base_package['package_relationships_under']
rule_names_caps = base_package['package_rules_caps']
rule_names_under = base_package['package_rules_under']
relationships_detail = base_package['package_relationships_detail']
index['impl_log'] = OrderedDict()
index['impl_log']['managers'] = OrderedDict()
index['impl_log']['sessions'] = OrderedDict()
for interface in package['interfaces']:
if 'Containable' in interface['inherit_shortnames']:
append_caps(interface['shortname'], containable_object_names_caps)
append_under(interface['shortname'],
containable_object_names_under)
# Find all OsidObject names in this package
if interface['category'] == 'objects':
object_namespace_table[
interface['shortname']] = interface['fullname'][5:]
if 'OsidObject' in interface['inherit_shortnames']:
append_caps(interface['shortname'], object_names_caps)
append_under(interface['shortname'], object_names_under)
map_under_to_camel(interface['shortname'],
object_names_under_to_caps)
# Find OsidRelationship names in this package
elif 'OsidRelationship' in interface['inherit_shortnames']:
append_caps(interface['shortname'], relationship_names_caps)
append_under(interface['shortname'], relationship_names_under)
map_under_to_camel(interface['shortname'],
object_names_under_to_caps)
if not camel_to_under(
interface['shortname']) in relationships_detail:
update_relationships_detail(relationships_detail,
interface,
source_unknown=True,
dest_unknown=True)
print('found relationship: {0}'.format(interface['fullname']))
if interface['shortname'] == 'Relationship':
update_relationships_detail(relationships_detail,
interface)
elif len(interface['methods']) >= 4:
first_method = interface['methods'][0]
second_method = interface['methods'][1]
third_method = interface['methods'][2]
fourth_method = interface['methods'][3]
if (is_id_version_of(first_method, second_method)
and is_id_version_of(third_method, fourth_method)):
update_relationships_detail(relationships_detail,
interface,
source=second_method,
dest=fourth_method)
print(' 2 args source = {0}, dest = {1}'.format(
second_method['name'][4:],
fourth_method['name'][4:]))
elif (is_id_version_of(first_method, second_method)
and third_method['name'].endswith('_id')):
update_relationships_detail(relationships_detail,
interface,
source=second_method,
dest=third_method,
dest_unknown=True)
print(' 1 arg source = {0}, dest = {1}'.format(
second_method['name'][4:],
third_method['name'][4:-3]))
elif (first_method['name'].endswith('_id')
and is_id_version_of(second_method, third_method)):
update_relationships_detail(relationships_detail,
interface,
source=first_method,
dest=third_method,
source_unknown=True)
print(' 1 arg source = {0}, dest = {1}'.format(
first_method['name'][4:-3],
third_method['name'][4:]))
else:
print(' source and destination not found')
else:
print(
' source and destination not found. less than 4 methods'
)
# Find OsidRule names in this package AND ADD THEM TO OBJECTS AS WELL, FOR NOW
elif 'OsidRule' in interface['inherit_shortnames']:
append_caps(interface['shortname'], rule_names_caps)
append_under(interface['shortname'], rule_names_under)
# AND ADD THEM TO OBJECTS AS WELL, FOR NOW:
append_caps(interface['shortname'], object_names_caps)
append_under(interface['shortname'], object_names_under)
map_under_to_camel(interface['shortname'],
object_names_under_to_caps)
# Find OsidCatalog name (should be only one) in this package
elif 'OsidCatalog' in interface['inherit_shortnames']:
if not interface['shortname'] == catalog_name_caps:
catalog_name_caps = interface['shortname']
if not camel_to_under(
interface['shortname']) == catalog_name_under:
catalog_name_under = camel_to_under(interface['shortname'])
# Run through again to find all catalog managed OsidObject names in this package.
if (interface['category'] == 'sessions'
and interface['shortname'].endswith('LookupSession')
and interface['shortname'][:-13] != catalog_name_caps):
append_caps(interface['shortname'][:-13],
cataloged_object_names_caps)
append_under(interface['shortname'][:-13],
cataloged_object_names_under)
# Now that we have the index, we can map things
index['package_object_namespace_table'] = object_namespace_table
index['package_objects_caps'] = object_names_caps
index['package_objects_under'] = object_names_under
index['package_containable_objects_caps'] = containable_object_names_caps
index['package_containable_objects_under'] = containable_object_names_under
index['package_cataloged_objects_caps'] = cataloged_object_names_caps
index['package_cataloged_objects_under'] = cataloged_object_names_under
index['package_objects_under_to_caps'] = object_names_under_to_caps
index['package_relationships_caps'] = relationship_names_caps
index['package_relationships_under'] = relationship_names_under
index['package_rules_caps'] = rule_names_caps
index['package_rules_under'] = rule_names_under
index['package_catalog_caps'] = catalog_name_caps
index['package_catalog_under'] = catalog_name_under
index['package_relationships_detail'] = relationships_detail
package_mapper_map = {
'osid': map_osid_patterns,
'type': map_type_patterns,
'id': map_id_patterns
}
interface_category_map = {
'managers': map_manager_patterns,
'sessions': map_session_patterns,
}
update_object_form_patterns_in_index(package, index)
update_object_data_patterns_in_index(package, index)
update_admin_data_sessions_in_index(package, index)
for interface in package['interfaces']:
if package['name'] in package_mapper_map.keys():
package_mapper_map[package['name']](interface, package, index)
elif interface['category'] in interface_category_map.keys():
cat = interface['category']
sn = interface['shortname']
index['impl_log'][cat][sn] = dict()
interface_category_map[cat](interface, package, index)
# THIS ONE MAY NEED TO BE SPLIT UP, BUT WE'LL TRY IT FOR NOW:
elif ('OsidObjectForm' in interface['inherit_shortnames']
or 'OsidRuleForm' in interface['inherit_shortnames']
or 'OsidRelationshipForm' in interface['inherit_shortnames']):
map_object_form_patterns(interface, package, index)
# THIS ONE MAY ALSO NEED TO BE SPLIT UP, BUT WE'LL TRY IT FOR NOW:
elif ('OsidObject' in interface['inherit_shortnames']
or 'OsidRule' in interface['inherit_shortnames']
or 'OsidRelationship' in interface['inherit_shortnames']):
map_object_patterns(interface, package, index)
elif any(q in interface['inherit_shortnames']
for q in ['OsidObjectQuery', 'OsidRelationshipQuery']):
map_query_patterns(interface, package, index)
elif 'OsidSearch' in interface['inherit_shortnames']:
map_search_patterns(interface, package, index)
elif 'OsidSearchResults' in interface['inherit_shortnames']:
map_search_results_patterns(interface, package, index)
elif 'OsidList' in interface['inherit_shortnames']:
map_list_patterns(interface, package, index)
elif 'OsidReceiver' in interface['inherit_shortnames']:
map_receiver_patterns(interface, package, index)
elif 'OsidCatalog' in interface['inherit_shortnames']:
map_catalog_patterns(interface, package, index)
elif 'OsidCatalogQuery' in interface['inherit_shortnames']:
map_catalog_query_patterns(interface, package, index)
elif ('OsidNode' in interface['inherit_shortnames'] and
interface['shortname'][:-4] == index['package_catalog_caps']):
map_catalog_node_patterns(interface, package, index)
return index
def map_under_to_camel(camel_value, under_to_camel_map):
under_to_camel_map[camel_to_under(camel_value)] = camel_value
def append_under(value, under_list):
if not camel_to_under(value) in under_list:
under_list.append(camel_to_under(value))
def process_text(root,
i_indent='',
s_indent=None,
make_doc_string_head=False,
make_doc_string_tail=False,
width=72):
# Send any text blocks to this function that includes text tags for things
# like copyright symbols, paragraphs breaks, headings, tokens and code blocks
# and outlines. Outlines are dispatched to make_outline which isn't afraid
# to deal with them (but it should be).
if not s_indent:
s_indent = i_indent
make_str = ''
iter_str = ' '.join(root.text.split())
for child in root:
if child.tag == (XOSID_NS + 'copyrightSymbol'):
iter_str = iter_str + ' (c) ' + ' '.join(child.tail.split()) + ' '
if child.tag == (XOSID_NS + 'pbreak'):
make_str = (make_str + wrap_and_indent(
iter_str, i_indent, s_indent, width)) + '\n' + i_indent + '\n'
iter_str = ' '.join(child.tail.split())
if child.tag == (XOSID_NS + 'heading'):
iter_str += ' '.join(str(child.text).split())
iter_str += ' '.join(str(child.tail).split())
if child.tag == (XOSID_NS + 'token'):
if is_mixed_case(str(child.text).strip()):
if len(str(child.text).split('.')) > 1:
segments = str(child.text).split('.')
segments[-1] = camel_to_under(segments[-1])
converted_text = '.'.join(segments)
elif str(child.text).strip().split(' ')[0] != 'a':
converted_text = camel_to_under(child.text.strip())
else:
converted_text = child.text
elif str(child.text).strip('. ') in OSID_ERRORS:
converted_text = caps_under_to_camel(child.text)
else:
converted_text = child.text
if converted_text is None or converted_text.strip() == '':
pass
elif converted_text.strip().endswith('.'):
converted_text = converted_text.split('.')[0]
iter_str = iter_str + ' ``' + ' '.join(
str(converted_text).split()) + '``. '
else:
iter_str = iter_str + ' ``' + ' '.join(
str(converted_text).split()) + '`` '
iter_str = iter_str + '' + ' '.join(str(child.tail).split()) + ''
if child.tag == (XOSID_NS + 'code'):
make_str = (make_str + wrap_and_indent(
iter_str, i_indent, s_indent, width)).strip() + '\n'
iter_str = reindent(child.text.strip(), i_indent + ' ')
make_str = make_str + iter_str + i_indent + '\n'
iter_str = ' '.join(child.tail.split())
if child.tag == (XOSID_NS + 'outline'):
make_str = (make_str + wrap_and_indent(
iter_str, i_indent, s_indent, width)).strip() + '\n'
iter_str = i_indent + '\n' + make_outline(child, i_indent + ' * ',
i_indent + ' ', width)
make_str += iter_str
iter_str = ' '.join(child.tail.split())
return_str = make_str + wrap_and_indent(iter_str, i_indent, s_indent,
width)
if make_doc_string_head:
return_doc = parse_docstring(return_str,
i_indent,
s_indent,
make_tail=make_doc_string_tail)
return return_doc['headstring'] + '\n\n' + return_doc['body']
else:
return return_str
def _is_session(interface, type_):
return '{}.is_{}_session'.format(
camel_to_under(interface['shortname']), type_)