Support passing standard input stream to execute helper

We want to support running existing git hooks that developers have
written. In order to do that, we need to support passing a standard
input stream, since some hooks use that as the mechanism to pass input.

This modifies the work we did in 317047a and 82d5220 to support long
argument lists by changing the signature of the `execute` helper to
accept an options hash, requiring that splittable arguments now be
passed using the `args` option so that the `input` option can also be
passed if necessary.

This also has the added benefit of having our `CommandSplitter` support
passing standard input streams, though there's probably not many
situations where that would actually be necessary.

Author: sds

lib/overcommit/command_splitter.rb

@@ -51,17 +51,19 @@ def stderr
     end
 
     class << self
-      def execute(args, splittable_args)
-        if splittable_args.empty?
+      def execute(initial_args, options)
+        options = options.dup
+
+        if (splittable_args = (options.delete(:args) { [] })).empty?
           raise Overcommit::Exceptions::InvalidCommandArgs,
                 'Must specify list of arguments to split on'
         end
 
         # Execute each chunk of arguments in serial. We don't parallelize (yet)
         # since in theory we want to support parallelization at the hook level
         # and not within individual hooks.
-        results = extract_argument_lists(args, splittable_args).map do |arg_list|
-          Overcommit::Subprocess.spawn(arg_list)
+        results = extract_argument_lists(initial_args, splittable_args).map do |arg_list|
+          Overcommit::Subprocess.spawn(arg_list, options)
         end
 
         Result.new(results.map(&:status), results.map(&:stdout), results.map(&:stderr))

lib/overcommit/hook/base.rb

@@ -90,11 +90,14 @@ def in_path?(cmd)
     # for splitting up long file lists.
     #
     # @param cmd [Array<String>] command arguments
-    # @param splittable_args [Array<String>] arguments that can be split up over
+    # @param options [Hash]
+    # @option options [Array<String>] :args arguments that can be split up over
     #   multiple invocations (usually a list of files)
+    # @option options [String] :input string to pass to process' standard input
+    #   stream
     # @return [#status,#stdout,#stderr] struct containing result of invocation
-    def execute(cmd, splittable_args = nil)
-      Overcommit::Utils.execute(cmd, splittable_args)
+    def execute(cmd, options = {})
+      Overcommit::Utils.execute(cmd, options)
     end
 
     def execute_in_background(cmd)

lib/overcommit/hook/pre_commit/hard_tabs.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for hard tabs in files.
   class HardTabs < Base
     def run
-      result = execute(command, applicable_files)
+      result = execute(command, args: applicable_files)
 
       extract_messages(
         result.stdout.split("\n"),

lib/overcommit/hook/pre_commit/local_paths_in_gemfile.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for local paths in files and issues a warning
   class LocalPathsInGemfile < Base
     def run
-      result = execute(command, applicable_files)
+      result = execute(command, args: applicable_files)
 
       unless result.stdout.empty?
         return :warn, "Avoid pointing to local paths in Gemfiles:\n#{result.stdout}"

lib/overcommit/hook/pre_commit/merge_conflicts.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for unresolved merge conflicts
   class MergeConflicts < Base
     def run
-      result = execute(command, applicable_files)
+      result = execute(command, args: applicable_files)
 
       unless result.stdout.empty?
         return :fail, "Merge conflict markers detected:\n#{result.stdout}"

lib/overcommit/hook/pre_commit/trailing_whitespace.rb

@@ -2,7 +2,7 @@ module Overcommit::Hook::PreCommit
   # Checks for trailing whitespace in files.
   class TrailingWhitespace < Base
     def run
-      result = execute(command, applicable_files)
+      result = execute(command, args: applicable_files)
 
       extract_messages(
         result.stdout.split("\n"),

lib/overcommit/subprocess.rb

@@ -19,12 +19,22 @@ def success?
     class << self
       # Spawns a new process using the given array of arguments (the first
       # element is the command).
-      def spawn(args)
+      #
+      # @param args [Array<String>]
+      # @param options [Hash]
+      # @option options [String] input string to pass via standard input stream
+      # @return [Result]
+      def spawn(args, options = {})
         process = ChildProcess.build(*args)
 
         out, err = assign_output_streams(process)
 
+        process.duplex = true if options[:input] # Make stdin available if needed
         process.start
+        if options[:input]
+          process.io.stdin.puts(options[:input])
+          process.io.stdin.close
+        end
         process.wait
 
         err.rewind

lib/overcommit/utils.rb

@@ -146,32 +146,33 @@ def parent_command
       # This is intended to provide a centralized place to perform any checks or
       # filtering of the command before executing it.
       #
-      # The `splittable_args` parameter provides a convenient way of splitting
-      # up long argument lists which would otherwise exceed the maximum command
-      # line length of the OS. It will break up the list into chunks and run the
-      # command with the same prefix `args`, finally combining the output
-      # together at the end.
+      # The `args` option provides a convenient way of splitting up long
+      # argument lists which would otherwise exceed the maximum command line
+      # length of the OS. It will break up the list into chunks and run the
+      # command with the same prefix `initial_args`, finally combining the
+      # output together at the end.
       #
       # This requires that the external command you are running can have its
       # work split up in this way and still produce the same resultant output
       # when outputs of the individual commands are concatenated back together.
       #
-      # @param args [Array<String>]
-      # @param splittable_args [Array<String>]
+      # @param initial_args [Array<String>]
+      # @param options [Hash]
+      # @option options [Array<String>] :args long list of arguments to split up
       # @return [Overcommit::Subprocess::Result] status, stdout, and stderr
-      def execute(args, splittable_args = nil)
-        if args.include?('|')
+      def execute(initial_args, options = {})
+        if initial_args.include?('|')
           raise Overcommit::Exceptions::InvalidCommandArgs,
                 'Cannot pipe commands with the `execute` helper'
         end
 
         result =
-          if splittable_args
-            debug(args.join(' ') + " ... (#{splittable_args.length} splittable args)")
-            Overcommit::CommandSplitter.execute(args, splittable_args)
+          if splittable_args = options[:args]
+            debug(initial_args.join(' ') + " ... (#{splittable_args.length} splittable args)")
+            Overcommit::CommandSplitter.execute(initial_args, options)
           else
-            debug(args.join(' '))
-            Overcommit::Subprocess.spawn(args)
+            debug(initial_args.join(' '))
+            Overcommit::Subprocess.spawn(initial_args, options)
           end
 
         debug("EXIT STATUS: #{result.status}")

spec/overcommit/command_splitter_spec.rb

@@ -4,8 +4,9 @@
   describe '.execute' do
     let(:args_prefix) { %w[cmd] }
     let(:max_command_length) { 10 }
+    let(:options) { { args: splittable_args } }
 
-    subject { described_class.execute(args_prefix, splittable_args) }
+    subject { described_class.execute(args_prefix, options) }
 
     before do
       described_class.stub(:max_command_length).and_return(max_command_length)
@@ -35,8 +36,10 @@
       let(:splittable_args) { %w[1 2 3 4 5 6 7 8] }
 
       it 'executes two commands with the appropriately split arguments' do
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 1 2 3 4 5 6 7])
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 8])
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 1 2 3 4 5 6 7],
+                                                           hash_excluding(:args))
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 8],
+                                                           hash_excluding(:args))
         subject
       end
 
@@ -55,7 +58,7 @@
       context 'when one command fails' do
         before do
           Overcommit::Subprocess.stub(:spawn).
-            with(%w[cmd 8]).
+            with(%w[cmd 8], anything).
             and_return(Overcommit::Subprocess::Result.new(2, 'whoa', 'bad error'))
         end
 
@@ -75,10 +78,14 @@
       let(:splittable_args) { 15.times.map { |i| (i + 1).to_s } }
 
       it 'executes multiple commands with the appropriately split arguments' do
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 1 2 3 4 5 6 7])
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 8 9 10 11])
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 12 13 14])
-        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 15])
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 1 2 3 4 5 6 7],
+                                                           hash_excluding(:args))
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 8 9 10 11],
+                                                           hash_excluding(:args))
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 12 13 14],
+                                                           hash_excluding(:args))
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cmd 15],
+                                                           hash_excluding(:args))
         subject
       end
     end
@@ -101,5 +108,19 @@
         expect { subject }.to raise_error Overcommit::Exceptions::InvalidCommandArgs
       end
     end
+
+    context 'with a standard input stream specified' do
+      let(:max_command_length) { 5 }
+      let(:args_prefix) { %w[cat] }
+      let(:options) { { args: %w[- - -], input: 'Hello' } }
+
+      it 'passes the same standard input to each command' do
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cat - -],
+                                                           hash_including(input: 'Hello'))
+        Overcommit::Subprocess.should_receive(:spawn).with(%w[cat -],
+                                                           hash_including(input: 'Hello'))
+        subject
+      end
+    end
   end
 end

spec/overcommit/utils_spec.rb

@@ -174,15 +174,26 @@
       end
     end
 
+    context 'when given an input stream' do
+      let(:arguments) { ['cat', '-'] }
+      let(:input) { 'Hello world' }
+
+      subject { described_class.execute(arguments, input: input) }
+
+      it 'passes the input to the standard input stream' do
+        subject.stdout.should == "Hello world\n"
+      end
+    end
+
     context 'when given a list of arguments to execute in chunks' do
       let(:arguments) { ['echo'] }
       let(:splittable_args) { %w[1 2 3] }
 
-      subject { described_class.execute(arguments, splittable_args) }
+      subject { described_class.execute(arguments, args: splittable_args) }
 
       it 'invokes CommandSplitter.execute' do
         Overcommit::CommandSplitter.should_receive(:execute).
-                                    with(arguments, splittable_args).
+                                    with(arguments, args: splittable_args).
                                     and_return(double(status: 0, stdout: '', stderr: ''))
         subject
       end