childprocess 0.8.0 → 2.0.0

data/lib/childprocess/tools/generator.rb

@@ -1,146 +1,146 @@
-require 'fileutils'
-
-module ChildProcess
-  module Tools
-    class Generator
-      EXE_NAME         = "childprocess-sizeof-generator"
-      TMP_PROGRAM      = "childprocess-sizeof-generator.c"
-      DEFAULT_INCLUDES = %w[stdio.h stddef.h]
-
-      def self.generate
-        new.generate
-      end
-
-      def initialize
-        @cc        = ENV['CC'] || 'gcc'
-        @out       = File.expand_path("../../unix/platform/#{ChildProcess.platform_name}.rb", __FILE__)
-        @sizeof    = {}
-        @constants = {}
-      end
-
-      def generate
-        fetch_size 'posix_spawn_file_actions_t', :include => "spawn.h"
-        fetch_size 'posix_spawnattr_t', :include => "spawn.h"
-        fetch_size 'sigset_t', :include => "signal.h"
-
-        fetch_constant 'POSIX_SPAWN_RESETIDS',   :include  => 'spawn.h'
-        fetch_constant 'POSIX_SPAWN_SETPGROUP',  :include  => 'spawn.h'
-        fetch_constant 'POSIX_SPAWN_SETSIGDEF',  :include  => 'spawn.h'
-        fetch_constant 'POSIX_SPAWN_SETSIGMASK', :include  => 'spawn.h'
-
-        if ChildProcess.linux?
-          fetch_constant 'POSIX_SPAWN_USEVFORK', :include => 'spawn.h', :define => {'_GNU_SOURCE' => nil}
-        end
-
-        write
-      end
-
-      def write
-        FileUtils.mkdir_p(File.dirname(@out))
-        File.open(@out, 'w') do |io|
-          io.puts result
-        end
-
-        puts "wrote #{@out}"
-      end
-
-      def fetch_size(type_name, opts = {})
-        print "sizeof(#{type_name}): "
-        src = <<-EOF
-int main() {
-  printf("%d", (unsigned int)sizeof(#{type_name}));
-  return 0;
-}
-        EOF
-
-        output = execute(src, opts)
-
-        if output.to_i < 1
-          raise "sizeof(#{type_name}) == #{output.to_i} (output=#{output})"
-        end
-
-        size = output.to_i
-        @sizeof[type_name] = size
-
-        puts size
-      end
-
-      def fetch_constant(name, opts)
-        print "#{name}: "
-        src = <<-EOF
-int main() {
-  printf("%d", (unsigned int)#{name});
-  return 0;
-}
-        EOF
-
-        output = execute(src, opts)
-        value  = Integer(output)
-        @constants[name] = value
-
-        puts value
-      end
-
-
-      def execute(src, opts)
-        program = Array(opts[:define]).map do |key, value|
-          <<-SRC
-#ifndef #{key}
-#define #{key} #{value}
-#endif
-          SRC
-        end.join("\n")
-        program << "\n"
-
-        includes = Array(opts[:include]) + DEFAULT_INCLUDES
-        program << includes.map { |include| "#include <#{include}>" }.join("\n")
-        program << "\n#{src}"
-
-        File.open(TMP_PROGRAM, 'w') do |file|
-          file << program
-        end
-
-        cmd = "#{@cc} #{TMP_PROGRAM} -o #{EXE_NAME}"
-        system cmd
-        unless $?.success?
-          raise "failed to compile program: #{cmd.inspect}\n#{program}"
-        end
-
-        output = `./#{EXE_NAME} 2>&1`
-
-        unless $?.success?
-          raise "failed to run program: #{cmd.inspect}\n#{output}"
-        end
-
-        output.chomp
-      ensure
-        File.delete TMP_PROGRAM if File.exist?(TMP_PROGRAM)
-        File.delete EXE_NAME if File.exist?(EXE_NAME)
-      end
-
-      def result
-        if @sizeof.empty? && @constants.empty?
-          raise "no data collected, nothing to do"
-        end
-
-        out =  ['module ChildProcess::Unix::Platform']
-        out << '  SIZEOF = {'
-
-        max = @sizeof.keys.map { |e| e.length }.max
-        @sizeof.each_with_index do |(type, size), idx|
-          out << "     :#{type.ljust max} => #{size}#{',' unless idx == @sizeof.size - 1}"
-        end
-        out << '  }'
-
-        max = @constants.keys.map { |e| e.length }.max
-        @constants.each do |name, val|
-          out << "  #{name.ljust max} = #{val}"
-        end
-        out << 'end'
-
-        out.join "\n"
-      end
-
-    end
-  end
+require 'fileutils'
+
+module ChildProcess
+  module Tools
+    class Generator
+      EXE_NAME         = "childprocess-sizeof-generator"
+      TMP_PROGRAM      = "childprocess-sizeof-generator.c"
+      DEFAULT_INCLUDES = %w[stdio.h stddef.h]
+
+      def self.generate
+        new.generate
+      end
+
+      def initialize
+        @cc        = ENV['CC'] || 'gcc'
+        @out       = File.expand_path("../../unix/platform/#{ChildProcess.platform_name}.rb", __FILE__)
+        @sizeof    = {}
+        @constants = {}
+      end
+
+      def generate
+        fetch_size 'posix_spawn_file_actions_t', :include => "spawn.h"
+        fetch_size 'posix_spawnattr_t', :include => "spawn.h"
+        fetch_size 'sigset_t', :include => "signal.h"
+
+        fetch_constant 'POSIX_SPAWN_RESETIDS',   :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETPGROUP',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGDEF',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGMASK', :include  => 'spawn.h'
+
+        if ChildProcess.linux?
+          fetch_constant 'POSIX_SPAWN_USEVFORK', :include => 'spawn.h', :define => {'_GNU_SOURCE' => nil}
+        end
+
+        write
+      end
+
+      def write
+        FileUtils.mkdir_p(File.dirname(@out))
+        File.open(@out, 'w') do |io|
+          io.puts result
+        end
+
+        puts "wrote #{@out}"
+      end
+
+      def fetch_size(type_name, opts = {})
+        print "sizeof(#{type_name}): "
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)sizeof(#{type_name}));
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+
+        if output.to_i < 1
+          raise "sizeof(#{type_name}) == #{output.to_i} (output=#{output})"
+        end
+
+        size = output.to_i
+        @sizeof[type_name] = size
+
+        puts size
+      end
+
+      def fetch_constant(name, opts)
+        print "#{name}: "
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)#{name});
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+        value  = Integer(output)
+        @constants[name] = value
+
+        puts value
+      end
+
+
+      def execute(src, opts)
+        program = Array(opts[:define]).map do |key, value|
+          <<-SRC
+#ifndef #{key}
+#define #{key} #{value}
+#endif
+          SRC
+        end.join("\n")
+        program << "\n"
+
+        includes = Array(opts[:include]) + DEFAULT_INCLUDES
+        program << includes.map { |include| "#include <#{include}>" }.join("\n")
+        program << "\n#{src}"
+
+        File.open(TMP_PROGRAM, 'w') do |file|
+          file << program
+        end
+
+        cmd = "#{@cc} #{TMP_PROGRAM} -o #{EXE_NAME}"
+        system cmd
+        unless $?.success?
+          raise "failed to compile program: #{cmd.inspect}\n#{program}"
+        end
+
+        output = `./#{EXE_NAME} 2>&1`
+
+        unless $?.success?
+          raise "failed to run program: #{cmd.inspect}\n#{output}"
+        end
+
+        output.chomp
+      ensure
+        File.delete TMP_PROGRAM if File.exist?(TMP_PROGRAM)
+        File.delete EXE_NAME if File.exist?(EXE_NAME)
+      end
+
+      def result
+        if @sizeof.empty? && @constants.empty?
+          raise "no data collected, nothing to do"
+        end
+
+        out =  ['module ChildProcess::Unix::Platform']
+        out << '  SIZEOF = {'
+
+        max = @sizeof.keys.map { |e| e.length }.max
+        @sizeof.each_with_index do |(type, size), idx|
+          out << "     :#{type.ljust max} => #{size}#{',' unless idx == @sizeof.size - 1}"
+        end
+        out << '  }'
+
+        max = @constants.keys.map { |e| e.length }.max
+        @constants.each do |name, val|
+          out << "  #{name.ljust max} = #{val}"
+        end
+        out << 'end'
+
+        out.join "\n"
+      end
+
+    end
+  end
 end

data/lib/childprocess/unix/fork_exec_process.rb

@@ -1,70 +1,78 @@
-module ChildProcess
-  module Unix
-    class ForkExecProcess < Process
-      private
-
-      def launch_process
-        if @io
-          stdout = @io.stdout
-          stderr = @io.stderr
-        end
-
-        # pipe used to detect exec() failure
-        exec_r, exec_w = ::IO.pipe
-        ChildProcess.close_on_exec exec_w
-
-        if duplex?
-          reader, writer = ::IO.pipe
-        end
-
-        @pid = Kernel.fork {
-          # Children of the forked process will inherit its process group
-          # This is to make sure that all grandchildren dies when this Process instance is killed
-          ::Process.setpgid 0, 0 if leader?
-
-          if @cwd
-            Dir.chdir(@cwd)
-          end
-
-          exec_r.close
-          set_env
-
-          STDOUT.reopen(stdout || "/dev/null")
-          STDERR.reopen(stderr || "/dev/null")
-
-          if duplex?
-            STDIN.reopen(reader)
-            writer.close
-          end
-
-          executable, *args = @args
-
-          begin
-            Kernel.exec([executable, executable], *args)
-          rescue SystemCallError => ex
-            exec_w << ex.message
-          end
-        }
-
-        exec_w.close
-
-        if duplex?
-          io._stdin = writer
-          reader.close
-        end
-
-        # if we don't eventually get EOF, exec() failed
-        unless exec_r.eof?
-          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
-        end
-
-        ::Process.detach(@pid) if detach?
-      end
-
-      def set_env
-        @environment.each { |k, v| ENV[k.to_s] = v.nil? ? nil : v.to_s }
-      end
-
-    end # Process
-  end # Unix
-end # ChildProcess
+module ChildProcess
+  module Unix
+    class ForkExecProcess < Process
+      private
+
+      def launch_process
+        if @io
+          stdout = @io.stdout
+          stderr = @io.stderr
+        end
+
+        # pipe used to detect exec() failure
+        exec_r, exec_w = ::IO.pipe
+        ChildProcess.close_on_exec exec_w
+
+        if duplex?
+          reader, writer = ::IO.pipe
+        end
+
+        @pid = Kernel.fork {
+          # Children of the forked process will inherit its process group
+          # This is to make sure that all grandchildren dies when this Process instance is killed
+          ::Process.setpgid 0, 0 if leader?
+
+          if @cwd
+            Dir.chdir(@cwd)
+          end
+
+          exec_r.close
+          set_env
+
+          if stdout
+            STDOUT.reopen(stdout)
+          else
+            STDOUT.reopen("/dev/null", "a+")
+          end
+          if stderr
+            STDERR.reopen(stderr)
+          else
+            STDERR.reopen("/dev/null", "a+")
+          end
+
+          if duplex?
+            STDIN.reopen(reader)
+            writer.close
+          end
+
+          executable, *args = @args
+
+          begin
+            Kernel.exec([executable, executable], *args)
+          rescue SystemCallError => ex
+            exec_w << ex.message
+          end
+        }
+
+        exec_w.close
+
+        if duplex?
+          io._stdin = writer
+          reader.close
+        end
+
+        # if we don't eventually get EOF, exec() failed
+        unless exec_r.eof?
+          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
+        end
+
+        ::Process.detach(@pid) if detach?
+      end
+
+      def set_env
+        @environment.each { |k, v| ENV[k.to_s] = v.nil? ? nil : v.to_s }
+      end
+
+    end # Process
+  end # Unix
+end # ChildProcess

data/lib/childprocess/unix/io.rb

@@ -1,21 +1,21 @@
-module ChildProcess
-  module Unix
-    class IO < AbstractIO
-      private
-
-      def check_type(io)
-        unless io.respond_to? :to_io
-          raise ArgumentError, "expected #{io.inspect} to respond to :to_io"
-        end
-
-        result = io.to_io
-        unless result && result.kind_of?(::IO)
-          raise TypeError, "expected IO, got #{result.inspect}:#{result.class}"
-        end
-      end
-
-    end # IO
-  end # Unix
-end # ChildProcess
-
-
+module ChildProcess
+  module Unix
+    class IO < AbstractIO
+      private
+
+      def check_type(io)
+        unless io.respond_to? :to_io
+          raise ArgumentError, "expected #{io.inspect} to respond to :to_io"
+        end
+
+        result = io.to_io
+        unless result && result.kind_of?(::IO)
+          raise TypeError, "expected IO, got #{result.inspect}:#{result.class}"
+        end
+      end
+
+    end # IO
+  end # Unix
+end # ChildProcess
+
+