def sandbox_file_line_match(self, match, line): """ Map content of file to self.dic['__files'][name]. Raise from loader.exceptions: - SyntaxErrorPL if no group 'file' was found - DirectoryNotFound if trying to load from a nonexistent directory - FileNotFound if the given file do not exists.""" try: directory, path = get_location(self.directory, match.group('file'), current=dirname(self.path)) name = basename(path) if not match.group('alias') else match.group( 'alias') self.dic['__dependencies'].append(path) with open(join(settings.FILEBROWSER_ROOT, directory, path)) as f: self.dic['__files'][name] = f.read() except FileNotFoundError as e: raise FileNotFound(self.path_parsed_file, line, match.group('file'), self.lineno, str(e)) except SyntaxError as e: raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno, str(e))
def from_file_line_match(self, match, line): """ Map (or append) the content if the file corresponding to file) to the key Raise from loader.exceptions: - SyntaxErrorPL if no group 'file' or 'key' was found - SemanticError if trying to append a nonexistent key - DirectoryNotFound if trying to load from a nonexistent directory - FileNotFound if the given file do not exists.""" key = match.group('key') op = match.group('operator') try: directory, path = get_location(self.directory, match.group('file'), current=dirname(self.path), parser=self) with open(join(settings.FILEBROWSER_ROOT, directory, path)) as f: if '+' in op: self.dic_add_key(key, f.read(), append=True) elif '-' in op: self.dic_add_key(key, f.read(), prepend=True) else: self.dic_add_key(key, f.read()) except FileNotFoundError as e: raise FileNotFound(self.path_parsed_file, line, match.group('file'), self.lineno, str(e)) except SyntaxError as e: raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno, str(e))
def extends_line_match(self, match, line): """ Appends file, line and lineno to self.dic['__extends'] so that it can be later processed by loader.parser. Raise from loader.exceptions - SyntaxErrorPL if no group 'file' was found. - DirectoryNotFound if the directory indicated by the pl couldn't be found""" try: directory, path = get_location(self.directory, match.group('file'), current=dirname(self.path)) except SyntaxError as e: raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno, str(e)) except FileNotFoundError as e: raise FileNotFound(self.path_parsed_file, line, match.group('file'), self.lineno, str(e)) self.dic['__extends'].append({ 'path': path, 'line': line, 'lineno': self.lineno, 'directory_name': directory })
def load_PLTP(directory, rel_path, force=False): """ Load the given file as a PLTP. Save it and its PL in the database. Return: - (PLTP, []) if the PLTP was loaded successfully - (PLTP, warning_list) if the PLTP was loaded with warnings - (None, None) if PLTP is already loaded """ name = splitext(basename(rel_path))[0] sha1 = hashlib.sha1() sha1.update((directory.name + ':' + rel_path).encode('utf-8')) sha1 = sha1.hexdigest() try: existing = PLTP.objects.get(sha1=sha1) if not force: return None, None existing.delete() # Delete the current PLTP entry if force is False except: # If the PLTP does not exist, keep going pass dic, warnings = parse_file(directory, rel_path) pl_list = list() for item in dic['__pl']: try: pl_directory = Directory.objects.get(name=item['directory_name']) except ObjectDoesNotExist: raise DirectoryNotFound(dic['__rel_path'], item['line'], item['path'], item['lineno']) pl_directory, pl_path = get_location(directory, item['path']) pl, pl_warnings = load_PL(pl_directory, pl_path) warnings += pl_warnings pl_list.append(pl) for pl in pl_list: pl.save() logger.info("PL '" + str(pl.id) + " (" + pl.name + ")' has been added to the database") pltp = PLTP(name=name, sha1=sha1, json=dic, directory=directory, rel_path=rel_path) pltp.save() logger.info("PLTP '" + sha1 + " (" + name + ")' has been added to the database") for pl in pl_list: pltp.pl.add(pl) return pltp, [exception_to_html(warning) for warning in warnings]
def from_file_line_match(self, match, line): """ Map (or append) the content if the file corresponding to file) to the key Raise from loader.exceptions: - SyntaxErrorPL if no group 'file' or 'key' was found - SemanticError if trying to append a nonexistent key - DirectoryNotFound if trying to load from a nonexistent directory - FileNotFound if the given file do not exists.""" if not match.group('file') or not match.group( 'key') or not match.group('operator'): raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno) key = match.group('key') op = match.group('operator') # Add warning when overwritting a key if key in self.dic and '+' not in op: self.add_warning("Key '" + key + "' overwritten at line " + str(self.lineno)) try: directory, path = get_location(self.directory, match.group('file'), current=self.path_parsed_file) path = abspath( join(directory.root, path.replace(directory.name + '/', ''))) with open(path, 'r') as f: if '+' in op: if not key in self.dic: raise SemanticError( self.path_parsed_file, line, self.lineno, "Trying to append to non-existent key '" + key + "'.") self.dic[key] += f.read() else: self.dic[key] = f.read() except ObjectDoesNotExist: raise DirectoryNotFound(self.path_parsed_file, line, match.group('file'), self.lineno) except FileNotFoundError: raise FileNotFound(self.path_parsed_file, line, path, lineno=self.lineno) except ValueError: raise FileNotFound( self.path_parsed_file, line, match.group('file'), lineno=self.lineno, message="Path from another directory must be absolute")
def abspath(self, ref): """ Converts the given path 'ref' to an absolute path in the file system. :param ref: the path to resolve relative to ``self.relative`` :return: the absolute path of the resolved reference. """ directory, path = get_location(self.directory, ref.strip(), current=dirname(self.relative)) path = join_fb_root(join(directory, path)) return path
def test_get_location(self): current_dir = Directory.objects.get(name='dir1') current_path = 'first1/second1/' # Correct absolute path to current directory path1 = '/first1/second1/third1/file.py' # Correct absolute path to current directory path2 = 'dir1:/first1/second1/third1/file.py' # Correct absolute path to another directory path3 = 'dir2:/first1/second1/third1/file.py' # Correct relative path to current directory path4 = '../second2/third2/file.py' # Correct relative path to current directory path5 = 'file.py' # dir3 does not exists, raise ObjectDoesNotExist path6 = 'dir3:/first1/second1/third?/file.py1' # Path to another directory is not absolute, raise ValueError path7 = 'dir1:first1/second1/third?/file.py1' self.assertEqual((current_dir, 'first1/second1/third1/file.py'), get_location(current_dir, path1)) self.assertEqual((current_dir, 'first1/second1/third1/file.py'), get_location(current_dir, path2)) self.assertEqual((Directory.objects.get(name='dir2'), 'first1/second1/third1/file.py'), get_location(current_dir, path3)) self.assertEqual((current_dir, 'first1/second2/third2/file.py'), get_location(current_dir, path4, current_path)) self.assertEqual((current_dir, 'first1/second1/file.py'), get_location(current_dir, path5, current_path)) with self.assertRaises(ObjectDoesNotExist): get_location(current_dir, path6) with self.assertRaises(ValueError): get_location(current_dir, path7)
def pl_file_line_match(self, match, line): """ Appends file, line and lineno to self.dic['__pl'] so that it can be later processed by loader.loader. Raise loader.exceptions.SyntaxErrorPL if no group 'file' was found.""" if not match.group('file'): raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno) directory, path = get_location(self.directory, match.group('file'), current=self.path_parsed_file) self.dic['__pl'].append({ 'path': path.replace(directory.name + '/', ''), 'line': line, 'lineno': self.lineno, 'directory_name': directory.name })
def url_line_match(self, match, line): """ Map value to a download url of a resource. Raise from loader.exceptions: - SyntaxErrorPL if no group 'key' or 'file' was found - DirectoryNotFound if trying to load from a nonexistent directory - FileNotFound if the given file do not exists.""" key = match.group('key') try: directory, path = get_location(self.directory, match.group('file'), current=dirname(self.path), parser=self) url = to_download_url(os.path.join(directory, path)) self.dic_add_key(key, url) except FileNotFoundError as e: raise FileNotFound(self.path_parsed_file, line, match.group('file'), self.lineno, str(e)) except SyntaxError as e: raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno, str(e))
def resolve_path(request): # TODO ADD TEST path = request.GET.get('path') if not path: return HttpResponseBadRequest(missing_parameter('path')) target = request.GET.get('target') if not target: return HttpResponseBadRequest(missing_parameter('target')) try: path_components = path.split('/') directory = Directory.objects.get(name=path_components[0]) current = path_components[1] if len(path_components) == 2 else \ os.path.join(*path_components[1:-1]) directory, path = get_location(directory, target, current=current) return HttpResponse(os.path.join(directory, path)) except Exception as e: msg = "Impossible to resolve the path '" + request.GET.get( 'target') + "' : " + htmlprint.code(str(type(e)) + ' - ' + str(e)) if settings.DEBUG: messages.error(request, "DEBUG set to True: " + htmlprint.html_exc()) return HttpResponseNotFound(msg)
def extends_line_match(self, match, line): """ Appends file, line and lineno to self.dic['__extends'] so that it can be later processed by loader.parser. Raise from loader.exceptions - SyntaxErrorPL if no group 'file' was found. - DirectoryNotFound if the directory indicated by the pl couldn't be found""" if not match.group('file'): raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno) try: directory, path = get_location(self.directory, match.group('file'), current=self.path_parsed_file) except ObjectDoesNotExist: raise DirectoryNotFound(self.path_parsed_file, line, match.group('file'), self.lineno) self.dic['__extends'].append({ 'path': path.replace(directory.name+'/', ''), 'line': line, 'lineno': self.lineno, 'directory_name': directory.name })
def sandbox_file_line_match(self, match, line): """ Map content of file to self.dic['__file'][name]. Raise from loader.exceptions: - SyntaxErrorPL if no group 'file' was found - DirectoryNotFound if trying to load from a nonexistent directory - FileNotFound if the given file do not exists.""" if not match.group('file'): raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno) try: directory, path = get_location(self.directory, match.group('file'), current=self.path_parsed_file) path = join(directory.root, path) name = basename(path) if not match.group('alias') else match.group('alias') with open(path, 'r') as f: self.dic['__file'][name] = f.read() except ObjectDoesNotExist: raise DirectoryNotFound(self.path_parsed_file, line, match.group('file'), self.lineno) except FileNotFoundError: raise FileNotFound(self.path_parsed_file, line, path, lineno=self.lineno) except ValueError: raise FileNotFound(self.path_parsed_file, line, match.group('file'), lineno=self.lineno, message="Path from another directory must be absolute")
def pl_file_line_match(self, match, line): """ Appends file, line and lineno to self.dic['__pl'] so that it can be later processed by loader.loader. Raise loader.exceptions.SyntaxErrorPL if no group 'file' was found.""" try: directory, path = get_location(self.directory, match.group('file'), current=dirname(self.path), parser=self) except SyntaxError as e: raise SyntaxErrorPL(self.path_parsed_file, line, self.lineno, str(e)) except FileNotFoundError as e: raise FileNotFound(self.path_parsed_file, line, match.group('file'), self.lineno, str(e)) self.dic['__pl'].append({ 'path': path, 'line': line, 'lineno': self.lineno, 'directory_name': directory })
def test_get_location(self): current_repo = 'repo1/' current_dir = 'dir1/' absolute = '~/repo1/file1.pl' rel_repo = '/file2.pl' relative = '../dir1/file3.pl' ref_lib = 'lib:/dir2/file4.pl' # Absolute outside of repo self.assertEqual((self.dir.name, 'repo1/file1.pl'), get_location(self.dir, absolute, current_dir)) # Absolute in a repo self.assertEqual((self.dir.name, 'repo1/file1.pl'), get_location(self.dir, absolute, current_repo)) # Relative to repo self.assertEqual((self.dir.name, 'repo1/file2.pl'), get_location(self.dir, rel_repo, current_repo)) # Relative outside of repo self.assertEqual((self.dir.name, 'dir1/file3.pl'), get_location(self.dir, relative, current_dir)) # Relative in a repo self.assertEqual((self.dir.name, 'dir1/file3.pl'), get_location(self.dir, relative, current_repo)) # Reference to a lib outside of repo self.assertEqual((self.lib.name, 'dir2/file4.pl'), get_location(self.dir, ref_lib, current_dir)) # Reference to a lib in a repo self.assertEqual((self.lib.name, 'dir2/file4.pl'), get_location(self.dir, ref_lib, current_repo)) with self.assertRaises(SyntaxError): get_location(self.dir, "lib:without/stating/slash", "") with self.assertRaises(SyntaxError): get_location(self.dir, "1234:lib/digit", "") with self.assertRaises(SyntaxError): get_location(self.dir, "/lib/digit", "") with self.assertRaises(FileNotFoundError): get_location(self.dir, "unknown:/file.pl", "") with self.assertRaises(FileNotFoundError): get_location(self.dir, "lib:/unknown.pl", "") with self.assertRaises(FileNotFoundError): get_location(self.dir, "~/unknown.pl", "") with self.assertRaises(FileNotFoundError): get_location(self.dir, "/unknown.pl", "repo1/") with self.assertRaises(FileNotFoundError): get_location(self.dir, "unknown.pl", "dir1/")