OpenGrok

import json
import os

from enum import auto, Enum
from typing import Any, Dict, List, NamedTuple, Optional, Tuple


JSON = Dict[str, Any]


DEFAULT_MAP_FILE = "projects.json"


class DownloadType(str, Enum):
    GIT = "git"
    ZIP = "zip"
    SCRIPT = "script"


class Size(int, Enum):
    """
    Size of the project.

    Sizes do not directly correspond to the number of lines or files in the
    project.  The key factor that is important for the developers of the
    analyzer is the time it takes to analyze the project.  Here is how
    the following sizes map to times:

    TINY:  <1min
    SMALL: 1min-10min
    BIG:   10min-1h
    HUGE:  >1h

    The borders are a bit of a blur, especially because analysis time varies
    from one machine to another.  However, the relative times will stay pretty
    similar, and these groupings will still be helpful.

    UNSPECIFIED is a very special case, which is intentionally last in the list
    of possible sizes.  If the user wants to filter projects by one of the
    possible sizes, we want projects with UNSPECIFIED size to be filtered out
    for any given size.
    """
    TINY = auto()
    SMALL = auto()
    BIG = auto()
    HUGE = auto()
    UNSPECIFIED = auto()

    @staticmethod
    def from_str(raw_size: Optional[str]) -> "Size":
        """
        Construct a Size object from an optional string.

        :param raw_size: optional string representation of the desired Size
                         object.  None will produce UNSPECIFIED size.

        This method is case-insensitive, so raw sizes 'tiny', 'TINY', and
        'TiNy' will produce the same result.
        """
        if raw_size is None:
            return Size.UNSPECIFIED

        raw_size_upper = raw_size.upper()
        # The implementation is decoupled from the actual values of the enum,
        # so we can easily add or modify it without bothering about this
        # function.
        for possible_size in Size:
            if possible_size.name == raw_size_upper:
                return possible_size

        possible_sizes = [size.name.lower() for size in Size
                          # no need in showing our users this size
                          if size != Size.UNSPECIFIED]
        raise ValueError(f"Incorrect project size '{raw_size}'. "
                         f"Available sizes are {possible_sizes}")


class ProjectInfo(NamedTuple):
    """
    Information about a project to analyze.
    """
    name: str
    mode: int
    source: DownloadType = DownloadType.SCRIPT
    origin: str = ""
    commit: str = ""
    enabled: bool = True
    size: Size = Size.UNSPECIFIED

    def with_fields(self, **kwargs) -> "ProjectInfo":
        """
        Create a copy of this project info with customized fields.
        NamedTuple is immutable and this is a way to create modified copies.

          info.enabled = True
          info.mode = 1

        can be done as follows:

          modified = info.with_fields(enbled=True, mode=1)
        """
        return ProjectInfo(**{**self._asdict(), **kwargs})


class ProjectMap:
    """
    Project map stores info about all the "registered" projects.
    """
    def __init__(self, path: Optional[str] = None, should_exist: bool = True):
        """
        :param path: optional path to a project JSON file, when None defaults
                     to DEFAULT_MAP_FILE.
        :param should_exist: flag to tell if it's an exceptional situation when
                             the project file doesn't exist, creates an empty
                             project list instead if we are not expecting it to
                             exist.
        """
        if path is None:
            path = os.path.join(os.path.abspath(os.curdir), DEFAULT_MAP_FILE)

        if not os.path.exists(path):
            if should_exist:
                raise ValueError(
                    f"Cannot find the project map file {path}"
                    f"\nRunning script for the wrong directory?\n")
            else:
                self._create_empty(path)

        self.path = path
        self._load_projects()

    def save(self):
        """
        Save project map back to its original file.
        """
        self._save(self.projects, self.path)

    def _load_projects(self):
        with open(self.path) as raw_data:
            raw_projects = json.load(raw_data)

            if not isinstance(raw_projects, list):
                raise ValueError(
                    "Project map should be a list of JSON objects")

            self.projects = self._parse(raw_projects)

    @staticmethod
    def _parse(raw_projects: List[JSON]) -> List[ProjectInfo]:
        return [ProjectMap._parse_project(raw_project)
                for raw_project in raw_projects]

    @staticmethod
    def _parse_project(raw_project: JSON) -> ProjectInfo:
        try:
            name: str = raw_project["name"]
            build_mode: int = raw_project["mode"]
            enabled: bool = raw_project.get("enabled", True)
            source: DownloadType = raw_project.get("source", "zip")
            size = Size.from_str(raw_project.get("size", None))

            if source == DownloadType.GIT:
                origin, commit = ProjectMap._get_git_params(raw_project)
            else:
                origin, commit = "", ""

            return ProjectInfo(name, build_mode, source, origin, commit,
                               enabled, size)

        except KeyError as e:
            raise ValueError(
                f"Project info is required to have a '{e.args[0]}' field")

    @staticmethod
    def _get_git_params(raw_project: JSON) -> Tuple[str, str]:
        try:
            return raw_project["origin"], raw_project["commit"]
        except KeyError as e:
            raise ValueError(
                f"Profect info is required to have a '{e.args[0]}' field "
                f"if it has a 'git' source")

    @staticmethod
    def _create_empty(path: str):
        ProjectMap._save([], path)

    @staticmethod
    def _save(projects: List[ProjectInfo], path: str):
        with open(path, "w") as output:
            json.dump(ProjectMap._convert_infos_to_dicts(projects),
                      output, indent=2)

    @staticmethod
    def _convert_infos_to_dicts(projects: List[ProjectInfo]) -> List[JSON]:
        return [ProjectMap._convert_info_to_dict(project)
                for project in projects]

    @staticmethod
    def _convert_info_to_dict(project: ProjectInfo) -> JSON:
        whole_dict = project._asdict()
        defaults = project._field_defaults

        # there is no need in serializing fields with default values
        for field, default_value in defaults.items():
            if whole_dict[field] == default_value:
                del whole_dict[field]

        return whole_dict