winrm-fs 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 959e097cf30b655d2e95f26e6ec808e9f99b5606
-  data.tar.gz: cff6d9bc348a2ac845ed9c4ae16890ea55ce509e
+  metadata.gz: 73ccc66738cd3d2154cdebcaf723ce05f8856cc9
+  data.tar.gz: b1495a0c00c6dd45dd1d590a6af8cef13217fe0a
 SHA512:
-  metadata.gz: 35047acdb0750d38697dd484dfcdbaa48972471b653a07f222cf7490746e913acb2da62dc47055c55cd7997158ca311d732e5b4cfcd933a5a9257706735087f7
-  data.tar.gz: dd3abe06a552686fb4cea084a056898f6012b2acceb9202226f5568f59d6cab1da0d839e25d7ae9328d5f2c7ae93aecf87d78be08428059b8dabc50cee616483
+  metadata.gz: 5bb6b796cc8b459f5f8c42b72df1e05c65978289d237d0aaa4d4b871473caac73324d91da73ac3fa13a0568b740e048195b72e29298e6241b96c26c621e73e59
+  data.tar.gz: 186861cd7b45f773f350b781e2f2563f820e7db3ae01696fa011e8856ec2b1caabe1e5d36729c0bf93d0ed5dff6eda1480e63b876aacb4b913481fd3422e54f3

data/README.md

@@ -10,11 +10,15 @@ require 'winrm-fs'
 
 service = WinRM::WinRMWebService.new(...
 file_manager = WinRM::FS::FileManager.new(service)
-file_manager.upload('c:/dev/my_dir', '$env:AppData')
-```
-Or an array of several files and/or directories can be included:
-```ruby
-file_manager.upload(['c:/dev/file1.txt','c:/dev/dir1'], '$env:AppData')
+
+# upload file.txt from the current working directory
+file_manager.upload('file.txt', 'c:/file.txt')
+
+# upload the entire contents of my_dir to c:/foo/my_dir
+file_manager.upload('/Users/sneal/my_dir', 'c:/foo/my_dir')
+
+# upload the entire directory contents of foo to c:\program files\bar
+file_manager.upload('/Users/sneal/foo', '$env:ProgramFiles/bar')
 ```
 
 ### Handling progress events

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/benchmark.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require 'winrm-fs'
+require 'benchmark'
+
+def files
+  # This is a fairly short list of small files, may also want a benchmark with larger files
+  `git ls-files`.lines.map(&:strip)
+end
+
+def create_zip(factory, file)
+  WinRM::FS::Core::TempZipFile.new(Dir.pwd, zip_file: file, via: factory, X: true) do | temp_zip |
+    temp_zip.add(*files)
+  end
+end
+
+Benchmark.bm do | benchmark |
+  benchmark.report('zip cmd') { `git ls-files | zip zip_command.zip -X --names-stdin` }
+  benchmark.report('shell') { create_zip(:shell, 'shell.zip') }
+  benchmark.report('ruby') { create_zip(:rubyzip, 'ruby.zip') }
+end

data/bin/rwinrmcp

@@ -36,7 +36,7 @@ def parse_options
   fail "Cannot find source file: #{options[:source_path]}" unless \
     File.exist?(options[:source_path])
 
-  m = /^(?<user>\w+)@{1}(?<host>[a-zA-Z0-9\.]+)(?<port>:[0-9]+)?:{1}(?<file>.+)/.match(ARGV[1])
+  m = /^(?<user>[a-z0-9\.\!\$ _-]+)@{1}(?<host>[a-z0-9\.\-]+)(?<port>:[0-9]+)?:{1}(?<file>.+)/i.match(ARGV[1])
   fail "#{ARGV[1]} is an invalid destination" unless m
   options[:user] = m[:user]
   options[:endpoint] = "http://#{m[:host]}#{m[:port] || ':5985'}/wsman"

data/changelog.md

@@ -1 +1,10 @@
-0.1.0 - Initial alpha quality release
+# WinRM-fs Gem Changelog
+
+# 0.2.0
+- Redesigned temp zip file creation system
+- Fixed lots of small edge case issues especially with directory uploads
+- Simplified file manager upload method API to take only a single source file or directory
+- Expanded acceptable username and hostnames for rwinrmcp
+
+# 0.1.0
+- Initial alpha quality release

data/lib/winrm-fs.rb

@@ -16,6 +16,7 @@
 
 require 'winrm'
 require 'logger'
+require 'pathname'
 require_relative 'winrm-fs/exceptions'
 require_relative 'winrm-fs/file_manager'
 

data/lib/winrm-fs/core/temp_zip_file.rb

@@ -14,72 +14,163 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'English'
 require 'zip'
+require 'fileutils'
+require 'pathname'
 
 module WinRM
   module FS
     module Core
       # Temporary zip file on the local system
       class TempZipFile
-        attr_reader :path
+        attr_reader :zip_file, :path, :paths, :basedir, :options
 
-        def initialize
-          @logger = Logging.logger[self]
-          @zip_file = Tempfile.new(['winrm_upload', '.zip'])
-          @zip_file.close
-          @path = @zip_file.path
+        # Creates a new local temporary zip file
+        # @param [String] Base directory to use when expanding out files passed to add
+        # @param [Hash] Options: zip_file, via, recurse_paths
+        def initialize(basedir = Dir.pwd, options = {})
+          @basedir = Pathname.new(basedir)
+          @options = options
+          @zip_file = options[:zip_file] || Tempfile.new(['winrm_upload', '.zip'])
+          @path = Pathname.new(@zip_file)
         end
 
         # Adds a file or directory to the temporary zip file
-        # @param [String] Directory or file path to add into zip
-        def add(path)
-          if File.directory?(path)
-            add_directory(path)
-          elsif File.file?(path)
-            add_file(path)
-          else
-            fail "#{path} doesn't exist"
+        # @param [String] Directory or file path relative to basedir to add into zip
+        def add(*new_paths)
+          new_paths.each do | path |
+            absolute_path = File.expand_path(path, basedir)
+            fail "#{path} must exist relative to #{basedir}" unless File.exist? absolute_path
+            paths << Pathname.new(absolute_path).relative_path_from(basedir)
           end
         end
 
-        # Adds all files in the specified directory recursively into the zip file
-        # @param [String] Directory to add into zip
-        def add_directory(dir)
-          fail "#{dir} isn't a directory" unless File.directory?(dir)
-          glob = File.join(dir, '**/*')
-          Dir.glob(glob).each do |file|
-            add_file_entry(file, dir)
-          end
-        end
-
-        def add_file(file)
-          fail "#{file} isn't a file" unless File.file?(file)
-          add_file_entry(file, File.dirname(file))
+        def paths
+          @paths ||= []
         end
 
         def delete
           @zip_file.delete
         end
 
+        def build
+          factory.new(self).build
+        end
+
+        private
+
+        def factory
+          @factory ||= case options[:via]
+                       when nil, :rubyzip
+                         RubyZipFactory
+                       when :shell
+                         ShellZipFactory
+                       else
+                         fail "Unknown zip factory: #{factory}"
+                       end
+        end
+      end
+
+      # Creates a zip file by shelling out to the zip command
+      class ShellZipFactory
+        attr_reader :zip_definition, :basedir, :zip_file, :paths, :options
+
+        def initialize(zip_definition)
+          @zip_definition = zip_definition
+          @zip_file = zip_definition.zip_file
+          @basedir = zip_definition.basedir
+          @paths = zip_definition.paths
+          @options = build_options.push('--names-stdin').join(' ')
+        end
+
+        def build
+          Dir.chdir(basedir) do
+            # zip doesn't like the file that already exists
+            output = `zip #{zip_definition.path}.tmp #{options} < #{write_file_list.path}`
+            fail "zip command failed: #{output}" unless $CHILD_STATUS.success?
+
+            FileUtils.mv("#{zip_definition.path}.tmp", "#{zip_definition.path}")
+          end
+        end
+
         private
 
-        def add_file_entry(file, base_dir)
-          base_dir = "#{base_dir}/" unless base_dir.end_with?('/')
-          file_entry_path = file[base_dir.length..-1]
-          write_zip_entry(file, file_entry_path)
+        def write_file_list
+          file_list = Tempfile.new('file_list')
+          file_list.puts paths.join("\n")
+          file_list.close
+          file_list
         end
 
-        def write_zip_entry(file, file_entry_path)
-          @logger.debug("adding zip entry: #{file_entry_path}")
-          Zip::File.open(@path, 'w') do |zipfile|
-            entry = new_zip_entry(file_entry_path)
-            zipfile.add(entry, file)
+        def build_options
+          zip_definition.options.map do | key, value |
+            prefix = key.length > 1 ? '--' : '-'
+            if value == true
+              "#{prefix}#{key}"
+            else
+              "#{prefix}#{key} #{value}"
+            end
           end
         end
+      end
+
+      # Creates a zip file using RubyZip
+      class RubyZipFactory
+        attr_reader :zip_definition, :basedir
+
+        def initialize(zip_definition)
+          @zip_definition = zip_definition
+          @basedir = zip_definition.basedir
+          @zip = Zip::File.open(zip_definition.path, Zip::File::CREATE)
+        end
+
+        def build
+          @zip_definition.paths.each do | path |
+            absolute_path = File.expand_path(path, basedir)
+            fail "#{path} doesn't exist" unless File.exist? absolute_path
+
+            if File.directory?(absolute_path)
+              add_directory(path)
+            else
+              add_file(path)
+            end
+          end
+          close
+        end
+
+        def close
+          @zip.close if @zip
+        end
+
+        private
+
+        # Adds all files in the specified directory recursively into the zip file
+        # @param [String] Directory to add into zip
+        def add_directory(dir)
+          glob_pattern = '*'
+          glob_pattern = '**/*' if zip_definition.options[:recurse_paths]
+
+          glob = File.join(basedir, dir, glob_pattern)
+          Dir.glob(glob).each do |file|
+            add_file(file)
+          end
+        end
+
+        def add_file(file)
+          write_zip_entry(file, basedir)
+        end
+
+        def write_zip_entry(file, _file_entry_path)
+          absolute_file = File.expand_path(file, basedir)
+          relative_file = Pathname.new(absolute_file).relative_path_from(basedir).to_s
+          entry = new_zip_entry(relative_file)
+          @zip.add(entry, absolute_file)
+        end
 
         def new_zip_entry(file_entry_path)
           Zip::Entry.new(
-            @path,
+            @zip,
             file_entry_path,
             nil,
             nil,

data/lib/winrm-fs/core/upload_orchestrator.rb

@@ -42,8 +42,8 @@ module WinRM
           end
         end
 
-        def upload_directory(local_paths, remote_path)
-          with_local_zip(local_paths) do |local_zip|
+        def upload_directory(local_path, remote_path)
+          with_local_zip(local_path) do |local_zip|
             temp_path = temp_file_path(local_zip.path)
             with_command_executor do |cmd_executor|
               return 0 unless out_of_date?(cmd_executor, local_zip.path, temp_path)
@@ -74,8 +74,8 @@ module WinRM
           cmd_executor.close
         end
 
-        def with_local_zip(local_paths)
-          local_zip = create_temp_zip_file(local_paths)
+        def with_local_zip(local_path)
+          local_zip = create_temp_zip_file(local_path)
           yield local_zip
         ensure
           local_zip.delete if local_zip
@@ -107,10 +107,11 @@ module WinRM
           "$env:TEMP/winrm-upload/#{local_checksum(local_path)}#{ext}"
         end
 
-        def create_temp_zip_file(local_paths)
-          temp_zip = WinRM::FS::Core::TempZipFile.new
-          local_paths.each { |p| temp_zip.add(p) }
-          temp_zip
+        def create_temp_zip_file(local_path)
+          zip = WinRM::FS::Core::TempZipFile.new(local_path, recurse_paths: true)
+          zip.add(local_path)
+          zip.build
+          zip
         end
       end
     end

data/lib/winrm-fs/file_manager.rb

@@ -86,16 +86,16 @@ module WinRM
       end
 
       # Upload one or more local files and directories to a remote directory
-      # @example copy a single directory to a winrm endpoint
+      # @example copy a single file to a winrm endpoint
       #
-      #   file_manager.upload('c:/dev/my_dir', '$env:AppData')
+      #   file_manager.upload('/Users/sneal/myfile.txt', 'c:/foo/myfile.txt')
       #
-      # @example copy several paths to the winrm endpoint
+      # @example copy a single directory to a winrm endpoint
       #
-      #   file_manager.upload(['c:/dev/file1.txt','c:/dev/dir1'], '$env:AppData')
+      #   file_manager.upload('c:/dev/my_dir', '$env:AppData')
       #
-      # @param [Array<String>] One or more paths that will be copied to the remote path.
-      #   These can be files or directories to be deeply copied
+      # @param [String] A path to a local directory or file that will be copied
+      #   to the remote Windows box.
       # @param [String] The target directory or file
       #   This path may contain powershell style environment variables
       # @yieldparam [Fixnum] Number of bytes copied in current payload sent to the winrm endpoint
@@ -103,21 +103,16 @@ module WinRM
       # @yieldparam [String] Path of file being copied
       # @yieldparam [String] Target path on the winrm endpoint
       # @return [Fixnum] The total number of bytes copied
-      def upload(local_paths, remote_path, &block)
-        @logger.debug("uploading: #{local_paths} -> #{remote_path}")
-        local_paths = [local_paths] if local_paths.is_a? String
+      def upload(local_path, remote_path, &block)
+        @logger.debug("uploading: #{local_path} -> #{remote_path}")
 
         upload_orchestrator = WinRM::FS::Core::UploadOrchestrator.new(@service)
-        if FileManager.src_is_single_file?(local_paths)
-          upload_orchestrator.upload_file(local_paths[0], remote_path, &block)
+        if File.file?(local_path)
+          upload_orchestrator.upload_file(local_path, remote_path, &block)
         else
-          upload_orchestrator.upload_directory(local_paths, remote_path, &block)
+          upload_orchestrator.upload_directory(local_path, remote_path, &block)
         end
       end
-
-      def self.src_is_single_file?(local_paths)
-        local_paths.count == 1 && File.file?(local_paths[0])
-      end
     end
   end
 end

data/spec/file_manager_spec.rb

@@ -1,8 +1,11 @@
 # encoding: UTF-8
+require 'pathname'
+
 describe WinRM::FS::FileManager, integration: true do
   let(:dest_dir) { File.join(subject.temp_dir, "winrm_#{rand(2**16)}") }
   let(:temp_upload_dir) { '$env:TEMP/winrm-upload' }
-  let(:src_dir) { File.expand_path(File.dirname(__FILE__)) }
+  let(:this_dir) { File.expand_path(File.dirname(__FILE__)) }
+  let(:this_file) { __FILE__ }
   let(:service) { winrm_connection }
 
   subject { WinRM::FS::FileManager.new(service) }
@@ -37,57 +40,73 @@ describe WinRM::FS::FileManager, integration: true do
   end
 
   context 'upload file' do
-    let(:src_file) { __FILE__ }
-    let(:dest_file) { File.join(dest_dir, File.basename(src_file)) }
+    let(:dest_file) { File.join(dest_dir, File.basename(this_file)) }
 
     before(:each) do
       expect(subject.delete(dest_dir)).to be true
     end
 
-    it 'should upload the file to the specified file' do
-      subject.upload(src_file, dest_file)
-      expect(subject).to have_created(dest_file).with_content(src_file)
+    it 'should upload the specified file' do
+      subject.upload(this_file, dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to root of the c: drive' do
+      subject.upload(this_file, 'c:/winrmtest.rb')
+      expect(subject).to have_created('c:/winrmtest.rb').with_content(this_file)
+      subject.delete('c:/winrmtest.rb')
+    end
+
+    it 'should upload using relative file path' do
+      subject.upload('./spec/file_manager_spec.rb', dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
     end
 
-    it 'should upload the file to the specified directory' do
-      subject.upload(src_file, dest_dir)
-      expect(subject).to have_created(dest_file).with_content(src_file)
+    it 'should upload to the specified directory' do
+      subject.upload(this_file, dest_dir)
+      expect(subject).to have_created(dest_file).with_content(this_file)
     end
 
-    it 'should upload the file to the specified directory with env var' do
-      subject.upload(src_file, '$env:Temp')
-      expected_dest_file = File.join(subject.temp_dir, File.basename(src_file))
-      expect(subject).to have_created(expected_dest_file).with_content(src_file)
+    it 'should upload to the specified directory with env var' do
+      subject.upload(this_file, '$env:Temp')
+      expected_dest_file = File.join(subject.temp_dir, File.basename(this_file))
+      expect(subject).to have_created(expected_dest_file).with_content(this_file)
     end
 
-    it 'should upload the file to the specified nested directory' do
+    it 'should upload to Program Files sub dir' do
+      subject.upload(this_file, '$env:ProgramFiles/foo')
+      expect(subject).to have_created('c:/Program Files/foo/file_manager_spec.rb') \
+        .with_content(this_file)
+    end
+
+    it 'should upload to the specified nested directory' do
       dest_sub_dir = File.join(dest_dir, 'subdir')
-      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(src_file))
-      subject.upload(src_file, dest_sub_dir)
-      expect(subject).to have_created(dest_sub_dir_file).with_content(src_file)
+      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(this_file))
+      subject.upload(this_file, dest_sub_dir)
+      expect(subject).to have_created(dest_sub_dir_file).with_content(this_file)
     end
 
     it 'yields progress data' do
-      total = subject.upload(src_file, dest_file) do \
+      total = subject.upload(this_file, dest_file) do \
         |bytes_copied, total_bytes, local_path, remote_path|
         expect(total_bytes).to be > 0
         expect(bytes_copied).to eq(total_bytes)
-        expect(local_path).to eq(src_file)
+        expect(local_path).to eq(this_file)
         expect(remote_path).to eq(dest_file)
       end
       expect(total).to be > 0
     end
 
-    it 'should not upload the file when content matches' do
-      subject.upload(src_file, dest_dir)
-      bytes_uploaded = subject.upload(src_file, dest_dir)
+    it 'should not upload when content matches' do
+      subject.upload(this_file, dest_dir)
+      bytes_uploaded = subject.upload(this_file, dest_dir)
       expect(bytes_uploaded).to eq 0
     end
 
-    it 'should upload file when content differs' do
-      another_src_file = File.join(src_dir, 'matchers.rb')
-      subject.upload(another_src_file, dest_file)
-      bytes_uploaded = subject.upload(src_file, dest_file)
+    it 'should upload when content differs' do
+      matchers_file = File.join(this_dir, 'matchers.rb')
+      subject.upload(matchers_file, dest_file)
+      bytes_uploaded = subject.upload(this_file, dest_file)
       expect(bytes_uploaded).to be > 0
     end
 
@@ -97,7 +116,6 @@ describe WinRM::FS::FileManager, integration: true do
   end
 
   context 'upload empty file' do
-    let(:src_file) { __FILE__ }
     let(:empty_src_file) { Tempfile.new('empty').path }
     let(:dest_file) { File.join(dest_dir, 'emptyfile.txt') }
 
@@ -107,33 +125,37 @@ describe WinRM::FS::FileManager, integration: true do
     end
 
     it 'overwrites an existing file' do
-      expect(subject.upload(src_file, dest_file)).to be > 0
+      expect(subject.upload(this_file, dest_file)).to be > 0
       expect(subject.upload(empty_src_file, dest_file)).to be 0
       expect(subject).to have_created(dest_file).with_content('')
     end
   end
 
   context 'upload directory' do
-    it 'copies the entire directory' do
-      bytes_uploaded = subject.upload(src_dir, dest_dir)
+    let(:root_dir) { File.expand_path('../', File.dirname(__FILE__)) }
+    let(:winrm_fs_dir) { File.join(root_dir, 'lib/winrm-fs') }
+    let(:core_dir) { File.join(root_dir, 'lib/winrm-fs/core') }
+
+    it 'copies the entire directory recursively' do
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
       expect(bytes_uploaded).to be > 0
-      Dir.glob(src_dir + '/*.rb').each do |host_file|
-        host_file_rel = host_file[src_dir.length..-1]
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(Pathname.new(winrm_fs_dir)).to_s
         remote_file = File.join(dest_dir, host_file_rel)
         expect(subject).to have_created(remote_file).with_content(host_file)
       end
     end
 
     it 'does not copy the directory when content is the same' do
-      subject.upload(src_dir, dest_dir)
-      bytes_uploaded = subject.upload(src_dir, dest_dir)
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
       expect(bytes_uploaded).to eq 0
     end
 
     it 'copies the directory when content differs' do
-      subject.upload(src_dir, dest_dir)
-      another_dir = File.dirname(src_dir)
-      bytes_uploaded = subject.upload(another_dir, dest_dir)
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(core_dir, dest_dir)
       expect(bytes_uploaded).to be > 0
     end
   end

data/spec/matchers.rb

@@ -41,14 +41,18 @@ end
 RSpec::Matchers.define :contain_zip_entries do |zip_entries|
   match do |temp_zip_file|
     zip_entries = [zip_entries] if zip_entries.is_a? String
-    zip_file = Zip::File.open(temp_zip_file.path)
+    @zip_file = Zip::File.open(temp_zip_file.path)
     @missing_entries = []
     zip_entries.each do |entry|
-      @missing_entries << entry unless zip_file.find_entry(entry)
+      @missing_entries << entry unless @zip_file.find_entry(entry)
     end
     @missing_entries.empty?
   end
   failure_message do |temp_zip_file|
-    "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}"
+    msg = "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}\n Got: "
+    @zip_file.each do |entry|
+      msg << entry.name << ', '
+    end
+    msg
   end
 end

data/spec/temp_zip_file_spec.rb

@@ -1,13 +1,12 @@
 # encoding: UTF-8
-require 'zip'
 require_relative '../lib/winrm-fs/core/temp_zip_file'
 
 describe WinRM::FS::Core::TempZipFile, integration: true do
-  let(:src_dir) { File.expand_path('../lib/winrm-fs', File.dirname(__FILE__)) }
-  let(:src_file) { __FILE__ }
+  let(:winrm_fs_dir) { File.expand_path('../lib/winrm-fs', File.dirname(__FILE__)) }
+  let(:temp_zip_file_spec) { __FILE__ }
+  let(:spec_helper) { File.expand_path('spec_helper.rb', File.dirname(__FILE__)) }
 
   subject { WinRM::FS::Core::TempZipFile.new }
-  after(:each) { subject.delete }
 
   context 'temp file creation' do
     it 'should create a temp file on disk' do
@@ -17,55 +16,40 @@ describe WinRM::FS::Core::TempZipFile, integration: true do
     end
   end
 
-  context 'add_file' do
+  context 'create zip' do
     it 'should raise error when file doesn not exist' do
-      expect { subject.add_file('/etc/foo/does/not/exist') }.to \
-        raise_error('/etc/foo/does/not/exist isn\'t a file')
-    end
-
-    it 'should raise error when file is a directory' do
-      dir = File.dirname(subject.path)
-      expect { subject.add_file(dir) }.to \
-        raise_error("#{dir} isn\'t a file")
+      expect { subject.add('/etc/foo/does/not/exist') }.to raise_error
     end
 
     it 'should add a file to the zip' do
-      subject.add_file(src_file)
-      expect(subject).to contain_zip_entries(File.basename(src_file))
+      subject.add(temp_zip_file_spec)
+      subject.build
+      expect(subject).to contain_zip_entries('spec/temp_zip_file_spec.rb')
     end
-  end
 
-  context 'add_directory' do
-    it 'should raise error when directory does not exist' do
-      expect { subject.add_directory('/etc/does/not/exist') }.to \
-        raise_error('/etc/does/not/exist isn\'t a directory')
+    it 'should add multiple files to the zip' do
+      subject.add(temp_zip_file_spec)
+      subject.add(spec_helper)
+      subject.build
+      expect(subject).to contain_zip_entries([
+        'spec/temp_zip_file_spec.rb',
+        'spec/spec_helper.rb'])
     end
 
-    it 'should raise error when directory is a file' do
-      expect { subject.add_directory(subject.path) }.to \
-        raise_error("#{subject.path} isn\'t a directory")
+    it 'should add all files in directory' do
+      subject.add(winrm_fs_dir)
+      subject.build
+      expect(subject).to contain_zip_entries('lib/winrm-fs/exceptions.rb')
     end
 
     it 'should add all files in directory to the zip recursively' do
-      subject.add_directory(src_dir)
-      expect(subject).to contain_zip_entries(['exceptions.rb', 'core/temp_zip_file.rb'])
-    end
-  end
-
-  context 'add' do
-    it 'should add all files when given a directory' do
-      subject.add(src_dir)
-      expect(subject).to contain_zip_entries(['exceptions.rb', 'core/temp_zip_file.rb'])
-    end
-
-    it 'should add a file when given only a file' do
-      subject.add(src_file)
-      expect(subject).to contain_zip_entries(File.basename(src_file))
-    end
-
-    it 'should raise error when given a non-path' do
-      expect { subject.add('garbage') }.to \
-        raise_error("garbage doesn't exist")
+      subject = WinRM::FS::Core::TempZipFile.new(Dir.pwd, recurse_paths: true)
+      subject.add(winrm_fs_dir)
+      subject.build
+      expect(subject).to contain_zip_entries([
+        'lib/winrm-fs/exceptions.rb',
+        'lib/winrm-fs/core/temp_zip_file.rb',
+        'lib/winrm-fs/scripts/checksum.ps1.erb'])
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: winrm-fs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Shawn Neal
@@ -9,110 +9,110 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-20 00:00:00.000000000 Z
+date: 2015-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
 - !ruby/object:Gem::Dependency
   name: logging
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.1
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: winrm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.3.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.3.2
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.28.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.28.0
 description: |2
@@ -127,16 +127,17 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - VERSION
 - Vagrantfile
+- benchmark.rb
 - bin/rwinrmcp
 - changelog.md
 - lib/winrm-fs.rb
@@ -164,25 +165,25 @@ licenses: []
 metadata: {}
 post_install_message: 
 rdoc_options:
-- -x
+- "-x"
 - test/
-- -x
+- "-x"
 - examples/
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: WinRM File System