coque 0.1.0

data/io.rb

@@ -0,0 +1,215 @@
+require 'open3'
+
+def banner(msg)
+  puts "******* #{msg} *******"
+end
+
+def read_from_spawned_pipe
+  banner("read_from_spawned_pipe")
+  pipe_me_in, pipe_peer_out = IO.pipe
+  pipe_peer_in, pipe_me_out = IO.pipe
+
+  pid = spawn('ls',
+              out: pipe_peer_out,
+              pipe_peer_out => pipe_peer_out,
+              in: pipe_peer_in,
+              pipe_peer_in => pipe_peer_in)
+  puts "Spawned #{pid}"
+
+  pipe_peer_out.close
+  puts pipe_me_in.read
+end
+
+def read_write_to_spawned
+  banner("read_write_to_spawned")
+  pipe_me_in, pipe_peer_out = IO.pipe
+  pipe_peer_in, pipe_me_out = IO.pipe
+
+  ['a', 'b', 'c', 'ab'].each { |l| pipe_me_out.puts(l) }
+
+  pid = spawn('grep a',
+              out: pipe_peer_out,
+              pipe_peer_out => pipe_peer_out,
+              in: pipe_peer_in,
+              pipe_peer_in => pipe_peer_in)
+  puts "Spawned #{pid}"
+  pipe_me_out.close
+
+  pipe_peer_out.close
+  puts pipe_me_in.read
+end
+
+def chain_two_native_processes
+  banner("chain_two_native_processes")
+  a_in_read, a_in_write = IO.pipe
+  a_out_read, a_out_write = IO.pipe
+
+  p1 = spawn('echo "a\nb\nc\nab\n"',
+             out: a_out_write,
+             a_out_write => a_out_write,
+             in: a_in_read,
+             a_in_read => a_in_read)
+
+  b_out_read, b_out_write = IO.pipe
+
+  p2 = spawn('grep a',
+             out: b_out_write,
+             b_out_write => b_out_write,
+             in: a_out_read,
+             a_out_read => a_out_read)
+
+  puts "Spawned a: #{p1}, b: #{p2}"
+  # Q: Why do we have to close these? do the spawned processes not close them?
+  b_out_write.close
+  a_out_write.close
+  puts b_out_read.read
+end
+
+def reading_large_output
+  banner("reading_large_output")
+  a_in_read, a_in_write = IO.pipe
+  a_out_read, a_out_write = IO.pipe
+
+  p1 = spawn('cat /usr/share/dict/words',
+             out: a_out_write,
+             a_out_write => a_out_write)
+
+  a_out_write.close
+  puts a_out_read.read
+end
+
+def pipe_to_forked_ruby
+  banner("pipe_to_forked_ruby")
+  a_in_read, a_in_write = IO.pipe
+  b_out_read, b_out_write = IO.pipe
+
+  ['a', 'b', 'c', 'ab'].each { |l| a_in_write.puts(l) }
+  a_in_write.flush
+  a_in_write.close
+
+  child = fork do
+    # change our stdin to be the read end of the pipe
+    STDOUT.puts "forked process to stdout (#{STDOUT.fileno})"
+    b_out_write.puts "******* forked process to pipe (#{b_out_write.fileno}) **********"
+
+    a_in_read.each_line { |l| b_out_write.puts "child - #{l}" }
+  end
+  puts "forked #{child}"
+
+  a_in_write.close
+  b_out_write.close
+
+  b_out_read.each_line { |l| puts "read from parent - #{l}" }
+end
+
+
+def native_process_to_ruby_block
+  banner("native_process_to_ruby_block")
+  # a_in_read, a_in_write = IO.pipe
+  a_out_read, a_out_write = IO.pipe
+  b_out_read, b_out_write = IO.pipe
+  puts "parent file descriptors"
+  puts "a read: #{a_out_read.fileno}"
+  puts "a write: #{a_out_write.fileno}"
+  puts "b read: #{b_out_read.fileno}"
+  puts "b write: #{b_out_write.fileno}"
+
+  # Receives copy of a_out_write; closes when done
+  p1 = spawn('echo "a\nb\nc\nab"', out: a_out_write)
+
+  # Receives copy of
+  # a_out_read - needs to read; closed automatically?
+  # a_out_write - doesn't need, close immediately
+  # b_out_read - doesn't need, close immediately
+  # b_out_write - needs to write; close when done
+  child = fork do
+    puts "child file descriptors:"
+    puts "a read: #{a_out_read.fileno}"
+    puts "a write: #{a_out_write.fileno}"
+    puts "b read: #{b_out_read.fileno}"
+    puts "b write: #{b_out_write.fileno}"
+    a_out_write.close
+    b_out_read.close
+
+    puts "******* IN FORK **********"
+
+    # while l = a_out_read.gets
+    #   puts "working #{l}"
+    #   b_out_write.puts "child - #{l}"
+    # end
+
+    a_out_read.each_line { |l| puts "working #{l}"; b_out_write.puts "child - #{l}" }
+    puts "child done - close writer"
+    a_out_read.close
+    b_out_write.close
+    puts "Fork work done"
+  end
+
+  puts "done forked"
+
+  a_out_write.close
+  b_out_write.close
+  a_out_read.close
+
+  puts "** Display child output:"
+  b_out_read.each_line { |l| puts "read from parent - #{l}" }
+  b_out_read.close
+  puts "done reading"
+end
+
+# read_from_spawned_pipe
+# read_write_to_spawned
+# pipe_to_forked_ruby
+# reading_large_output
+# chain_two_native_processes
+# native_process_to_ruby_block
+
+def run_fork(stdin, stdout, &block)
+  fork do
+    STDOUT.reopen(stdout)
+    stdin.each_line(&block)
+  end
+end
+
+def three_step
+  writers = []
+  banner("three step")
+  a_in_read, a_in_write = IO.pipe
+  a_out_read, a_out_write = IO.pipe
+
+  a_unused = [a_out_write]
+
+  p1 = spawn('echo "a\nb\nc\nab\n"',
+             out: a_out_write,
+             a_out_write => a_out_write,
+             in: a_in_read,
+             a_in_read => a_in_read)
+
+  b_out_read, b_out_write = IO.pipe
+  b_unused = [b_out_write]
+
+  a_unused.each(&:close)
+  run_fork(a_out_read, b_out_write) { |l| puts "~~ - #{l}" }
+
+  c_out_read, c_out_write = IO.pipe
+  c_unused = [c_out_write]
+
+  p2 = spawn('grep a',
+             out: c_out_write,
+             c_out_write => c_out_write,
+             in: b_out_read,
+             b_out_read => b_out_read)
+  b_unused.each(&:close)
+
+  # Q: Why do we have to close these? do the spawned processes not close them?
+  c_unused.each(&:close)
+  puts c_out_read.read
+end
+
+# three_step
+
+def stdin_redirect
+  stdin = File.open("/usr/share/dict/words", "r")
+  spawn("head", in: stdin, stdin => stdin)
+end
+stdin_redirect

data/lib/coque/cmd.rb

@@ -0,0 +1,35 @@
+module Coque
+  class Cmd
+    include Redirectable
+    attr_reader :context
+
+    def |(other)
+      verify_redirectable(other)
+      case other
+      when Cmd
+        Pipeline.new([self, other])
+      when Pipeline
+        Pipeline.new([self] + other.commands)
+      end
+    end
+
+    def clone
+      raise "Not Implemented - Override"
+    end
+
+    def ensure_default_fds
+      if self.stdin.nil?
+        inr, inw = IO.pipe
+        inw.close
+        self.stdin = inr
+      end
+
+      if self.stdout.nil?
+        outr, outw = IO.pipe
+        self.stdout = outw
+        # only used for Result if this is the last command in a pipe
+        @stdout_read = outr
+      end
+    end
+  end
+end

data/lib/coque/context.rb

@@ -0,0 +1,35 @@
+module Coque
+  class Context
+    attr_reader :dir, :env
+    def initialize(dir = Dir.pwd, env = {}, disinherits_env = false)
+      @dir = dir
+      @env = env
+      @disinherits_env = disinherits_env
+    end
+
+    def disinherits_env?
+      @disinherits_env
+    end
+
+    def [](*args)
+      Sh.new(self, args)
+    end
+
+    def rb(&block)
+      Rb.new(self, &block)
+    end
+
+    def chdir(new_dir)
+      Context.new(new_dir, env, disinherits_env?)
+    end
+
+    def setenv(opts)
+      opts = opts.map { |k,v| [k.to_s, v.to_s] }.to_h
+      Context.new(dir, self.env.merge(opts), disinherits_env?)
+    end
+
+    def disinherit_env
+      Context.new(dir, {}, true)
+    end
+  end
+end

data/lib/coque/errors.rb

@@ -0,0 +1,4 @@
+module Coque
+  class RedirectionError < RuntimeError
+  end
+end

data/lib/coque/pipeline.rb

@@ -0,0 +1,62 @@
+module Coque
+  class Pipeline
+    include Redirectable
+
+    attr_reader :commands
+    def initialize(commands = [])
+      @commands = commands
+    end
+
+    def clone
+      self.class.new(commands)
+    end
+
+    def to_s
+      "<Pipeline #{commands.join(" | ")} >"
+    end
+
+    def |(other)
+      verify_redirectable(other)
+      case other
+      when Pipeline
+        Pipeline.new(commands + other.commands)
+      when Cmd
+        Pipeline.new(commands + [other])
+      end
+    end
+
+    def stitch
+      # Set head in
+      if commands.first.stdin.nil?
+        start_r, start_w = IO.pipe
+        start_w.close
+        commands.first.stdin = start_r
+      end
+
+      # Connect intermediate in/outs
+      commands.each_cons(2) do |left, right|
+        read, write = IO.pipe
+        left.stdout = write
+        right.stdin = read
+      end
+
+      # Set tail out
+      if self.stdout
+        commands.last.stdout = stdout
+        stdout
+      elsif commands.last.stdout
+        commands.last.stdout
+      else
+        next_r, next_w = IO.pipe
+        commands.last.stdout = next_w
+        next_r
+      end
+    end
+
+    def run
+      stdout = stitch
+      results = commands.map(&:run)
+      Result.new(results.last.pid, stdout)
+    end
+  end
+end

data/lib/coque/rb.rb

@@ -0,0 +1,54 @@
+module Coque
+  class Rb < Cmd
+    NOOP = Proc.new { }
+    attr_reader :block, :pre_block, :post_block
+    def initialize(context = Context.new, &block)
+      if block_given?
+        @block = block
+      else
+        @block = NOOP
+      end
+      @pre_block = nil
+      @post_block = nil
+      @context = context
+    end
+
+    def clone
+      self.class.new(context, &block).pre(&pre_block).post(&post_block)
+    end
+
+    def pre(&block)
+      if block_given?
+        @pre_block = block
+      end
+      self
+    end
+
+    def post(&block)
+      if block_given?
+        @post_block = block
+      end
+      self
+    end
+
+    def run
+      ensure_default_fds
+
+      pid = fork do
+        STDOUT.reopen(stdout)
+        Dir.chdir(context.dir)
+        if context.disinherits_env?
+          ENV.clear
+        end
+        context.env.each do |k,v|
+          ENV[k] = v
+        end
+        @pre_block.call if @pre_block
+        stdin.each_line(&@block)
+        @post_block.call if @post_block
+      end
+      stdout.close
+      Result.new(pid, stdout_read)
+    end
+  end
+end

data/lib/coque/redirectable.rb

@@ -0,0 +1,96 @@
+require "pathname"
+
+module Coque
+  module Redirectable
+    attr_reader :stdin, :stdout, :stderr
+
+    def >(io)
+      clone.tap do |c|
+        c.stdout = io
+      end
+    end
+
+    def <(io)
+      clone.tap do |c|
+        c.stdin = io
+      end
+    end
+
+    def >=(io)
+      clone.tap do |c|
+        c.stderr = io
+      end
+    end
+
+    def getio(io, mode = "r")
+      case io
+      when String
+        File.open(io, mode)
+      when Pathname
+        File.open(io, mode)
+      when IO
+        io
+      when Tempfile
+        io
+      else
+        raise ArgumentError.new("Can't redirect stream to #{io}, must be String, Pathname, or IO")
+      end
+    end
+
+    def stdin_redirected?
+      defined? @stdin
+    end
+
+    def stdout_redirected?
+      defined? @stdout
+    end
+
+    def stderr_redirected?
+      defined? @stderr
+    end
+
+    def stderr=(s)
+      if stderr_redirected?
+        raise RedirectionError.new("Can't set stderr of #{self} to #{s}, is already set to #{stderr}")
+      else
+        @stderr = getio(s, "w")
+      end
+    end
+
+    def stdout=(s)
+      if stdout_redirected?
+        raise RedirectionError.new("Can't set stdout of #{self} to #{s}, is already set to #{stdout}")
+      else
+        @stdout = getio(s, "w")
+      end
+    end
+
+    def stdin=(s)
+      if stdin_redirected?
+        raise RedirectionError.new("Can't set stdin of #{self} to #{s}, is already set to #{stdin}")
+      else
+        @stdin = getio(s, "r")
+      end
+    end
+
+    def verify_redirectable(other)
+      if self.stdout_redirected?
+        raise RedirectionError.new("Can't pipe #{self} into #{other} -- #{self}'s STDIN is already redirected")
+      end
+
+      if other.stdin_redirected?
+        raise RedirectionError.new("Can't pipe #{self} into #{other} -- #{other}'s STDIN is already redirected")
+      end
+    end
+
+    private
+
+    def stdout_read
+      if defined? @stdout_read
+        @stdout_read
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/coque/result.rb

@@ -0,0 +1,24 @@
+class Coque::Result
+  attr_reader :pid, :exit_code
+  include Enumerable
+
+  def initialize(pid, out)
+    @pid = pid
+    @out = out
+  end
+
+  def each(&block)
+    @out.each_line do |line|
+      block.call(line.chomp)
+    end
+    unless defined? @exit_code
+      wait
+    end
+  end
+
+  def wait
+    _, status = Process.waitpid2(pid)
+    @exit_code = status.exitstatus
+    self
+  end
+end

data/lib/coque/sh.rb

@@ -0,0 +1,45 @@
+module Coque
+  class Sh < Cmd
+    attr_reader :args, :context
+    def initialize(context, args)
+      @context = context
+      @args = args
+    end
+
+    def clone
+      self.class.new(context, args)
+    end
+
+    def to_s
+      "<Coque::Sh #{args.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def [](*new_args)
+      self.class.new(self.context, self.args + new_args)
+    end
+
+    def run
+      ensure_default_fds
+      opts = {in: stdin, stdin.fileno => stdin.fileno,
+              out: stdout, stdout.fileno => stdout.fileno,
+              chdir: context.dir, unsetenv_others: context.disinherits_env?}
+
+      # Redirect err to out: (e.g. for 2>&1)
+      # {err: [:child, :out]}
+      err_opts = if stderr
+                   {err: stderr, stderr.fileno => stderr.fileno}
+                 else
+                   {}
+                 end
+
+      pid = spawn(context.env, args.join(" "), opts.merge(err_opts))
+
+      stdout.close
+      Result.new(pid, stdout_read)
+    end
+  end
+end

data/lib/coque/version.rb

@@ -0,0 +1,3 @@
+module Coque
+  VERSION = "0.1.0"
+end

data/lib/coque.rb

@@ -0,0 +1,27 @@
+require "coque/redirectable"
+require "coque/cmd"
+require "coque/sh"
+require "coque/rb"
+require "coque/context"
+require "coque/errors"
+require "coque/pipeline"
+require "coque/result"
+require "coque/version"
+
+module Coque
+  def self.context(dir: Dir.pwd, env: {}, disinherits_env: false)
+    Context.new(dir, env, disinherits_env)
+  end
+
+  def self.[](*args)
+    Context.new[*args]
+  end
+
+  def self.rb(&block)
+    Rb.new(Context.new, &block)
+  end
+
+  def self.pipeline(*commands)
+    commands.reduce(:|)
+  end
+end