Simplify Windows command string

Process.spawn takes care of the escaping for us.

lib/aruba/platforms/windows_command_string.rb

@@ -4,8 +4,6 @@ module Aruba
   module Platforms
     # This is a command which should be run
     #
-    # This adds `cmd.exec` in front of commmand
-    #
     # @private
     class WindowsCommandString
       def initialize(command, *arguments)
@@ -15,22 +13,7 @@ def initialize(command, *arguments)
 
       # Convert to array
       def to_a
-        [cmd_path, "/c", [escaped_command, *escaped_arguments].join(" ")]
-      end
-
-      private
-
-      def escaped_arguments
-        @arguments.map { |arg| arg.gsub(/"/, '"""') }
-                  .map { |arg| / /.match?(arg) ? "\"#{arg}\"" : arg }
-      end
-
-      def escaped_command
-        @command.gsub(/ /, '""" """')
-      end
-
-      def cmd_path
-        Aruba.platform.which("cmd.exe")
+        [@command, *@arguments]
       end
     end
   end

spec/aruba/platforms/windows_command_string_spec.rb

@@ -2,24 +2,19 @@
 
 RSpec.describe Aruba::Platforms::WindowsCommandString do
   let(:command_string) { described_class.new(base_command, *arguments) }
-  let(:cmd_path) { 'C:\Some Path\cmd.exe' }
   let(:arguments) { [] }
 
-  before do
-    allow(Aruba.platform).to receive(:which).with("cmd.exe").and_return(cmd_path)
-  end
-
   describe "#to_a" do
     context "with a command with a path" do
       let(:base_command) { "C:\\Foo\\Bar" }
 
-      it { expect(command_string.to_a).to eq [cmd_path, "/c", base_command] }
+      it { expect(command_string.to_a).to eq [base_command] }
     end
 
     context "with a command with a path containing spaces" do
       let(:base_command) { "C:\\Foo Bar\\Baz" }
 
-      it { expect(command_string.to_a).to eq [cmd_path, "/c", 'C:\Foo""" """Bar\Baz'] }
+      it { expect(command_string.to_a).to eq [base_command] }
     end
 
     context "with a command and arguments" do
@@ -28,7 +23,7 @@
 
       it {
         expect(command_string.to_a)
-          .to eq [cmd_path, "/c", "#{base_command} -w \"baz quux\""]
+          .to eq [base_command, *arguments]
       }
     end
   end

spec/aruba/processes/spawn_process_spec.rb

@@ -266,7 +266,6 @@
       before do
         allow(Aruba.platform).to receive(:command_string)
           .and_return Aruba::Platforms::WindowsCommandString
-        allow(Aruba.platform).to receive(:which).with("cmd.exe").and_return(cmd_path)
         allow(Aruba.platform)
           .to receive(:which).with(command, anything).and_return(command_path)
         allow(Aruba::Processes::ProcessRunner).to receive(:new).and_return(child)
@@ -289,30 +288,30 @@
       end
 
       context "with a command without a space in the path" do
-        it "passes the command and shell paths as single strings to ProcessRunner.new" do
+        it "passes the command as-is" do
           process.start
           expect(Aruba::Processes::ProcessRunner).to have_received(:new)
-            .with([cmd_path, "/c", command_path])
+            .with([command_path])
         end
       end
 
       context "with a command with a space in the path" do
         let(:command_path) { 'D:\Bar Baz\foo' }
 
-        it "escapes the spaces using excessive double quotes" do
+        it "passes the command as-is" do
           process.start
           expect(Aruba::Processes::ProcessRunner).to have_received(:new)
-            .with([cmd_path, "/c", 'D:\Bar""" """Baz\foo'])
+            .with([command_path])
         end
       end
 
       context "with a command with arguments" do
         let(:command_line) { "foo -x 'bar \"baz\"'" }
 
-        it "passes the command and arguments as one string with escaped quotes" do
+        it "passes the command and arguments individually" do
           process.start
           expect(Aruba::Processes::ProcessRunner).to have_received(:new)
-            .with([cmd_path, "/c", "#{command_path} -x \"bar \"\"\"baz\"\"\"\""])
+            .with([command_path, "-x", "bar \"baz\""])
         end
       end
     end