Merge pull request #14 from n0rfas/dev

Author: n0rfas

.github/workflows/code-check-dev.yml

@@ -44,4 +44,4 @@ jobs:
       - run: pipx install "poetry~=2.0.0"
       - run: poetry install --with dev
       - run: poetry run ruff check --select I .
-      - run: poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=40
+      - run: poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=45

README.md

@@ -49,7 +49,7 @@ poetry run git-analytics
 
 ```bash
 poetry run pytest
-poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=40
+poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=45
 ```
 
 ### Type Checking

git_analytics/analyzers/__init__.py

@@ -2,12 +2,14 @@
 from .commit_type import CommitTypeAnalyzer
 from .commits_summary import CommitsSummaryAnalyzer
 from .historical_statistics import HistoricalStatisticsAnalyzer
+from .language_statistics import LanguageAnalyzer
 from .lines_statistics import LinesAnalyzer
 
 __all__ = [
     "AuthorsStatisticsAnalyzer",
     "CommitTypeAnalyzer",
     "CommitsSummaryAnalyzer",
     "HistoricalStatisticsAnalyzer",
+    "LanguageAnalyzer",
     "LinesAnalyzer",
 ]

git_analytics/analyzers/commit_type.py

@@ -1,52 +1,57 @@
 from collections import Counter, defaultdict
 from dataclasses import dataclass
-from datetime import date
-from enum import Enum
-from typing import Dict
+from typing import Dict, List
 
 from git_analytics.entities import AnalyticsCommit, AnalyticsResult
+from git_analytics.helpers import get_number_week
 from git_analytics.interfaces import CommitAnalyzer
 
 
-class CommitType(Enum):
-    FEATURE = "feature"
-    FIX = "fix"
-    DOCS = "docs"
-    STYLE = "style"
-    REFACTOR = "refactor"
-    TEST = "test"
-    CHORE = "chore"
-    WIP = "wip"
-    MERGE = "merge"
-    UNKNOWN = "unknown"
-
-
 @dataclass
 class Result(AnalyticsResult):
-    items: Dict[date, Dict[CommitType, int]]
+    commit_type_by_week: Dict[str, Dict[str, int]]
+    commit_type_counter: Dict[str, int]
+    author_commit_type_by_week: Dict[str, Dict[str, Dict[str, int]]]
+    author_commit_type_counter: Dict[str, Dict[str, int]]
 
 
-TYPE_COMMIT_LIST: tuple = tuple(ct.value for ct in CommitType)
+LIST_OF_TYPE_COMMIT: List[str] = ["feature", "fix", "docs", "style", "refactor", "test", "chore", "wip", "merge"]
 
 
-def _get_type_list(commit_message: str):
-    result = [tag for tag in TYPE_COMMIT_LIST if tag in commit_message]
+def _get_type_list(commit_message: str) -> List[str]:
+    result = [tag for tag in LIST_OF_TYPE_COMMIT if tag in commit_message.lower()]
     if result:
         return result
-    return [CommitType.UNKNOWN]
+    return ["unknown"]
 
 
 class CommitTypeAnalyzer(CommitAnalyzer):
     name = "commit_type"
 
     def __init__(self) -> None:
-        self._by_date: Dict[date, Counter] = defaultdict(Counter)
+        self._commit_type_by_week: Dict[str, Counter] = defaultdict(Counter)
+        self._commit_type_counter: Counter = Counter()
+        self._author_commit_type_by_week: Dict[str, Dict[str, Counter]] = defaultdict(lambda: defaultdict(Counter))
+        self._author_commit_type_counter: Dict[str, Counter] = defaultdict(Counter)
 
     def process(self, commit: AnalyticsCommit) -> None:
-        commit_date = commit.committed_datetime.date()
+        week_number = get_number_week(commit.committed_datetime)
         commit_types = _get_type_list(commit.message)
         for commit_type in commit_types:
-            self._by_date[commit_date][commit_type] += 1
+            self._commit_type_by_week[week_number][commit_type] += 1
+            self._commit_type_counter[commit_type] += 1
+            self._author_commit_type_by_week[commit.commit_author][week_number][commit_type] += 1
+            self._author_commit_type_counter[commit.commit_author][commit_type] += 1
 
     def result(self) -> Result:
-        return Result(items={dt: dict(counter) for dt, counter in self._by_date.items()})
+        return Result(
+            commit_type_by_week={wn: dict(sorted(c.items())) for wn, c in sorted(self._commit_type_by_week.items())},
+            commit_type_counter=dict(sorted(self._commit_type_counter.items())),
+            author_commit_type_by_week={
+                a: {wn: dict(sorted(c.items())) for wn, c in sorted(weeks.items())}
+                for a, weeks in sorted(self._author_commit_type_by_week.items())
+            },
+            author_commit_type_counter={
+                a: dict(sorted(c.items())) for a, c in sorted(self._author_commit_type_counter.items())
+            },
+        )

git_analytics/analyzers/language_statistics.py

@@ -0,0 +1,53 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Dict
+
+from git_analytics.entities import AnalyticsCommit, AnalyticsResult
+from git_analytics.interfaces import CommitAnalyzer
+
+
+@dataclass
+class FileExtensionChangeStats:
+    insertions: int = 0
+    deletions: int = 0
+
+
+@dataclass
+class Result(AnalyticsResult):
+    files_extensions_total: Dict[str, FileExtensionChangeStats]
+    files_extensions_by_author: Dict[str, Dict[str, FileExtensionChangeStats]]
+
+
+def _get_file_extension(file_path: str) -> str:
+    filename = file_path.split("/")[-1]
+    filename_parts = filename.split(".")
+    if len(filename_parts) == 1 or filename_parts[0] == "":
+        return "no_extension"
+    return filename_parts[-1].lower().replace("}", "")
+
+
+class LanguageAnalyzer(CommitAnalyzer):
+    name = "language_statistics"
+
+    def __init__(self) -> None:
+        self._total: Dict[str, FileExtensionChangeStats] = defaultdict(FileExtensionChangeStats)
+        self._by_author: Dict[str, Dict[str, FileExtensionChangeStats]] = defaultdict(
+            lambda: defaultdict(FileExtensionChangeStats)
+        )
+
+    def process(self, commit: AnalyticsCommit) -> None:
+        for changed_file in commit.files:
+            file_extension = _get_file_extension(changed_file)
+            self._total[file_extension].insertions += commit.files[changed_file].insertions
+            self._total[file_extension].deletions += commit.files[changed_file].deletions
+            self._by_author[commit.commit_author][file_extension].insertions += commit.files[changed_file].insertions
+            self._by_author[commit.commit_author][file_extension].deletions += commit.files[changed_file].deletions
+
+    def result(self) -> Result:
+        return Result(
+            files_extensions_total=dict(sorted(self._total.items(), key=lambda item: item[1].insertions, reverse=True)),
+            files_extensions_by_author={
+                author: dict(sorted(counter.items(), key=lambda item: item[1].insertions, reverse=True))
+                for author, counter in self._by_author.items()
+            },
+        )

git_analytics/engine.py

@@ -1,5 +1,5 @@
 from datetime import date, timezone
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from git_analytics.entities import AnalyticsResult
 from git_analytics.interfaces import CommitSource
@@ -10,9 +10,11 @@ def __init__(
         self,
         source: CommitSource,
         analyzers_factory,
+        additional_data: Optional[Dict[str, Any]] = None,
     ) -> None:
         self._source = source
         self._analyzers_factory = analyzers_factory
+        self._additional_data = additional_data
 
     def run(
         self,
@@ -36,4 +38,7 @@ def run(
             for analyzer in analyzers:
                 analyzer.process(commit)
 
-        return {analyzer.name: analyzer.result() for analyzer in analyzers}
+        result = {analyzer.name: analyzer.result() for analyzer in analyzers}
+        if self._additional_data:
+            result["additional_data"] = self._additional_data
+        return result

git_analytics/entities.py

@@ -5,6 +5,12 @@
 from typing import Any, Dict
 
 
+@dataclass
+class FileChangeStats:
+    insertions: int
+    deletions: int
+
+
 @dataclass
 class AnalyticsCommit:
     sha: str
@@ -14,11 +20,15 @@ class AnalyticsCommit:
     lines_deletions: int
     files_changed: int
     message: str
+    files: Dict[str, FileChangeStats]
 
 
 @dataclass
 class AnalyticsResult:
-    def to_dict(self) -> Dict[str, Any]:
+    def __iter__(self):
+        return iter(self._to_dict().items())
+
+    def _to_dict(self) -> Dict[str, Any]:
         return self._make_json_safe(asdict(self))
 
     @staticmethod

git_analytics/helpers.py

@@ -0,0 +1,8 @@
+from datetime import date, datetime
+from typing import Union
+
+
+def get_number_week(dt: Union[date, datetime]) -> str:
+    year = dt.year
+    week = dt.isocalendar()[1]
+    return f"{year}-W{week:02d}"  # ISO-8601 week number

git_analytics/main.py

@@ -1,3 +1,4 @@
+import os
 from wsgiref.simple_server import make_server
 
 from git import InvalidGitRepositoryError, Repo
@@ -7,6 +8,7 @@
     CommitsSummaryAnalyzer,
     CommitTypeAnalyzer,
     HistoricalStatisticsAnalyzer,
+    LanguageAnalyzer,
     LinesAnalyzer,
 )
 from git_analytics.engine import CommitAnalyticsEngine
@@ -20,20 +22,24 @@ def make_analyzers():
         CommitsSummaryAnalyzer(),
         CommitTypeAnalyzer(),
         HistoricalStatisticsAnalyzer(),
+        LanguageAnalyzer(),
         LinesAnalyzer(),
     ]
 
 
 def run():
     try:
-        repo = Repo()
+        path_repo = os.getenv("PATH_REPO", ".")
+        repo = Repo(path_repo)
+        name_branch = repo.active_branch.name
     except InvalidGitRepositoryError:
         print("Error: Current directory is not a git repository.")
         return
 
     engine = CommitAnalyticsEngine(
         source=GitCommitSource(repo),
         analyzers_factory=make_analyzers,
+        additional_data={"name_branch": name_branch},
     )
 
     web_app = create_web_app(engine=engine)

git_analytics/sources/git_commit_adapter.py

@@ -3,7 +3,7 @@
 from git import Repo
 from git.objects import Commit
 
-from git_analytics.entities import AnalyticsCommit
+from git_analytics.entities import AnalyticsCommit, FileChangeStats
 from git_analytics.interfaces import CommitSource
 
 
@@ -25,4 +25,8 @@ def git_commit_to_analytics_commit(commit: Commit) -> AnalyticsCommit:
             lines_deletions=commit.stats.total["deletions"],
             files_changed=commit.stats.total["files"],
             message=str(commit.summary).strip(),
+            files={
+                str(file): FileChangeStats(insertions=value.get("insertions", 0), deletions=value.get("deletions", 0))
+                for file, value in commit.stats.files.items()
+            },
         )