batchfetch 1.0.9__tar.gz → 1.1.1__tar.gz

{batchfetch-1.0.9/batchfetch.egg-info → batchfetch-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batchfetch
-Version: 1.0.9
+Version: 1.1.1
 Summary: Efficiently clone and pull multiple Git repositories.
 Home-page: https://github.com/jamescherti/batchfetch
 Author: James Cherti

{batchfetch-1.0.9 → batchfetch-1.1.1}/batchfetch/batchfetch_base.py

@@ -32,39 +32,20 @@ class BatchFetchError(Exception):
     """Exception raised by Downloader()."""
 
 
-class BatchFetchBase:
-    """Plugin downloader base class."""
-
-    def __init__(self, data: Dict[str, Any], options: Dict[str, Any]):
-        self.indent = 4
-        self.env = os.environ.copy()
-
-        # Default
-        self.global_options_schema: Dict[Any, Any] = {
-            Optional("exec_before"): Or([str], str),
-            Optional("exec_after"): Or([str], str),
-        }
+class DataAlreadyInitialized(Exception):
+    """Data already initialized."""
 
-        self.item_schema: Dict[Any, Any] = {
-            Optional("path"): str,
-            Optional("delete"): bool,
 
-            Optional("exec_before"): Or([str], str),
-            Optional("exec_after"): Or([str], str),
-        }
+class TaskBase:
+    def __init__(self, data: Dict[str, Any], options: Dict[str, Any]):
+        self.global_options_schema: Dict[Any, Any] = {}
+        self.global_options_values: Dict[str, Any] = {}
 
-        self.global_options_values: Dict[str, Any] = {
-            "exec_before": [],
-            "exec_after": [],
-        }
-
-        self.item_default_values: Dict[str, Any] = {
-            # Optional items
-            "delete": False,
-        }
+        self.task_schema: Dict[Any, Any] = {}
+        self.task_default_values: Dict[str, Any] = {}
 
         self._item_values = data
-        self._item_global_options = options
+        self._item_options = options
 
         # Variables
         self.values: Dict[str, Any] = {}
@@ -73,20 +54,20 @@ class BatchFetchBase:
 
     def _initialize_data(self):
         if self._values_initialized:
-            return
+            raise DataAlreadyInitialized
 
         # Options
         self.options = {}
-        self.options.update(deepcopy(self._item_global_options))
+        self.options.update(deepcopy(self.global_options_values))  # Default
+        self.options.update(deepcopy(self._item_options))
         schema = Schema(self.global_options_schema)
         schema.validate(self.options)
 
         # Data
         self.values = {}
-        self.values.update(deepcopy(self.item_default_values))
+        self.values.update(deepcopy(self.task_default_values))
         self.values.update(deepcopy(self._item_values))
-        # self.values.update(deepcopy(self._item_global_options))
-        schema = Schema(self.item_schema)
+        schema = Schema(self.task_schema)
         schema.validate(self.values)
 
         self.values["result"] = {
@@ -95,14 +76,66 @@ class BatchFetchBase:
             "changed": False,
         }
 
-        self._values_initialized = True
+    def validate_schema(self):
+        self._initialize_data()
+
+    def __getitem__(self, key):
+        self._initialize_data()
+
+        if key in self.values:
+            return self.values[key]
 
-        # Strip spaces
-        self.values = {
-            key: value.strip() if isinstance(value, str) else value
-            for key, value in self.values.items()
+        if key in self.options:
+            return self.options[key]
+
+        if key in self.global_options_values:
+            return self.global_options_values[key]
+
+        raise KeyError(f"The item '{key}' was not found in '{self.values}")
+
+
+class BatchFetchBase(TaskBase):
+    """Plugin downloader base class."""
+
+    def __init__(self, data: Dict[str, Any], options: Dict[str, Any]):
+        super().__init__(data=data, options=options)
+        self.indent = 4
+        self.indent_spaces = " " * self.indent
+        self.env = os.environ.copy()
+
+        # Default
+        self.global_options_schema: Dict[Any, Any] = {
+            Optional("exec_before"): Or([str], str),
+            Optional("exec_after"): Or([str], str),
+        }
+
+        self.task_schema: Dict[Any, Any] = {
+            Optional("path"): str,
+            Optional("delete"): bool,
+
+            Optional("exec_before"): Or([str], str),
+            Optional("exec_after"): Or([str], str),
+        }
+
+        self.global_options_values: Dict[str, Any] = {
+            "exec_before": [],
+            "exec_after": [],
+        }
+
+        self.task_default_values: Dict[str, Any] = {
+            # Optional items
+            "delete": False,
         }
 
+    def _initialize_data(self):
+        try:
+            super()._initialize_data()
+        except DataAlreadyInitialized:
+            return
+
+        # Mark values as initialized
+        self._values_initialized = True
+
     def _run(self, *args, **kwargs):
         stdout = run_indent_str(*args, **kwargs)
 
@@ -131,23 +164,6 @@ class BatchFetchBase:
             self._run(post_exec, cwd=str(cwd), env=self.env,
                       spaces=self.indent)
 
-    def __getitem__(self, key):
-        self._initialize_data()
-
-        if key in self.values:
-            return self.values[key]
-
-        if key in self.options:
-            return self.options[key]
-
-        if key in self.global_options_values:
-            return self.global_options_values[key]
-
-        raise KeyError(f"The item '{key}' was not found in '{self.values}")
-
-    def validate_schema(self):
-        self._initialize_data()
-
     def is_changed(self) -> bool:
         self._initialize_data()
         return bool(self.values["result"]["changed"])

{batchfetch-1.0.9 → batchfetch-1.1.1}/batchfetch/batchfetch_cli.py

@@ -60,7 +60,7 @@ class BatchFetchCli:
                                                options={})
         batchfetch_instance.validate_schema()
 
-        self.batchfetch_schemas[keyword] = batchfetch_instance.item_schema
+        self.batchfetch_schemas[keyword] = batchfetch_instance.task_schema
         self.batchfetch_classes[keyword] = batchfetch_class
         self.cfg_schema = {
             Optional("options"):
@@ -105,7 +105,7 @@ class BatchFetchCli:
             sys.exit(1)
 
         self.cfg = {
-            "options": {"clone_args": []},
+            "options": {"git_clone_args": []},
             "tasks": [],
         }
 

{batchfetch-1.0.9 → batchfetch-1.1.1}/batchfetch/batchfetch_git.py

@@ -42,31 +42,31 @@ class BatchFetchGit(BatchFetchBase):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.env["GIT_TERMINAL_PROMPT"] = "0"
-        self.indent_spaces = " " * self.indent
+        self.env["GIT_PAGER"] = ""
         self.main_key = "git"
 
         # Schema
-        self.item_schema.update({
+        self.task_schema.update({
             # Local options
             self.main_key: str,
             Optional("reference"): str,
 
             # Same as global options
-            Optional("clone_args"): [str],
+            Optional("git_clone_args"): [str],
             Optional("git_pull"): bool,
         })
 
         self.global_options_schema.update({
             # Global options
-            Optional("clone_args"): [str],
+            Optional("git_clone_args"): [str],
             Optional("git_pull"): bool,
         })
 
         # Data
-        self.global_options_values.update({"clone_args": [],
+        self.global_options_values.update({"git_clone_args": [],
                                            "git_pull": True})
 
-        self.item_default_values.update({
+        self.task_default_values.update({
             self.main_key: "",
             "reference": "",
             "delete": False,
@@ -191,7 +191,7 @@ class BatchFetchGit(BatchFetchBase):
             self.set_changed(True)
 
     def _repo_clone(self):
-        git_clone_args = self["clone_args"]
+        git_clone_args = self["git_clone_args"]
         git_clone_args += ["--recurse-submodules"]
 
         cmd = ["git", "clone"] + git_clone_args + \
@@ -209,57 +209,65 @@ class BatchFetchGit(BatchFetchBase):
 
         # Merge
         do_git_pull = self["git_pull"]
-        disable_merge = False
         if self["reference"]:
+            do_git_pull = False
             commit_ref = None
+
             try:
                 # Returns the commit ref of the branch or commit
-                commit_ref = self._git_tags(self["reference"])[0]
+                #
+                # If the tag is annotated, it points to a tag object, not
+                # directly to a commit. You need to resolve it to the commit it
+                # points to. Using `git rev-parse <tagname>^{commit}` allows
+                # getting the right reference.
+                commit_ref = self._git_tags(self["reference"] + "^{commit}")[0]
             except GitReferenceDoesNotExist:
-                # The reference does not exist. We should git pull
-                # in case we can get the reference
+                # The wanted reference does not exist. We should git pull in
+                # case we can get the reference
                 do_git_pull = True
             else:  # The reference exists
-                if not self._git_is_local_branch(self["reference"]):
-                    # This is not a real branch where we can merge
-                    disable_merge = True
-
                 try:
-                    # Returns the commit ref of the branch or commit
-                    commit_ref_head = self._git_tags("HEAD")[0]
+                    # If the tag is annotated, it points to a tag object, not
+                    # directly to a commit. You need to resolve it to the
+                    # commit it points to. Using `git rev-parse
+                    # <tagname>^{commit}` allows getting the right reference.
+                    commit_ref_head = self._git_tags("HEAD^{commit}")[0]
                 except GitReferenceDoesNotExist:
                     # HEAD is detached
                     commit_ref_head = None
 
                 # The wanted commit reference does not exist
                 # Or the commit ref of HEAD hasn't changed
-                if not commit_ref or commit_ref_head != commit_ref:
-                    do_git_pull = True
-                else:
+                if commit_ref and commit_ref_head == commit_ref:
                     do_git_pull = False
+                else:
+                    do_git_pull = True
 
         if not do_git_pull:
-            self.add_output(self.indent_spaces +
-                            "[INFO] git pull ignored\n")
-        else:
-            cmd = ["git", "fetch", "origin"]
-            self._run(cmd, cwd=str(self.git_local_dir), env=self.env)
+            self.add_output(self.indent_spaces + "[INFO] git pull ignored\n")
+            return git_merge
+
+        # Fetch
+        cmd = ["git", "fetch", "origin"]
+        self._run(cmd, cwd=str(self.git_local_dir), env=self.env)
 
+        # Merge
+        real_branch = self._git_is_local_branch("HEAD")
+        if real_branch:
             # TODO: only merge when difference from upstream
             commit_ref_head = self._git_ref(cwd=self.git_local_dir)
-            if not disable_merge:
-                self._run(["git", "merge", "--ff-only"],
-                          cwd=str(self.git_local_dir), env=self.env)
-                git_ref_after_merge = self._git_ref(cwd=self.git_local_dir)
-                if commit_ref_head != git_ref_after_merge:
-                    git_merge = True
-                    self.set_changed(True)
-                    self._run(["git", "log",
-                               '--pretty=format:"%h %ad %s [%cn]"',
-                               "--decorate", "--date=short",
-                               f"{commit_ref_head}..{git_ref_after_merge}"],
-                              cwd=str(self.git_local_dir),
-                              env=self.env)
+            self._run(["git", "merge", "--ff-only"],
+                      cwd=str(self.git_local_dir), env=self.env)
+            git_ref_after_merge = self._git_ref(cwd=self.git_local_dir)
+            if commit_ref_head != git_ref_after_merge:
+                git_merge = True
+                self.set_changed(True)
+                self._run(["git", "log",
+                           '--pretty=format:"%h %ad %s [%cn]"',
+                           "--decorate", "--date=short",
+                           f"{commit_ref_head}..{git_ref_after_merge}"],
+                          cwd=str(self.git_local_dir),
+                          env=self.env)
 
         return git_merge
 
@@ -307,9 +315,10 @@ class BatchFetchGit(BatchFetchBase):
             # Also check the commit reference in case
             # branch is a commit reference instead of a tag
             try:
-                git_ref_branch = self._git_tags(self["reference"])[0]
+                git_ref_branch = self._git_tags(self["reference"] +
+                                                "^{commit}")[0]
             except GitReferenceDoesNotExist as err:
-                raise BatchFetchError(f"The branch '{self['branch']}' "
+                raise BatchFetchError(f"The branch '{self['reference']}' "
                                       "does not exist.") from err
 
             if git_ref_after_merge != git_ref_branch and \

{batchfetch-1.0.9 → batchfetch-1.1.1/batchfetch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batchfetch
-Version: 1.0.9
+Version: 1.1.1
 Summary: Efficiently clone and pull multiple Git repositories.
 Home-page: https://github.com/jamescherti/batchfetch
 Author: James Cherti

{batchfetch-1.0.9 → batchfetch-1.1.1}/setup.py

@@ -22,7 +22,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="batchfetch",
-    version="1.0.9",
+    version="1.1.1",
     packages=find_packages(),
     description="Efficiently clone and pull multiple Git repositories.",
     license="GPLv3",