capistrano-git-copy 1.5.2 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ff186491f9d22f79fab6c98f8e8f803240d94c3e364b74ecad60b0d358df60e
-  data.tar.gz: fef778eafe2a6b6f188577fa6e36d7fc1b0caec838b854274a8e933b485ef8c4
+  metadata.gz: 100d26afc3422d8280d7ec211f0af3c9f2b2802c66aa5ffcdaa17d919de52292
+  data.tar.gz: 1d44966f13986f6ebd4f5c4d37a00b9fddb452ce0b82da0f8a863894bc320b40
 SHA512:
-  metadata.gz: 80a5adb7628716d21644b2e7f5a14bde6737bc23443949f20656e10e0017d4751af50fe2cc8884f7f2172fb86d8c00db1fd30429f5901e6b0072edf7be144973
-  data.tar.gz: 7e6f01a93481ca06c2a95e958b070187a46ab126403706b6e953183ee7176067cbb731a3e0bd67147231a1055d69523b194a5ff9a6f875897dde629b1e199ba7
+  metadata.gz: 3b38135587cf0d941be9664bbe3573544180398fcc13e9f466815ae47b4a1adcad2317fcd8ae4376a25f1e6d9413f264804045f8f5b4a805bea53fc798b015eb
+  data.tar.gz: a59f7e452bc4f0a54f8262c4b08576a3337c03c797b1531e3f36ed8dac88c86f972228580a14bf7b4da656fcfb3ed5eff2fb3c93e0febb45766de7da72a044a8

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 1.5.3 (2018-11-02)
+### Changes
+  - updated _git-archive-all_ to 1.19.1
+
 ## 1.5.2 (2018-10-07)
 ### Changes
   - updated _git-archive-all_ to 1.18.3

data/lib/capistrano/git_copy/version.rb

@@ -5,6 +5,6 @@ module Capistrano
   # GitCopy
   module GitCopy
     # gem version
-    VERSION = '1.5.2'
+    VERSION = '1.5.3'
   end
 end

data/vendor/git-archive-all/git_archive_all.py

@@ -32,7 +32,7 @@ from subprocess import CalledProcessError, Popen, PIPE
 import sys
 import re
 
-__version__ = "1.18.3"
+__version__ = "1.19.1"
 
 
 try:
@@ -121,7 +121,9 @@ class GitArchiver(object):
         self.force_sub = force_sub
         self.main_repo_abspath = main_repo_abspath
 
-    def create(self, output_path, dry_run=False, output_format=None):
+        self._check_attr_gens = {}
+
+    def create(self, output_path, dry_run=False, output_format=None, compresslevel=None):
         """
         Create the archive at output_file_path.
 
@@ -147,7 +149,13 @@ class GitArchiver(object):
             if output_format in self.ZIPFILE_FORMATS:
                 from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
 
-                archive = ZipFile(path.abspath(output_path), 'w')
+                if compresslevel is not None:
+                    if sys.version_info > (3, 7):
+                        archive = ZipFile(path.abspath(output_path), 'w', compresslevel=compresslevel)
+                    else:
+                        raise ValueError("Compression level for zip archives requires Python 3.7+")
+                else:
+                    archive = ZipFile(path.abspath(output_path), 'w')
 
                 def add_file(file_path, arcname):
                     if not path.islink(file_path):
@@ -161,7 +169,14 @@ class GitArchiver(object):
                 import tarfile
 
                 mode = self.TARFILE_FORMATS[output_format]
-                archive = tarfile.open(path.abspath(output_path), mode)
+
+                if compresslevel is not None:
+                    try:
+                        archive = tarfile.open(path.abspath(output_path), mode, compresslevel=compresslevel)
+                    except TypeError:
+                        raise ValueError("{0} cannot be compressed".format(output_format))
+                else:
+                    archive = tarfile.open(path.abspath(output_path), mode)
 
                 def add_file(file_path, arcname):
                     archive.add(file_path, arcname)
@@ -195,15 +210,9 @@ class GitArchiver(object):
         @return: True if file should be excluded. Otherwise False.
         @rtype: bool
         """
-        out = self.run_git_shell(
-            'git check-attr -z export-ignore -- %s' % quote(repo_file_path),
-            cwd=repo_abspath
-        ).split('\0')
-
-        try:
-            return out[2] == 'set'
-        except IndexError:
-            return False
+        next(self._check_attr_gens[repo_abspath])
+        attrs = self._check_attr_gens[repo_abspath].send(repo_file_path)
+        return attrs['export-ignore'] == 'set'
 
     def archive_all_files(self, archiver):
         """
@@ -235,55 +244,73 @@ class GitArchiver(object):
         @rtype: Iterable
         """
         repo_abspath = path.join(self.main_repo_abspath, repo_path)
-        repo_file_paths = self.run_git_shell(
-            'git ls-files -z --cached --full-name --no-empty-directory',
-            repo_abspath
-        ).split('\0')[:-1]
+        assert repo_abspath not in self._check_attr_gens
+        self._check_attr_gens[repo_abspath] = self.check_attr(repo_abspath, ['export-ignore'])
 
-        for repo_file_path in repo_file_paths:
-            repo_file_abspath = path.join(repo_abspath, repo_file_path)  # absolute file path
-            main_repo_file_path = path.join(repo_path, repo_file_path)  # file path relative to the main repo
+        try:
+            repo_file_paths = self.run_git_shell(
+                'git ls-files -z --cached --full-name --no-empty-directory',
+                repo_abspath
+            ).split('\0')[:-1]
 
-            # Only list symlinks and files.
-            if not path.islink(repo_file_abspath) and path.isdir(repo_file_abspath):
-                continue
+            for repo_file_path in repo_file_paths:
+                repo_file_abspath = path.join(repo_abspath, repo_file_path)  # absolute file path
+                main_repo_file_path = path.join(repo_path, repo_file_path)  # relative to main_repo_abspath
 
-            if self.is_file_excluded(repo_abspath, repo_file_path):
-                continue
+                # Only list symlinks and files.
+                if not path.islink(repo_file_abspath) and path.isdir(repo_file_abspath):
+                    continue
 
-            yield main_repo_file_path
+                if self.is_file_excluded(repo_abspath, repo_file_path):
+                    continue
 
-        if self.force_sub:
-            self.run_git_shell('git submodule init', repo_abspath)
-            self.run_git_shell('git submodule update', repo_abspath)
+                yield main_repo_file_path
 
-        try:
-            repo_gitmodules_abspath = path.join(repo_abspath, ".gitmodules")
+            if self.force_sub:
+                self.run_git_shell('git submodule init', repo_abspath)
+                self.run_git_shell('git submodule update', repo_abspath)
 
-            with open(repo_gitmodules_abspath) as f:
-                lines = f.readlines()
+            try:
+                repo_gitmodules_abspath = path.join(repo_abspath, ".gitmodules")
 
-            for l in lines:
-                m = re.match("^\\s*path\\s*=\\s*(.*)\\s*$", l)
+                with open(repo_gitmodules_abspath) as f:
+                    lines = f.readlines()
 
-                if m:
-                    repo_submodule_path = m.group(1)  # relative to repo_path
-                    main_repo_submodule_path = path.join(repo_path, repo_submodule_path)  # relative to main_repo_abspath
+                for l in lines:
+                    m = re.match("^\\s*path\\s*=\\s*(.*)\\s*$", l)
 
-                    if self.is_file_excluded(repo_abspath, repo_submodule_path):
-                        continue
+                    if m:
+                        repo_submodule_path = m.group(1)  # relative to repo_path
+                        main_repo_submodule_path = path.join(repo_path, repo_submodule_path)  # relative to main_repo_abspath
 
-                    for main_repo_submodule_file_path in self.walk_git_files(main_repo_submodule_path):
-                        repo_submodule_file_path = main_repo_submodule_file_path.replace(repo_path, "", 1).strip("/")
-                        if self.is_file_excluded(repo_abspath, repo_submodule_file_path):
+                        if self.is_file_excluded(repo_abspath, repo_submodule_path):
                             continue
 
-                        yield main_repo_submodule_file_path
-        except IOError:
-            pass
+                        for main_repo_submodule_file_path in self.walk_git_files(main_repo_submodule_path):
+                            repo_submodule_file_path = main_repo_submodule_file_path.replace(repo_path, "", 1).strip("/")  # relative to repo_path
+                            if self.is_file_excluded(repo_abspath, repo_submodule_file_path):
+                                continue
+
+                            yield main_repo_submodule_file_path
+            except IOError:
+                pass
+        finally:
+            self._check_attr_gens[repo_abspath].close()
+            del self._check_attr_gens[repo_abspath]
+
+    @classmethod
+    def decode_git_output(cls, output):
+        """
+        Decode Git's binary output handeling the way it escapes unicode characters.
+
+        @type output: bytes
+
+        @rtype: str
+        """
+        return output.decode('unicode_escape').encode('raw_unicode_escape').decode('utf-8')
 
-    @staticmethod
-    def run_git_shell(cmd, cwd=None):
+    @classmethod
+    def run_git_shell(cls, cmd, cwd=None):
         """
         Runs git shell command, reads output and decodes it into unicode string.
 
@@ -300,7 +327,7 @@ class GitArchiver(object):
         """
         p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
         output, _ = p.communicate()
-        output = output.decode('unicode_escape').encode('raw_unicode_escape').decode('utf-8')
+        output = cls.decode_git_output(output)
 
         if p.returncode:
             if sys.version_info > (2, 6):
@@ -310,13 +337,82 @@ class GitArchiver(object):
 
         return output
 
+    @classmethod
+    def check_attr(cls, repo_abspath, attrs):
+        """
+        Generator that returns attributes for given paths relative to repo_abspath.
+
+        >>> g = GitArchiver.check_attr('repo_path', ['export-ignore'])
+        >>> next(g)
+        >>> attrs = g.send('relative_path')
+        >>> print(attrs['export-ignore'])
+
+        @param repo_abspath: Absolute path to a git repository.
+        @type repo_abspath: str
+
+        @param attrs: Attributes to check.
+        @type attrs: [str]
+
+        @rtype: generator
+        """
+        def make_process():
+            cmd = 'GIT_FLUSH=1 git check-attr --stdin -z {0}'.format(' '.join(attrs))
+            return Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, cwd=repo_abspath)
+
+        def read_attrs(process, repo_file_path):
+            process.stdin.write(repo_file_path.encode('utf-8') + b'\0')
+            process.stdin.flush()
+
+            # For every attribute check-attr will output: <path> NUL <attribute> NUL <info> NUL
+            path, attr, info = b'', b'', b''
+            nuls_count = 0
+            nuls_expected = 3 * len(attrs)
+
+            while nuls_count != nuls_expected:
+                b = process.stdout.read(1)
+
+                if b == b'' and process.poll() is not None:
+                    raise RuntimeError("check-attr exited prematurely")
+                elif b == b'\0':
+                    nuls_count += 1
+
+                    if nuls_count % 3 == 0:
+                        yield map(cls.decode_git_output, (path, attr, info))
+                        path, attr, info = b'', b'', b''
+                elif nuls_count % 3 == 0:
+                    path += b
+                elif nuls_count % 3 == 1:
+                    attr += b
+                elif nuls_count % 3 == 2:
+                    info += b
+
+        if not attrs:
+            return
+
+        process = make_process()
+
+        try:
+            while True:
+                repo_file_path = yield
+                repo_file_attrs = {}
+
+                for path, attr, value in read_attrs(process, repo_file_path):
+                    assert path == repo_file_path
+                    assert attr in attrs
+                    repo_file_attrs[attr] = value
+
+                yield repo_file_attrs
+        finally:
+            process.stdin.close()
+            process.wait()
+
 
 def main():
-    from optparse import OptionParser
+    from optparse import OptionParser, SUPPRESS_HELP
 
     parser = OptionParser(
         usage="usage: %prog [-v] [--prefix PREFIX] [--no-exclude] [--force-submodules]"
-              " [--extra EXTRA1 [EXTRA2]] [--dry-run] OUTPUT_FILE",
+              " [--extra EXTRA1 ...] [--dry-run] [-0 | ... | -9] OUTPUT_FILE",
         version="%prog {0}".format(__version__)
     )
 
@@ -355,6 +451,13 @@ def main():
                       dest='dry_run',
                       help="don't actually archive anything, just show what would be done")
 
+    for i in range(10):
+        parser.add_option('-{0}'.format(i),
+                          action='store_const',
+                          const=i,
+                          dest='compresslevel',
+                          help=SUPPRESS_HELP)
+
     options, args = parser.parse_args()
 
     if len(args) != 1:
@@ -386,7 +489,7 @@ def main():
                                options.exclude,
                                options.force_sub,
                                options.extra)
-        archiver.create(output_file_path, options.dry_run)
+        archiver.create(output_file_path, options.dry_run, compresslevel=options.compresslevel)
     except Exception as e:
         parser.exit(2, "{0}\n".format(e))
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-git-copy
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.5.3
 platform: ruby
 authors:
 - Florian Schwab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-07 00:00:00.000000000 Z
+date: 2018-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano