def run_impl(self, arg): start = time.clock() self.build_cmd_output_file.truncate() cmd = "cd " + self.build_cmd_dir + " && " + self.build_cmd ret = subprocess.call(cmd, shell=True, stdout=self.build_cmd_output_file, stderr=self.build_cmd_output_file) end = time.clock() logging.info("Cmd '{0}' took {1}".format(cmd, end-start)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_ProjectBuilder_Apply('" + self.build_cmd_output_file.name + "')")
def run_impl(self, args): contents_filename = str(args[0]) original_filename = str(args[1]) compiler_args = list(str(args[2]).split()) project_root_directory = str(args[3]) start = time.clock() self.syntax_highlighter.generate_vim_syntax_file_from_clang(contents_filename, compiler_args, project_root_directory) end = time.clock() logging.info("Generating vim syntax for '{0}' took {1}.".format(original_filename, end-start)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeHighlighter_Apply('" + original_filename + "'" + ", '" + self.output_syntax_file + "')")
def __call__(self, args): filename, apply_fixes = args cmd = self.cmd + ' ' + filename + ' ' + str('-fix' if apply_fixes else '') + ' ' + self.compiler_options logging.info("Triggering clang-tidy over '{0}' with '{1}'".format(filename, cmd)) with open(self.output_file.name, 'w') as f: start = time.clock() subprocess.call(cmd, shell=True, stdout=f) end = time.clock() logging.info("Clang-Tidy over '{0}' completed in {1}s.".format(filename, end-start)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_ClangTidy_Apply('" + self.output_file.name + "')")
def __startup_callback(self, args): self.config_file = args[0] compilation_database = args[1] root, ext = os.path.splitext(compilation_database) if ext == '.json': # In case we have a JSON compilation database we simply use one self.compiler_options = '-p ' + compilation_database logging.info("clang-tidy will extract compiler flags from existing JSON database.") else: # Otherwise we provide compilation flags inline with open(compilation_database) as f: self.compiler_options = '-- ' + f.read().replace('\n', ' ') logging.info("clang-tidy will use compiler flags given inline: '{0}'.".format(self.compiler_options)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_ClangTidy_StartCompleted()")
def __call__(self, diagnostics_iter, args): def clang_severity_to_quickfix_type(severity): # Clang severity | Vim Quickfix type # ---------------------------------- # Ignored = 0 0 () # Note = 1 I (info) # Warning = 2 W (warning) # Error = 3 E (error) # Fatal = 4 other () # ---------------------------------- if severity == 0: return '0' elif severity == 1: return 'I' elif severity == 2: return 'W' elif severity == 3: return 'E' elif severity == 4: return 'other' return '0' diagnostics = [] if diagnostics_iter: for d in diagnostics_iter: diagnostics.append( "{'filename': '" + str(args[1]) + "', " + "'lnum': '" + str(d.location.line) + "', " + "'col': '" + str(d.location.column) + "', " + "'type': '" + clang_severity_to_quickfix_type(d.severity) + "', " + "'text': '" + d.category_name + " | " + str(d.spelling).replace("'", r"") + "'}" ) fixits = "Hint:" for f in d.fixits: fixits += \ " Try using '" + str(f.value) + "' instead. [col=" + \ str(f.range.start.column) + ":" + str(f.range.end.column) + "]" # TODO How to handle multiline quickfix entries? It would be nice show each fixit in its own line. if len(d.fixits): diagnostics.append( "{'filename': '" + str(args[1]) + "', " + "'lnum': '" + str(d.location.line) + "', " + "'col': '" + str(d.location.column) + "', " + "'type': 'I', " + "'text': '" + str(fixits).replace("'", r"") + "'}" ) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeDiagnostics_Apply(" + str(diagnostics).replace('"', r"") + ")") logging.debug("Diagnostics: " + str(diagnostics))
def __init__(self, params): self.file_types_whitelist = params.file_types self.indexers = {} # Build a list of indexers which correspond to the given file types programming_languages = set() for file_type in self.file_types_whitelist: programming_languages.add( YavideUtils.file_type_to_programming_language(file_type)) for programming_language in programming_languages: self.indexers[ programming_language] = YavideSourceCodeIndexerFactory.getIndexer( programming_language, params) # Setup the filesystem event monitoring self.event_handler = YavideFileSystemEventHandler(self) self.observer = Observer() self.observer.deamon = True self.observer.schedule(self.event_handler, params.proj_root_directory, recursive=True) # Print some debug information logging.info("File extension whitelist: {0}".format( self.file_types_whitelist)) logging.info("Active indexers:") for prog_language in programming_languages: logging.info( "For [{0}] programming language:".format(prog_language)) indexers = self.indexers[prog_language] if indexers: for indexer in indexers: logging.info("\t\t {0}".format(indexer))
def __init__(self, params): self.file_types_whitelist = params.file_types self.indexers = {} # Build a list of indexers which correspond to the given file types programming_languages = set() for file_type in self.file_types_whitelist: programming_languages.add(YavideUtils.file_type_to_programming_language(file_type)) for programming_language in programming_languages: self.indexers[programming_language] = YavideSourceCodeIndexerFactory.getIndexer(programming_language, params) # Setup the filesystem event monitoring self.event_handler = YavideFileSystemEventHandler(self) self.observer = Observer() self.observer.deamon = True self.observer.schedule(self.event_handler, params.proj_root_directory, recursive=True) # Print some debug information logging.info("File extension whitelist: {0}".format(self.file_types_whitelist)) logging.info("Active indexers:") for prog_language in programming_languages: logging.info("For [{0}] programming language:".format(prog_language)) indexers = self.indexers[prog_language] if indexers: for indexer in indexers: logging.info("\t\t {0}".format(indexer))
def __call__(self, tunit, clang_parser, args): def visitor(ast_node, ast_parent_node, client_data): if ast_node.location.file and ast_node.location.file.name == tunit.spelling: # we're only interested in symbols from associated translation unit ast_node_id = client_data.clang_parser.get_ast_node_id(ast_node) if ast_node_id != ASTNodeId.getUnsupportedId(): highlight_rule = VimSyntaxGenerator.__tag_id_to_vim_syntax_group(ast_node_id) + " " + client_data.clang_parser.get_ast_node_name(ast_node) client_data.vim_syntax_element.append( "call matchaddpos('" + str(VimSyntaxGenerator.__tag_id_to_vim_syntax_group(ast_node_id)) + "', [[" + str(client_data.clang_parser.get_ast_node_line(ast_node)) + ", " + str(client_data.clang_parser.get_ast_node_column(ast_node)) + ", " + str(len(client_data.clang_parser.get_ast_node_name(ast_node))) + "]], -1)" + "\n" ) else: logging.debug("Unsupported token id: [{0}, {1}]: {2} '{3}'".format( ast_node.location.line, ast_node.location.column, ast_node.kind, client_data.clang_parser.get_ast_node_name(ast_node) ) ) return ChildVisitResult.RECURSE.value # If we are positioned in TU of interest, then we'll traverse through all descendants return ChildVisitResult.CONTINUE.value # Otherwise, we'll skip to the next sibling # Build Vim syntax highlight rules start = time.clock() vim_syntax_element = ['call clearmatches()\n'] if tunit: client_data = collections.namedtuple('client_data', ['clang_parser', 'vim_syntax_element']) clang_parser.traverse(tunit.cursor, client_data(clang_parser, vim_syntax_element), visitor) # Write Vim syntax file vim_syntax_file = open(self.output_syntax_file, "w", 0) vim_syntax_file.writelines(vim_syntax_element) time_elapsed = time.clock() - start # Apply newly generated syntax rules YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeHighlighter_Apply('" + str(args[1]) + "'" + ", '" + self.output_syntax_file + "')") # Write some debug information clang_parser.dump_ast_nodes(tunit) # Log how long generating Vim syntax file took logging.info("Vim syntax generator for '{0}' took {1}.".format(str(args[1]), time_elapsed))
def __startup_callback(self, args): project_root_directory = args[0] compiler_args_filename = args[1] # Instantiate source-code-model services with Clang parser configured self.parser = ClangParser(compiler_args_filename, TranslationUnitCache(FifoCache(20))) self.clang_indexer = ClangIndexer(self.parser, project_root_directory, VimIndexer(self.yavide_instance)) self.service = { 0x0 : self.clang_indexer, 0x1 : SyntaxHighlighter(self.parser, VimSyntaxGenerator(self.yavide_instance, "/tmp/yavideSyntaxFile.vim")), 0x2 : Diagnostics(self.parser, VimQuickFixDiagnostics(self.yavide_instance)), 0x3 : TypeDeduction(self.parser, VimTypeDeduction(self.yavide_instance)), 0x4 : GoToDefinition(self.parser, self.clang_indexer.get_symbol_db(), VimGoToDefinition(self.yavide_instance)), 0x5 : GoToInclude(self.parser, VimGoToInclude(self.yavide_instance)) } YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeModel_StartCompleted()") logging.info("SourceCodeModel configured with: project root directory='{0}', compiler args='{1}'".format(project_root_directory, compiler_args_filename))
def __find_all_references(self, args): other_args, references = args quickfix_list = [] for ref in references: quickfix_list.append("{'filename': '" + str(ref[0]) + "', " + "'lnum': '" + str(ref[1]) + "', " + "'col': '" + str(ref[2]) + "', " + "'type': 'I', " + "'text': '" + str(ref[4]).replace("'", r"''").rstrip() + "'}") with open(self.find_all_references_output, 'w', 0) as f: f.writelines(', '.join(item for item in quickfix_list)) YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeIndexer_FindAllReferencesCompleted('" + self.find_all_references_output + "')") logging.debug("References: " + str(quickfix_list))
def __call__(self, clang_parser, args): start = time.clock() # Build Vim syntax highlight rules vim_syntax_element = ['call clearmatches()\n'] ast_node_list = clang_parser.get_ast_node_list() for ast_node in ast_node_list: ast_node_id = clang_parser.get_ast_node_id(ast_node) if ast_node_id != ASTNodeId.getUnsupportedId(): highlight_rule = self.__tag_id_to_vim_syntax_group(ast_node_id) + " " + clang_parser.get_ast_node_name(ast_node) vim_syntax_element.append( "call matchaddpos('" + str(self.__tag_id_to_vim_syntax_group(ast_node_id)) + "', [[" + str(clang_parser.get_ast_node_line(ast_node)) + ", " + str(clang_parser.get_ast_node_column(ast_node)) + ", " + str(len(clang_parser.get_ast_node_name(ast_node))) + "]], -1)" + "\n" ) else: logging.debug("Unsupported token id: [{0}, {1}]: {2} '{3}'".format( ast_node.location.line, ast_node.location.column, ast_node.kind, clang_parser.get_ast_node_name(ast_node) ) ) # Write Vim syntax file vim_syntax_file = open(self.output_syntax_file, "w", 0) vim_syntax_file.writelines(vim_syntax_element) time_elapsed = time.clock() - start # Apply newly generated syntax rules YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeHighlighter_Apply('" + clang_parser.filename + "'" + ", '" + self.output_syntax_file + "')") # Write some debug information clang_parser.dump_ast_nodes() # Log how long generating Vim syntax file took logging.info("Vim syntax generator for '{0}' took {1}.".format(clang_parser.filename, time_elapsed))
def update(self, filename, event_type): file_type = os.path.splitext(filename)[1] if file_type in self.file_types_whitelist: programming_language = YavideUtils.file_type_to_programming_language(file_type) if programming_language in self.indexers: logging.info("Filename: '{0}' Event_type: '{1}' Programming lang: '{2}'".format( os.path.basename(filename), event_type, programming_language) ) indexers = self.indexers[programming_language] for indexer in indexers: indexer.update(filename, event_type)
def __find_all_references(self, args): other_args, references = args quickfix_list = [] for ref in references: quickfix_list.append( "{'filename': '" + str(ref[0]) + "', " + "'lnum': '" + str(ref[1]) + "', " + "'col': '" + str(ref[2]) + "', " + "'type': 'I', " + "'text': '" + str(ref[4]).replace("'", r"''").rstrip() + "'}" ) with open(self.find_all_references_output, 'w', 0) as f: f.writelines(', '.join(item for item in quickfix_list)) YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeIndexer_FindAllReferencesCompleted('" + self.find_all_references_output + "')" ) logging.debug("References: " + str(quickfix_list))
def update(self, filename, event_type): file_type = os.path.splitext(filename)[1] if file_type in self.file_types_whitelist: programming_language = YavideUtils.file_type_to_programming_language( file_type) if programming_language in self.indexers: logging.info( "Filename: '{0}' Event_type: '{1}' Programming lang: '{2}'" .format(os.path.basename(filename), event_type, programming_language)) indexers = self.indexers[programming_language] for indexer in indexers: indexer.update(filename, event_type)
def do_init(): # Find first available port number port = YavideUtils.get_available_port( int(vim.eval('g:YAVIDE_SOURCE_CODE_INDEXER_PORT')), 65535 ) # Save it in environment variable for later usage var = 'let g:YAVIDE_SOURCE_CODE_INDEXER_PORT = ' + str(port) vim.command(var) # Build a command string cmd = 'python ' cmd += vim.eval('g:YAVIDE_SOURCE_CODE_INDEXER') cmd += ' ' cmd += str(port) # Run the indexer server listening on a given port new_env = os.environ.copy() new_env['PYTHONPATH'] = vim.eval('g:YAVIDE_CORE_DIRECTORY') subprocess.Popen(shlex.split(cmd), shell=False, env=new_env)
def db_reset(self): function = 'Y_SrcNav_ReInit()' YavideUtils.call_vim_remote_function(self.yavide_instance, function) logging.info("Resetting the db connection: '{0}'".format(cmd))
def db_add(self): cmd = ':cscope add ' + os.path.join(self.root_directory, self.tags_filename) YavideUtils.send_vim_remote_command(self.yavide_instance, cmd) logging.info("Adding a new db connection: '{0}'".format(cmd))
def db_set_default_params(self): cmd = ':set cscopetag | set cscopetagorder=0' YavideUtils.send_vim_remote_command(self.yavide_instance, cmd) logging.info("Setting default parameters: '{0}'".format(cmd))
def __call__(self, include, args): YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeNavigation_GoToIncludeCompleted('" + str(include) + "')") logging.info("include filename = " + str(include))
def __drop_single_file(self, args): YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeIndexer_DropSingleFileCompleted()")
def db_reset(self): cmd = ':cscope reset' YavideUtils.send_vim_remote_command(self.yavide_instance, cmd) logging.info("Resetting the db connection: '{0}'".format(cmd))
def __call__(self, include, args): YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeNavigation_GoToIncludeCompleted('" + str(include) + "')") logging.info("include filename = " + str(include))
def __run_on_directory(self, args): YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeIndexer_RunOnDirectoryCompleted()")
def __drop_all(self, args): YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeIndexer_DropAllCompleted()")
def __startup_callback(self, args): self.build_cmd_dir = args[0] self.build_cmd_output_file = tempfile.NamedTemporaryFile(prefix='yavide', suffix='build', delete=True) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_ProjectBuilder_StartCompleted()") logging.info("Args = {0}, build_cmd_output_file = {1}.".format(args, self.build_cmd_output_file.name))
def run_impl(self, filename): cmd = self.format_cmd + " " + filename ret = subprocess.call(cmd, shell=True) logging.info("Filename = {0}. Cmd = {1}".format(filename, cmd)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeFormatter_Apply('" + filename + "')")
def __run_on_directory(self, args): YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeIndexer_RunOnDirectoryCompleted()")
def __shutdown_callback(self, args): reply_with_callback = bool(args) if reply_with_callback: YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_ClangTidy_StopCompleted()")
def __call__(self, type_spelling, args): YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeTypeDeduction_Apply('" + str(type_spelling) + "')") logging.debug("type_spelling = " + str(type_spelling))
def __call__(self, type_spelling, args): YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeTypeDeduction_Apply('" + str(type_spelling) + "')") logging.debug("type_spelling = " + str(type_spelling))
def __drop_all(self, args): YavideUtils.call_vim_remote_function( self.yavide_instance, "Y_SrcCodeIndexer_DropAllCompleted()")
def __drop_single_file(self, args): YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeIndexer_DropSingleFileCompleted()")
def run_impl(self, filename): start = time.clock() self.syntax_highlighter.generate_vim_syntax_file(filename) end = time.clock() logging.info("Generating vim syntax for '{0}' took {1}.".format(filename, end-start)) YavideUtils.call_vim_remote_function(self.yavide_instance, "Y_SrcCodeHighlighter_Apply('" + filename + "'" + ", '" + self.output_syntax_file + "')")
def db_reset(self): function = "Y_SrcNav_ReInit()" YavideUtils.call_vim_remote_function(self.yavide_instance, function) logging.info("Resetting the db connection")