vagrant-rsync-only-changed 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19b21c8078ed412f7a9f550e5d34dcbbcbc79ddc
+  data.tar.gz: 26ed3e283a53874f0a8b12ffb7e7cfe366279ed8
+SHA512:
+  metadata.gz: e9c41278bc21bc1a7abe11cc2dcc65b02fa7b178a54280e08aa62829bf723db25e3e1017df56b9a42bad8dfed532c881db6ff0f9ff5dd651b402e4eb44a8db49
+  data.tar.gz: 0a54d6abce4d152809f1fb1f6e8112c0f821241ca87c7656ae7f720f776ad77cca69e323225fe46f8d11d6706cb5a3f40886700f4cd577cd2c574ab86eff4be9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>vagrant-rsync-only-changed</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.dltk.core.scriptbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.dltk.ruby.core.nature</nature>
+	</natures>
+</projectDescription>

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+group :development do
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-rsync-only-changed", path: "."
+end

data/README.md

@@ -0,0 +1,36 @@
+# Vagrant::Rsync::Only::Changed
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/vagrant/rsync/only/changed`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vagrant-rsync-only-changed'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vagrant-rsync-only-changed
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/vagrant-rsync-only-changed.
+

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "vagrant/rsync/only/changed"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/vagrant-rsync-only-changed.rb

@@ -0,0 +1,24 @@
+# This file is required because Vagrant's plugin system expects
+# an eponymous ruby file matching the rubygem.
+#
+# So this gem is called 'vagrant-gatling-rsync' and thus vagrant tries
+# to require "vagrant-gatling-rsync"
+
+require "vagrant-rsync-only-changed/plugin"
+
+require "pathname"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    lib_path = Pathname.new(File.expand_path("../vagrant-rsync-only-changed", __FILE__))
+    autoload :Errors, lib_path.join("errors")
+    autoload :Errors, lib_path.join("helper")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/action/startup_rsync.rb

@@ -0,0 +1,48 @@
+require "vagrant"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    class StartupRsync
+      include Vagrant::Action::Builtin::MixinSyncedFolders
+
+      def initialize(app, env)
+        @app = app
+        @rsync_only_changed_startup_registered = false
+        @rsync_folder_count = 0
+      end
+
+      def call(env)
+        folders = synced_folders(env[:machine])
+        @rsync_folder_count += folders[:rsync].size if folders.key?(:rsync)
+
+        @app.call(env)
+
+        # Ensure only one at_exit block is registered.
+        return unless @rsync_only_changed_startup_registered == false
+
+        return unless env[:machine].config.gatling.rsync_on_startup == true
+
+        at_exit do
+          unless $!.is_a?(SystemExit)
+            env[:ui].warn "Vagrant's startup was interrupted by an exception."
+            exit 1
+          end
+
+          exit_status = $!.status
+          if exit_status != 0
+            env[:ui].warn "The previous process exited with exit code #{exit_status}."
+            exit exit_status
+          end
+
+          # Don't run if there are no rsynced folders.
+          unless @rsync_folder_count == 0 then
+            env[:ui].info I18n.t("vagrant_rsync-only-changed.startup_sync")
+            env[:machine].env.cli("rsync-auto-only-changed")
+          end
+        end
+
+        @rsync_only_changed_startup_registered = true
+      end
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/command/rsync_auto.rb

@@ -0,0 +1,208 @@
+require "log4r"
+require "optparse"
+
+require "vagrant"
+
+require "log4r"
+require 'optparse'
+require "thread"
+
+require "vagrant/action/builtin/mixin_synced_folders"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+
+require_relative "../helper"
+
+# This is to avoid a bug in nio 1.0.0. Remove around nio 1.0.1
+if Vagrant::Util::Platform.windows?
+  ENV["NIO4R_PURE"] = "1"
+end
+
+require "listen"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    module Command
+      class RsyncOnlyChangedAuto < Vagrant.plugin("2", :command)
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def self.synopsis
+          "syncs rsync synced folders automatically when files change"
+        end
+
+        def execute
+          @logger = Log4r::Logger.new("vagrant::commands::rsync-auto-only-changed")
+
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant rsync-auto-only-changed [vm-name]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--[no-]poll", "Force polling filesystem (slow)") do |poll|
+              options[:poll] = poll
+            end
+          end
+
+          # Parse the options and return if we don't have any target.
+          argv = parse_options(opts)
+          return if !argv
+
+          # Build up the paths that we need to listen to.
+          paths = {}
+          ignores = []
+          with_target_vms(argv) do |machine|
+            if machine.provider.capability?(:proxy_machine)
+              proxy = machine.provider.capability(:proxy_machine)
+              if proxy
+                machine.ui.warn(I18n.t(
+                  "vagrant.rsync_proxy_machine",
+                  name: machine.name.to_s,
+                  provider: machine.provider_name.to_s))
+
+                machine = proxy
+              end
+            end
+
+            cached = synced_folders(machine, cached: true)
+            fresh  = synced_folders(machine)
+            diff   = synced_folders_diff(cached, fresh)
+            if !diff[:added].empty?
+              machine.ui.warn(I18n.t("vagrant.rsync_auto_new_folders"))
+            end
+
+            folders = cached[:rsync]
+            next if !folders || folders.empty?
+
+            # Get the SSH info for this machine so we can do an initial
+            # sync to the VM.
+            ssh_info = machine.ssh_info
+            if ssh_info
+              machine.ui.info(I18n.t("vagrant.rsync_auto_initial"))
+              folders.each do |id, folder_opts|
+                RsyncHelper.rsync_single(machine, ssh_info, folder_opts)
+              end
+            end
+
+            folders.each do |id, folder_opts|
+              # If we marked this folder to not auto sync, then
+              # don't do it.
+              next if folder_opts.key?(:auto) && !folder_opts[:auto]
+
+              hostpath = folder_opts[:hostpath]
+              hostpath = File.expand_path(hostpath, machine.env.root_path)
+              paths[hostpath] ||= []
+              paths[hostpath] << {
+                id: id,
+                machine: machine,
+                opts:    folder_opts,
+              }
+
+              if folder_opts[:exclude]
+                Array(folder_opts[:exclude]).each do |pattern|
+                  ignores << RsyncHelper.exclude_to_regexp(hostpath, pattern.to_s)
+                end
+              end
+            end
+          end
+
+          # Exit immediately if there is nothing to watch
+          if paths.empty?
+            @env.ui.info(I18n.t("vagrant.rsync_auto_no_paths"))
+            return 1
+          end
+
+          # Output to the user what paths we'll be watching
+          paths.keys.sort.each do |path|
+            paths[path].each do |path_opts|
+              path_opts[:machine].ui.info(I18n.t(
+                "vagrant.rsync_auto_path",
+                path: path.to_s,
+              ))
+            end
+          end
+
+          @logger.info("Listening to paths: #{paths.keys.sort.inspect}")
+          @logger.info("Ignoring #{ignores.length} paths:")
+          ignores.each do |ignore|
+            @logger.info("  -- #{ignore.to_s}")
+          end
+          @logger.info("Listening via: #{Listen::Adapter.select.inspect}")
+          callback = method(:callback).to_proc.curry[paths]
+          listopts = { ignore: ignores, force_polling: !!options[:poll] }
+          listener = Listen.to(*paths.keys, listopts, &callback)
+
+          # Create the callback that lets us know when we've been interrupted
+          queue    = Queue.new
+          callback = lambda do
+            # This needs to execute in another thread because Thread
+            # synchronization can't happen in a trap context.
+            Thread.new { queue << true }
+          end
+
+          # Run the listener in a busy block so that we can cleanly
+          # exit once we receive an interrupt.
+          Vagrant::Util::Busy.busy(callback) do
+            listener.start
+            queue.pop
+            listener.stop if listener.state != :stopped
+          end
+
+          0
+        end
+
+        # This is the callback that is called when any changes happen
+        def callback(paths, modified, added, removed)
+          @logger.info("File change callback called!")
+          @logger.info("  - Modified: #{modified.inspect}")
+          @logger.info("  - Added: #{added.inspect}")
+          @logger.info("  - Removed: #{removed.inspect}")
+
+		      toSyncPaths = Hash.new
+		  
+          paths.each do |hostpath, folders|
+            changed_paths = []
+            [modified, added, removed].each do |changed|
+              changed.each do |listenpath|
+                if listenpath.start_with?(hostpath)
+                  changed_paths << listenpath
+                end
+              end
+            end
+
+            if changed_paths.any?
+              toSyncPaths[folders] = changed_paths
+            end
+          end
+		  
+          # Sync all the folders that need to be synced
+          toSyncPaths.each do |folders, changed_paths|
+            folders.each do |opts|
+              # Reload so we get the latest ID
+              opts[:machine].reload
+              if !opts[:machine].id || opts[:machine].id == ""
+                # Skip since we can't get SSH info without an ID
+                next
+              end
+
+              ssh_info = opts[:machine].ssh_info
+              begin
+                VagrantPlugins::RsyncOnlyChanged::RsyncHelper.rsync_single(opts[:machine], ssh_info, opts[:opts], changed_paths)
+              rescue Vagrant::Errors::MachineGuestNotReady
+                # Error communicating to the machine, probably a reload or
+                # halt is happening. Just notify the user but don't fail out.
+                opts[:machine].ui.error(I18n.t(
+                  "vagrant.rsync_communicator_not_ready_callback"))
+              rescue Vagrant::Errors::RSyncError => e
+                # Error executing rsync, so show an error
+                opts[:machine].ui.error(I18n.t(
+                  "vagrant.rsync_auto_rsync_error", message: e.to_s))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/config.rb

@@ -0,0 +1,22 @@
+require "vagrant"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    class Config < Vagrant.plugin(2, :config)
+      attr_accessor :rsync_on_startup
+
+      def initialize
+        @rsync_on_startup = UNSET_VALUE
+      end
+
+      def finalize!
+        if @rsync_on_startup == UNSET_VALUE
+          @rsync_on_startup = true
+        else
+          @rsync_on_startup = !!@rsync_on_startup
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    module Errors
+      class VagrantRsyncOnlyChangedError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_gatling_rsync.errors")
+      end
+
+      class OSNotSupportedError < VagrantRsyncOnlyChangedError
+        error_key(:os_not_supported)
+      end
+
+      class Vagrant15RequiredError < VagrantRsyncOnlyChangedError
+        error_key(:vagrant_15_required)
+      end
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/helper.rb

@@ -0,0 +1,200 @@
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    # This is a helper that abstracts out the functionality of rsyncing
+    # folders so that it can be called from anywhere.
+    class RsyncHelper
+      # This converts an rsync exclude pattern to a regular expression
+      # we can send to Listen.
+      def self.exclude_to_regexp(path, exclude)
+        start_anchor = false
+
+        if exclude.start_with?("/")
+          start_anchor = true
+          exclude      = exclude[1..-1]
+        end
+
+        path   = "#{path}/" if !path.end_with?("/")
+        regexp = "^#{Regexp.escape(path)}"
+        regexp += ".*" if !start_anchor
+
+        # This is REALLY ghetto, but its a start. We can improve and
+        # keep unit tests passing in the future.
+        exclude = exclude.gsub("**", "|||GLOBAL|||")
+        exclude = exclude.gsub("*", "|||PATH|||")
+        exclude = exclude.gsub("|||PATH|||", "[^/]*")
+        exclude = exclude.gsub("|||GLOBAL|||", ".*")
+        regexp += exclude
+
+        Regexp.new(regexp)
+      end
+      
+      def self.adapt_path_for_rsync(root_path, path)
+        path = File.expand_path(path, root_path)
+        path = Vagrant::Util::Platform.fs_real_path(path).to_s
+        
+        if Vagrant::Util::Platform.windows?
+          # rsync for Windows expects cygwin style paths, always.
+          path = Vagrant::Util::Platform.cygwin_path(path)
+        end
+        
+        return path
+      end
+      
+      def self.adapt_filepath_for_rsync(root_path, filepath)
+        path = File.dirname(filepath)
+        filename = File.basename(filepath)
+        
+        return adapt_path_for_rsync(root_path, path) + "/" +  filename
+      end
+      
+      def self.rsync_single(machine, ssh_info, opts, changed_folders=[])
+        # Folder info
+        guestpath = opts[:guestpath]
+        hostpath  = opts[:hostpath]
+        original_path = opts[:hostpath]
+
+        root_path = machine.env.root_path
+        hostpath  = adapt_path_for_rsync(root_path, hostpath)
+
+        # Make sure the host path ends with a "/" to avoid creating
+        # a nested directory...
+        if !hostpath.end_with?("/")
+          hostpath += "/"
+        end
+
+        # Folder options
+        opts[:owner] ||= ssh_info[:username]
+        opts[:group] ||= ssh_info[:username]
+
+        # Connection information
+        username = ssh_info[:username]
+        host     = ssh_info[:host]
+        proxy_command = ""
+        if ssh_info[:proxy_command]
+          proxy_command = "-o ProxyCommand='#{ssh_info[:proxy_command]}' "
+        end
+
+        rsh = [
+          "ssh -p #{ssh_info[:port]} " +
+          proxy_command +
+          "-o StrictHostKeyChecking=no " +
+          "-o IdentitiesOnly=true " +
+          "-o UserKnownHostsFile=/dev/null",
+          ssh_info[:private_key_path].map { |p| "-i '#{p}'" },
+        ].flatten.join(" ")
+
+        # Exclude some files by default, and any that might be configured
+        # by the user.
+        excludes = ['.vagrant/']
+        excludes += Array(opts[:exclude]).map(&:to_s) if opts[:exclude]
+        excludes.uniq!
+
+        # Get the command-line arguments
+        args = nil
+        args = Array(opts[:args]).dup if opts[:args]
+        args ||= ["--verbose", "--archive", "--delete", "-z", "--copy-links"]
+
+        # On Windows, we have to set a default chmod flag to avoid permission issues
+        if Vagrant::Util::Platform.windows? && !args.any? { |arg| arg.start_with?("--chmod=") }
+          # Ensures that all non-masked bits get enabled
+          args << "--chmod=ugo=rwX"
+
+          # Remove the -p option if --archive is enabled (--archive equals -rlptgoD)
+          # otherwise new files will not have the destination-default permissions
+          args << "--no-perms" if args.include?("--archive") || args.include?("-a")
+        end
+
+        # Disable rsync's owner/group preservation (implied by --archive) unless
+        # specifically requested, since we adjust owner/group to match shared
+        # folder setting ourselves.
+        args << "--no-owner" unless args.include?("--owner") || args.include?("-o")
+        args << "--no-group" unless args.include?("--group") || args.include?("-g")
+
+        # Tell local rsync how to invoke remote rsync with sudo
+        rsync_path = opts[:rsync_path]
+        if !rsync_path && machine.guest.capability?(:rsync_command)
+          rsync_path = machine.guest.capability(:rsync_command)
+        end
+        if rsync_path
+          args << "--rsync-path"<< rsync_path
+        end
+        
+        # Make sure the original host path ends with a "/" to create
+        # only relative entries in the changed files list...
+        if !original_path.end_with?("/")
+          original_path += "/"
+        end
+        
+        # Create a file with the list of changed files/directories
+        if changed_folders.any?
+          changed_list_file = File.join(Dir.tmpdir, "rsync.#{rand(1000)}")
+          File.open(changed_list_file, "w+") do |f|
+            changed_folders.each do |folder| 
+              rsync_folder = folder.sub(original_path, '')
+              
+              #The changed file needs to be relative to the rsync root
+              f.puts(rsync_folder) 
+            end
+          end
+          
+          args << "--files-from=" + adapt_filepath_for_rsync(root_path, changed_list_file)
+        end
+
+        # Build up the actual command to execute
+        command = [
+          "rsync",
+          args,
+          "-e", rsh,
+          excludes.map { |e| ["--exclude", e] },
+          hostpath,
+          "#{username}@#{host}:#{guestpath}",
+        ].flatten
+
+        # The working directory should be the root path
+        command_opts = {}
+        command_opts[:workdir] = machine.env.root_path.to_s
+
+        machine.ui.info(I18n.t(
+          "vagrant.rsync_folder", guestpath: guestpath, hostpath: hostpath))
+        if excludes.length > 1
+          machine.ui.info(I18n.t(
+            "vagrant.rsync_folder_excludes", excludes: excludes.inspect))
+        end
+        if opts.include?(:verbose)
+          machine.ui.info(I18n.t("vagrant.rsync_showing_output"));
+        end
+
+        # If we have tasks to do before rsyncing, do those.
+        if machine.guest.capability?(:rsync_pre)
+          machine.guest.capability(:rsync_pre, opts)
+        end
+
+        if opts.include?(:verbose)
+          command_opts[:notify] = [:stdout, :stderr]
+          r = Vagrant::Util::Subprocess.execute(*(command + [command_opts])) {
+            |io_name,data| data.each_line { |line|
+              machine.ui.info("rsync[#{io_name}] -> #{line}") }
+          }
+        else
+          r = Vagrant::Util::Subprocess.execute(*(command + [command_opts]))
+        end
+
+        if r.exit_code != 0
+          raise Vagrant::Errors::RSyncError,
+            command: command.join(" "),
+            guestpath: guestpath,
+            hostpath: hostpath,
+            stderr: r.stderr
+        end
+
+        # If we have tasks to do after rsyncing, do those.
+        if machine.guest.capability?(:rsync_post)
+          machine.guest.capability(:rsync_post, opts)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/plugin.rb

@@ -0,0 +1,40 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant gatling rsync plugin must be run within Vagrant."
+end
+
+module VagrantPlugins
+  module RsyncOnlyChanged
+    class Plugin < Vagrant.plugin(2)
+      name "Rsync only the changed files and/or directories"
+      description <<-DESC
+      Rsync large project directories to your Vagrant VM without incurring the delay from the rsync filetree comparison.
+      DESC
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", RsyncOnlyChanged.source_root)
+        I18n.reload!
+      end
+
+      action_hook "startup-rsync" do |hook|
+        setup_i18n
+        require_relative "action/startup_rsync"
+        hook.after Vagrant::Action::Builtin::SyncedFolders, StartupRsync
+      end
+
+      command "rsync-auto-only-changed" do
+        setup_i18n
+
+        require_relative "command/rsync_auto"
+        RsyncOnlyChangedAuto
+      end
+
+      config "gatling" do
+        require_relative "config"
+        Config
+      end
+    end
+  end
+end

data/lib/vagrant-rsync-only-changed/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module RsyncOnlyChanged
+    VERSION = "0.5.0"
+  end
+end

data/vagrant-rsync-only-changed.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-rsync-only-changed/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-rsync-only-changed"
+  spec.version       = VagrantPlugins::RsyncOnlyChanged::VERSION
+  spec.authors       = ["Fl\xC3\xA1vio Botelho"]
+  spec.email         = ["fezsentido@gmail.com"]
+
+  spec.summary       = %q{Vagrant plugin to speed rsync-auto for big file trees}
+  spec.description   = %q{Currently Vagrant rsync-auto command will always issue a full rsync when an event is detected during rsync-auto. With this plugin rsync will be called with the parameter --files-from with only the added/changed/removed files and/or directories listed. This will speed up a lot the command for big file trees.}
+  spec.homepage      = "https://github.com/nuncanada/vagrant-rsync-only-changed"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-rsync-only-changed
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Flávio Botelho
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Currently Vagrant rsync-auto command will always issue a full rsync when
+  an event is detected during rsync-auto. With this plugin rsync will be called with
+  the parameter --files-from with only the added/changed/removed files and/or directories
+  listed. This will speed up a lot the command for big file trees.
+email:
+- fezsentido@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".project"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/vagrant-rsync-only-changed.rb
+- lib/vagrant-rsync-only-changed/action/startup_rsync.rb
+- lib/vagrant-rsync-only-changed/command/rsync_auto.rb
+- lib/vagrant-rsync-only-changed/config.rb
+- lib/vagrant-rsync-only-changed/errors.rb
+- lib/vagrant-rsync-only-changed/helper.rb
+- lib/vagrant-rsync-only-changed/plugin.rb
+- lib/vagrant-rsync-only-changed/version.rb
+- vagrant-rsync-only-changed.gemspec
+homepage: https://github.com/nuncanada/vagrant-rsync-only-changed
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Vagrant plugin to speed rsync-auto for big file trees
+test_files: []