vagrant-reflect 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10bf068f0fcd1751185c72edc2b8a9d0f9d3fc62
-  data.tar.gz: 62751eb5164e9a8f7bfd1f9d8793d245a300de67
+  metadata.gz: a125c9d631f0aa19172f28895bacb5a8e243c372
+  data.tar.gz: 124396c75e4bb6d37cf44ab64426dd9a496517b0
 SHA512:
-  metadata.gz: f5639afa42e9dc1767a9a29978dbcbed82904fa70b079d12d3c72ee4bec3c93751ea1422ad8838911383426a14d7e56bfb0a1b241af353340f9603fd29366c91
-  data.tar.gz: 2fe41628e246d06af901be938cded207f5a635a627cf1844f2d3ffdbeeda2f47f8319f9898c9d0170734eed42e700217254e98b049d3ee78bcfbe3965e1e7ae5
+  metadata.gz: 4a90cb48ce6ef31359cb746cca2930ffeaa3a8a2844c8cc4b662a57efe1bab7900cb0871cd59654996530e231b9c42f13305226351bcdd0586936b2ffe09dab6
+  data.tar.gz: ca55fd199a30b59757018e2f502ba70b77568558cd76e44439905d596f8ace5619fee25d3e9d7c0522fc33ab5e0ec2bee6aa86a04f68dd4546e4298421a1bf78

data/lib/vagrant-reflect/command/reflect.rb

@@ -120,16 +120,11 @@ module VagrantReflect
 
           ignores = []
           opts.each do |path_opts|
+            ignores += path_opts[:syncer].excludes_to_regexp
             path_opts[:machine].ui.info(
               I18n.t(
                 'vagrant.plugins.vagrant-reflect.rsync_auto_path',
                 path: path.to_s))
-
-            next unless path_opts[:opts][:exclude]
-
-            Array(path_opts[:opts][:exclude]).each do |pattern|
-              ignores << Syncer.exclude_to_regexp(pattern.to_s)
-            end
           end
 
           @logger.info("Listening to path: #{path}")
@@ -170,43 +165,13 @@ module VagrantReflect
         @logger.info("  - Added: #{added.inspect}")
         @logger.info("  - Removed: #{removed.inspect}")
 
+        callback = options[:incremental] ? :sync_incremental : :sync_full
+
         # Perform the sync for each machine
         opts.each do |path_opts|
           begin
-            # If we have any removals or have disabled incremental, perform a
-            # single full sync
-            # It's seemingly impossible to ask rsync to only do a deletion
-            if !options[:incremental] || !removed.empty?
-              removed.each do |remove|
-                path_opts[:machine].ui.info(
-                  I18n.t(
-                    'vagrant.plugins.vagrant-reflect.rsync_auto_full_remove',
-                    path: strip_path(path, remove)))
-              end
-
-              [modified, added].each do |changes|
-                changes.each do |change|
-                  path_opts[:machine].ui.info(
-                    I18n.t(
-                      'vagrant.plugins.vagrant-reflect.rsync_auto_full_change',
-                      path: strip_path(path, change)))
-                end
-              end
-
-              path_opts[:machine].ui.info(
-                I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_full'))
-
-              path_opts[:syncer].sync_full
-            elsif !modified.empty? || !added.empty?
-              # Pass the list of changes to rsync so we quickly synchronise only
-              # the changed files instead of the whole folder
-              items = strip_paths(path, modified + added)
-              path_opts[:syncer].sync_incremental(items) do |item|
-                path_opts[:machine].ui.info(
-                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment',
-                         path: item))
-              end
-            end
+            # If disabled incremental, do a full
+            send callback, path, path_opts, modified, added, removed
 
             path_opts[:machine].ui.info(
               I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_synced'))
@@ -222,6 +187,50 @@ module VagrantReflect
         end
       end
 
+      def sync_full(path, path_opts, modified, added, removed)
+        [modified, added].flatten.each do |change|
+          path_opts[:machine].ui.info(
+            I18n.t(
+              'vagrant.plugins.vagrant-reflect.rsync_auto_full_change',
+              path: strip_path(path, change)))
+        end
+
+        removed.each do |remove|
+          path_opts[:machine].ui.info(
+            I18n.t(
+              'vagrant.plugins.vagrant-reflect.rsync_auto_full_remove',
+              path: strip_path(path, remove)))
+        end
+
+        path_opts[:machine].ui.info(
+          I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_full'))
+
+        path_opts[:syncer].sync_full
+      end
+
+      def sync_incremental(path, path_opts, modified, added, removed)
+        if !modified.empty? || !added.empty?
+          # Pass the list of changes to rsync so we quickly synchronise only
+          # the changed files instead of the whole folder
+          items = strip_paths(path, modified + added)
+          path_opts[:syncer].sync_incremental(items) do |item|
+            path_opts[:machine].ui.info(
+              I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment_change',
+                     path: item))
+          end
+        end
+
+        return if removed.empty?
+
+        # Pass list of changes to a remove command
+        items = strip_paths(path, removed)
+        path_opts[:syncer].sync_removals(items) do |item|
+          path_opts[:machine].ui.info(
+            I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment_remove',
+                   path: item))
+        end
+      end
+
       def strip_paths(path, items)
         items.map do |item|
           item[path.length..-1]

data/lib/vagrant-reflect/util/syncer.rb

@@ -6,51 +6,79 @@ module VagrantReflect
   # This is a helper that abstracts out the functionality of rsyncing
   # folders so that it can be called from anywhere.
   class Syncer
-    # This converts an rsync exclude pattern to a regular expression
-    # we can send to Listen.
-    def self.exclude_to_regexp(exclude)
-      start_anchor = false
-      dir_only = false
+    RSYNC_TO_REGEXP_PATTERNS = [
+      ['.', '\\.'],
+      ['***', '|||EMPTY|||'],
+      ['**', '|||GLOBAL|||'],
+      ['*', '|||PATH|||'],
+      ['?', '[^/]'],
+      ['|||PATH|||', '[^/]+'],
+      ['|||GLOBAL|||', '.+'],
+      ['|||EMPTY|||', '.*']
+    ].freeze
 
-      if exclude.start_with?('/')
-        start_anchor = true
-        exclude      = exclude[1..-1]
-      end
+    def initialize(machine, opts)
+      @opts = opts
+      @machine = machine
+      @workdir = @machine.env.root_path.to_s
 
-      if exclude.end_with?('/')
-        dir_only = true
-        exclude      = exclude[0..-2]
-      end
+      init_paths
+      init_connection_info
+      init_excludes
+      init_commands
+    end
 
-      regexp = start_anchor ? '^' : '(?:^|/)'
+    def log_configuration
+      @machine.ui.info(
+        I18n.t(
+          'vagrant.plugins.vagrant-reflect.rsync_folder_configuration',
+          guestpath: @guestpath,
+          hostpath: @hostpath))
 
-      # This is REALLY ghetto, but its a start. We can improve and
-      # keep unit tests passing in the future.
-      # TODO: Escaped wildcards get substituted incorrectly - replace with FSM?
-      exclude = exclude.gsub('.', '\\.')
-      exclude = exclude.gsub('***', '|||EMPTY|||')
-      exclude = exclude.gsub('**', '|||GLOBAL|||')
-      exclude = exclude.gsub('*', '|||PATH|||')
-      exclude = exclude.gsub('?', '[^/]')
-      exclude = exclude.gsub('|||PATH|||', '[^/]+')
-      exclude = exclude.gsub('|||GLOBAL|||', '.+')
-      exclude = exclude.gsub('|||EMPTY|||', '.*')
-      regexp += exclude
-
-      regexp += dir_only ? '/' : '(?:/|$)'
+      return if @excludes.empty?
 
-      Regexp.new(regexp)
+      @machine.ui.info(
+        I18n.t(
+          'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
+          excludes: @excludes.inspect))
     end
 
-    def initialize(machine, opts)
-      @opts = opts
-      @machine = machine
-      @workdir = @machine.env.root_path.to_s
+    # This converts the rsync exclude patterns to regular expressions we can
+    # send to Listen.
+    def excludes_to_regexp
+      return @regexp if @regexp
+
+      @regexp = @excludes.map(&method(:exclude_to_regex_single))
+    end
+
+    def sync_incremental(items, &block)
+      send_items_to_command items, @rsync_command_inc, &block
+    end
+
+    def sync_full
+      r = Vagrant::Util::SubprocessPatched.execute(*@rsync_command_full)
+      check_exit @rsync_command_full, r
+    end
+
+    def sync_removals(items, &block)
+      # Look for removed directories and fill in guest paths
+      dirs = prepare_items_for_removal(items)
+
+      send_items_to_command items, @rm_command, &block
+      sync_removals_parents dirs.values, &block unless dirs.empty?
+    end
 
+    def sync_removals_parents(guest_items, &block)
+      send_items_to_command guest_items, @rmdir_command, &block
+    end
+
+    protected
+
+    def init_paths
       # Folder info
       @guestpath = @opts[:guestpath]
       @hostpath  = @opts[:hostpath]
-      @hostpath  = File.expand_path(@hostpath, machine.env.root_path)
+      @hostpath  = File.expand_path(@hostpath, @machine.env.root_path)
       @hostpath  = Vagrant::Util::Platform.fs_real_path(@hostpath).to_s
 
       if Vagrant::Util::Platform.windows?
@@ -61,86 +89,113 @@ module VagrantReflect
       # Make sure the host path ends with a "/" to avoid creating
       # a nested directory...
       @hostpath += '/' unless @hostpath.end_with?('/')
+    end
 
+    def init_connection_info
       # Connection information
       username = @machine.ssh_info[:username]
       host     = @machine.ssh_info[:host]
-      proxy_command = ''
+      @remote = "#{username}@#{host}"
+      @target = "#{@remote}:#{@guestpath}"
+    end
+
+    def init_excludes
+      # Exclude some files by default, and any that might be configured
+      # by the user.
+      @excludes = []
+      @excludes += Array(@opts[:exclude]).map(&:to_s) if @opts[:exclude]
+      @excludes.uniq!
+    end
+
+    def init_commands
+      init_rsh_command
+      init_rsync_command
+      init_rsync_command_full
+      init_rsync_command_inc
+      init_rm_command
+      init_rmdir_command
+    end
+
+    def init_rsh_command
+      proxy_command = []
       if @machine.ssh_info[:proxy_command]
-        proxy_command = "-o ProxyCommand='#{@machine.ssh_info[:proxy_command]}' "
+        proxy_command += [
+          '-o',
+          "ProxyCommand='#{@machine.ssh_info[:proxy_command]}'"
+        ]
       end
 
-      rsh = [
-        "ssh -p #{@machine.ssh_info[:port]} " +
-          proxy_command +
-          '-o StrictHostKeyChecking=no '\
-          '-o IdentitiesOnly=true '\
-          '-o UserKnownHostsFile=/dev/null',
-        @machine.ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
-      ].flatten.join(' ')
-
-      @target = "#{username}@#{host}:#{@guestpath}"
+      @rsh = build_rsh_command(proxy_command).flatten
+    end
 
-      # Exclude some files by default, and any that might be configured
-      # by the user.
-      excludes = []
-      excludes += Array(@opts[:exclude]).map(&:to_s) if @opts[:exclude]
-      excludes.uniq!
+    def build_rsh_command(proxy_command)
+      [
+        'ssh',
+        '-p', @machine.ssh_info[:port].to_s,
+        proxy_command,
+        '-o', 'StrictHostKeyChecking=no',
+        '-o', 'IdentitiesOnly=true',
+        '-o', 'UserKnownHostsFile=/dev/null',
+        @machine.ssh_info[:private_key_path].map { |p| ['-i', p] }
+      ]
+    end
 
+    def init_rsync_command
       # Get the command-line arguments
-      @command = ['rsync']
-      @command += Array(@opts[:args]).dup if @opts[:args]
-      @command ||= ['--verbose', '--archive', '--delete', '-z', '--copy-links']
+      @rsync_command = ['rsync']
+      @rsync_command += Array(@opts[:args]).dup if @opts[:args]
+      @rsync_command ||= [
+        '--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?
-        unless @command.any? { |arg| arg.start_with?('--chmod=') }
-          # Ensures that all non-masked bits get enabled
-          @command << '--chmod=ugo=rwX'
-
-          # Remove the -p option if --archive is enabled (--archive equals
-          # -rlptgoD) otherwise new files will not have the destination-default
-          # permissions
-          @command << '--no-perms' if
-            @command.include?('--archive') || @command.include?('-a')
-        end
-      end
+      build_windows_chmod_args if Vagrant::Util::Platform.windows?
+
+      build_owner_args
+
+      @rsync_command << '-e'
+      @rsync_command << @rsh.join(' ')
+
+      @excludes.map { |e| @rsync_command += ['--exclude', e] }
+    end
+
+    def build_windows_chmod_args
+      return if @rsync_command.any? { |arg| arg.start_with?('--chmod=') }
 
+      # Ensures that all non-masked bits get enabled
+      @rsync_command << '--chmod=ugo=rwX'
+
+      # Remove the -p option if --archive is enabled (--archive equals
+      # -rlptgoD) otherwise new files will not have the destination-default
+      # permissions
+      return unless @rsync_command.include?('--archive') ||
+                    @rsync_command.include?('-a')
+
+      @rsync_command << '--no-perms'
+    end
+
+    def build_owner_args
       # Disable rsync's owner/group preservation (implied by --archive) unless
       # specifically requested, since we adjust owner/group to match shared
       # folder setting ourselves.
-      @command << '--no-owner' unless
-        @command.include?('--owner') || @command.include?('-o')
-      @command << '--no-group' unless
-        @command.include?('--group') || @command.include?('-g')
-
-      # Tell local rsync how to invoke remote rsync with sudo
-      if @machine.guest.capability?(:rsync_command)
-        @command << '--rsync-path' << @machine.guest.capability(:rsync_command)
-      end
+      @rsync_command << '--no-owner' unless
+        @rsync_command.include?('--owner') || @rsync_command.include?('-o')
+      @rsync_command << '--no-group' unless
+        @rsync_command.include?('--group') || @rsync_command.include?('-g')
+    end
 
-      @command += [
-        '-e', rsh
+    def init_rsync_command_full
+      @rsync_command_full = @rsync_command.dup + [
+        @hostpath,
+        @target,
+        {
+          workdir: @workdir
+        }
       ]
-
-      excludes.map { |e| @command += ['--exclude', e] }
-
-      machine.ui.info(
-        I18n.t(
-          'vagrant.plugins.vagrant-reflect.rsync_folder_configuration',
-          guestpath: @guestpath,
-          hostpath: @hostpath))
-      if excludes.length > 1
-        machine.ui.info(
-          I18n.t(
-            'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
-            excludes: excludes.inspect))
-      end
     end
 
-    def sync_incremental(items, &block)
-      command = @command.dup + [
+    def init_rsync_command_inc
+      @rsync_command_inc = @rsync_command.dup + [
         '--files-from=-',
         @hostpath,
         @target,
@@ -149,56 +204,86 @@ module VagrantReflect
           notify: :stdin
         }
       ]
-
-      current = false
-      r = Vagrant::Util::SubprocessPatched.execute(*command) do |what, io|
-        next if what != :stdin
-
-        current = process_items(io, items, current, &block)
-      end
-
-      check_exit command, r
     end
 
-    def sync_full
-      command = @command.dup + [
-        @hostpath,
-        @target,
+    def init_rm_command
+      @rm_command = @rsh.dup + [
+        @remote,
+        'xargs rm -f',
         {
-          workdir: @workdir
+          workdir: @workdir,
+          notify: :stdin
         }
       ]
+    end
 
-      r = Vagrant::Util::SubprocessPatched.execute(*command)
-
-      check_exit command, r
+    def init_rmdir_command
+      @rmdir_command = @rsh.dup + [
+        @remote,
+        'xargs rmdir',
+        {
+          workdir: @workdir,
+          notify: :stdin
+        }
+      ]
     end
 
-    protected
+    def prepare_items_for_removal(items)
+      dirs = {}
+      items.map! do |rel_path|
+        check_for_empty_parents(rel_path, dirs)
+        @guestpath + rel_path
+      end
+      dirs
+    end
 
-    def process_items(io, items, current, &block)
-      until items.empty?
-        # If we don't have a line, grab one and print it
-        if current === false
-          current = items.shift + "\n"
-          block.call(current) if block_given?
+    def check_for_empty_parents(rel_path, dirs)
+      parent = rel_path
+      loop do
+        parent = File.dirname(parent)
+        break if parent == '/'
+        unless File.exist?(@hostpath + parent) || dirs.key?(parent)
+          dirs[parent] = @guestpath + parent
         end
+      end
+    end
 
-        # Handle partial writes
-        n = io.write_nonblock(current)
-        if n < current.length
-          current = current[n..current.length]
-          break
-        end
+    def send_items_to_command(items, command, &block)
+      current = next_item(items, &block)
+      r = Vagrant::Util::SubprocessPatched.execute(*command) do |what, io|
+        next if what != :stdin
 
-        # Request a new line for next write
-        current = false
+        current = process_items(io, items, current, &block)
+      end
+      check_exit command, r
+    end
+
+    def process_items(io, items, current, &block)
+      until current.nil?
+        send_data(io, current)
+        current = next_item(items, &block)
       end
 
       # Finished! Close stdin
       io.close_write
     rescue IO::WaitWritable, Errno::EINTR
-      # Ignore
+      # Wait for writable again
+      return current
+    end
+
+    def next_item(items)
+      return nil if items.empty?
+      current = items.shift + "\n"
+      yield current if block_given?
+      current
+    end
+
+    def send_data(io, current)
+      # Handle partial writes
+      n = io.write_nonblock(current)
+      return unless n < current.length
+      current.slice! 0, n
+      throw IO::WaitWritable
     end
 
     def check_exit(command, r)
@@ -210,5 +295,30 @@ module VagrantReflect
             hostpath: @hostpath,
             stderr: r.stderr
     end
+
+    def exclude_to_regex_single(exclude)
+      start_anchor = false
+
+      if exclude.start_with?('/')
+        start_anchor = true
+        exclude = exclude[1..-1]
+      end
+
+      regexp = start_anchor ? '^' : '(?:^|/)'
+      regexp += perform_substitutions(exclude)
+      regexp += exclude.end_with?('/') ? '' : '(?:/|$)'
+
+      Regexp.new(regexp)
+    end
+
+    def perform_substitutions(exclude)
+      # This is REALLY ghetto, but its a start. We can improve and
+      # keep unit tests passing in the future.
+      # TODO: Escaped wildcards get substituted incorrectly - replace with FSM?
+      RSYNC_TO_REGEXP_PATTERNS.each do |pattern|
+        exclude = exclude.gsub(pattern[0], pattern[1])
+      end
+      exclude
+    end
   end
 end

data/lib/vagrant-reflect/version.rb

@@ -1,3 +1,3 @@
 module VagrantReflect
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/templates/locales/en.yml

@@ -14,8 +14,10 @@ en:
           have specified `rsync_auto` to be false.
         rsync_auto_path: |-
           Watching: %{path}
-        rsync_auto_increment: |-
+        rsync_auto_increment_change: |-
           Sending change: %{path}
+        rsync_auto_increment_remove: |-
+          Sending removal: %{path}
         rsync_auto_full_change: |-
           Processing change: %{path}
         rsync_auto_full_remove: |-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-reflect
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jason Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-23 00:00:00.000000000 Z
+date: 2016-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: driskell-listen