pvc 0.0.1 → 0.0.2

data/.gitignore

@@ -1,2 +1,6 @@
 .DS_Store
 *.sw*
+pkg/*
+*.gem
+TODO.md
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile.lock

@@ -2,11 +2,15 @@ PATH
   remote: .
   specs:
     pvc (0.0.1)
+      childprocess
 
 GEM
   remote: http://rubygems.org/
   specs:
+    childprocess (0.3.6)
+      ffi (~> 1.0, >= 1.0.6)
     diff-lcs (1.1.3)
+    ffi (1.3.1)
     rspec (2.12.0)
       rspec-core (~> 2.12.0)
       rspec-expectations (~> 2.12.0)

data/README.md

@@ -7,9 +7,6 @@ Pipe between processes as easily as in the shell
     # run the specs
     bundle exec rspec spec
 
-    # run the simulation interactively (see description below)
-    ./bin/gorobo
-
 ## Install it as a RubyGem
 
 This code is packaged as a Gem. If you like, you can build and install it by running:
@@ -17,8 +14,41 @@ This code is packaged as a Gem. If you like, you can build and install it by run
     gem build pvc.gemspec
     gem install pvc-*.gem
 
-## Description
+## Synopsis - implemented
+
+    # Run a single process
+    PVC.new("echo hello").run
+
+    # Or pipe from one process to another
+    PVC.new("echo hello").to("tr h H").run
+
+    # Get individual or several outputs from the final result
+    PVC.new("echo hello && ls doesnotexist").run.stdout   # => "hello\n"
+    PVC.new("echo hello && ls doesnotexist").run.stderr   # => "ls: doesnotexist: No such file or directory\n"
+    PVC.new("echo hello && ls doesnotexist").run.stdboth  # => "hello\nls: doesnotexist: No such file or directory\n"
+    PVC.new("echo hello && ls doesnotexist").run.code     # => 1
+    stderr, code = PVC.new("echo hello && ls doesnotexist").run.get(:stderr, :code)  # => ["ls: doesnotexist: No such file or directory\n", 1]
+
+    # Input a string into stdin
+    PVC.new.input("one\ntwo\nthree\n").to("sort -r").run.stdout  # => "two\nthree\none\n"
+
+    # Process intermediate results with Ruby
+    PVC.new("cat some.log").to { |i,o| i.each_line { |line| o.puts line if line.match(/ERROR/) } }.to("tail -n10").run
+
+    # Mix stderr and stdin at some point in a pipeline
+    PVC.new("echo hello && ls doesnotexist").with_err.to("wc -l").run.stdout  # => "       2\n"
+
+    # Pass on only stderr at some point in a pipeline
+    PVC.new("echo hello && ls doesnotexist").only_err.to("wc -l").run.stdout  # => "       1\n"
+
+    # Insert one pipeline into another
+    upcase_unique_pipeline = PVC.new("tr a-z A-Z").to("uniq")
+    PVC.new.input("hello\nHeLlO\nworld\nWoRlD\n").to(upcase_unique_pipeline).to("sort -r").run.stdout # => "WORLD\nHELLO"
+
+## Synopsis - unimplemented
 
+    # Kill run if it does not finish in time (miliseconds)
+    PVC.new("sleep 2").run(:timeout => 1000)
 
 ## Compatibility
 

data/lib/pvc/block_piece.rb

@@ -0,0 +1,43 @@
+module PVC
+  class BlockPiece
+
+    class Runner
+
+      def initialize(&block)
+        @block = block
+        @read, @write = IO.pipe
+        @read.close_on_exec = true
+        @write.close_on_exec = true
+      end
+
+      def stdin
+        @write
+      end
+
+      def start(following_piece)
+        @return = nil
+        @thread = Thread.new do
+          @return = @block.call(@read, following_piece.stdin)
+        end
+      end
+
+      def finish
+        @write.close
+        @thread.join
+        @read.close
+      end
+
+      attr_reader :return
+    end
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def runner
+      Runner.new(&@block)
+    end
+
+  end
+end
+

data/lib/pvc/input_piece.rb

@@ -0,0 +1,37 @@
+module PVC
+  class InputPiece
+
+    class Runner
+      def initialize(input)
+        @input = input
+        @read, @write = IO.pipe
+        @read.close_on_exec = true
+        @write.close_on_exec = true
+      end
+
+      def stdin
+        @write
+      end
+
+      def start(following_piece)
+        following_piece.stdin.write(@input)
+        following_piece.stdin.flush
+      end
+
+      def finish
+        @write.close
+        @read.close
+      end
+    end
+
+    def initialize(input)
+      @input = input
+    end
+
+    def runner
+      Runner.new(@input)
+    end
+
+  end
+end
+

data/lib/pvc/null_piece.rb

@@ -0,0 +1,32 @@
+module PVC
+  class NullPiece
+
+    class Runner
+      def initialize
+        @read, @write = IO.pipe
+        @read.close_on_exec = true
+        @write.close_on_exec = true
+      end
+
+      def stdin
+        @write
+      end
+
+      def start(following=nil)
+        # do nothing
+      end
+
+      def finish
+        @write.close
+        @read.close
+      end
+
+    end
+    
+    def runner
+      Runner.new
+    end
+
+  end
+end
+

data/lib/pvc/only_err_piece.rb

@@ -0,0 +1,44 @@
+module PVC
+  class OnlyErrPiece
+
+    class Runner
+      def initialize
+        @stdread, @stdwrite = IO.pipe
+        @errread, @errwrite = IO.pipe
+        @stdread.close_on_exec = true
+        @stdwrite.close_on_exec = true
+        @errread.close_on_exec = true
+        @errwrite.close_on_exec = true
+      end
+
+      def stdin
+        @stdwrite
+      end
+
+      def errin
+        @errwrite
+      end
+
+      def start(following_piece)
+        @errthread = Thread.new do
+          @errread.each_line { |line| following_piece.stdin.puts line }
+        end
+      end
+
+      def finish
+        @stdwrite.close
+        @errwrite.close
+        @errthread.join
+        @stdread.close
+        @errread.close
+      end
+
+    end
+
+    def runner
+      Runner.new
+    end
+
+  end
+end
+

data/lib/pvc/pipeline.rb

@@ -0,0 +1,74 @@
+require "childprocess"
+
+require "pvc/block_piece"
+require "pvc/null_piece"
+require "pvc/process_piece"
+require "pvc/with_err_piece"
+require "pvc/only_err_piece"
+require "pvc/result_piece"
+require "pvc/input_piece"
+require "pvc/result"
+
+module PVC
+  class Pipeline
+
+    def initialize(*args, &block)
+      @pieces = []
+      if args.length > 0 || block_given?
+        self.to(*args, &block)
+      end
+    end
+
+    def to(*args, &block)
+      if block_given?
+        @pieces << BlockPiece.new(&block)
+      elsif args.length == 1 && args.first.respond_to?(:pieces)
+        args.first.pieces.each { |piece| @pieces << piece }
+      else
+        @pieces << ProcessPiece.new(*args)
+      end
+      self
+    end
+
+    def input(input)
+      @pieces << InputPiece.new(input)
+      self
+    end
+    
+    def with_err
+      @pieces << WithErrPiece.new
+      self
+    end
+
+    def only_err
+      @pieces << OnlyErrPiece.new
+      self
+    end
+
+    def run
+      runners = ([NullPiece.new] + @pieces + [ResultPiece.new]).map(&:runner)
+      
+      runners.zip(runners[1..-1]).reverse.each do |current, following|
+        current.start(following)
+      end
+
+      runners.each do |current|
+        current.finish
+      end
+
+      Result.new(
+        :stdout => runners.last.stdout,
+        :stderr => runners.last.stderr,
+        :stdboth => runners.last.stdboth,
+        :codes => runners.inject([]) { |codes, runner| codes << runner.code if runner.respond_to?(:code); codes },
+        :returns => runners.inject([]) { |returns, runner| returns << runner.return if runner.respond_to?(:return); returns }
+      )
+    end
+
+    protected
+
+    attr_reader :pieces
+
+  end
+end
+

data/lib/pvc/process_piece.rb

@@ -0,0 +1,41 @@
+module PVC
+  class ProcessPiece
+
+    class Runner
+      def initialize(*args)
+        @args = args
+        @process = ChildProcess.build(*args)
+      end
+
+      def stdin
+        @process.io.stdin
+      end
+
+      def start(following_piece)
+        @process.duplex = true
+        @process.io.stdout = following_piece.stdin
+        @process.io.stderr = following_piece.errin if following_piece.respond_to?(:errin)
+        @process.start
+      end
+
+      def finish
+        @process.io.stdin.close
+        @process.wait
+      end
+
+      def code
+        @process.exit_code
+      end
+    end
+
+    def initialize(args)
+      @args = args
+    end
+
+    def runner
+      Runner.new(@args)
+    end
+
+  end
+end
+

data/lib/pvc/result.rb

@@ -0,0 +1,32 @@
+module PVC
+  class Result
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :stdboth
+
+    def initialize(args)
+      @stdout = args[:stdout]
+      @stderr = args[:stderr]
+      @stdboth = args[:stdboth]
+      @returns = args[:returns]
+      @codes = args[:codes]
+    end
+
+    def return
+      @returns.last
+    end
+
+    def code
+      @codes.last
+    end
+
+    def get(*requested_outputs)
+      allowed_outputs = [:stdout, :stderr, :stdboth, :return, :code]
+      raise "No such output to get!" unless (requested_outputs-allowed_outputs)==[]
+      requested_outputs.map { |output_kind| self.send(output_kind) }
+    end
+
+  end
+end
+

data/lib/pvc/result_piece.rb

@@ -0,0 +1,69 @@
+module PVC
+  class ResultPiece
+    
+    class Runner
+      def initialize
+        @stdread, @stdwrite = IO.pipe
+        @errread, @errwrite = IO.pipe
+        @stdread.close_on_exec = true
+        @stdwrite.close_on_exec = true
+        @errread.close_on_exec = true
+        @errwrite.close_on_exec = true
+        @stdout = []
+        @stderr = []
+        @stdboth = []
+      end
+
+      def stdin
+        @stdwrite
+      end
+
+      def errin
+        @errwrite
+      end
+
+      def start(following=nil)
+        @stdthread = Thread.new do
+          @stdread.each_line do |line|
+            @stdout << line
+            @stdboth << line
+          end
+        end
+        @errthread = Thread.new do
+          @errread.each_line do |line|
+            @stderr << line
+            @stdboth << line
+          end
+        end
+      end
+
+      def finish
+        @stdwrite.close
+        @errwrite.close
+        @stdthread.join
+        @errthread.join
+        @stdread.close
+        @errread.close
+      end
+
+      def stdout
+        @stdout.join("")
+      end
+
+      def stderr
+        @stderr.join("")
+      end
+
+      def stdboth
+        @stdboth.join("")
+      end
+
+    end
+
+    def runner
+      Runner.new
+    end
+
+  end
+end
+

data/lib/pvc/version.rb

@@ -1,3 +1,3 @@
 module PVC
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/pvc/with_err_piece.rb

@@ -0,0 +1,48 @@
+module PVC
+  class WithErrPiece
+
+    class Runner
+      def initialize
+        @stdread, @stdwrite = IO.pipe
+        @errread, @errwrite = IO.pipe
+        @stdread.close_on_exec = true
+        @stdwrite.close_on_exec = true
+        @errread.close_on_exec = true
+        @errwrite.close_on_exec = true
+      end
+
+      def stdin
+        @stdwrite
+      end
+
+      def errin
+        @errwrite
+      end
+
+      def start(following_piece)
+        @stdthread = Thread.new do
+          @stdread.each_line { |line| following_piece.stdin.puts line }
+        end
+        @errthread = Thread.new do
+          @errread.each_line { |line| following_piece.stdin.puts line }
+        end
+      end
+
+      def finish
+        @stdwrite.close
+        @errwrite.close
+        @stdthread.join
+        @errthread.join
+        @stdread.close
+        @errread.close
+      end
+
+    end
+
+    def runner
+      Runner.new
+    end
+
+  end
+end
+

data/lib/pvc.rb

@@ -0,0 +1,12 @@
+require "childprocess"
+
+require "pvc/pipeline"
+
+module PVC
+
+  def self.new(*args, &block)
+    Pipeline.new(*args, &block)
+  end
+
+end
+

data/pvc.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = PVC::VERSION
   s.authors     = ["Chris Berkhout"]
   s.email       = ["chrisberkhout@gmail.com"]
-  s.homepage    = "http://chrisberkhout.com"
+  s.homepage    = "http://github.com/chrisberkhout/pvc"
   s.summary     = %q{Easy piping between processes}
 
   s.rubyforge_project = "pvc"
@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
+  s.add_runtime_dependency "childprocess"
+
   s.add_development_dependency "rspec"
   
   s.required_ruby_version = '>= 1.9.0'

data/spec/pvc/integration_spec.rb

@@ -0,0 +1,109 @@
+require "pvc"
+
+describe "pvc" do
+
+  describe "(synopsis tests)" do
+
+    it "should run a single process" do
+      PVC.new("echo hello").run.stdout.should == "hello\n"
+    end
+
+    it "should pipe from one process to another" do
+      PVC.new("echo hello").to("tr h H").run.stdout.should == "Hello\n"
+    end
+
+    it "should let you get stdout" do
+      PVC.new("echo hello && ls doesnotexist").run.stdout.should == "hello\n"
+    end
+
+    it "should let you get stderr" do
+      PVC.new("echo hello && ls doesnotexist").run.stderr.should == "ls: doesnotexist: No such file or directory\n"
+    end
+
+    it "should let you get stdout and stderr together" do
+      PVC.new("echo hello && ls doesnotexist").run.stdboth.should == "hello\nls: doesnotexist: No such file or directory\n"
+    end
+
+    it "should let you get the exit code of the last process" do
+      PVC.new("echo hello").run.code.should == 0
+      PVC.new("echo hello && ls doesnotexist").run.code.should == 1
+    end
+
+    it "should let you get several outputs from the final result" do
+      PVC.new("echo hello && ls doesnotexist").run.get(:stderr, :code).should == ["ls: doesnotexist: No such file or directory\n", 1]
+    end
+
+    it "should let you input into the stdin" do
+      PVC.new.input("one\ntwo\nthree\n").to("sort -r").run.stdout.should == "two\nthree\none\n"
+    end
+
+    it "should let you process intermediate results with Ruby" do
+      PVC.new.input("one\ntwo\nthree\n").to do |i,o|
+        i.each_line { |line| o.puts line if line.match(/^t/) }
+      end.to("cat").run.stdout.should == "two\nthree\n"
+    end
+
+    it "should let you mix stderr and stdin at some point in a pipeline" do
+      PVC.new("echo hello && ls doesnotexist").with_err.to("wc -l").run.stdout.should == "       2\n"
+    end
+
+    it "should let you pass on only stderr at some point in a pipeline" do
+      PVC.new("echo hello && ls doesnotexist").only_err.to("wc -l").run.stdout.should == "       1\n"
+    end
+
+    it "should let you insert one pipeline into another" do
+      upcase_unique_pipeline = PVC.new("tr a-z A-Z").to("uniq")
+      string = "hello\nHeLlO\nworld\nWoRlD\n"
+      PVC.new.input(string).to(upcase_unique_pipeline).to("sort -r").run.stdout.should == "WORLD\nHELLO\n"
+    end
+
+  end
+
+  describe "(original manual tests)" do
+
+    let(:log) { [] }
+
+    it "should work with 2 shell commands and a block" do
+      PVC.new.
+        to("echo BBB && echo AAA").
+        to("sort").
+        to do |input, output|
+          input.each_line { |line| log << line.chomp }
+        end.run
+
+      log.should == %w{AAA BBB}
+    end
+
+    it "should work with sevearal blocks" do
+      PVC.new.
+        to("echo BBB && echo AAA").
+        to("sort").
+        to do |input, output|
+          input.each_line { |line| output.write line }
+        end.
+        to do |input, output|
+          input.each_line { |line| log << line.chomp }
+        end.run
+
+      log.should == %w{AAA BBB}
+    end
+
+    it "should work with sevearal blocks separated by a shell command" do
+      PVC.new.
+        to("echo BBB && echo AAA").
+        to("sort").
+        to do |input, output|
+          input.each_line { |line| output.write line }
+        end.
+        to("cat").
+        to do |input, output|
+          input.each_line { |line| log << line.chomp }
+        end.run
+
+      log.should == %w{AAA BBB}
+    end
+
+  end
+
+end
+

data/spec/ruby/pipe_io_spec.rb

@@ -0,0 +1,64 @@
+require "childprocess"
+
+describe "pipe io" do
+
+  def fork_childprocess
+    ChildProcess.unix?.should == true && ChildProcess.posix_spawn?.should == false  # to ensure this does fork+exec
+    process = ChildProcess.build("cat")
+    process.duplex = true  # to make stdin available on start
+    process.start
+    yield if block_given?
+    process.io.stdin.close
+    process.wait
+  end
+
+  # see also the example at: http://rubydoc.info/stdlib/core/1.9.3/IO.pipe
+
+  it "will not show EOF on close if a fork has an open copy of the file handle" do
+    read, write = IO.pipe
+    fork_childprocess do
+      write.close
+      expect { read.read_nonblock(1) }.to raise_error(Errno::EAGAIN)  # not yet EOF
+    end
+  end
+
+  it "should show EOF on close if the fork has closed its copy of the file handle (by exiting)" do
+    read, write = IO.pipe
+    fork_childprocess
+    write.close
+    expect { read.read_nonblock(1) }.to raise_error(EOFError)
+  end
+
+  it "should show EOF on close if the fork has closed its copy of the file handle (by closing on exec)" do
+    read, write = IO.pipe
+    write.close_on_exec = true
+    fork_childprocess do
+      write.close
+      expect { read.read_nonblock(1) }.to raise_error(EOFError)
+    end
+  end
+
+  it "should not close everywhere if closed in a fork" do
+    read, write = IO.pipe
+    read.close_on_exec = true
+    write.close_on_exec = true
+    fork_childprocess do
+      read.closed?.should be_false
+    end
+  end
+
+  it "should get a final unterminated line via #each_line" do
+    read, write = IO.pipe
+    lines_read = []
+    thread = Thread.new do
+      read.each_line { |line| lines_read << line }
+    end
+    write.puts "terminated line"
+    write.print "unterminated line"
+    write.close
+    thread.join
+    lines_read.should == ["terminated line\n", "unterminated line"]
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pvc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-26 00:00:00.000000000 Z
+date: 2013-02-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -35,15 +51,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
 - README.md
 - Rakefile
 - lib/pvc.rb
+- lib/pvc/block_piece.rb
+- lib/pvc/input_piece.rb
+- lib/pvc/null_piece.rb
+- lib/pvc/only_err_piece.rb
+- lib/pvc/pipeline.rb
+- lib/pvc/process_piece.rb
+- lib/pvc/result.rb
+- lib/pvc/result_piece.rb
 - lib/pvc/version.rb
+- lib/pvc/with_err_piece.rb
 - pvc.gemspec
+- spec/pvc/integration_spec.rb
+- spec/ruby/pipe_io_spec.rb
 - spec/spec_helper.rb
-homepage: http://chrisberkhout.com
+homepage: http://github.com/chrisberkhout/pvc
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -68,5 +96,7 @@ signing_key:
 specification_version: 3
 summary: Easy piping between processes
 test_files:
+- spec/pvc/integration_spec.rb
+- spec/ruby/pipe_io_spec.rb
 - spec/spec_helper.rb
 has_rdoc: