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_)