capistrano-git-copy 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9843651d93a14f12fca78795fed3654ade0c30cc
-  data.tar.gz: 706c6e4ae076521b794c31f0af831d9698ad1272
+  metadata.gz: 4071457c639166076052d94779f9fb7b78f67df6
+  data.tar.gz: 91fff803b0beaad67d114d7d9d9ba8def134abbd
 SHA512:
-  metadata.gz: 0f63eb347f0d6ea7d28882e2d13e171e119c7108c7e9b528eb30553260c5decf2b56636bde0ff2e4e00ee81a58645d7164be496971061d082fdf5254ad1d404f
-  data.tar.gz: 407bff892e724b1b0d257712477f9d2b974990855f3fd64f3e7227067b52dc5029a1fc4affec4b7a01f34eaf6fbbf2474b5325f9f11e1851af2960d9562d2829
+  metadata.gz: 715d74acefef227adf864d744af203628337ba5d229d7b93a0c6a2d99cf01f831d740eea0d0bd24d0172c6e5915ea92bb503e4232846c11974e4793e1d4cd892
+  data.tar.gz: bf787dbe3850e122baeda5f0eda224d561a6b2fe25e3ff9e95f4ceff2e97c93c5c4af9f67dfa92d691d084a78de0d8740846ef9f8eba23dc6967f94344dc4788

data/README.md

@@ -6,30 +6,32 @@ Creates a tar archive from the locale git repository and uploads it to the remot
 
 * [git-archive-all](https://github.com/Kentzo/git-archive-all)
 
-## Installation
+## Setup
 
-Add this line to your application's Gemfile:
+Add the library to your `Gemfile`:
 
-    gem 'capistrano', '~> 3.0.0'
-    gem 'capistrano-git-copy'
+```ruby
+group :development do
+  gem 'capistrano-git-copy', require: false
+end
+```
 
-And then execute:
+And load it in your `Capfile`:
 
-    $ bundle
+```ruby
+require 'capistrano/git/copy'
+```
 
-Or install it yourself as:
+Now use `git_copy` as your SCM type in your `config/deploy.rb`:
 
-    $ gem install capistrano-git-copy
-
-## Usage
-
-Require in `Capfile` to use the default task:
+    set :scm, :git_copy
 
-    require 'capistrano/git/copy'
+## Configuration
 
-Now use `git_copy` as your SCM type:
+You can modify any of the following Capistrano variables in your deploy.rb config.
 
-    set :scm, :git_copy
+- `git_archive_all_bin`     - Set git-archive-all command. Defaults to git-archive-all found in $PATH or to included version.
+- `git_copy_tmp_path`       - Temp path used to clone the repository and create archive.
 
 ## Contributing
 

data/lib/capistrano/git/copy.rb

@@ -1,2 +1,12 @@
+module Capistrano
+  module Git
+    module Copy
+      def self.root_path
+        File.expand_path('../../../..', __FILE__)
+      end
+    end
+  end
+end
+
 require 'capistrano/git/copy/version'
 require 'capistrano/git/copy/deploy'

data/lib/capistrano/git/copy/deploy.rb

@@ -1 +1,3 @@
+require 'tmpdir'
+
 load File.expand_path("../tasks/deploy.cap", __FILE__)

data/lib/capistrano/git/copy/tasks/deploy.cap

@@ -1,14 +1,19 @@
-require 'tmpdir'
+namespace :load do
+  task :defaults do
+    set :git_archive_all_bin, -> {
+      bin = `which git-archive-all`
+      bin.strip.length > 0 ? bin : File.join(Capistrano::Git::Copy.root_path, 'vendor', 'bin', 'git-archive-all')
+    }
+
+    set :git_copy_tmp_path, -> { File.join(Dir.tmpdir, "#{fetch(:application)}_#{fetch(:stage)}") }
+  end
+end
 
 namespace :git_copy do
 
   task :wrapper do
     on roles :all do
-      set :git_archive_all_bin, (fetch(:git_archive_all_bin) || `which git-archive-all`)
-      fail "git-archive-all binary not found" if fetch(:git_archive_all_bin).strip == ''
-
-      set :local_repo_path, File.join(Dir.tmpdir, "#{fetch(:application)}")
-      set :local_tar_file, File.join(Dir.tmpdir, "#{fetch(:application)}.tar.gz")
+      fail "git-archive-all binary not found" if fetch(:git_archive_all_bin).strip.length == 0
     end
   end
 
@@ -17,25 +22,31 @@ namespace :git_copy do
 
   desc 'Create tar and upload to server'
   task update: :'git_copy:wrapper' do
-    system("rm -rf #{fetch(:local_repo_path)}")
-    system("git clone #{fetch(:repo_url)} #{fetch(:local_repo_path)} > /dev/null 2> /dev/null")
+    local_repo_path = File.join(fetch(:git_copy_tmp_path), 'repo')
+    local_tar_file = File.join(fetch(:git_copy_tmp_path), 'archive.tar.gz')
+
+    system("rm -rf #{fetch(:git_copy_tmp_path)}")
+    system("mkdir -p #{fetch(:git_copy_tmp_path)}")
+
+    system("git clone #{fetch(:repo_url)} #{local_repo_path}")
 
     on roles :all do
-      system("cd #{fetch(:local_repo_path)} && git checkout #{fetch(:branch)} && git submodule init && git submodule update && git-archive-all __tmp.tar")
-      system("cd #{fetch(:local_repo_path)} && tar -xf __tmp.tar && cd __tmp && tar -czf #{fetch(:local_tar_file)} .")
+      system("cd #{local_repo_path} && git checkout #{fetch(:branch)} && git submodule init && git submodule update && git-archive-all __tmp.tar")
+      system("cd #{local_repo_path} && tar -xf __tmp.tar && cd __tmp && tar -czf #{local_tar_file} .")
 
-      upload! fetch(:local_tar_file), "#{fetch(:tmp_dir)}/#{File.basename(fetch(:local_tar_file))}"
+      upload!(local_tar_file, "#{fetch(:tmp_dir)}/#{fetch(:application)}_#{fetch(:stage)}.tar.gz")
 
-      system("rm -rf #{fetch(:local_repo_path)}")
-      system("rm -rf #{fetch(:local_tar_file)}")
+      system("rm -rf #{local_repo_path}")
+      system("rm -rf #{local_tar_file}")
     end
   end
 
   desc 'Extract tar to release path'
   task create_release: :'git_copy:update' do
     on roles :all do
-      execute :mkdir, '-p', release_path
-      execute :tar, '-f', "#{fetch(:tmp_dir)}/#{File.basename(fetch(:local_tar_file))}", '-x -C', release_path
+      execute(:mkdir, '-p', release_path)
+      execute(:tar, '-f', "#{fetch(:tmp_dir)}/#{fetch(:application)}_#{fetch(:stage)}.tar.gz", '-x -C', release_path)
+      execute(:rm, '-f', "#{fetch(:tmp_dir)}/#{fetch(:application)}_#{fetch(:stage)}.tar.gz")
     end
   end
 end

data/lib/capistrano/git/copy/version.rb

@@ -1,7 +1,7 @@
 module Capistrano
   module Git
     module Copy
-      VERSION = '0.2.0'
+      VERSION = '0.3.0'
     end
   end
 end

data/vendor/bin/git-archive-all

@@ -0,0 +1,494 @@
+#! /usr/bin/env python
+# coding=utf-8
+
+from __future__ import print_function
+from __future__ import unicode_literals
+
+__version__ = "1.8"
+
+import logging
+from os import extsep, path, readlink
+from subprocess import CalledProcessError, Popen, PIPE
+import sys
+import tarfile
+from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
+
+
+class GitArchiver(object):
+    """
+    GitArchiver
+
+    Scan a git repository and export all tracked files, and submodules.
+    Checks for .gitattributes files in each directory and uses 'export-ignore'
+    pattern entries for ignore files in the archive.
+
+    >>> archiver = GitArchiver(main_repo_abspath='my/repo/path')
+    >>> archiver.create('output.zip')
+    """
+    LOG = logging.getLogger('GitArchiver')
+
+    def __init__(self, prefix='', exclude=True, force_sub=False, extra=None, main_repo_abspath=None):
+        """
+        @param prefix: Prefix used to prepend all paths in the resulting archive.
+            Extra file paths are only prefixed if they are not relative.
+            E.g. if prefix is 'foo' and extra is ['bar', '/baz'] the resulting archive will look like this:
+            /
+              baz
+              foo/
+                bar
+        @type prefix: string
+
+        @param exclude: Determines whether archiver should follow rules specified in .gitattributes files.
+        @type exclude:  bool
+
+        @param force_sub: Determines whether submodules are initialized and updated before archiving.
+        @type force_sub: bool
+
+        @param extra: List of extra paths to include in the resulting archive.
+        @type extra: list
+
+        @param main_repo_abspath: Absolute path to the main repository (or one of subdirectories).
+            If given path is path to a subdirectory (but not a submodule directory!) it will be replaced
+            with abspath to top-level directory of the repository.
+            If None, current cwd is used.
+        @type main_repo_abspath: string
+        """
+        if extra is None:
+            extra = []
+
+        if main_repo_abspath is None:
+            main_repo_abspath = path.abspath('')
+        elif not path.isabs(main_repo_abspath):
+            raise ValueError("You MUST pass absolute path to the main git repository.")
+
+        try:
+            self.run_shell("[ -d .git ] || git rev-parse --git-dir > /dev/null 2>&1", main_repo_abspath)
+        except Exception as e:
+            raise ValueError("Not a git repository (or any of the parent directories).".format(path=main_repo_abspath))
+
+        main_repo_abspath = path.abspath(self.read_git_shell('git rev-parse --show-toplevel', main_repo_abspath).rstrip())
+
+        self.prefix = prefix
+        self.exclude = exclude
+        self.extra = extra
+        self.force_sub = force_sub
+        self.main_repo_abspath = main_repo_abspath
+
+    def create(self, output_path, dry_run=False, output_format=None):
+        """
+        Create the archive at output_file_path.
+
+        Type of the archive is determined either by extension of output_file_path or by output_format.
+        Supported formats are: gz, zip, bz2, tar, tgz
+
+        @param output_path: Output file path.
+        @type output_path: string
+
+        @param dry_run: Determines whether create should do nothing but print what it would archive.
+        @type dry_run: bool
+
+        @param output_format: Determines format of the output archive. If None, format is determined from extension
+            of output_file_path.
+        @type output_format: string
+        """
+        if output_format is None:
+            file_name, file_ext = path.splitext(output_path)
+            output_format = file_ext[len(extsep):].lower()
+            self.LOG.debug("Output format is not explicitly set, determined format is {0}.".format(output_format))
+
+        if not dry_run:
+            if output_format == 'zip':
+                archive = ZipFile(path.abspath(output_path), 'w')
+
+                def add_file(file_path, arcname):
+                    if not path.islink(file_path):
+                        archive.write(file_path, arcname, ZIP_DEFLATED)
+                    else:
+                        i = ZipInfo(arcname)
+                        i.create_system = 3
+                        i.external_attr = 0xA1ED0000
+                        archive.writestr(i, readlink(file_path))
+            elif output_format in ['tar', 'bz2', 'gz', 'tgz']:
+                if output_format == 'tar':
+                    t_mode = 'w'
+                elif output_format == 'tgz':
+                    t_mode = 'w:gz'
+                else:
+                    t_mode = 'w:{0}'.format(output_format)
+
+                archive = tarfile.open(path.abspath(output_path), t_mode)
+                add_file = lambda file_path, arcname: archive.add(file_path, arcname)
+            else:
+                raise RuntimeError("Unknown format: {0}".format(output_format))
+
+            def archiver(file_path, arcname):
+                self.LOG.debug("Compressing {0} => {1}...".format(file_path, arcname))
+                add_file(file_path, arcname)
+        else:
+            archive = None
+            archiver = lambda file_path, arcname: self.LOG.info("{0} => {1}".format(file_path, arcname))
+
+        self.archive_all_files(archiver)
+
+        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']}
+
+        @type repo_abspath:     string
+        @param repo_abspath:    Absolute path to the git repository.
+
+        @type repo_file_paths:  list
+        @param repo_file_paths: List of paths relative to the repo_abspath that are under git control.
+
+        @rtype:         dict
+        @return:    Dictionary representing exclude patterns.
+                    Keys are tuples of strings. Values are lists of strings.
+                    Returns None if self.exclude is not set.
+        """
+        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.read_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):
+        """
+        Checks whether file at a given path is excluded.
+
+        @type repo_abspath: string
+        @param repo_abspath: Absolute path to the git repository.
+
+        @type repo_file_path:   string
+        @param repo_file_path:  Path to a file within repo_abspath.
+
+        @type exclude_patterns:     dict
+        @param exclude_patterns:    Exclude patterns with format specified for get_exclude_patterns.
+
+        @rtype: bool
+        @return: True if file should be excluded. Otherwise False.
+        """
+        if exclude_patterns is None or not len(exclude_patterns):
+            return False
+
+        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 {pattern}: {path}".format(pattern=p, path=repo_file_path))
+                        is_excluded = True
+
+            if not len(components):
+                break
+
+            components.pop()
+
+        return is_excluded
+
+    def archive_all_files(self, archiver):
+        """
+        Archive all files using archiver.
+
+        @param archiver: Function that accepts 2 arguments: abspath to file on the system and relative path within archive.
+        """
+        for file_path in self.extra:
+            archiver(path.abspath(file_path), path.join(self.prefix, file_path))
+
+        for file_path in self.walk_git_files():
+            archiver(path.join(self.main_repo_abspath, file_path), path.join(self.prefix, file_path))
+
+    def walk_git_files(self, repo_path=''):
+        """
+        An iterator method that yields a file path relative to main_repo_abspath
+        for each file that should be included in the archive.
+        Skips those that match the exclusion patterns found in
+        any discovered .gitattributes files along the way.
+
+        Recurs into submodules as well.
+
+        @type repo_path:    string
+        @param repo_path:   Path to the git submodule repository relative to main_repo_abspath.
+
+        @rtype:     iterator
+        @return:    Iterator to traverse files under git control relative to main_repo_abspath.
+        """
+        repo_abspath = path.join(self.main_repo_abspath, repo_path)
+        repo_file_paths = self.read_git_shell("git ls-files --cached --full-name --no-empty-directory", repo_abspath).splitlines()
+        exclude_patterns = self.get_exclude_patterns(repo_abspath, repo_file_paths)
+
+        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
+            file_name = path.basename(repo_file_path)
+
+            # Only list symlinks and files that don't start with git.
+            if file_name.startswith(".git") or (not path.islink(repo_file_path) and path.isdir(repo_file_path)):
+                continue
+
+            main_repo_file_path = path.join(repo_path, repo_file_path)  # file path relative to the main repo
+
+            if self.is_file_excluded(repo_abspath, repo_file_path, exclude_patterns):
+                continue
+
+            yield main_repo_file_path
+
+        if self.force_sub:
+            self.run_shell("git submodule init", repo_abspath)
+            self.run_shell("git submodule update", repo_abspath)
+
+        for submodule_path in self.read_shell("git submodule --quiet foreach 'pwd'", repo_abspath).splitlines():
+            # Shell command returns absolute paths to submodules.
+            submodule_path = path.relpath(submodule_path, self.main_repo_abspath)
+            for file_path in self.walk_git_files(submodule_path):
+                yield file_path
+
+    @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 '.' (concrete symbol depends on OS).
+
+        @param repo_abspath: Absolute path to the git repository. Normalized via os.path.normpath.
+        @type repo_abspath: string
+
+        @param abspath: Absolute path to a file within repo_abspath. Normalized via os.path.normpath.
+        @type abspath: string
+
+        @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)
+
+        # Get portable version of '.'
+        components.insert(0, path.relpath(repo_abspath, repo_abspath))
+        return components
+
+    @staticmethod
+    def run_shell(cmd, cwd=None):
+        """
+        Runs shell command.
+
+        @type cmd:  string
+        @param cmd: Command to be executed.
+
+        @type cwd:  string
+        @param cwd: Working directory.
+
+        @rtype:     int
+        @return:    Return code of the command.
+
+        @raise CalledProcessError:  Raises exception if return code of the command is non-zero.
+        """
+        p = Popen(cmd, shell=True, cwd=cwd)
+        p.wait()
+
+        if p.returncode:
+            raise CalledProcessError(returncode=p.returncode, cmd=cmd)
+
+        return p.returncode
+
+    @staticmethod
+    def read_shell(cmd, cwd=None, encoding='utf-8'):
+        """
+        Runs shell command and reads output.
+
+        @type cmd:  string
+        @param cmd: Command to be executed.
+
+        @type cwd:  string
+        @param cwd: Working directory.
+
+        @type encoding: string
+        @param encoding: Encoding used to decode bytes returned by Popen into string.
+
+        @rtype:     string
+        @return:    Output of the command.
+
+        @raise CalledProcessError:  Raises exception if return code of the command is non-zero.
+        """
+        p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
+        output, _ = p.communicate()
+        output = output.decode(encoding)
+
+        if p.returncode:
+            if sys.version_info > (2,6):
+                raise CalledProcessError(returncode=p.returncode, cmd=cmd, output=output)
+            else:
+                raise CalledProcessError(returncode=p.returncode, cmd=cmd)
+
+        return output
+
+    @staticmethod
+    def read_git_shell(cmd, cwd=None):
+        """
+        Runs git shell command, reads output and decodes it into unicode string
+
+        @type cmd:  string
+        @param cmd: Command to be executed.
+
+        @type cwd:  string
+        @param cwd: Working directory.
+
+        @rtype:     string
+        @return:    Output of the command.
+
+        @raise CalledProcessError:  Raises exception if return code of the command is non-zero.
+        """
+        p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
+        output, _ = p.communicate()
+        output = output.decode('unicode_escape').encode('raw_unicode_escape').decode('utf-8')
+
+        if p.returncode:
+            if sys.version_info > (2,6):
+                raise CalledProcessError(returncode=p.returncode, cmd=cmd, output=output)
+            else:
+                raise CalledProcessError(returncode=p.returncode, cmd=cmd)
+
+        return output
+
+
+if __name__ == '__main__':
+    from optparse import OptionParser
+
+    parser = OptionParser(usage="usage: %prog [-v] [--prefix PREFIX] [--no-exclude] [--force-submodules] [--extra EXTRA1 [EXTRA2]] [--dry-run] OUTPUT_FILE",
+                          version="%prog {version}".format(version=__version__))
+
+    parser.add_option('--prefix',
+                      type='string',
+                      dest='prefix',
+                      default='',
+                      help="prepend PREFIX to each filename in the archive. OUTPUT_FILE name is used by default to avoid tarbomb")
+
+    parser.add_option('-v', '--verbose',
+                      action='store_true',
+                      dest='verbose',
+                      help='enable verbose mode')
+
+    parser.add_option('--no-exclude',
+                      action='store_false',
+                      dest='exclude',
+                      default=True,
+                      help="don't read .gitattributes files for patterns containing export-ignore attrib")
+
+    parser.add_option('--force-submodules',
+                      action='store_true',
+                      dest='force_sub',
+                      help="force a git submodule init && git submodule update at each level before iterating submodules")
+
+    parser.add_option('--extra',
+                      action='append',
+                      dest='extra',
+                      default=[],
+                      help="any additional files to include in the archive")
+
+    parser.add_option('--dry-run',
+                      action='store_true',
+                      dest='dry_run',
+                      help="don't actually archive anything, just show what would be done")
+
+    options, args = parser.parse_args()
+
+    if len(args) != 1:
+        parser.error("You must specify exactly one output file")
+
+    output_file_path = args[0]
+
+    if path.isdir(output_file_path):
+        parser.error("You cannot use directory as output")
+
+    # avoid tarbomb
+    if options.prefix:
+        options.prefix = path.join(options.prefix, '')
+    else:
+        import re
+
+        output_name = path.basename(output_file_path)
+        output_name = re.sub('(\.zip|\.tar|\.tgz|\.gz|\.bz2|\.tar\.gz|\.tar\.bz2)$', '', output_name) or "Archive"
+        options.prefix = path.join(output_name, '')
+
+    try:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter('%(message)s'))
+        GitArchiver.LOG.addHandler(handler)
+        GitArchiver.LOG.setLevel(logging.DEBUG if options.verbose else logging.INFO)
+        archiver = GitArchiver(options.prefix,
+                               options.exclude,
+                               options.force_sub,
+                               options.extra)
+        archiver.create(output_file_path, options.dry_run)
+    except Exception as e:
+        parser.exit(2, "{0}\n".format(e))
+
+    sys.exit(0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-git-copy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Florian Schwab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-09 00:00:00.000000000 Z
+date: 2014-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -71,6 +71,7 @@ files:
 - lib/capistrano/git/copy/tasks/deploy.cap
 - lib/capistrano/git/copy/version.rb
 - lib/capistrano/git_copy.rb
+- vendor/bin/git-archive-all
 homepage: https://github.com/ydkn/capistrano-git-copy
 licenses:
 - MIT