Bachlorthesis Friedel

tests/utils/test_git_util.py

@@ -28,6 +28,7 @@
     get_submodule_head,
     calc_code_churn_range,
     RepositoryAtCommit,
+    calc_surviving_lines,
 )
 
 
@@ -226,6 +227,24 @@ def test_contains_source_code_with(self) -> None:
             )
         )
 
+    def test_calc_surviving_lines(self):
+        lines = calc_surviving_lines(
+            "MutliMethodAuthorCoordination",
+            FullCommitHash("f2f294bdda48526915b5a018e7e91f9f80204269")
+        )
+        self.assertEqual(
+            lines[FullCommitHash("28f1624bda75a0c2da961e2572f9eebc31998346")], 3
+        )
+        self.assertEqual(
+            lines[FullCommitHash("9209cff2d5b6cf9b7b39020b43081bd840347be2")], 4
+        )
+        self.assertEqual(
+            lines[FullCommitHash("ffb0fb502072846e081ac9f63f1eb86667197b95")], 3
+        )
+        self.assertEqual(
+            lines[FullCommitHash("f2f294bdda48526915b5a018e7e91f9f80204269")], 9
+        )
+
 
 class TestChurnConfig(unittest.TestCase):
     """Test if ChurnConfig sets languages correctly."""

uicomponents/CaseStudyGeneration.ui

@@ -10,7 +10,7 @@
     <x>0</x>
     <y>0</y>
     <width>760</width>
-    <height>443</height>
+    <height>491</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -150,6 +150,19 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QComboBox" name="case_study"/>
+        </item>
+        <item>
+         <widget class="QComboBox" name="experiment"/>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="cs_filter">
+          <property name="text">
+           <string>Filter CaseStudy´</string>
+          </property>
+         </widget>
+        </item>
         <item>
          <widget class="QLineEdit" name="commit_search">
           <property name="placeholderText">
@@ -358,8 +371,8 @@
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
-&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Ubuntu'; font-size:11pt; font-weight:400; font-style:normal;&quot;&gt;
-&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Noto Sans'; font-size:10pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Ubuntu'; font-size:11pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
@@ -374,7 +387,7 @@ p, li { white-space: pre-wrap; }
      <x>0</x>
      <y>0</y>
      <width>760</width>
-     <height>22</height>
+     <height>34</height>
     </rect>
    </property>
   </widget>

varats-core/varats/experiment/experiment_util.py

@@ -366,7 +366,7 @@ def report_spec(cls) -> ReportSpecification:
         return cls.REPORT_SPEC
 
     @classmethod
-    def file_belongs_to_experiment(cls, file_name: str) -> bool:
+    def file_belongs_to_experiment(cls, file_name: ReportFilename) -> bool:
         """
         Checks if the file belongs to this experiment.
 
@@ -377,7 +377,7 @@ def file_belongs_to_experiment(cls, file_name: str) -> bool:
             True, if the file belongs to this experiment type
         """
         try:
-            other_short_hand = ReportFilename(file_name).experiment_shorthand
+            other_short_hand = file_name.experiment_shorthand
             return cls.shorthand() == other_short_hand
         except ValueError:
             return False

varats-core/varats/mapping/author_map.py

@@ -31,7 +31,7 @@ def __eq__(self, other) -> bool:
         return False
 
     def __str__(self) -> str:
-        return f"{self.name} <{self.mail}>"
+        return f"{self.name} {self.mail}"
 
     def __repr__(self) -> str:
         return f"{self.name} <{self.mail}>; {self.names},{self.mail_addresses}"

varats-core/varats/utils/git_util.py

@@ -476,7 +476,7 @@ class Language(Enum):
         value: tp.Set[str]  # pylint: disable=invalid-name
 
         C = {"h", "c"}
-        CPP = {"h", "hxx", "hpp", "cxx", "cpp", "cc"}
+        CPP = {"h", "hxx", "hpp", "cxx", "cpp", "cc", "hh"}
 
     def __init__(self) -> None:
         self.__enabled_languages: tp.List[ChurnConfig.Language] = []
@@ -1135,15 +1135,17 @@ def branch_has_upstream(
     return tp.cast(bool, exit_code == 0)
 
 
-class RepositoryAtCommit():
+class RepositoryAtCommit:
     """Context manager to work with a repository at a specific revision, without
     duplicating the repository."""
 
     def __init__(self, project_name: str, revision: ShortCommitHash) -> None:
         self.__repo = pygit2.Repository(
             get_local_project_git_path(project_name)
         )
-        self.__initial_head = self.__repo.head
+
+        self.__initial_head: pygit2.Reference = self.__repo.head
+        print(self.__initial_head.name)
         self.__revision = self.__repo.get(revision.hash)
 
     def __enter__(self) -> Path:
@@ -1155,4 +1157,59 @@ def __exit__(
         exc_value: tp.Optional[BaseException],
         exc_traceback: tp.Optional[TracebackType]
     ) -> None:
-        self.__repo.checkout(self.__initial_head)
+        self.__repo.checkout(
+            self.__initial_head, strategy=pygit2.GIT_CHECKOUT_FORCE
+        )
+
+
+def calc_surviving_lines(project_name: str, revision: tp.Optional[FullCommitHash] = None) -> \
+tp.Dict[FullCommitHash, int]:
+    """
+    Get the surviving lines of older commits at a given revision.
+
+    Args:
+        project_name: project to analyze
+        revision: revision to analyze at
+
+    returns: number of lines per prior commit
+    """
+    churn_config = ChurnConfig.create_c_style_languages_config()
+    file_pattern = re.compile(
+        "|".join(churn_config.get_extensions_repr(r"^.*\.", r"$"))
+    )
+    if revision is not None:
+        hash = revision.hash
+    else:
+        hash = "HEAD"
+    lines_per_revision: tp.Dict[FullCommitHash, int] = {}
+    repo = pygit2.Repository(get_local_project_git_path(project_name))
+
+    initial_head: pygit2.Reference = repo.head
+    repo_folder = get_local_project_git_path(project_name)
+    git(__get_git_path_arg(repo_folder), "checkout", "-f", hash)
+    files = git(
+        __get_git_path_arg(repo_folder), "ls-tree", "-r", "--name-only", hash
+    ).splitlines()
+
+    for file in files:
+        if file_pattern.match(file):
+            lines = git(
+                __get_git_path_arg(repo_folder), "blame", "--root", "-l",
+                f"{file}"
+            ).splitlines()
+            for line in lines:
+                if line:
+                    last_change = line[:FullCommitHash.hash_length()]
+                    try:
+                        last_change = FullCommitHash(last_change)
+                    except ValueError:
+                        continue
+
+                    if lines_per_revision.keys().__contains__(last_change):
+                        lines_per_revision[
+                            last_change] = lines_per_revision[last_change] + 1
+                    else:
+                        lines_per_revision[last_change] = 1
+
+    git(__get_git_path_arg(repo_folder), "checkout", initial_head.name)
+    return lines_per_revision

varats/varats/data/databases/author_interactions_database.py

@@ -0,0 +1,156 @@
+import typing as tp
+
+import pandas as pd
+
+from varats.data.cache_helper import build_cached_report_table
+from varats.data.databases.evaluationdatabase import EvaluationDatabase
+from varats.data.reports.blame_report import (
+    gen_base_to_inter_commit_repo_pair_mapping,
+)
+from varats.experiments.vara.blame_report_experiment import (
+    BlameReportExperiment,
+)
+from varats.jupyterhelper.file import load_blame_report
+from varats.mapping.author_map import Author, generate_author_map
+from varats.mapping.commit_map import CommitMap
+from varats.paper.case_study import CaseStudy
+from varats.paper_mgmt.case_study import get_case_study_file_name_filter
+from varats.project.project_util import (
+    get_local_project_git_path,
+    get_primary_project_source,
+)
+from varats.report.report import ReportFilepath
+from varats.revision.revisions import (
+    get_processed_revisions_files,
+    get_failed_revisions_files,
+)
+from varats.utils.git_util import (
+    create_commit_lookup_helper,
+    UNCOMMITTED_COMMIT_HASH,
+    CommitRepoPair,
+)
+
+
+class AuthorInteractionsDatabase(
+    EvaluationDatabase,
+    cache_id="author_contribution_data_base",
+    column_types={
+        "author_name": 'str',
+        "author_mail": 'str',
+        "internal_interactions": 'int32',
+        "external_interactions": 'int32'
+    }
+):
+    """Provides access to internal and external interactions of authors."""
+
+    @classmethod
+    def _load_dataframe(
+        cls, project_name: str, commit_map: CommitMap,
+        case_study: tp.Optional[CaseStudy], **kwargs: tp.Dict[str, tp.Any]
+    ) -> pd.DataFrame:
+
+        def create_dataframe_layout() -> pd.DataFrame:
+            df_layout = pd.DataFrame(columns=cls.COLUMNS)
+            df_layout = df_layout.astype(cls.COLUMN_TYPES)
+            return df_layout
+
+        def create_data_frame_for_report(
+            report_path: ReportFilepath
+        ) -> tp.Tuple[pd.DataFrame, str, str]:
+            report = load_blame_report(report_path)
+            base_inter_c_repo_pair_mapping = \
+                gen_base_to_inter_commit_repo_pair_mapping(report)
+            revision = report.head_commit
+
+            def build_dataframe_row(
+                author: Author, internal_interactions: int,
+                external_interactions: int
+            ) -> tp.Dict[str, tp.Any]:
+                data_dict: tp.Dict[str, tp.Any] = {
+                    'revision': revision.hash,
+                    'time_id': commit_map.short_time_id(revision),
+                    'author_name': author.name,
+                    'author_mail': author.mail,
+                    'internal_interactions': internal_interactions,
+                    'external_interactions': external_interactions
+                }
+                return data_dict
+
+            result_data_dicts: tp.Dict[Author, tp.Dict[str, tp.Any]] = {}
+            amap = generate_author_map(project_name)
+            repo_name = get_primary_project_source(project_name).local
+            commit_lookup_helper = create_commit_lookup_helper(project_name)
+            for base_pair in base_inter_c_repo_pair_mapping:
+                if not base_pair.commit.repository_name.startswith(repo_name):
+                    # Skip interactions with submodules
+                    continue
+                inter_pair_dict = base_inter_c_repo_pair_mapping[base_pair]
+                if base_pair.commit.commit_hash == UNCOMMITTED_COMMIT_HASH:
+                    continue
+                base_commit = commit_lookup_helper(
+                    CommitRepoPair(base_pair.commit.commit_hash, repo_name)
+                )
+                base_author = amap.get_author(
+                    base_commit.author.name, base_commit.author.email
+                )
+                if base_author is None:
+                    amap.add_entry(
+                        base_commit.author.name, base_commit.author.email
+                    )
+                    base_author = amap.get_author(
+                        base_commit.author.name, base_commit.author.email
+                    )
+                internal_interactions = 0
+                external_interactions = 0
+                for inter_pair, interactions in inter_pair_dict.items():
+                    if inter_pair.commit.commit_hash == UNCOMMITTED_COMMIT_HASH or not inter_pair.commit.repository_name.startswith(
+                        repo_name
+                    ):
+                        continue
+                    inter_commit = commit_lookup_helper(
+                        CommitRepoPair(
+                            inter_pair.commit.commit_hash, repo_name
+                        )
+                    )
+                    inter_author = amap.get_author(
+                        inter_commit.author.name, inter_commit.author.email
+                    )
+                    if base_author == inter_author:
+                        internal_interactions += interactions
+                    else:
+                        external_interactions += interactions
+                if base_author in result_data_dicts:
+                    result_data_dicts[base_author]['internal_interactions'
+                                                  ] += internal_interactions
+                    result_data_dicts[base_author]['external_interactions'
+                                                  ] += external_interactions
+                else:
+                    result_data_dicts[base_author] = build_dataframe_row(
+                        base_author, internal_interactions,
+                        external_interactions
+                    )
+
+            return pd.DataFrame(
+                list(result_data_dicts.values())
+            ), report.head_commit.hash, str(report_path.stat().st_mtime_ns)
+
+        report_files = get_processed_revisions_files(
+            project_name,
+            BlameReportExperiment,
+            file_name_filter=get_case_study_file_name_filter(case_study)
+        )
+
+        failed_report_files = get_failed_revisions_files(
+            project_name,
+            BlameReportExperiment,
+            file_name_filter=get_case_study_file_name_filter(case_study)
+        )
+
+        data_frame = build_cached_report_table(
+            cls.CACHE_ID, project_name, report_files, failed_report_files,
+            create_dataframe_layout, create_data_frame_for_report,
+            lambda path: path.report_filename.commit_hash.hash,
+            lambda path: str(path.stat().st_mtime_ns),
+            lambda a, b: int(a) > int(b)
+        )
+        return data_frame