capistrano-git-copy 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07c610ece9909effffdeee0113bf361c64c88039fafff39564e9a2742e862d8c
-  data.tar.gz: 90046d84e5b763fc5bf6c947433813934c12f9e16c86b4a082883ab6f89c1fec
+  metadata.gz: '0193555dcc7eefb6ad1c129cc92d99314fd5631a386f8daf39e4ef53a5ab9d7d'
+  data.tar.gz: 60b392776e795ee02a8cf2af8c4952c8d33eceb9277a2fd7c782e67b01189da3
 SHA512:
-  metadata.gz: 91c2cc32118c9ac4fbe1d941c3c9bfd1b60d63e98b68bb487abc2171e58582cc218a39c0893b21e591b7e41c12ded879e431abe2d85a1c848aa0547b94e43b48
-  data.tar.gz: 62ac5254df68295657e40ba341a2a4eee4d6a3be37e38bfa5f58f8996c5d70cd2042cefc173198435a38bd941c64c6b4b4204ffec67d644289a9b817360fe975
+  metadata.gz: e125d7493ca8d54242e211604105b5d138e5c1944a165efdd888fde77599204a40ca47dcd9b5ea4ba16d765b6c2af9fdcc2f8cc5bd93435fb3c8158f5f827282
+  data.tar.gz: d5627c293b8a6cf4b614dae2b86779468eb0fd48baa43ea9ad43ff745bc5437a994785f02575221549c1e9b6627ccad340c7abf65c38b875ff5d084973b19c9d

data/.gitlab-ci.yml

@@ -0,0 +1,5 @@
+rubocop:
+  image: ruby:2.5
+  script:
+    - gem install rubocop --no-ri --no-rdoc
+    - rubocop

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/git-archive-all"]
 	path = vendor/git-archive-all
-	url = https://github.com/ydkn/git-archive-all.git
+	url = https://gitlab.com/ydkn/git-archive-all.git

data/.rubocop.yml

@@ -0,0 +1,5 @@
+Metrics/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  Max: 100

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 1.5.1 (2018-09-24)
+### Changes
+  - updated _git-archive-all_ to 1.18.2
+
 ## 1.5.0 (2018-05-24)
 ### Feature
   - add option to switch off running git clean (#25)

data/README.md

@@ -1,10 +1,3 @@
-[![Gem Version](https://img.shields.io/gem/v/capistrano-git-copy.svg)](https://rubygems.org/gems/capistrano-git-copy)
-[![Dependencies](https://img.shields.io/gemnasium/ydkn/capistrano-git-copy.svg)](https://gemnasium.com/ydkn/capistrano-git-copy)
-[![Code Climate](https://img.shields.io/codeclimate/github/ydkn/capistrano-git-copy.svg)](https://codeclimate.com/github/ydkn/capistrano-git-copy)
-
-[![Join the chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ydkn/capistrano-git-copy)
-
-
 # Capistrano::GitCopy
 
 Creates a tar archive locally from the git repository and uploads it to the remote server.

data/capistrano-git-copy.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'capistrano/git_copy/version'
 
@@ -10,17 +9,17 @@ Gem::Specification.new do |spec|
   spec.email         = ['me@ydkn.de']
   spec.description   = 'Copy local git repository deploy strategy for capistrano.'
   spec.summary       = 'Copy local git repository deploy strategy for capistrano.'
-  spec.homepage      = 'https://github.com/ydkn/capistrano-git-copy'
+  spec.homepage      = 'https://gitlab.com/ydkn/capistrano-git-copy'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/) + %w( vendor/git-archive-all/git_archive_all.py )
+  spec.files         = `git ls-files`.split("\n") + %w[vendor/git-archive-all/git_archive_all.py]
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_dependency 'capistrano', '>= 3.7.0', '< 4.0.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'rubocop'
 end

data/lib/capistrano/git_copy/scm.rb

@@ -1,11 +1,14 @@
 require 'tmpdir'
 require 'capistrano/scm/plugin'
+require 'capistrano/git_copy/scm_helpers'
 
 module Capistrano
   module GitCopy
     # SCM plugin for capistrano
     # uses a local clone and uploads a tar archive to the server
     class SCM < ::Capistrano::SCM::Plugin
+      include Capistrano::GitCopy::SCMHelpers
+
       # set default values
       def set_defaults
         set_if_empty :with_clean, true
@@ -16,7 +19,7 @@ module Capistrano
 
       # define plugin tasks
       def define_tasks
-        eval_rakefile File.expand_path('../tasks/git_copy.rake', __FILE__)
+        eval_rakefile File.expand_path('tasks/git_copy.rake', __dir__)
       end
 
       # register capistrano hooks
@@ -38,15 +41,7 @@ module Capistrano
       # @return [Boolean] indicates if repo cache exists
       def test
         if backend.test("[ -d #{repo_cache_path} ]")
-          backend.within(repo_cache_path) do
-            if backend.test(:git, :status, '>/dev/null 2>/dev/null')
-              true
-            else
-              backend.execute(:rm, '-rf', repo_cache_path)
-
-              false
-            end
-          end
+          check_repo_cache_path
         else
           false
         end
@@ -76,26 +71,16 @@ module Capistrano
         end
 
         # cleanup
-        if fetch(:with_clean)
-          git(:clean, '-d', '-f')
-        end
+        git(:clean, '-d', '-f') if fetch(:with_clean)
 
-        if fetch(:with_submodules)
-          git(:submodule, :foreach, '--recursive', :git, :clean, '-d', '-f')
-        end
+        git(:submodule, :foreach, '--recursive', :git, :clean, '-d', '-f') if fetch(:with_submodules)
       end
 
       # Create tar archive
       #
       # @return void
       def prepare_release
-        if fetch(:upload_path) != '.'
-          backend.execute(:tar, '-czf', archive_path, '-C', fetch(:upload_path), '.')
-        elsif fetch(:with_submodules)
-          backend.execute(git_archive_all_bin, "--prefix=''", archive_path)
-        else
-          git(:archive, '--format=tar', 'HEAD', '|', 'gzip', "> #{archive_path}")
-        end
+        package_release_archive
 
         exclude_files_from_archive if fetch(:git_excludes, []).count > 0
       end
@@ -110,9 +95,7 @@ module Capistrano
 
         backend.upload!(archive_path, remote_archive_path)
 
-        backend.execute(:mkdir, '-p', release_path)
-        backend.execute(:tar, '-f', remote_archive_path, '-x', '-C', release_path)
-        backend.execute(:rm, '-f', remote_archive_path)
+        extract_archive_on_remote(remote_archive_path)
       end
 
       # Set deployed revision
@@ -135,74 +118,21 @@ module Capistrano
       #
       # @return [String]
       def tmp_path
-        @_tmp_path ||= File.join(Dir.tmpdir, deploy_id)
+        @tmp_path ||= File.join(Dir.tmpdir, deploy_id)
       end
 
       # Path to repository cache
       #
       # @return [String]
       def repo_cache_path
-        @_repo_cache_path ||= fetch(:git_repo_cach_path, File.join(tmp_path, 'repo'))
+        @repo_cache_path ||= fetch(:git_repo_cach_path, File.join(tmp_path, 'repo'))
       end
 
       # Path to archive
       #
       # @return [String]
       def archive_path
-        @_archive_path ||= File.join(tmp_path, 'archive.tar.gz')
-      end
-
-      private
-
-      def deploy_id
-        [
-          fetch(:application),
-          fetch(:stage),
-          Digest::MD5.hexdigest(fetch(:repo_url))[0..7],
-          Digest::MD5.hexdigest(Dir.getwd)[0..7]
-        ].compact.join('_').gsub(/[^\w]/, '')
-      end
-
-      def commit_hash
-        return @_commit_hash if @_commit_hash
-
-        branch = fetch(:branch, 'master').to_s.strip
-
-        if backend.test(:git, 'rev-parse', "origin/#{branch}", '>/dev/null 2>/dev/null')
-          @_commit_hash = backend.capture(:git, 'rev-parse', "origin/#{branch}").strip
-        else
-          @_commit_hash = backend.capture(:git, 'rev-parse', branch).strip
-        end
-      end
-
-      def git_archive_all_bin
-        File.expand_path('../../../../vendor/git-archive-all/git_archive_all.py', __FILE__)
-      end
-
-      def git(*args)
-        backend.execute(:git, *args)
-      end
-
-      def exclude_files_from_archive
-        archive_dir = File.join(tmp_path, 'archive')
-
-        backend.execute(:rm, '-rf', archive_dir)
-        backend.execute(:mkdir, '-p', archive_dir)
-        backend.execute(:tar, '-xzf', archive_path, '-C', archive_dir)
-
-        fetch(:git_excludes, []).each do |f|
-          file_path = File.join(archive_dir, f.gsub(/\A\//, ''))
-
-          unless File.exists?(file_path)
-            backend.warn("#{f} does not exists!")
-
-            next
-          end
-
-          FileUtils.rm_rf(file_path)
-        end
-
-        backend.execute(:tar, '-czf', archive_path, '-C', archive_dir, '.')
+        @archive_path ||= File.join(tmp_path, 'archive.tar.gz')
       end
     end
   end

data/lib/capistrano/git_copy/scm_helpers.rb

@@ -0,0 +1,93 @@
+require 'tmpdir'
+
+module Capistrano
+  module GitCopy
+    # Helper methods for capistrano SCM plugin
+    module SCMHelpers
+      private
+
+      def deploy_id
+        [
+          fetch(:application),
+          fetch(:stage),
+          Digest::MD5.hexdigest(fetch(:repo_url))[0..7],
+          Digest::MD5.hexdigest(Dir.getwd)[0..7]
+        ].compact.join('_').gsub(/[^\w]/, '')
+      end
+
+      def commit_hash
+        return @commit_hash if @commit_hash
+
+        branch = fetch(:branch, 'master').to_s.strip
+
+        @commit_hash = if backend.test(:git, 'rev-parse', "origin/#{branch}", '>/dev/null 2>/dev/null')
+                         backend.capture(:git, 'rev-parse', "origin/#{branch}").strip
+                       else
+                         backend.capture(:git, 'rev-parse', branch).strip
+                       end
+      end
+
+      def git_archive_all_bin
+        File.expand_path('../../../vendor/git-archive-all/git_archive_all.py', __dir__)
+      end
+
+      def git(*args)
+        backend.execute(:git, *args)
+      end
+
+      def check_repo_cache_path
+        backend.within(repo_cache_path) do
+          if backend.test(:git, :status, '>/dev/null 2>/dev/null')
+            true
+          else
+            backend.execute(:rm, '-rf', repo_cache_path)
+
+            false
+          end
+        end
+      end
+
+      def package_release_archive
+        if fetch(:upload_path) != '.'
+          backend.execute(:tar, '-czf', archive_path, '-C', fetch(:upload_path), '.')
+        elsif fetch(:with_submodules)
+          backend.execute(git_archive_all_bin, "--prefix=''", archive_path)
+        else
+          git(:archive, '--format=tar', 'HEAD', '|', 'gzip', "> #{archive_path}")
+        end
+      end
+
+      def exclude_files_from_archive
+        archive_dir = File.join(tmp_path, 'archive')
+
+        backend.execute(:rm, '-rf', archive_dir)
+        backend.execute(:mkdir, '-p', archive_dir)
+        backend.execute(:tar, '-xzf', archive_path, '-C', archive_dir)
+
+        remove_file_from_archive_dir(archive_dir)
+
+        backend.execute(:tar, '-czf', archive_path, '-C', archive_dir, '.')
+      end
+
+      def remove_file_from_archive_dir(archive_dir)
+        fetch(:git_excludes, []).each do |f|
+          file_path = File.join(archive_dir, f.gsub(%r{\A/}, ''))
+
+          unless File.exist?(file_path)
+            backend.warn("#{f} does not exists!")
+
+            next
+          end
+
+          FileUtils.rm_rf(file_path)
+        end
+      end
+
+      def extract_archive_on_remote(remote_archive_path)
+        backend.execute(:mkdir, '-p', release_path)
+        backend.execute(:tar, '-f', remote_archive_path, '-x', '-C', release_path)
+        backend.execute(:rm, '-f', remote_archive_path)
+      end
+    end
+  end
+end

data/lib/capistrano/git_copy/version.rb

@@ -3,6 +3,6 @@ module Capistrano
   # GitCopy
   module GitCopy
     # gem version
-    VERSION = '1.5.0'
+    VERSION = '1.5.1'.freeze
   end
 end

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

@@ -27,14 +27,29 @@ from __future__ import print_function
 from __future__ import unicode_literals
 
 import logging
-from os import extsep, path, readlink, curdir
+from os import extsep, path, readlink
 from subprocess import CalledProcessError, Popen, PIPE
 import sys
-import tarfile
-from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
 import re
 
-__version__ = "1.17.1"
+__version__ = "1.18.2"
+
+
+try:
+    # Python 3.3+
+    from shlex import quote
+except ImportError:
+    _find_unsafe = re.compile(r'[^a-zA-Z0-9_@%+=:,./-]').search
+
+    def quote(s):
+        """Return a shell-escaped version of the string *s*."""
+        if not s:
+            return "''"
+
+        if _find_unsafe(s) is None:
+            return s
+
+        return "'" + s.replace("'", "'\"'\"'") + "'"
 
 
 class GitArchiver(object):
@@ -48,6 +63,17 @@ class GitArchiver(object):
     >>> archiver = GitArchiver(main_repo_abspath='my/repo/path')
     >>> archiver.create('output.zip')
     """
+    TARFILE_FORMATS = {
+        'tar': 'w',
+        'tbz2': 'w:bz2',
+        'tgz': 'w:gz',
+        'txz': 'w:xz',
+        'bz2': 'w:bz2',
+        'gz': 'w:gz',
+        'xz': 'w:xz'
+    }
+    ZIPFILE_FORMATS = ('.zip',)
+
     LOG = logging.getLogger('GitArchiver')
 
     def __init__(self, prefix='', exclude=True, force_sub=False, extra=None, main_repo_abspath=None):
@@ -118,7 +144,9 @@ class GitArchiver(object):
             self.LOG.debug("Output format is not explicitly set, determined format is {0}.".format(output_format))
 
         if not dry_run:
-            if output_format == 'zip':
+            if output_format in self.ZIPFILE_FORMATS:
+                from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
+
                 archive = ZipFile(path.abspath(output_path), 'w')
 
                 def add_file(file_path, arcname):
@@ -129,25 +157,19 @@ class GitArchiver(object):
                         i.create_system = 3
                         i.external_attr = 0xA1ED0000
                         archive.writestr(i, readlink(file_path))
-            elif output_format in ['tar', 'bz2', 'gz', 'xz', 'tgz', 'txz']:
-                if output_format == 'tar':
-                    t_mode = 'w'
-                elif output_format == 'tgz':
-                    t_mode = 'w:gz'
-                elif output_format == 'txz':
-                    t_mode = 'w:xz'
-                else:
-                    t_mode = 'w:{0}'.format(output_format)
-
-                archive = tarfile.open(path.abspath(output_path), t_mode)
+            elif output_format in self.TARFILE_FORMATS:
+                import tarfile
+
+                mode = self.TARFILE_FORMATS[output_format]
+                archive = tarfile.open(path.abspath(output_path), mode)
 
                 def add_file(file_path, arcname):
                     archive.add(file_path, arcname)
             else:
-                raise RuntimeError("unknown format: {0}".format(output_format))
+                raise ValueError("unknown format: {0}".format(output_format))
 
             def archiver(file_path, arcname):
-                self.LOG.debug("Compressing {0} => {1}...".format(file_path, arcname))
+                self.LOG.debug("{0} => {1}".format(file_path, arcname))
                 add_file(file_path, arcname)
         else:
             archive = None
@@ -160,105 +182,28 @@ class GitArchiver(object):
         if archive is not None:
             archive.close()
 
-    def get_exclude_patterns(self, repo_abspath, repo_file_paths):
-        """
-        Returns exclude patterns for a given repo. It looks for .gitattributes files in repo_file_paths.
-
-        Resulting dictionary will contain exclude patterns per path (relative to the repo_abspath).
-        E.g. {('.', 'Catalyst', 'Editions', 'Base'): ['Foo*', '*Bar']}
-
-        @param repo_abspath: Absolute path to the git repository.
-        @type repo_abspath: str
-
-        @param repo_file_paths: List of paths relative to the repo_abspath that are under git control.
-        @type repo_file_paths:  list
-
-        @return: Dictionary representing exclude patterns.
-            Keys are tuples of strings. Values are lists of strings.
-            Returns None if self.exclude is not set.
-        @rtype: dict or None
-        """
-        if not self.exclude:
-            return None
-
-        def read_attributes(attributes_abspath):
-            patterns = []
-            if path.isfile(attributes_abspath):
-                attributes = open(attributes_abspath, 'r').readlines()
-                patterns = []
-                for line in attributes:
-                    tokens = line.strip().split()
-                    if "export-ignore" in tokens[1:]:
-                        patterns.append(tokens[0])
-            return patterns
-
-        exclude_patterns = {(): []}
-
-        # There may be no gitattributes.
-        try:
-            global_attributes_abspath = self.run_git_shell("git config --get core.attributesfile", repo_abspath).rstrip()
-            exclude_patterns[()] = read_attributes(global_attributes_abspath)
-        except:
-            # And it's valid to not have them.
-            pass
-
-        for attributes_abspath in [path.join(repo_abspath, f) for f in repo_file_paths if f.endswith(".gitattributes")]:
-            # Each .gitattributes affects only files within its directory.
-            key = tuple(self.get_path_components(repo_abspath, path.dirname(attributes_abspath)))
-            exclude_patterns[key] = read_attributes(attributes_abspath)
-
-        local_attributes_abspath = path.join(repo_abspath, ".git", "info", "attributes")
-        key = tuple(self.get_path_components(repo_abspath, repo_abspath))
-
-        if key in exclude_patterns:
-            exclude_patterns[key].extend(read_attributes(local_attributes_abspath))
-        else:
-            exclude_patterns[key] = read_attributes(local_attributes_abspath)
-
-        return exclude_patterns
-
-    def is_file_excluded(self, repo_abspath, repo_file_path, exclude_patterns):
+    def is_file_excluded(self, repo_abspath, repo_file_path):
         """
         Checks whether file at a given path is excluded.
 
         @param repo_abspath: Absolute path to the git repository.
         @type repo_abspath: str
 
-        @param repo_file_path: Path to a file within repo_abspath.
+        @param repo_file_path: Path to a file relative to repo_abspath.
         @type repo_file_path: str
 
-        @param exclude_patterns: Exclude patterns with format specified for get_exclude_patterns.
-        @type exclude_patterns: dict
-
         @return: True if file should be excluded. Otherwise False.
         @rtype: bool
         """
-        if exclude_patterns is None or not len(exclude_patterns):
-            return False
+        out = self.run_git_shell(
+            'git check-attr -z export-ignore -- %s' % quote(repo_file_path),
+            cwd=repo_abspath
+        ).split('\0')
 
-        from fnmatch import fnmatch
-
-        file_name = path.basename(repo_file_path)
-        components = self.get_path_components(repo_abspath, path.join(repo_abspath, path.dirname(repo_file_path)))
-
-        is_excluded = False
-        # We should check all patterns specified in intermediate directories to the given file.
-        # At the end we should also check for the global patterns (key '()' or empty tuple).
-        while not is_excluded:
-            key = tuple(components)
-            if key in exclude_patterns:
-                patterns = exclude_patterns[key]
-                for p in patterns:
-                    if fnmatch(file_name, p) or fnmatch(repo_file_path, p):
-                        self.LOG.debug("Exclude pattern matched {0}: {1}".format(p, repo_file_path))
-                        is_excluded = True
-
-            if not len(components):
-                break
-
-            components.pop()
-
-        return is_excluded
+        try:
+            return out[2] == 'set'
+        except IndexError:
+            return False
 
     def archive_all_files(self, archiver):
         """
@@ -291,14 +236,11 @@ class GitArchiver(object):
         """
         repo_abspath = path.join(self.main_repo_abspath, repo_path)
         repo_file_paths = self.run_git_shell(
-            "git ls-files --cached --full-name --no-empty-directory",
+            'git ls-files -z --cached --full-name --no-empty-directory',
             repo_abspath
-        ).splitlines()
-        exclude_patterns = self.get_exclude_patterns(repo_abspath, repo_file_paths)
+        ).split('\0')[:-1]
 
         for repo_file_path in repo_file_paths:
-            # Git puts path in quotes if file path has unicode characters.
-            repo_file_path = repo_file_path.strip('"')  # file path relative to current repo
             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
 
@@ -306,14 +248,14 @@ class GitArchiver(object):
             if not path.islink(repo_file_abspath) and path.isdir(repo_file_abspath):
                 continue
 
-            if self.is_file_excluded(repo_abspath, repo_file_path, exclude_patterns):
+            if self.is_file_excluded(repo_abspath, repo_file_path):
                 continue
 
             yield main_repo_file_path
 
         if self.force_sub:
-            self.run_git_shell("git submodule init", repo_abspath)
-            self.run_git_shell("git submodule update", repo_abspath)
+            self.run_git_shell('git submodule init', repo_abspath)
+            self.run_git_shell('git submodule update', repo_abspath)
 
         try:
             repo_gitmodules_abspath = path.join(repo_abspath, ".gitmodules")
@@ -322,70 +264,24 @@ class GitArchiver(object):
                 lines = f.readlines()
 
             for l in lines:
-                m = re.match("^\s*path\s*=\s*(.*)\s*$", l)
+                m = re.match("^\\s*path\\s*=\\s*(.*)\\s*$", l)
 
                 if m:
-                    submodule_path = m.group(1)
-                    submodule_path = path.join(repo_path, submodule_path)
+                    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
 
-                    if self.is_file_excluded(repo_abspath, submodule_path, exclude_patterns):
+                    if self.is_file_excluded(repo_abspath, repo_submodule_path):
                         continue
 
-                    for submodule_file_path in self.walk_git_files(submodule_path):
-                        if self.is_file_excluded(repo_abspath, submodule_file_path, exclude_patterns):
+                    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):
                             continue
 
-                        yield submodule_file_path
+                        yield main_repo_submodule_file_path
         except IOError:
             pass
 
-    @staticmethod
-    def get_path_components(repo_abspath, abspath):
-        """
-        Split given abspath into components relative to repo_abspath.
-        These components are primarily used as unique keys of files and folders within a repository.
-
-        E.g. if repo_abspath is '/Documents/Hobby/ParaView/' and abspath is
-        '/Documents/Hobby/ParaView/Catalyst/Editions/Base/', function will return:
-        ['.', 'Catalyst', 'Editions', 'Base']
-
-        First element is always os.curdir (concrete symbol depends on OS).
-
-        @param repo_abspath: Absolute path to the git repository. Normalized via os.path.normpath.
-        @type repo_abspath: str
-
-        @param abspath: Absolute path to a file within repo_abspath. Normalized via os.path.normpath.
-        @type abspath: str
-
-        @return: List of path components.
-        @rtype: list
-        """
-        repo_abspath = path.normpath(repo_abspath)
-        abspath = path.normpath(abspath)
-
-        if not path.isabs(repo_abspath):
-            raise ValueError("repo_abspath MUST be absolute path.")
-
-        if not path.isabs(abspath):
-            raise ValueError("abspath MUST be absoulte path.")
-
-        if not path.commonprefix([repo_abspath, abspath]):
-            raise ValueError(
-                "abspath (\"{0}\") MUST have common prefix with repo_abspath (\"{1}\")"
-                .format(abspath, repo_abspath)
-            )
-
-        components = []
-
-        while not abspath == repo_abspath:
-            abspath, tail = path.split(abspath)
-
-            if tail:
-                components.insert(0, tail)
-
-        components.insert(0, curdir)
-        return components
-
     @staticmethod
     def run_git_shell(cmd, cwd=None):
         """
@@ -473,11 +369,9 @@ def main():
     if options.prefix is not None:
         options.prefix = path.join(options.prefix, '')
     else:
-        import re
-
         output_name = path.basename(output_file_path)
         output_name = re.sub(
-            '(\.zip|\.tar|\.tgz|\.txz|\.gz|\.bz2|\.xz|\.tar\.gz|\.tar\.bz2|\.tar\.xz)$',
+            '(\\.zip|\\.tar|\\.tbz2|\\.tgz|\\.txz|\\.bz2|\\.gz|\\.xz|\\.tar\\.bz2|\\.tar\\.gz|\\.tar\\.xz)$',
             '',
             output_name
         ) or "Archive"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-git-copy
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Florian Schwab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-24 00:00:00.000000000 Z
+date: 2018-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -34,16 +34,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,7 +80,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitlab-ci.yml"
 - ".gitmodules"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -89,10 +91,11 @@ files:
 - capistrano-git-copy.gemspec
 - lib/capistrano/git_copy.rb
 - lib/capistrano/git_copy/scm.rb
+- lib/capistrano/git_copy/scm_helpers.rb
 - lib/capistrano/git_copy/tasks/git_copy.rake
 - lib/capistrano/git_copy/version.rb
 - vendor/git-archive-all/git_archive_all.py
-homepage: https://github.com/ydkn/capistrano-git-copy
+homepage: https://gitlab.com/ydkn/capistrano-git-copy
 licenses:
 - MIT
 metadata: {}
@@ -112,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Copy local git repository deploy strategy for capistrano.