rubysh 0.2.4 → 0.3.0

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.3.0 2014-05-25
+
+* Add block execution support to Rubysh. De-support old semantics here
+  providing a block was a wrapper for generating an argument array.

data/README.md

@@ -58,6 +58,12 @@ are arbitrary symbols):
     runner.read(:stdout) # "hi\n"
     runner.read(:stderr) # ""
 
+You can also have your child run a Ruby block rather than execute a command:
+
+    command = Rubysh(Rubysh.stdout > :stdout) {puts "hi from child"}
+    runner = command.run
+    runner.read(:stdout) # "hi from child\n"
+
 ## Controlled input
 
 You can easily read and write data interactively:
@@ -67,9 +73,26 @@ You can easily read and write data interactively:
     >> runner.read(:how => :partial) # block until some output available
     => ".\n.\n.\n.\n.\n.\n.\n.\n.\n"
     >> runner.read(:how => :nonblock)
-    => ""
+    => nil
     >> runner.read # block until all output available
-    => [truncated]
+    => ".\n[...]"
+
+## Reactive output
+
+You can also receive real-time notifications as data becomes available:
+
+    >> runner = Rubysh(
+        'examples/on_read_example.sh',
+         Rubysh.stdout > :stdout, Rubysh.stderr > :stderr,
+         on_read: Proc.new {|target, data| puts "[#{target}]: #{data}"}
+        )
+    => Command: examples/on_read_example.sh >:stdout 2>:stderr {:on_read=>#<Proc:0x007f8ad3bc5790@(irb):4>}
+    >> runner.run
+    [stdout]: [1] Hello from stdout
+    [stderr]: [1] Hello from stderr
+    [stdout]: [2] Hello from stdout
+    [stderr]: [2] Hello from stderr
+    [...]
 
 ## API
 

data/examples/on_read_example.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+for i in {1..10}; do
+    echo "[$i] Hello from stdout"
+    echo >&2 "[$i] Hello from stderr"
+    sleep 1
+done

data/lib/rubysh.rb

@@ -62,23 +62,12 @@ require 'rubysh/util'
 # Rubysh('ls', '/tmp', Rubysh.&)
 # => Command: ls /tmp &
 
-# Either create a new Rubysh command:
+# You can then create a new Rubysh command:
 #
 #  command = Rubysh('ls')
 #  command.run
-#
-# Or use the block syntax to create and run one:
-#
-#  Rubysh {'ls'}
 def Rubysh(*args, &blk)
-  if blk
-    raise Rubysh::Error::BaseError.new("Can't provide arguments and a block") if args.length > 0
-    command = blk.call
-    command = Rubysh::Command.new(command) unless command.kind_of?(Rubysh::Command)
-    command.run
-  else
-    Rubysh::Command.new(args)
-  end
+  Rubysh::Command.new(args, &blk)
 end
 
 def AliasRubysh(name)
@@ -90,22 +79,22 @@ end
 module Rubysh
   # Convenience methods
   def self.run(*args, &blk)
-    command = Rubysh::Command.new(args)
-    command.run(&blk)
+    command = Rubysh::Command.new(args, &blk)
+    command.run
   end
 
   def self.run_async(*args, &blk)
-    command = Rubysh::Command.new(args)
-    command.run_async(&blk)
+    command = Rubysh::Command.new(args, &blk)
+    command.run_async
   end
 
   def self.check_call(*args, &blk)
-    command = Rubysh::Command.new(args)
-    command.check_call(&blk)
+    command = Rubysh::Command.new(args, &blk)
+    command.check_call
   end
 
-  def self.Command(*args)
-    Command.new(*args)
+  def self.Command(*args, &blk)
+    Command.new(*args, &blk)
   end
 
   def self.Pipeline(*args)

data/lib/rubysh/command.rb

@@ -1,16 +1,17 @@
 module Rubysh
   class Command < BaseCommand
-    attr_accessor :raw_args, :directives, :args
+    attr_accessor :raw_args, :directives, :args, :blk
 
-    def initialize(args)
+    def initialize(args, &blk)
       if args.length == 1 && args[0].kind_of?(Array)
-        raise "It looks like you created a Rubysh::Command with a singleton nested array: #{args.inspect}. That'll never be runnable, and probably indicates you forgot a splat somewhere."
+        raise Rubysh::Error::BaseError.new("It looks like you created a Rubysh::Command with a singleton nested array: #{args.inspect}. That'll never be runnable, and probably indicates you forgot a splat somewhere.")
       end
 
       @raw_args = args
       @directives = []
       @args = nil
       @opts = {}
+      @blk = blk
 
       process_args
     end
@@ -32,6 +33,10 @@ module Rubysh
           arg.to_s
         end
       end.compact
+
+      if @args.length > 0 && @blk
+        raise Rubysh::Error::BaseError.new("You can't provide command-line arguments and a block at the same time.")
+      end
     end
 
     def stringify
@@ -123,7 +128,7 @@ module Rubysh
       # pipeline, which should not win out over internal redirects.
       directives = extra_directives(runner) + @directives
       post_forks = base_post_forks + extra_post_forks(runner)
-      state(runner)[:subprocess] = Subprocess.new(args, directives, post_forks, runner)
+      state(runner)[:subprocess] = Subprocess.new(args, blk, directives, post_forks, runner)
     end
   end
 end

data/lib/rubysh/subprocess.rb

@@ -14,11 +14,18 @@ module Rubysh
 
     # TODO: switch directives over to an OrderedHash of some form? Really
     # want to preserve the semantics here.
-    def initialize(args, directives=[], post_fork=[], runner=nil)
+    def initialize(args, blk=nil, directives=[], post_fork=[], runner=nil)
       raise ArgumentError.new("Must provide an array (#{args.inspect} provided)") unless args.kind_of?(Array)
-      raise ArgumentError.new("No command specified (#{args.inspect} provided)") unless args.length > 0
+
+      if args.length > 0 && blk
+        raise ArgumentError.new("Provided both arguments (#{args.inspect}) and a block (#{blk.inspect}). You can only provide one.")
+      elsif args.length == 0 && !blk
+        raise ArgumentError.new("No command specified (#{args.inspect} provided)")
+      end
+
       @command = args[0]
       @args = args[1..-1]
+      @blk = blk
       @directives = directives
       @runner = runner
 
@@ -35,7 +42,7 @@ module Rubysh
     end
 
     def to_s
-      "Subprocess: command=#{@command.inspect} args=#{@args.inspect} directives: #{@directives.inspect}"
+      "Subprocess: command=#{@command.inspect} blk=#{@blk.inspect} args=#{@args.inspect} directives: #{@directives.inspect}"
     end
 
     def run
@@ -93,7 +100,12 @@ module Rubysh
       @exec_status.write_only
       run_post_fork
       apply_directives_child
-      exec_program
+
+      if @blk
+        run_blk
+      else
+        exec_program
+      end
     end
 
     def run_post_fork
@@ -120,6 +132,21 @@ module Rubysh
       end
     end
 
+    def run_blk
+      # Close the writing end of the pipe
+      @exec_status.read_only
+
+      begin
+        # Run the actual block
+        @blk.call
+      rescue Exception => e
+        render_exception(e)
+        hard_exit(e)
+      else
+        hard_exit(nil)
+      end
+    end
+
     def exec_program
       begin
         Kernel.exec([command, command], *args)
@@ -131,9 +158,9 @@ module Rubysh
           'caller' => e.send(:caller)
         }
         @exec_status.dump_json_and_close(msg)
-        # Note: atexit handlers will fire in this case. May want to do
-        # something about that.
-        exit(1)
+        # Abort without running at_exit handlers or giving the user a
+        # chance to accidentally catch the exit.
+        hard_exit(e)
       else
         raise Rubysh::Error::UnreachableError.new("This code should be unreachable. If you are seeing this exception, it means someone overrode Kernel.exec. That's not very nice of them.")
       end
@@ -153,5 +180,17 @@ module Rubysh
 
       raise @exec_error if @exec_error
     end
+
+    def render_exception(e)
+      $stderr.print("[Rubysh subprocess #{$$}] #{e.class}: #{e.message}\n\t")
+      $stderr.print(e.backtrace.join("\n\t"))
+      $stderr.print("\n")
+    end
+
+    # Broken out for the tests
+    def hard_exit(exception)
+      status = exception ? 1 : 0
+      exit!(status)
+    end
   end
 end

data/lib/rubysh/version.rb

@@ -1,3 +1,3 @@
 module Rubysh
-  VERSION = '0.2.4'
+  VERSION = '0.3.0'
 end

data/test/functional/lib/execute_block.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../_lib', File.dirname(__FILE__))
+
+module RubyshTest::Functional
+  class EnvTest < FunctionalTest
+    describe 'when executing a block' do
+      it 'runs the expected code' do
+        result = Rubysh.run(Rubysh.stdout > :stdout) {puts "hi"}
+
+        assert_equal(0, result.exitstatus)
+        output = result.read(:stdout)
+        assert_equal("hi\n", output)
+      end
+
+      it 'hard exits from the subprocess' do
+        Rubysh::Subprocess.any_instance.stubs(:render_exception)
+
+        begin
+          result = Rubysh.run {raise "this should in fact get printed"}
+        rescue Exception
+        end
+
+        assert_equal(1, result.exitstatus)
+      end
+    end
+  end
+end

data/test/unit/lib/rubysh/subprocess.rb

@@ -2,10 +2,19 @@ require File.expand_path('../../_lib', File.dirname(__FILE__))
 
 module RubyshTest::Unit
   class SubprocessTest < UnitTest
+    before do
+      Rubysh::Subprocess.any_instance.stubs(:hard_exit).with do |e|
+        raise e if e
+        true
+      end
+    end
+
     describe 'when running a command' do
       it 'calls exec with the expected arguments' do
         read_fd, write_fd = stub_pipe
-        Kernel.expects(:exec).with(['cmd', 'cmd'], 'arg1', 'arg2')
+        Kernel.expects(:exec).with do |*args|
+          assert_equal([['cmd', 'cmd'], 'arg1', 'arg2'], args)
+        end
 
         proc = Rubysh::Subprocess.new(['cmd', 'arg1', 'arg2'])
         proc.send(:open_exec_status)
@@ -19,13 +28,15 @@ module RubyshTest::Unit
           runner = mock
 
           read_fd, write_fd = stub_pipe
-          Kernel.expects(:exec).with(['cmd', 'cmd'], 'arg1', 'arg2')
+          Kernel.expects(:exec).with do |*args|
+            assert_equal([['cmd', 'cmd'], 'arg1', 'arg2'], args)
+          end
 
           redirect = Rubysh::Redirect.new(2, '>', 1)
           redirect.expects(:apply!).with(runner)
 
           proc = Rubysh::Subprocess.new(['cmd', 'arg1', 'arg2'],
-            [redirect], [], runner)
+            nil, [redirect], [], runner)
           proc.send(:open_exec_status)
           assert_raises(Rubysh::Error::UnreachableError) do
             proc.send(:do_run_child)
@@ -33,5 +44,18 @@ module RubyshTest::Unit
         end
       end
     end
+
+    describe 'with a block' do
+      it 'executes the block and then calls exit!' do
+        called = false
+        blk = Proc.new {called = true}
+
+        proc = Rubysh::Subprocess.new([], blk)
+        proc.send(:open_exec_status)
+        proc.send(:do_run_child)
+
+        assert(called, "Did not call the block")
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubysh
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-12 00:00:00.000000000 Z
+date: 2014-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -84,10 +84,12 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- History.txt
 - LICENSE
 - README.md
 - Rakefile
 - examples/dots.sh
+- examples/on_read_example.sh
 - examples/self_tee_example.rb
 - lib/rubysh.rb
 - lib/rubysh/base_command.rb
@@ -111,6 +113,7 @@ files:
 - test/_lib.rb
 - test/functional/_lib.rb
 - test/functional/lib/env.rb
+- test/functional/lib/execute_block.rb
 - test/functional/lib/fd-lister
 - test/functional/lib/kill.rb
 - test/functional/lib/leaked_fds.rb
@@ -143,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1239245545634239752
+      hash: 3769802053247508870
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -152,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1239245545634239752
+      hash: 3769802053247508870
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -166,6 +169,7 @@ test_files:
 - test/_lib.rb
 - test/functional/_lib.rb
 - test/functional/lib/env.rb
+- test/functional/lib/execute_block.rb
 - test/functional/lib/fd-lister
 - test/functional/lib/kill.rb
 - test/functional/lib/leaked_fds.rb