def process_project_version(self, project: Project, version: ProjectVersion) -> List[str]:
logger = logging.getLogger("checkout")
try:
checkout = version.get_checkout(self.checkouts_path)
except ValueError as e:
logger.error("Checkout data corrupted: %s", e)
return self.skip(version)
try:
checkout_exists = checkout.exists()
logger.debug("Checkout exists = %r", checkout_exists)
if checkout_exists and not self.force_checkout:
logger.debug("Already checked out %s.", version)
else:
logger.info("Fetching %s from %s...", version, checkout)
if self.force_checkout:
checkout.delete()
checkout.create()
return self.ok()
except CommandFailedError as e:
logger.error("Checkout failed: %s", e)
return self.skip(version)
except IOError:
logger.error("Checkout failed.", exc_info=True)
return self.skip(version)
def process_project_version(self, project: Project, version: ProjectVersion):
self.__logger.info(" - Version : %s", version.version_id)
revision = "-"
if project.repository.vcstype == "git":
revision = version.revision + "~1"
elif project.repository.vcstype == "svn":
revision = str(int(version.revision) - 1)
self.__logger.info(" Revision : %s", revision)
checkout = version.get_checkout(self.__checkouts_path)
if not checkout.exists():
self.__logger.info(" Checkout : not checked out")
else:
self.__logger.info(" Checkout : %s", checkout.checkout_dir)
version_compile = version.get_compile(self.__compiles_path)
if version_compile.needs_compile():
compile_state = "not compiled"
elif version_compile.needs_compile_patterns():
compile_state = "project compiled, patterns not compiled"
else:
compile_state = "compiled"
self.__logger.info(" Compile : %s", compile_state)
super().process_project_version(project, version)
def process_project_version_misuse(self, project: Project, version: ProjectVersion, misuse: Misuse):
self.__logger.info(" - Misuse : %s", misuse.misuse_id)
self.__logger.info(" Description : %s", misuse.description.strip())
self.__logger.info(" Fix Description : %s", misuse.fix.description.strip())
self.__logger.info(" Misuse Elements : - %s", misuse.characteristics[0])
for characteristic in misuse.characteristics[1:]:
self.__logger.info(" - %s", characteristic)
checkout = version.get_checkout(self.__checkouts_path)
if checkout.exists():
location = misuse.location
if project.repository.vcstype == "synthetic":
checkout_path = join(version.path, "compile")
else:
checkout_path = checkout.checkout_dir
source_file_path = join(checkout_path, version.source_dir, location.file)
self.__logger.info(" Source File : %s", source_file_path)
self.__logger.info(" Enclosing Method : %s", location.method)
self.__logger.info(" Fix Diff : %s", misuse.fix.commit)
def process_project_version(self, project: Project, version: ProjectVersion):
logger = logging.getLogger("compile")
logger.info("Compiling %s...", version)
logger.debug("- Force compile = %r", self.force_compile)
logger = logging.getLogger("compile.tasks")
project_compile = version.get_compile(self.compiles_base_path)
build_path = join(project_compile.base_path, Compile.__BUILD_DIR)
sources_path = join(build_path, version.source_dir)
classes_path = join(build_path, version.classes_dir)
needs_copy_sources = project_compile.needs_copy_sources() or self.force_compile
needs_compile = project_compile.needs_compile() or self.force_compile
if needs_copy_sources or needs_compile:
logger.debug("Copying to build directory...")
checkout_path = version.get_checkout(self.checkouts_base_path).checkout_dir
self.__clean_copy(checkout_path, build_path)
logger.debug("Copying additional resources...")
self.__copy_additional_compile_sources(version, build_path)
if not needs_copy_sources:
logger.debug("Already copied project source.")
else:
try:
logger.info("Copying project sources...")
self.__clean_copy(sources_path, project_compile.original_sources_path)
self.__copy_misuse_sources(sources_path, version.misuses, project_compile.misuse_source_path)
except IOError as e:
logger.error("Failed to copy project sources: %s", e)
return self.skip(version)
if not version.compile_commands:
logger.warn("Skipping compilation: not configured.")
return self.skip(version)
if not needs_compile:
logger.info("Already compiled project.")
else:
try:
logger.info("Compiling project...")
self._compile(version.compile_commands, build_path)
logger.debug("Copying project classes...")
self.__clean_copy(classes_path, project_compile.original_classes_path)
self.__copy_misuse_classes(classes_path, version.misuses, project_compile.misuse_classes_path)
except CommandFailedError as e:
logger.error("Compilation failed: %s", e)
return self.skip(version)
except FileNotFoundError as e:
logger.error("Failed to copy classes: %s", e)
return self.skip(version)
if not version.patterns:
logger.info("Skipping pattern compilation: no patterns.")
return self.ok()
needs_copy_pattern_sources = project_compile.needs_copy_pattern_sources() or self.force_compile
needs_compile_patterns = project_compile.needs_compile_patterns() or self.force_compile
if needs_copy_pattern_sources or needs_compile_patterns:
logger.debug("Copying to build directory...")
checkout_path = version.get_checkout(self.checkouts_base_path).checkout_dir
self.__clean_copy(checkout_path, build_path)
logger.debug("Copying additional resources...")
self.__copy_additional_compile_sources(version, build_path)
if not needs_copy_pattern_sources:
logger.debug("Already copied pattern sources.")
else:
try:
logger.info("Copying pattern sources...")
self.__copy_pattern_sources(version.misuses, project_compile)
except IOError as e:
logger.error("Failed to copy pattern sources: %s", e)
return self.skip(version)
if not needs_compile_patterns:
logger.info("Already compiled patterns.")
else:
try:
logger.debug("Copying patterns to source directory...")
self.__copy(version.patterns, sources_path)
logger.info("Compiling patterns...")
self._compile(version.compile_commands, build_path)
logger.debug("Copying pattern classes...")
self.__copy_pattern_classes(version.misuses, classes_path, project_compile)
except FileNotFoundError as e:
remove_tree(project_compile.pattern_classes_base_path)
logger.error("Compilation failed: %s", e)
return self.skip(version)
except CommandFailedError as e:
logger.error("Compilation failed: %s", e)
return self.skip(version)
return self.ok()
